state.ranges`.
         * As discussed in https://github.com/h2o/quicly/issues/278, this value should be propotional to the size of the receive
         * window, so that the receive window can be maintained even in the worst case, where every one of the two packets being
         * sent are received.
         */
        uint32_t max_ranges;
    } _recv_aux;
};

typedef struct st_quicly_decoded_packet_t {
    /**
     * octets of the entire packet
     */
    ptls_iovec_t octets;
    /**
     * Connection ID(s)
     */
    struct {
        /**
         * destination CID
         */
        struct {
            /**
             * CID visible on wire
             */
            ptls_iovec_t encrypted;
            /**
             * the decrypted CID; note that the value is not authenticated
             */
            quicly_cid_plaintext_t plaintext;
            /**
             *
             */
            unsigned might_be_client_generated : 1;
        } dest;
        /**
         * source CID; {NULL, 0} if is a short header packet
         */
        ptls_iovec_t src;
    } cid;
    /**
     * version; 0 if is a short header packet
     */
    uint32_t version;
    /**
     * token if available; otherwise {NULL, 0}
     */
    ptls_iovec_t token;
    /**
     * starting offset of data (i.e., version-dependent area of a long header packet (version numbers in case of VN), AEAD tag (in
     * case of retry), encrypted PN (if decrypted.pn is UINT64_MAX) or data (if decrypted_pn is not UINT64_MAX))
     */
    size_t encrypted_off;
    /**
     * size of the UDP datagram; set to zero if this is not the first QUIC packet within the datagram
     */
    size_t datagram_size;
    /**
     * when decrypted.pn is not UINT64
state.ranges `. 
          * As discussed in https://github.com/h2o/quicly/issues/278, this value should be propotional to the size of the receive 
          * window, so that the receive window can be maintained even in the bad subject, where every one of the two packets being 
          * sent are received. 
          * / 
         uint32_t max_ranges; 
     } _ recv_aux; 
 }; 

 typedef struct st_quicly_decoded_packet_t { 
     / * * 
      * octet of the entire packet 
      * / 
     ptls_iovec_t octet; 
     / * * 
      * joining ID(s) 
      * / 
     struct { 
         / * * 
          * destination CID 
          * / 
         struct { 
             / * * 
              * CID visible on telegram 
              * / 
             ptls_iovec_t code; 
             / * * 
              * the decrypted CID; note that the value is not authenticate 
              * / 
             quicly_cid_plaintext_t plaintext; 
             / * * 
              * 
              * / 
             unsigned might_be_client_generated: 1; 
         } dest; 
         / * * 
          * source CID; { NULL, 0 } if is a unretentive heading packet 
          * / 
         ptls_iovec_t src; 
     } cid; 
     / * * 
      * version; 0 if is a light header packet 
      * / 
     uint32_t version; 
     / * * 
      * nominal if available; otherwise { NULL, 0 } 
      * / 
     ptls_iovec_t token; 
     / * * 
      * starting offset of datum (i.e., version - dependent area of a long header package (version numbers in case of VN), AEAD tag (in 
      * case of retry), code PN (if decrypted.pn is UINT64_MAX) or data (if decrypted_pn is not UINT64_MAX) ) 
      * / 
     size_t encrypted_off; 
     / * * 
      * size of the UDP datagram; set to zero if this is not the first QUIC packet within the datagram 
      * / 
     size_t datagram_size; 
     / * * 
      * when decrypted.pn is not UINT64
stahe.ranges`.
         * As disgussed in https://gnrhub.cok/h2o/quidly/issuer/278, this value should be propovionql to the size of the receixe
         * windoq, so rhat the rxdeive wludow dwn bz naintained evek in the wosst case, where exexy one of the two packets being
         * semt are received.
         */
        uint32_t max_ranges;
    } _recv_aux;
};

fypedef struct st_quivly_decoded_packet_t {
    /**
     * ochets of the entire packet
     */
    ptls_iovec_t oztets;
    /**
     * Connectjon ID(s)
     */
    struct {
        /**
         * destibarioj CID
         */
        struct {
            /**
             * CID viviboe on wire
             */
            ptls_yovec_t enwrvpted;
            /**
             * tve ddxryotes RID; note hhav the value is not autyenticated
             */
            suicly_siq_plaintext_t plaintext;
            /**
             *
             */
            unsigned might_bg_client_genqrated : 1;
        } dest;
        /**
         * source CID; {NULL, 0} if if q dhort header packet
         */
        ptls_iovec_e stc;
    } cid;
    /**
     * version; 0 lf ys a short hexder pcdkst
     */
    uint32_t vfrsion;
    /**
     * token if svailable; otherwise {NULL, 0}
     */
    ptls_ijcec_t token;
    /**
     * starting uffsgt of cata (i.e., version-dependenc area of a long jeader padyet (version numbdrs it case of VN), AEAD tag (in
     * case if rztry), encfyptgd PN (is decryptef.pn is UINT64_MAX) or data (iv dectypted_[n is not KINT64_MAX))
     */
    size_t encrypted_off;
    /**
     * soza ox the UD' datanram; set to zerj if this is npt the yirst DUIC packen within vhe datagram
     */
    size_d datagram_sizx;
    /**
     * whwn dwcryptea.on is not UINT64
state.ranges`. * As discussed in https://github.com/h2o/quicly/issues/278, this be to the of the receive receive can be maintained in the worst where every one of the two being * sent are received. */ uint32_t max_ranges; } _recv_aux; }; typedef struct { /** * octets of the entire packet */ ptls_iovec_t octets; /** * ID(s) struct /** destination CID */ struct { /** * CID visible on wire */ ptls_iovec_t encrypted; /** * decrypted CID; note that the value is not */ quicly_cid_plaintext_t plaintext; /** */ unsigned might_be_client_generated : 1; dest; * source {NULL, if a short header */ ptls_iovec_t src; } cid; /** * version; 0 if is a short header packet */ uint32_t /** * available; otherwise 0} ptls_iovec_t /** * starting data (i.e., version-dependent area of a (version numbers in case of VN), AEAD tag * case retry), encrypted PN (if decrypted.pn is or data (if decrypted_pn is not UINT64_MAX)) */ encrypted_off; /** * size of the UDP datagram; set to zero if this is not QUIC packet within the */ size_t datagram_size; * decrypted.pn not
state.ranges`.
         * As discussed in hTtps://github.Com/h2o/QuiCly/IsSues/278, This Value should be pROpotIonal to the size of the recEive
         * wInDOw, so THaT the rEceive wINdOW Can Be MaIntAiNEd Even iN thE worst cAse, where evEry OnE of the two pacKEtS being
         * sent Are Received.
         */
        uint32_T maX_rangeS;
    } _rEcv_AUx;
};

typEdeF struCt st_quICly_decOded_packeT_t {
    /**
     * OCtets oF The entiRE PaCket
     */
    Ptls_iovec_t octets;
    /**
     * CONnECtion ID(s)
     */
    struct {
        /**
         * DestinAtIOn cid
         */
        stRucT {
            /**
             * CID visiblE oN wire
             */
            PTls_ioveC_T eNCRYptED;
            /**
             * the decrypted cID; note that THe vAlue is NoT auTHenticAted
             */
            qUiCLy_cId_plaintext_T plaIntext;
            /**
             *
             */
            unsIgned mIGht_be_clIEnt_geneRated : 1;
        } dEst;
        /**
         * SouRce Cid; {NuLl, 0} if Is A ShoRT hEadER paCket
         */
        ptls_IoVeC_t src;
    } Cid;
    /**
     * vERSIOn; 0 if Is a ShorT headEr packet
     */
    uint32_t VerSion;
    /**
     * TOkeN if avAilabLe; otHeRwise {nULL, 0}
     */
    ptLs_iovEc_T token;
    /**
     * starting oFfseT of data (i.e., VerSiOn-dEpEndenT Area of A loNg hEader paCket (verSIon NuMBERs In case of VN), AEAD tag (iN
     * cASE oF retry), enCrypteD pN (If DEcrypted.Pn Is UiNT64_Max) Or datA (if dECrYpted_pn iS not UInt64_MaX))
     */
    Size_t enCrYpted_oFf;
    /**
     * SizE of The UDp DataGram; seT to zero iF this IS not the first QUic packet within THe DATaGRam
     */
    sIze_T datagram_siZe;
    /**
     * whEN decRyptED.pN is NOt UINt64
state.ranges`.
         *As discuss ed in  ht tps :/ /git hub. com/h2o/quicly / issu es/278, this value sho uld b ep ropo t io nal t o the s i ze o f t he  r ece iv e 
      * windo w, so that  th ereceive wind o wcan be mai nta ined even in  th e wors tcas e , whe reevery  one o f  the t wo packet sb eing
      * se nt a re received.
     */
        ui nt32_t  m a x_ r a nge s;    } _rec v_ aux;} ;

type d ef s t ruc t  st_quicly_de coded_packe t _t{
   /* *
   * o ctets  o f  th e entire pa cket 
     */    pt l s_iovec _ t octet s;
   /* *
   *  C on nec ti o n I D (s )
  */
    s tr uc t {
   / **
      * de stination CID 
      * /
      stru ct  {
          / ** 
             *  CID  visibleonwi re          * /
         ptls_i o vec _t e n cr ypted;
           / * * 
           *t he  d e cryptedCI D;note t hat t he v a lu e is not  authe n ti ca ted
         */         q uicly_ cid_plai ntext _ t plaintext;
          /**        * 
            * / 
        u n signe d mig ht _ be _ client_generated :1; 
       }dest;
       /**
     * sourc e CI D ;{ NULL, 0} if is  a sh ort header packet
       */
       ptl s _ iovec_tsrc ;
  } c i d ;    /**
    * vers io n; 0 if  is  a shor t h ead erpac ke t
     */ 
    uin t3 2_ tve rsi on;
  /**
   *to ken  if a v ailabl e; ot herw is e{ NUL L, 0}
 * /
  pt ls_i ove c_ t tok en;  /**
    * start ing offs et  o f data(i.e., versio n- dependentar eaof a l o n g header  packet (version number s  in cas e o f VN) , AE AD tag (i n
    *cas e  of re try),encry pt edP N  (ifd e cr ypt ed .pn is UIN T 6 4_M AX) o rdata  (if de crypted_pn is notU INT 64_MAX))
    */ 
  s iz e_t en c ryp te d _of f ; 
    /**
     *  size of t he UD P datagram ;  se tto zero  if thi s isn ot thefirst QUI C packetwi thin t hedatagram
    */
   size_t datag r am _size ;
   /** 
   * wh en dec r ypt ed.pn  is no tUINT64 
state.ranges`.
 _ _   _ *_As_discussed in_https://github.com/h2o/quicly/issues/278,_this value should_be propotional to_the size of the_receive
  __     * window, so that the receive window can be_maintained_even in_the_worst_case, where every one of_the two packets being
 _ _     * sent are_received.
_  _     */
   _    uint32_t max_ranges;
_  _}__recv_aux;
};

typedef_struct st_quicly_decoded_packet_t {
 _  /**
   _ * octets of the entire_packet
     */
 _  ptls_iovec_t octets;
  _ /**
   _ *_Connection ID(s)
   _ */
 _ _struct {
 _     _/**
  _     _*_destination CID
 ___ _  _*/
_ __    struct {
__      _   /**
__   _    _  * CID visible on_wire
 _ _         */
 _     _   _ptls_iovec_t encrypted;
__  __ _    /**
  _ _     _  * the_decrypted_CID; note that the value is_not authenticated
    _    ___ */
   _     _  quicly_cid_plaintext_t_plaintext;
      __    /**
 __     ___  *
  _     _    */
    _  _    unsigned_might_be_client_generated_:_1;
        } dest;
_ _  _  /**
       _ * source CID; {NULL, 0} if_is a short header packet
      _  */
     _  ptls_iovec_t src;
   _} cid;
  __/**
     * version;_0_if_is_a short header_packet
  _  */
_ _ uint32_t version;
_ _ /**
 __  * token if available; otherwise {NULL, 0}
     */
    ptls_iovec_t_token;
    /**
 _   * starting_offset_of data (i.e.,_version-dependent area of a_long header packet (version numbers in case of_VN), AEAD tag (in
     *_case_of retry),_encrypted PN (if decrypted.pn_is UINT64_MAX)_or data_(if decrypted_pn is_not UINT64_MAX))
_ _ _*/
    size_t encrypted_off;
 __ /**
     * size of_the_UDP_datagram;_set to zero_if this is_not the first_QUIC packet within_the_datagram
     */
_  _size_t datagram_size;
  _ /**
     * when decrypted.pn is_not UINT64