mc-core/mc/local_datasource/rrc_sib.pb-c.c

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: rrc_sib.proto */
   3
   4 /* Do not generate deprecated warnings for self */
   5 #ifndef PROTOBUF_C__NO_DEPRECATED
   6 #define PROTOBUF_C__NO_DEPRECATED
   7 #endif
   8
   9 #include "rrc_sib.pb-c.h"
  10 void   streaming_protobufs__sib1__init
  11                      (StreamingProtobufs__SIB1         *message)
  12 {
  13   static const StreamingProtobufs__SIB1 init_value = STREAMING_PROTOBUFS__SIB1__INIT;
  14   *message = init_value;
  15 }
  16 size_t streaming_protobufs__sib1__get_packed_size
  17                      (const StreamingProtobufs__SIB1 *message)
  18 {
  19   assert(message->base.descriptor == &streaming_protobufs__sib1__descriptor);
  20   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21 }
  22 size_t streaming_protobufs__sib1__pack
  23                      (const StreamingProtobufs__SIB1 *message,
  24                       uint8_t       *out)
  25 {
  26   assert(message->base.descriptor == &streaming_protobufs__sib1__descriptor);
  27   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28 }
  29 size_t streaming_protobufs__sib1__pack_to_buffer
  30                      (const StreamingProtobufs__SIB1 *message,
  31                       ProtobufCBuffer *buffer)
  32 {
  33   assert(message->base.descriptor == &streaming_protobufs__sib1__descriptor);
  34   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35 }
  36 StreamingProtobufs__SIB1 *
  37        streaming_protobufs__sib1__unpack
  38                      (ProtobufCAllocator  *allocator,
  39                       size_t               len,
  40                       const uint8_t       *data)
  41 {
  42   return (StreamingProtobufs__SIB1 *)
  43      protobuf_c_message_unpack (&streaming_protobufs__sib1__descriptor,
  44                                 allocator, len, data);
  45 }
  46 void   streaming_protobufs__sib1__free_unpacked
  47                      (StreamingProtobufs__SIB1 *message,
  48                       ProtobufCAllocator *allocator)
  49 {
  50   if(!message)
  51     return;
  52   assert(message->base.descriptor == &streaming_protobufs__sib1__descriptor);
  53   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  54 }
  55 void   streaming_protobufs__sib1_cell_selection_info__init
  56                      (StreamingProtobufs__SIB1CellSelectionInfo         *message)
  57 {
  58   static const StreamingProtobufs__SIB1CellSelectionInfo init_value = STREAMING_PROTOBUFS__SIB1_CELL_SELECTION_INFO__INIT;
  59   *message = init_value;
  60 }
  61 size_t streaming_protobufs__sib1_cell_selection_info__get_packed_size
  62                      (const StreamingProtobufs__SIB1CellSelectionInfo *message)
  63 {
  64   assert(message->base.descriptor == &streaming_protobufs__sib1_cell_selection_info__descriptor);
  65   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  66 }
  67 size_t streaming_protobufs__sib1_cell_selection_info__pack
  68                      (const StreamingProtobufs__SIB1CellSelectionInfo *message,
  69                       uint8_t       *out)
  70 {
  71   assert(message->base.descriptor == &streaming_protobufs__sib1_cell_selection_info__descriptor);
  72   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  73 }
  74 size_t streaming_protobufs__sib1_cell_selection_info__pack_to_buffer
  75                      (const StreamingProtobufs__SIB1CellSelectionInfo *message,
  76                       ProtobufCBuffer *buffer)
  77 {
  78   assert(message->base.descriptor == &streaming_protobufs__sib1_cell_selection_info__descriptor);
  79   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  80 }
  81 StreamingProtobufs__SIB1CellSelectionInfo *
  82        streaming_protobufs__sib1_cell_selection_info__unpack
  83                      (ProtobufCAllocator  *allocator,
  84                       size_t               len,
  85                       const uint8_t       *data)
  86 {
  87   return (StreamingProtobufs__SIB1CellSelectionInfo *)
  88      protobuf_c_message_unpack (&streaming_protobufs__sib1_cell_selection_info__descriptor,
  89                                 allocator, len, data);
  90 }
  91 void   streaming_protobufs__sib1_cell_selection_info__free_unpacked
  92                      (StreamingProtobufs__SIB1CellSelectionInfo *message,
  93                       ProtobufCAllocator *allocator)
  94 {
  95   if(!message)
  96     return;
  97   assert(message->base.descriptor == &streaming_protobufs__sib1_cell_selection_info__descriptor);
  98   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  99 }
 100 void   streaming_protobufs__sib1_uac__barring_info__init
 101                      (StreamingProtobufs__SIB1UACBarringInfo         *message)
 102 {
 103   static const StreamingProtobufs__SIB1UACBarringInfo init_value = STREAMING_PROTOBUFS__SIB1_UAC__BARRING_INFO__INIT;
 104   *message = init_value;
 105 }
 106 size_t streaming_protobufs__sib1_uac__barring_info__get_packed_size
 107                      (const StreamingProtobufs__SIB1UACBarringInfo *message)
 108 {
 109   assert(message->base.descriptor == &streaming_protobufs__sib1_uac__barring_info__descriptor);
 110   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 111 }
 112 size_t streaming_protobufs__sib1_uac__barring_info__pack
 113                      (const StreamingProtobufs__SIB1UACBarringInfo *message,
 114                       uint8_t       *out)
 115 {
 116   assert(message->base.descriptor == &streaming_protobufs__sib1_uac__barring_info__descriptor);
 117   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 118 }
 119 size_t streaming_protobufs__sib1_uac__barring_info__pack_to_buffer
 120                      (const StreamingProtobufs__SIB1UACBarringInfo *message,
 121                       ProtobufCBuffer *buffer)
 122 {
 123   assert(message->base.descriptor == &streaming_protobufs__sib1_uac__barring_info__descriptor);
 124   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 125 }
 126 StreamingProtobufs__SIB1UACBarringInfo *
 127        streaming_protobufs__sib1_uac__barring_info__unpack
 128                      (ProtobufCAllocator  *allocator,
 129                       size_t               len,
 130                       const uint8_t       *data)
 131 {
 132   return (StreamingProtobufs__SIB1UACBarringInfo *)
 133      protobuf_c_message_unpack (&streaming_protobufs__sib1_uac__barring_info__descriptor,
 134                                 allocator, len, data);
 135 }
 136 void   streaming_protobufs__sib1_uac__barring_info__free_unpacked
 137                      (StreamingProtobufs__SIB1UACBarringInfo *message,
 138                       ProtobufCAllocator *allocator)
 139 {
 140   if(!message)
 141     return;
 142   assert(message->base.descriptor == &streaming_protobufs__sib1_uac__barring_info__descriptor);
 143   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 144 }
 145 void   streaming_protobufs__uac__access_category1__selection_assistance_info__init
 146                      (StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo         *message)
 147 {
 148   static const StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo init_value = STREAMING_PROTOBUFS__UAC__ACCESS_CATEGORY1__SELECTION_ASSISTANCE_INFO__INIT;
 149   *message = init_value;
 150 }
 151 size_t streaming_protobufs__uac__access_category1__selection_assistance_info__get_packed_size
 152                      (const StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo *message)
 153 {
 154   assert(message->base.descriptor == &streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor);
 155   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 156 }
 157 size_t streaming_protobufs__uac__access_category1__selection_assistance_info__pack
 158                      (const StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo *message,
 159                       uint8_t       *out)
 160 {
 161   assert(message->base.descriptor == &streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor);
 162   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 163 }
 164 size_t streaming_protobufs__uac__access_category1__selection_assistance_info__pack_to_buffer
 165                      (const StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo *message,
 166                       ProtobufCBuffer *buffer)
 167 {
 168   assert(message->base.descriptor == &streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor);
 169   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 170 }
 171 StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo *
 172        streaming_protobufs__uac__access_category1__selection_assistance_info__unpack
 173                      (ProtobufCAllocator  *allocator,
 174                       size_t               len,
 175                       const uint8_t       *data)
 176 {
 177   return (StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo *)
 178      protobuf_c_message_unpack (&streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor,
 179                                 allocator, len, data);
 180 }
 181 void   streaming_protobufs__uac__access_category1__selection_assistance_info__free_unpacked
 182                      (StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo *message,
 183                       ProtobufCAllocator *allocator)
 184 {
 185   if(!message)
 186     return;
 187   assert(message->base.descriptor == &streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor);
 188   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 189 }
 190 void   streaming_protobufs__individual_plmnlist__init
 191                      (StreamingProtobufs__IndividualPLMNList         *message)
 192 {
 193   static const StreamingProtobufs__IndividualPLMNList init_value = STREAMING_PROTOBUFS__INDIVIDUAL_PLMNLIST__INIT;
 194   *message = init_value;
 195 }
 196 size_t streaming_protobufs__individual_plmnlist__get_packed_size
 197                      (const StreamingProtobufs__IndividualPLMNList *message)
 198 {
 199   assert(message->base.descriptor == &streaming_protobufs__individual_plmnlist__descriptor);
 200   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 201 }
 202 size_t streaming_protobufs__individual_plmnlist__pack
 203                      (const StreamingProtobufs__IndividualPLMNList *message,
 204                       uint8_t       *out)
 205 {
 206   assert(message->base.descriptor == &streaming_protobufs__individual_plmnlist__descriptor);
 207   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 208 }
 209 size_t streaming_protobufs__individual_plmnlist__pack_to_buffer
 210                      (const StreamingProtobufs__IndividualPLMNList *message,
 211                       ProtobufCBuffer *buffer)
 212 {
 213   assert(message->base.descriptor == &streaming_protobufs__individual_plmnlist__descriptor);
 214   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 215 }
 216 StreamingProtobufs__IndividualPLMNList *
 217        streaming_protobufs__individual_plmnlist__unpack
 218                      (ProtobufCAllocator  *allocator,
 219                       size_t               len,
 220                       const uint8_t       *data)
 221 {
 222   return (StreamingProtobufs__IndividualPLMNList *)
 223      protobuf_c_message_unpack (&streaming_protobufs__individual_plmnlist__descriptor,
 224                                 allocator, len, data);
 225 }
 226 void   streaming_protobufs__individual_plmnlist__free_unpacked
 227                      (StreamingProtobufs__IndividualPLMNList *message,
 228                       ProtobufCAllocator *allocator)
 229 {
 230   if(!message)
 231     return;
 232   assert(message->base.descriptor == &streaming_protobufs__individual_plmnlist__descriptor);
 233   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 234 }
 235 void   streaming_protobufs__sib2__init
 236                      (StreamingProtobufs__SIB2         *message)
 237 {
 238   static const StreamingProtobufs__SIB2 init_value = STREAMING_PROTOBUFS__SIB2__INIT;
 239   *message = init_value;
 240 }
 241 size_t streaming_protobufs__sib2__get_packed_size
 242                      (const StreamingProtobufs__SIB2 *message)
 243 {
 244   assert(message->base.descriptor == &streaming_protobufs__sib2__descriptor);
 245   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 246 }
 247 size_t streaming_protobufs__sib2__pack
 248                      (const StreamingProtobufs__SIB2 *message,
 249                       uint8_t       *out)
 250 {
 251   assert(message->base.descriptor == &streaming_protobufs__sib2__descriptor);
 252   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 253 }
 254 size_t streaming_protobufs__sib2__pack_to_buffer
 255                      (const StreamingProtobufs__SIB2 *message,
 256                       ProtobufCBuffer *buffer)
 257 {
 258   assert(message->base.descriptor == &streaming_protobufs__sib2__descriptor);
 259   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 260 }
 261 StreamingProtobufs__SIB2 *
 262        streaming_protobufs__sib2__unpack
 263                      (ProtobufCAllocator  *allocator,
 264                       size_t               len,
 265                       const uint8_t       *data)
 266 {
 267   return (StreamingProtobufs__SIB2 *)
 268      protobuf_c_message_unpack (&streaming_protobufs__sib2__descriptor,
 269                                 allocator, len, data);
 270 }
 271 void   streaming_protobufs__sib2__free_unpacked
 272                      (StreamingProtobufs__SIB2 *message,
 273                       ProtobufCAllocator *allocator)
 274 {
 275   if(!message)
 276     return;
 277   assert(message->base.descriptor == &streaming_protobufs__sib2__descriptor);
 278   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 279 }
 280 void   streaming_protobufs__sib2_cell_reselection_info_common__init
 281                      (StreamingProtobufs__SIB2CellReselectionInfoCommon         *message)
 282 {
 283   static const StreamingProtobufs__SIB2CellReselectionInfoCommon init_value = STREAMING_PROTOBUFS__SIB2_CELL_RESELECTION_INFO_COMMON__INIT;
 284   *message = init_value;
 285 }
 286 size_t streaming_protobufs__sib2_cell_reselection_info_common__get_packed_size
 287                      (const StreamingProtobufs__SIB2CellReselectionInfoCommon *message)
 288 {
 289   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_info_common__descriptor);
 290   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 291 }
 292 size_t streaming_protobufs__sib2_cell_reselection_info_common__pack
 293                      (const StreamingProtobufs__SIB2CellReselectionInfoCommon *message,
 294                       uint8_t       *out)
 295 {
 296   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_info_common__descriptor);
 297   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 298 }
 299 size_t streaming_protobufs__sib2_cell_reselection_info_common__pack_to_buffer
 300                      (const StreamingProtobufs__SIB2CellReselectionInfoCommon *message,
 301                       ProtobufCBuffer *buffer)
 302 {
 303   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_info_common__descriptor);
 304   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 305 }
 306 StreamingProtobufs__SIB2CellReselectionInfoCommon *
 307        streaming_protobufs__sib2_cell_reselection_info_common__unpack
 308                      (ProtobufCAllocator  *allocator,
 309                       size_t               len,
 310                       const uint8_t       *data)
 311 {
 312   return (StreamingProtobufs__SIB2CellReselectionInfoCommon *)
 313      protobuf_c_message_unpack (&streaming_protobufs__sib2_cell_reselection_info_common__descriptor,
 314                                 allocator, len, data);
 315 }
 316 void   streaming_protobufs__sib2_cell_reselection_info_common__free_unpacked
 317                      (StreamingProtobufs__SIB2CellReselectionInfoCommon *message,
 318                       ProtobufCAllocator *allocator)
 319 {
 320   if(!message)
 321     return;
 322   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_info_common__descriptor);
 323   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 324 }
 325 void   streaming_protobufs__q__hyst__init
 326                      (StreamingProtobufs__QHyst         *message)
 327 {
 328   static const StreamingProtobufs__QHyst init_value = STREAMING_PROTOBUFS__Q__HYST__INIT;
 329   *message = init_value;
 330 }
 331 size_t streaming_protobufs__q__hyst__get_packed_size
 332                      (const StreamingProtobufs__QHyst *message)
 333 {
 334   assert(message->base.descriptor == &streaming_protobufs__q__hyst__descriptor);
 335   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 336 }
 337 size_t streaming_protobufs__q__hyst__pack
 338                      (const StreamingProtobufs__QHyst *message,
 339                       uint8_t       *out)
 340 {
 341   assert(message->base.descriptor == &streaming_protobufs__q__hyst__descriptor);
 342   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 343 }
 344 size_t streaming_protobufs__q__hyst__pack_to_buffer
 345                      (const StreamingProtobufs__QHyst *message,
 346                       ProtobufCBuffer *buffer)
 347 {
 348   assert(message->base.descriptor == &streaming_protobufs__q__hyst__descriptor);
 349   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 350 }
 351 StreamingProtobufs__QHyst *
 352        streaming_protobufs__q__hyst__unpack
 353                      (ProtobufCAllocator  *allocator,
 354                       size_t               len,
 355                       const uint8_t       *data)
 356 {
 357   return (StreamingProtobufs__QHyst *)
 358      protobuf_c_message_unpack (&streaming_protobufs__q__hyst__descriptor,
 359                                 allocator, len, data);
 360 }
 361 void   streaming_protobufs__q__hyst__free_unpacked
 362                      (StreamingProtobufs__QHyst *message,
 363                       ProtobufCAllocator *allocator)
 364 {
 365   if(!message)
 366     return;
 367   assert(message->base.descriptor == &streaming_protobufs__q__hyst__descriptor);
 368   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 369 }
 370 void   streaming_protobufs__speed_state_reselection_pars__init
 371                      (StreamingProtobufs__SpeedStateReselectionPars         *message)
 372 {
 373   static const StreamingProtobufs__SpeedStateReselectionPars init_value = STREAMING_PROTOBUFS__SPEED_STATE_RESELECTION_PARS__INIT;
 374   *message = init_value;
 375 }
 376 size_t streaming_protobufs__speed_state_reselection_pars__get_packed_size
 377                      (const StreamingProtobufs__SpeedStateReselectionPars *message)
 378 {
 379   assert(message->base.descriptor == &streaming_protobufs__speed_state_reselection_pars__descriptor);
 380   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 381 }
 382 size_t streaming_protobufs__speed_state_reselection_pars__pack
 383                      (const StreamingProtobufs__SpeedStateReselectionPars *message,
 384                       uint8_t       *out)
 385 {
 386   assert(message->base.descriptor == &streaming_protobufs__speed_state_reselection_pars__descriptor);
 387   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 388 }
 389 size_t streaming_protobufs__speed_state_reselection_pars__pack_to_buffer
 390                      (const StreamingProtobufs__SpeedStateReselectionPars *message,
 391                       ProtobufCBuffer *buffer)
 392 {
 393   assert(message->base.descriptor == &streaming_protobufs__speed_state_reselection_pars__descriptor);
 394   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 395 }
 396 StreamingProtobufs__SpeedStateReselectionPars *
 397        streaming_protobufs__speed_state_reselection_pars__unpack
 398                      (ProtobufCAllocator  *allocator,
 399                       size_t               len,
 400                       const uint8_t       *data)
 401 {
 402   return (StreamingProtobufs__SpeedStateReselectionPars *)
 403      protobuf_c_message_unpack (&streaming_protobufs__speed_state_reselection_pars__descriptor,
 404                                 allocator, len, data);
 405 }
 406 void   streaming_protobufs__speed_state_reselection_pars__free_unpacked
 407                      (StreamingProtobufs__SpeedStateReselectionPars *message,
 408                       ProtobufCAllocator *allocator)
 409 {
 410   if(!message)
 411     return;
 412   assert(message->base.descriptor == &streaming_protobufs__speed_state_reselection_pars__descriptor);
 413   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 414 }
 415 void   streaming_protobufs__q__hyst_sf__init
 416                      (StreamingProtobufs__QHystSF         *message)
 417 {
 418   static const StreamingProtobufs__QHystSF init_value = STREAMING_PROTOBUFS__Q__HYST_SF__INIT;
 419   *message = init_value;
 420 }
 421 size_t streaming_protobufs__q__hyst_sf__get_packed_size
 422                      (const StreamingProtobufs__QHystSF *message)
 423 {
 424   assert(message->base.descriptor == &streaming_protobufs__q__hyst_sf__descriptor);
 425   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 426 }
 427 size_t streaming_protobufs__q__hyst_sf__pack
 428                      (const StreamingProtobufs__QHystSF *message,
 429                       uint8_t       *out)
 430 {
 431   assert(message->base.descriptor == &streaming_protobufs__q__hyst_sf__descriptor);
 432   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 433 }
 434 size_t streaming_protobufs__q__hyst_sf__pack_to_buffer
 435                      (const StreamingProtobufs__QHystSF *message,
 436                       ProtobufCBuffer *buffer)
 437 {
 438   assert(message->base.descriptor == &streaming_protobufs__q__hyst_sf__descriptor);
 439   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 440 }
 441 StreamingProtobufs__QHystSF *
 442        streaming_protobufs__q__hyst_sf__unpack
 443                      (ProtobufCAllocator  *allocator,
 444                       size_t               len,
 445                       const uint8_t       *data)
 446 {
 447   return (StreamingProtobufs__QHystSF *)
 448      protobuf_c_message_unpack (&streaming_protobufs__q__hyst_sf__descriptor,
 449                                 allocator, len, data);
 450 }
 451 void   streaming_protobufs__q__hyst_sf__free_unpacked
 452                      (StreamingProtobufs__QHystSF *message,
 453                       ProtobufCAllocator *allocator)
 454 {
 455   if(!message)
 456     return;
 457   assert(message->base.descriptor == &streaming_protobufs__q__hyst_sf__descriptor);
 458   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 459 }
 460 void   streaming_protobufs__sf__medium__high__init
 461                      (StreamingProtobufs__SFMediumHigh         *message)
 462 {
 463   static const StreamingProtobufs__SFMediumHigh init_value = STREAMING_PROTOBUFS__SF__MEDIUM__HIGH__INIT;
 464   *message = init_value;
 465 }
 466 size_t streaming_protobufs__sf__medium__high__get_packed_size
 467                      (const StreamingProtobufs__SFMediumHigh *message)
 468 {
 469   assert(message->base.descriptor == &streaming_protobufs__sf__medium__high__descriptor);
 470   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 471 }
 472 size_t streaming_protobufs__sf__medium__high__pack
 473                      (const StreamingProtobufs__SFMediumHigh *message,
 474                       uint8_t       *out)
 475 {
 476   assert(message->base.descriptor == &streaming_protobufs__sf__medium__high__descriptor);
 477   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 478 }
 479 size_t streaming_protobufs__sf__medium__high__pack_to_buffer
 480                      (const StreamingProtobufs__SFMediumHigh *message,
 481                       ProtobufCBuffer *buffer)
 482 {
 483   assert(message->base.descriptor == &streaming_protobufs__sf__medium__high__descriptor);
 484   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 485 }
 486 StreamingProtobufs__SFMediumHigh *
 487        streaming_protobufs__sf__medium__high__unpack
 488                      (ProtobufCAllocator  *allocator,
 489                       size_t               len,
 490                       const uint8_t       *data)
 491 {
 492   return (StreamingProtobufs__SFMediumHigh *)
 493      protobuf_c_message_unpack (&streaming_protobufs__sf__medium__high__descriptor,
 494                                 allocator, len, data);
 495 }
 496 void   streaming_protobufs__sf__medium__high__free_unpacked
 497                      (StreamingProtobufs__SFMediumHigh *message,
 498                       ProtobufCAllocator *allocator)
 499 {
 500   if(!message)
 501     return;
 502   assert(message->base.descriptor == &streaming_protobufs__sf__medium__high__descriptor);
 503   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 504 }
 505 void   streaming_protobufs__sib2_cell_reselection_serving_freq_info__init
 506                      (StreamingProtobufs__SIB2CellReselectionServingFreqInfo         *message)
 507 {
 508   static const StreamingProtobufs__SIB2CellReselectionServingFreqInfo init_value = STREAMING_PROTOBUFS__SIB2_CELL_RESELECTION_SERVING_FREQ_INFO__INIT;
 509   *message = init_value;
 510 }
 511 size_t streaming_protobufs__sib2_cell_reselection_serving_freq_info__get_packed_size
 512                      (const StreamingProtobufs__SIB2CellReselectionServingFreqInfo *message)
 513 {
 514   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor);
 515   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 516 }
 517 size_t streaming_protobufs__sib2_cell_reselection_serving_freq_info__pack
 518                      (const StreamingProtobufs__SIB2CellReselectionServingFreqInfo *message,
 519                       uint8_t       *out)
 520 {
 521   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor);
 522   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 523 }
 524 size_t streaming_protobufs__sib2_cell_reselection_serving_freq_info__pack_to_buffer
 525                      (const StreamingProtobufs__SIB2CellReselectionServingFreqInfo *message,
 526                       ProtobufCBuffer *buffer)
 527 {
 528   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor);
 529   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 530 }
 531 StreamingProtobufs__SIB2CellReselectionServingFreqInfo *
 532        streaming_protobufs__sib2_cell_reselection_serving_freq_info__unpack
 533                      (ProtobufCAllocator  *allocator,
 534                       size_t               len,
 535                       const uint8_t       *data)
 536 {
 537   return (StreamingProtobufs__SIB2CellReselectionServingFreqInfo *)
 538      protobuf_c_message_unpack (&streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor,
 539                                 allocator, len, data);
 540 }
 541 void   streaming_protobufs__sib2_cell_reselection_serving_freq_info__free_unpacked
 542                      (StreamingProtobufs__SIB2CellReselectionServingFreqInfo *message,
 543                       ProtobufCAllocator *allocator)
 544 {
 545   if(!message)
 546     return;
 547   assert(message->base.descriptor == &streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor);
 548   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 549 }
 550 void   streaming_protobufs__cell_reselection_sub_priority__init
 551                      (StreamingProtobufs__CellReselectionSubPriority         *message)
 552 {
 553   static const StreamingProtobufs__CellReselectionSubPriority init_value = STREAMING_PROTOBUFS__CELL_RESELECTION_SUB_PRIORITY__INIT;
 554   *message = init_value;
 555 }
 556 size_t streaming_protobufs__cell_reselection_sub_priority__get_packed_size
 557                      (const StreamingProtobufs__CellReselectionSubPriority *message)
 558 {
 559   assert(message->base.descriptor == &streaming_protobufs__cell_reselection_sub_priority__descriptor);
 560   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 561 }
 562 size_t streaming_protobufs__cell_reselection_sub_priority__pack
 563                      (const StreamingProtobufs__CellReselectionSubPriority *message,
 564                       uint8_t       *out)
 565 {
 566   assert(message->base.descriptor == &streaming_protobufs__cell_reselection_sub_priority__descriptor);
 567   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 568 }
 569 size_t streaming_protobufs__cell_reselection_sub_priority__pack_to_buffer
 570                      (const StreamingProtobufs__CellReselectionSubPriority *message,
 571                       ProtobufCBuffer *buffer)
 572 {
 573   assert(message->base.descriptor == &streaming_protobufs__cell_reselection_sub_priority__descriptor);
 574   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 575 }
 576 StreamingProtobufs__CellReselectionSubPriority *
 577        streaming_protobufs__cell_reselection_sub_priority__unpack
 578                      (ProtobufCAllocator  *allocator,
 579                       size_t               len,
 580                       const uint8_t       *data)
 581 {
 582   return (StreamingProtobufs__CellReselectionSubPriority *)
 583      protobuf_c_message_unpack (&streaming_protobufs__cell_reselection_sub_priority__descriptor,
 584                                 allocator, len, data);
 585 }
 586 void   streaming_protobufs__cell_reselection_sub_priority__free_unpacked
 587                      (StreamingProtobufs__CellReselectionSubPriority *message,
 588                       ProtobufCAllocator *allocator)
 589 {
 590   if(!message)
 591     return;
 592   assert(message->base.descriptor == &streaming_protobufs__cell_reselection_sub_priority__descriptor);
 593   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 594 }
 595 void   streaming_protobufs__sib2_intra_freq_cell_reselection_info__init
 596                      (StreamingProtobufs__SIB2IntraFreqCellReselectionInfo         *message)
 597 {
 598   static const StreamingProtobufs__SIB2IntraFreqCellReselectionInfo init_value = STREAMING_PROTOBUFS__SIB2_INTRA_FREQ_CELL_RESELECTION_INFO__INIT;
 599   *message = init_value;
 600 }
 601 size_t streaming_protobufs__sib2_intra_freq_cell_reselection_info__get_packed_size
 602                      (const StreamingProtobufs__SIB2IntraFreqCellReselectionInfo *message)
 603 {
 604   assert(message->base.descriptor == &streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor);
 605   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 606 }
 607 size_t streaming_protobufs__sib2_intra_freq_cell_reselection_info__pack
 608                      (const StreamingProtobufs__SIB2IntraFreqCellReselectionInfo *message,
 609                       uint8_t       *out)
 610 {
 611   assert(message->base.descriptor == &streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor);
 612   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 613 }
 614 size_t streaming_protobufs__sib2_intra_freq_cell_reselection_info__pack_to_buffer
 615                      (const StreamingProtobufs__SIB2IntraFreqCellReselectionInfo *message,
 616                       ProtobufCBuffer *buffer)
 617 {
 618   assert(message->base.descriptor == &streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor);
 619   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 620 }
 621 StreamingProtobufs__SIB2IntraFreqCellReselectionInfo *
 622        streaming_protobufs__sib2_intra_freq_cell_reselection_info__unpack
 623                      (ProtobufCAllocator  *allocator,
 624                       size_t               len,
 625                       const uint8_t       *data)
 626 {
 627   return (StreamingProtobufs__SIB2IntraFreqCellReselectionInfo *)
 628      protobuf_c_message_unpack (&streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor,
 629                                 allocator, len, data);
 630 }
 631 void   streaming_protobufs__sib2_intra_freq_cell_reselection_info__free_unpacked
 632                      (StreamingProtobufs__SIB2IntraFreqCellReselectionInfo *message,
 633                       ProtobufCAllocator *allocator)
 634 {
 635   if(!message)
 636     return;
 637   assert(message->base.descriptor == &streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor);
 638   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 639 }
 640 void   streaming_protobufs__speed_state_scale_factors__init
 641                      (StreamingProtobufs__SpeedStateScaleFactors         *message)
 642 {
 643   static const StreamingProtobufs__SpeedStateScaleFactors init_value = STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS__INIT;
 644   *message = init_value;
 645 }
 646 size_t streaming_protobufs__speed_state_scale_factors__get_packed_size
 647                      (const StreamingProtobufs__SpeedStateScaleFactors *message)
 648 {
 649   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors__descriptor);
 650   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 651 }
 652 size_t streaming_protobufs__speed_state_scale_factors__pack
 653                      (const StreamingProtobufs__SpeedStateScaleFactors *message,
 654                       uint8_t       *out)
 655 {
 656   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors__descriptor);
 657   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 658 }
 659 size_t streaming_protobufs__speed_state_scale_factors__pack_to_buffer
 660                      (const StreamingProtobufs__SpeedStateScaleFactors *message,
 661                       ProtobufCBuffer *buffer)
 662 {
 663   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors__descriptor);
 664   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 665 }
 666 StreamingProtobufs__SpeedStateScaleFactors *
 667        streaming_protobufs__speed_state_scale_factors__unpack
 668                      (ProtobufCAllocator  *allocator,
 669                       size_t               len,
 670                       const uint8_t       *data)
 671 {
 672   return (StreamingProtobufs__SpeedStateScaleFactors *)
 673      protobuf_c_message_unpack (&streaming_protobufs__speed_state_scale_factors__descriptor,
 674                                 allocator, len, data);
 675 }
 676 void   streaming_protobufs__speed_state_scale_factors__free_unpacked
 677                      (StreamingProtobufs__SpeedStateScaleFactors *message,
 678                       ProtobufCAllocator *allocator)
 679 {
 680   if(!message)
 681     return;
 682   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors__descriptor);
 683   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 684 }
 685 void   streaming_protobufs__speed_state_scale_factors_sf__medium__high__init
 686                      (StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh         *message)
 687 {
 688   static const StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh init_value = STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS_SF__MEDIUM__HIGH__INIT;
 689   *message = init_value;
 690 }
 691 size_t streaming_protobufs__speed_state_scale_factors_sf__medium__high__get_packed_size
 692                      (const StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh *message)
 693 {
 694   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor);
 695   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 696 }
 697 size_t streaming_protobufs__speed_state_scale_factors_sf__medium__high__pack
 698                      (const StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh *message,
 699                       uint8_t       *out)
 700 {
 701   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor);
 702   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 703 }
 704 size_t streaming_protobufs__speed_state_scale_factors_sf__medium__high__pack_to_buffer
 705                      (const StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh *message,
 706                       ProtobufCBuffer *buffer)
 707 {
 708   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor);
 709   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 710 }
 711 StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh *
 712        streaming_protobufs__speed_state_scale_factors_sf__medium__high__unpack
 713                      (ProtobufCAllocator  *allocator,
 714                       size_t               len,
 715                       const uint8_t       *data)
 716 {
 717   return (StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh *)
 718      protobuf_c_message_unpack (&streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor,
 719                                 allocator, len, data);
 720 }
 721 void   streaming_protobufs__speed_state_scale_factors_sf__medium__high__free_unpacked
 722                      (StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh *message,
 723                       ProtobufCAllocator *allocator)
 724 {
 725   if(!message)
 726     return;
 727   assert(message->base.descriptor == &streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor);
 728   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 729 }
 730 void   streaming_protobufs__sib3__init
 731                      (StreamingProtobufs__SIB3         *message)
 732 {
 733   static const StreamingProtobufs__SIB3 init_value = STREAMING_PROTOBUFS__SIB3__INIT;
 734   *message = init_value;
 735 }
 736 size_t streaming_protobufs__sib3__get_packed_size
 737                      (const StreamingProtobufs__SIB3 *message)
 738 {
 739   assert(message->base.descriptor == &streaming_protobufs__sib3__descriptor);
 740   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 741 }
 742 size_t streaming_protobufs__sib3__pack
 743                      (const StreamingProtobufs__SIB3 *message,
 744                       uint8_t       *out)
 745 {
 746   assert(message->base.descriptor == &streaming_protobufs__sib3__descriptor);
 747   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 748 }
 749 size_t streaming_protobufs__sib3__pack_to_buffer
 750                      (const StreamingProtobufs__SIB3 *message,
 751                       ProtobufCBuffer *buffer)
 752 {
 753   assert(message->base.descriptor == &streaming_protobufs__sib3__descriptor);
 754   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 755 }
 756 StreamingProtobufs__SIB3 *
 757        streaming_protobufs__sib3__unpack
 758                      (ProtobufCAllocator  *allocator,
 759                       size_t               len,
 760                       const uint8_t       *data)
 761 {
 762   return (StreamingProtobufs__SIB3 *)
 763      protobuf_c_message_unpack (&streaming_protobufs__sib3__descriptor,
 764                                 allocator, len, data);
 765 }
 766 void   streaming_protobufs__sib3__free_unpacked
 767                      (StreamingProtobufs__SIB3 *message,
 768                       ProtobufCAllocator *allocator)
 769 {
 770   if(!message)
 771     return;
 772   assert(message->base.descriptor == &streaming_protobufs__sib3__descriptor);
 773   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 774 }
 775 void   streaming_protobufs__intra_freq_neigh_cell_list__init
 776                      (StreamingProtobufs__IntraFreqNeighCellList         *message)
 777 {
 778   static const StreamingProtobufs__IntraFreqNeighCellList init_value = STREAMING_PROTOBUFS__INTRA_FREQ_NEIGH_CELL_LIST__INIT;
 779   *message = init_value;
 780 }
 781 size_t streaming_protobufs__intra_freq_neigh_cell_list__get_packed_size
 782                      (const StreamingProtobufs__IntraFreqNeighCellList *message)
 783 {
 784   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_list__descriptor);
 785   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 786 }
 787 size_t streaming_protobufs__intra_freq_neigh_cell_list__pack
 788                      (const StreamingProtobufs__IntraFreqNeighCellList *message,
 789                       uint8_t       *out)
 790 {
 791   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_list__descriptor);
 792   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 793 }
 794 size_t streaming_protobufs__intra_freq_neigh_cell_list__pack_to_buffer
 795                      (const StreamingProtobufs__IntraFreqNeighCellList *message,
 796                       ProtobufCBuffer *buffer)
 797 {
 798   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_list__descriptor);
 799   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 800 }
 801 StreamingProtobufs__IntraFreqNeighCellList *
 802        streaming_protobufs__intra_freq_neigh_cell_list__unpack
 803                      (ProtobufCAllocator  *allocator,
 804                       size_t               len,
 805                       const uint8_t       *data)
 806 {
 807   return (StreamingProtobufs__IntraFreqNeighCellList *)
 808      protobuf_c_message_unpack (&streaming_protobufs__intra_freq_neigh_cell_list__descriptor,
 809                                 allocator, len, data);
 810 }
 811 void   streaming_protobufs__intra_freq_neigh_cell_list__free_unpacked
 812                      (StreamingProtobufs__IntraFreqNeighCellList *message,
 813                       ProtobufCAllocator *allocator)
 814 {
 815   if(!message)
 816     return;
 817   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_list__descriptor);
 818   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 819 }
 820 void   streaming_protobufs__intra_freq_neigh_cell_info__init
 821                      (StreamingProtobufs__IntraFreqNeighCellInfo         *message)
 822 {
 823   static const StreamingProtobufs__IntraFreqNeighCellInfo init_value = STREAMING_PROTOBUFS__INTRA_FREQ_NEIGH_CELL_INFO__INIT;
 824   *message = init_value;
 825 }
 826 size_t streaming_protobufs__intra_freq_neigh_cell_info__get_packed_size
 827                      (const StreamingProtobufs__IntraFreqNeighCellInfo *message)
 828 {
 829   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_info__descriptor);
 830   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 831 }
 832 size_t streaming_protobufs__intra_freq_neigh_cell_info__pack
 833                      (const StreamingProtobufs__IntraFreqNeighCellInfo *message,
 834                       uint8_t       *out)
 835 {
 836   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_info__descriptor);
 837   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 838 }
 839 size_t streaming_protobufs__intra_freq_neigh_cell_info__pack_to_buffer
 840                      (const StreamingProtobufs__IntraFreqNeighCellInfo *message,
 841                       ProtobufCBuffer *buffer)
 842 {
 843   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_info__descriptor);
 844   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 845 }
 846 StreamingProtobufs__IntraFreqNeighCellInfo *
 847        streaming_protobufs__intra_freq_neigh_cell_info__unpack
 848                      (ProtobufCAllocator  *allocator,
 849                       size_t               len,
 850                       const uint8_t       *data)
 851 {
 852   return (StreamingProtobufs__IntraFreqNeighCellInfo *)
 853      protobuf_c_message_unpack (&streaming_protobufs__intra_freq_neigh_cell_info__descriptor,
 854                                 allocator, len, data);
 855 }
 856 void   streaming_protobufs__intra_freq_neigh_cell_info__free_unpacked
 857                      (StreamingProtobufs__IntraFreqNeighCellInfo *message,
 858                       ProtobufCAllocator *allocator)
 859 {
 860   if(!message)
 861     return;
 862   assert(message->base.descriptor == &streaming_protobufs__intra_freq_neigh_cell_info__descriptor);
 863   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 864 }
 865 void   streaming_protobufs__intra_freq_black_cell_list__init
 866                      (StreamingProtobufs__IntraFreqBlackCellList         *message)
 867 {
 868   static const StreamingProtobufs__IntraFreqBlackCellList init_value = STREAMING_PROTOBUFS__INTRA_FREQ_BLACK_CELL_LIST__INIT;
 869   *message = init_value;
 870 }
 871 size_t streaming_protobufs__intra_freq_black_cell_list__get_packed_size
 872                      (const StreamingProtobufs__IntraFreqBlackCellList *message)
 873 {
 874   assert(message->base.descriptor == &streaming_protobufs__intra_freq_black_cell_list__descriptor);
 875   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 876 }
 877 size_t streaming_protobufs__intra_freq_black_cell_list__pack
 878                      (const StreamingProtobufs__IntraFreqBlackCellList *message,
 879                       uint8_t       *out)
 880 {
 881   assert(message->base.descriptor == &streaming_protobufs__intra_freq_black_cell_list__descriptor);
 882   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 883 }
 884 size_t streaming_protobufs__intra_freq_black_cell_list__pack_to_buffer
 885                      (const StreamingProtobufs__IntraFreqBlackCellList *message,
 886                       ProtobufCBuffer *buffer)
 887 {
 888   assert(message->base.descriptor == &streaming_protobufs__intra_freq_black_cell_list__descriptor);
 889   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 890 }
 891 StreamingProtobufs__IntraFreqBlackCellList *
 892        streaming_protobufs__intra_freq_black_cell_list__unpack
 893                      (ProtobufCAllocator  *allocator,
 894                       size_t               len,
 895                       const uint8_t       *data)
 896 {
 897   return (StreamingProtobufs__IntraFreqBlackCellList *)
 898      protobuf_c_message_unpack (&streaming_protobufs__intra_freq_black_cell_list__descriptor,
 899                                 allocator, len, data);
 900 }
 901 void   streaming_protobufs__intra_freq_black_cell_list__free_unpacked
 902                      (StreamingProtobufs__IntraFreqBlackCellList *message,
 903                       ProtobufCAllocator *allocator)
 904 {
 905   if(!message)
 906     return;
 907   assert(message->base.descriptor == &streaming_protobufs__intra_freq_black_cell_list__descriptor);
 908   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 909 }
 910 void   streaming_protobufs__sib4__init
 911                      (StreamingProtobufs__SIB4         *message)
 912 {
 913   static const StreamingProtobufs__SIB4 init_value = STREAMING_PROTOBUFS__SIB4__INIT;
 914   *message = init_value;
 915 }
 916 size_t streaming_protobufs__sib4__get_packed_size
 917                      (const StreamingProtobufs__SIB4 *message)
 918 {
 919   assert(message->base.descriptor == &streaming_protobufs__sib4__descriptor);
 920   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 921 }
 922 size_t streaming_protobufs__sib4__pack
 923                      (const StreamingProtobufs__SIB4 *message,
 924                       uint8_t       *out)
 925 {
 926   assert(message->base.descriptor == &streaming_protobufs__sib4__descriptor);
 927   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 928 }
 929 size_t streaming_protobufs__sib4__pack_to_buffer
 930                      (const StreamingProtobufs__SIB4 *message,
 931                       ProtobufCBuffer *buffer)
 932 {
 933   assert(message->base.descriptor == &streaming_protobufs__sib4__descriptor);
 934   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 935 }
 936 StreamingProtobufs__SIB4 *
 937        streaming_protobufs__sib4__unpack
 938                      (ProtobufCAllocator  *allocator,
 939                       size_t               len,
 940                       const uint8_t       *data)
 941 {
 942   return (StreamingProtobufs__SIB4 *)
 943      protobuf_c_message_unpack (&streaming_protobufs__sib4__descriptor,
 944                                 allocator, len, data);
 945 }
 946 void   streaming_protobufs__sib4__free_unpacked
 947                      (StreamingProtobufs__SIB4 *message,
 948                       ProtobufCAllocator *allocator)
 949 {
 950   if(!message)
 951     return;
 952   assert(message->base.descriptor == &streaming_protobufs__sib4__descriptor);
 953   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 954 }
 955 void   streaming_protobufs__inter_freq_carrier_freq_list__init
 956                      (StreamingProtobufs__InterFreqCarrierFreqList         *message)
 957 {
 958   static const StreamingProtobufs__InterFreqCarrierFreqList init_value = STREAMING_PROTOBUFS__INTER_FREQ_CARRIER_FREQ_LIST__INIT;
 959   *message = init_value;
 960 }
 961 size_t streaming_protobufs__inter_freq_carrier_freq_list__get_packed_size
 962                      (const StreamingProtobufs__InterFreqCarrierFreqList *message)
 963 {
 964   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_list__descriptor);
 965   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 966 }
 967 size_t streaming_protobufs__inter_freq_carrier_freq_list__pack
 968                      (const StreamingProtobufs__InterFreqCarrierFreqList *message,
 969                       uint8_t       *out)
 970 {
 971   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_list__descriptor);
 972   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 973 }
 974 size_t streaming_protobufs__inter_freq_carrier_freq_list__pack_to_buffer
 975                      (const StreamingProtobufs__InterFreqCarrierFreqList *message,
 976                       ProtobufCBuffer *buffer)
 977 {
 978   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_list__descriptor);
 979   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 980 }
 981 StreamingProtobufs__InterFreqCarrierFreqList *
 982        streaming_protobufs__inter_freq_carrier_freq_list__unpack
 983                      (ProtobufCAllocator  *allocator,
 984                       size_t               len,
 985                       const uint8_t       *data)
 986 {
 987   return (StreamingProtobufs__InterFreqCarrierFreqList *)
 988      protobuf_c_message_unpack (&streaming_protobufs__inter_freq_carrier_freq_list__descriptor,
 989                                 allocator, len, data);
 990 }
 991 void   streaming_protobufs__inter_freq_carrier_freq_list__free_unpacked
 992                      (StreamingProtobufs__InterFreqCarrierFreqList *message,
 993                       ProtobufCAllocator *allocator)
 994 {
 995   if(!message)
 996     return;
 997   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_list__descriptor);
 998   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 999 }
1000 void   streaming_protobufs__inter_freq_carrier_freq_info__init
1001                      (StreamingProtobufs__InterFreqCarrierFreqInfo         *message)
1002 {
1003   static const StreamingProtobufs__InterFreqCarrierFreqInfo init_value = STREAMING_PROTOBUFS__INTER_FREQ_CARRIER_FREQ_INFO__INIT;
1004   *message = init_value;
1005 }
1006 size_t streaming_protobufs__inter_freq_carrier_freq_info__get_packed_size
1007                      (const StreamingProtobufs__InterFreqCarrierFreqInfo *message)
1008 {
1009   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info__descriptor);
1010   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1011 }
1012 size_t streaming_protobufs__inter_freq_carrier_freq_info__pack
1013                      (const StreamingProtobufs__InterFreqCarrierFreqInfo *message,
1014                       uint8_t       *out)
1015 {
1016   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info__descriptor);
1017   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1018 }
1019 size_t streaming_protobufs__inter_freq_carrier_freq_info__pack_to_buffer
1020                      (const StreamingProtobufs__InterFreqCarrierFreqInfo *message,
1021                       ProtobufCBuffer *buffer)
1022 {
1023   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info__descriptor);
1024   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1025 }
1026 StreamingProtobufs__InterFreqCarrierFreqInfo *
1027        streaming_protobufs__inter_freq_carrier_freq_info__unpack
1028                      (ProtobufCAllocator  *allocator,
1029                       size_t               len,
1030                       const uint8_t       *data)
1031 {
1032   return (StreamingProtobufs__InterFreqCarrierFreqInfo *)
1033      protobuf_c_message_unpack (&streaming_protobufs__inter_freq_carrier_freq_info__descriptor,
1034                                 allocator, len, data);
1035 }
1036 void   streaming_protobufs__inter_freq_carrier_freq_info__free_unpacked
1037                      (StreamingProtobufs__InterFreqCarrierFreqInfo *message,
1038                       ProtobufCAllocator *allocator)
1039 {
1040   if(!message)
1041     return;
1042   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info__descriptor);
1043   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1044 }
1045 void   streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__init
1046                      (StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ         *message)
1047 {
1048   static const StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ init_value = STREAMING_PROTOBUFS__INTER_FREQ_CARRIER_FREQ_INFO_THRESH_X__Q__INIT;
1049   *message = init_value;
1050 }
1051 size_t streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__get_packed_size
1052                      (const StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ *message)
1053 {
1054   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor);
1055   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1056 }
1057 size_t streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__pack
1058                      (const StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ *message,
1059                       uint8_t       *out)
1060 {
1061   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor);
1062   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1063 }
1064 size_t streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__pack_to_buffer
1065                      (const StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ *message,
1066                       ProtobufCBuffer *buffer)
1067 {
1068   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor);
1069   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1070 }
1071 StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ *
1072        streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__unpack
1073                      (ProtobufCAllocator  *allocator,
1074                       size_t               len,
1075                       const uint8_t       *data)
1076 {
1077   return (StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ *)
1078      protobuf_c_message_unpack (&streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor,
1079                                 allocator, len, data);
1080 }
1081 void   streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__free_unpacked
1082                      (StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ *message,
1083                       ProtobufCAllocator *allocator)
1084 {
1085   if(!message)
1086     return;
1087   assert(message->base.descriptor == &streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor);
1088   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1089 }
1090 void   streaming_protobufs__inter_freq_neigh_cell_list__init
1091                      (StreamingProtobufs__InterFreqNeighCellList         *message)
1092 {
1093   static const StreamingProtobufs__InterFreqNeighCellList init_value = STREAMING_PROTOBUFS__INTER_FREQ_NEIGH_CELL_LIST__INIT;
1094   *message = init_value;
1095 }
1096 size_t streaming_protobufs__inter_freq_neigh_cell_list__get_packed_size
1097                      (const StreamingProtobufs__InterFreqNeighCellList *message)
1098 {
1099   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_list__descriptor);
1100   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1101 }
1102 size_t streaming_protobufs__inter_freq_neigh_cell_list__pack
1103                      (const StreamingProtobufs__InterFreqNeighCellList *message,
1104                       uint8_t       *out)
1105 {
1106   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_list__descriptor);
1107   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1108 }
1109 size_t streaming_protobufs__inter_freq_neigh_cell_list__pack_to_buffer
1110                      (const StreamingProtobufs__InterFreqNeighCellList *message,
1111                       ProtobufCBuffer *buffer)
1112 {
1113   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_list__descriptor);
1114   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1115 }
1116 StreamingProtobufs__InterFreqNeighCellList *
1117        streaming_protobufs__inter_freq_neigh_cell_list__unpack
1118                      (ProtobufCAllocator  *allocator,
1119                       size_t               len,
1120                       const uint8_t       *data)
1121 {
1122   return (StreamingProtobufs__InterFreqNeighCellList *)
1123      protobuf_c_message_unpack (&streaming_protobufs__inter_freq_neigh_cell_list__descriptor,
1124                                 allocator, len, data);
1125 }
1126 void   streaming_protobufs__inter_freq_neigh_cell_list__free_unpacked
1127                      (StreamingProtobufs__InterFreqNeighCellList *message,
1128                       ProtobufCAllocator *allocator)
1129 {
1130   if(!message)
1131     return;
1132   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_list__descriptor);
1133   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1134 }
1135 void   streaming_protobufs__inter_freq_neigh_cell_info__init
1136                      (StreamingProtobufs__InterFreqNeighCellInfo         *message)
1137 {
1138   static const StreamingProtobufs__InterFreqNeighCellInfo init_value = STREAMING_PROTOBUFS__INTER_FREQ_NEIGH_CELL_INFO__INIT;
1139   *message = init_value;
1140 }
1141 size_t streaming_protobufs__inter_freq_neigh_cell_info__get_packed_size
1142                      (const StreamingProtobufs__InterFreqNeighCellInfo *message)
1143 {
1144   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_info__descriptor);
1145   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1146 }
1147 size_t streaming_protobufs__inter_freq_neigh_cell_info__pack
1148                      (const StreamingProtobufs__InterFreqNeighCellInfo *message,
1149                       uint8_t       *out)
1150 {
1151   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_info__descriptor);
1152   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1153 }
1154 size_t streaming_protobufs__inter_freq_neigh_cell_info__pack_to_buffer
1155                      (const StreamingProtobufs__InterFreqNeighCellInfo *message,
1156                       ProtobufCBuffer *buffer)
1157 {
1158   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_info__descriptor);
1159   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1160 }
1161 StreamingProtobufs__InterFreqNeighCellInfo *
1162        streaming_protobufs__inter_freq_neigh_cell_info__unpack
1163                      (ProtobufCAllocator  *allocator,
1164                       size_t               len,
1165                       const uint8_t       *data)
1166 {
1167   return (StreamingProtobufs__InterFreqNeighCellInfo *)
1168      protobuf_c_message_unpack (&streaming_protobufs__inter_freq_neigh_cell_info__descriptor,
1169                                 allocator, len, data);
1170 }
1171 void   streaming_protobufs__inter_freq_neigh_cell_info__free_unpacked
1172                      (StreamingProtobufs__InterFreqNeighCellInfo *message,
1173                       ProtobufCAllocator *allocator)
1174 {
1175   if(!message)
1176     return;
1177   assert(message->base.descriptor == &streaming_protobufs__inter_freq_neigh_cell_info__descriptor);
1178   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1179 }
1180 void   streaming_protobufs__inter_freq_black_cell_list__init
1181                      (StreamingProtobufs__InterFreqBlackCellList         *message)
1182 {
1183   static const StreamingProtobufs__InterFreqBlackCellList init_value = STREAMING_PROTOBUFS__INTER_FREQ_BLACK_CELL_LIST__INIT;
1184   *message = init_value;
1185 }
1186 size_t streaming_protobufs__inter_freq_black_cell_list__get_packed_size
1187                      (const StreamingProtobufs__InterFreqBlackCellList *message)
1188 {
1189   assert(message->base.descriptor == &streaming_protobufs__inter_freq_black_cell_list__descriptor);
1190   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1191 }
1192 size_t streaming_protobufs__inter_freq_black_cell_list__pack
1193                      (const StreamingProtobufs__InterFreqBlackCellList *message,
1194                       uint8_t       *out)
1195 {
1196   assert(message->base.descriptor == &streaming_protobufs__inter_freq_black_cell_list__descriptor);
1197   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1198 }
1199 size_t streaming_protobufs__inter_freq_black_cell_list__pack_to_buffer
1200                      (const StreamingProtobufs__InterFreqBlackCellList *message,
1201                       ProtobufCBuffer *buffer)
1202 {
1203   assert(message->base.descriptor == &streaming_protobufs__inter_freq_black_cell_list__descriptor);
1204   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1205 }
1206 StreamingProtobufs__InterFreqBlackCellList *
1207        streaming_protobufs__inter_freq_black_cell_list__unpack
1208                      (ProtobufCAllocator  *allocator,
1209                       size_t               len,
1210                       const uint8_t       *data)
1211 {
1212   return (StreamingProtobufs__InterFreqBlackCellList *)
1213      protobuf_c_message_unpack (&streaming_protobufs__inter_freq_black_cell_list__descriptor,
1214                                 allocator, len, data);
1215 }
1216 void   streaming_protobufs__inter_freq_black_cell_list__free_unpacked
1217                      (StreamingProtobufs__InterFreqBlackCellList *message,
1218                       ProtobufCAllocator *allocator)
1219 {
1220   if(!message)
1221     return;
1222   assert(message->base.descriptor == &streaming_protobufs__inter_freq_black_cell_list__descriptor);
1223   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1224 }
1225 void   streaming_protobufs__sib5__init
1226                      (StreamingProtobufs__SIB5         *message)
1227 {
1228   static const StreamingProtobufs__SIB5 init_value = STREAMING_PROTOBUFS__SIB5__INIT;
1229   *message = init_value;
1230 }
1231 size_t streaming_protobufs__sib5__get_packed_size
1232                      (const StreamingProtobufs__SIB5 *message)
1233 {
1234   assert(message->base.descriptor == &streaming_protobufs__sib5__descriptor);
1235   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1236 }
1237 size_t streaming_protobufs__sib5__pack
1238                      (const StreamingProtobufs__SIB5 *message,
1239                       uint8_t       *out)
1240 {
1241   assert(message->base.descriptor == &streaming_protobufs__sib5__descriptor);
1242   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1243 }
1244 size_t streaming_protobufs__sib5__pack_to_buffer
1245                      (const StreamingProtobufs__SIB5 *message,
1246                       ProtobufCBuffer *buffer)
1247 {
1248   assert(message->base.descriptor == &streaming_protobufs__sib5__descriptor);
1249   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1250 }
1251 StreamingProtobufs__SIB5 *
1252        streaming_protobufs__sib5__unpack
1253                      (ProtobufCAllocator  *allocator,
1254                       size_t               len,
1255                       const uint8_t       *data)
1256 {
1257   return (StreamingProtobufs__SIB5 *)
1258      protobuf_c_message_unpack (&streaming_protobufs__sib5__descriptor,
1259                                 allocator, len, data);
1260 }
1261 void   streaming_protobufs__sib5__free_unpacked
1262                      (StreamingProtobufs__SIB5 *message,
1263                       ProtobufCAllocator *allocator)
1264 {
1265   if(!message)
1266     return;
1267   assert(message->base.descriptor == &streaming_protobufs__sib5__descriptor);
1268   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1269 }
1270 void   streaming_protobufs__carrier_freq_list_eutra__init
1271                      (StreamingProtobufs__CarrierFreqListEUTRA         *message)
1272 {
1273   static const StreamingProtobufs__CarrierFreqListEUTRA init_value = STREAMING_PROTOBUFS__CARRIER_FREQ_LIST_EUTRA__INIT;
1274   *message = init_value;
1275 }
1276 size_t streaming_protobufs__carrier_freq_list_eutra__get_packed_size
1277                      (const StreamingProtobufs__CarrierFreqListEUTRA *message)
1278 {
1279   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_list_eutra__descriptor);
1280   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1281 }
1282 size_t streaming_protobufs__carrier_freq_list_eutra__pack
1283                      (const StreamingProtobufs__CarrierFreqListEUTRA *message,
1284                       uint8_t       *out)
1285 {
1286   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_list_eutra__descriptor);
1287   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1288 }
1289 size_t streaming_protobufs__carrier_freq_list_eutra__pack_to_buffer
1290                      (const StreamingProtobufs__CarrierFreqListEUTRA *message,
1291                       ProtobufCBuffer *buffer)
1292 {
1293   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_list_eutra__descriptor);
1294   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1295 }
1296 StreamingProtobufs__CarrierFreqListEUTRA *
1297        streaming_protobufs__carrier_freq_list_eutra__unpack
1298                      (ProtobufCAllocator  *allocator,
1299                       size_t               len,
1300                       const uint8_t       *data)
1301 {
1302   return (StreamingProtobufs__CarrierFreqListEUTRA *)
1303      protobuf_c_message_unpack (&streaming_protobufs__carrier_freq_list_eutra__descriptor,
1304                                 allocator, len, data);
1305 }
1306 void   streaming_protobufs__carrier_freq_list_eutra__free_unpacked
1307                      (StreamingProtobufs__CarrierFreqListEUTRA *message,
1308                       ProtobufCAllocator *allocator)
1309 {
1310   if(!message)
1311     return;
1312   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_list_eutra__descriptor);
1313   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1314 }
1315 void   streaming_protobufs__carrier_freq_eutra__init
1316                      (StreamingProtobufs__CarrierFreqEUTRA         *message)
1317 {
1318   static const StreamingProtobufs__CarrierFreqEUTRA init_value = STREAMING_PROTOBUFS__CARRIER_FREQ_EUTRA__INIT;
1319   *message = init_value;
1320 }
1321 size_t streaming_protobufs__carrier_freq_eutra__get_packed_size
1322                      (const StreamingProtobufs__CarrierFreqEUTRA *message)
1323 {
1324   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutra__descriptor);
1325   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1326 }
1327 size_t streaming_protobufs__carrier_freq_eutra__pack
1328                      (const StreamingProtobufs__CarrierFreqEUTRA *message,
1329                       uint8_t       *out)
1330 {
1331   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutra__descriptor);
1332   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1333 }
1334 size_t streaming_protobufs__carrier_freq_eutra__pack_to_buffer
1335                      (const StreamingProtobufs__CarrierFreqEUTRA *message,
1336                       ProtobufCBuffer *buffer)
1337 {
1338   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutra__descriptor);
1339   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1340 }
1341 StreamingProtobufs__CarrierFreqEUTRA *
1342        streaming_protobufs__carrier_freq_eutra__unpack
1343                      (ProtobufCAllocator  *allocator,
1344                       size_t               len,
1345                       const uint8_t       *data)
1346 {
1347   return (StreamingProtobufs__CarrierFreqEUTRA *)
1348      protobuf_c_message_unpack (&streaming_protobufs__carrier_freq_eutra__descriptor,
1349                                 allocator, len, data);
1350 }
1351 void   streaming_protobufs__carrier_freq_eutra__free_unpacked
1352                      (StreamingProtobufs__CarrierFreqEUTRA *message,
1353                       ProtobufCAllocator *allocator)
1354 {
1355   if(!message)
1356     return;
1357   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutra__descriptor);
1358   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1359 }
1360 void   streaming_protobufs__eutra__freq_neigh_cell_list__init
1361                      (StreamingProtobufs__EUTRAFreqNeighCellList         *message)
1362 {
1363   static const StreamingProtobufs__EUTRAFreqNeighCellList init_value = STREAMING_PROTOBUFS__EUTRA__FREQ_NEIGH_CELL_LIST__INIT;
1364   *message = init_value;
1365 }
1366 size_t streaming_protobufs__eutra__freq_neigh_cell_list__get_packed_size
1367                      (const StreamingProtobufs__EUTRAFreqNeighCellList *message)
1368 {
1369   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_list__descriptor);
1370   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1371 }
1372 size_t streaming_protobufs__eutra__freq_neigh_cell_list__pack
1373                      (const StreamingProtobufs__EUTRAFreqNeighCellList *message,
1374                       uint8_t       *out)
1375 {
1376   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_list__descriptor);
1377   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1378 }
1379 size_t streaming_protobufs__eutra__freq_neigh_cell_list__pack_to_buffer
1380                      (const StreamingProtobufs__EUTRAFreqNeighCellList *message,
1381                       ProtobufCBuffer *buffer)
1382 {
1383   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_list__descriptor);
1384   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1385 }
1386 StreamingProtobufs__EUTRAFreqNeighCellList *
1387        streaming_protobufs__eutra__freq_neigh_cell_list__unpack
1388                      (ProtobufCAllocator  *allocator,
1389                       size_t               len,
1390                       const uint8_t       *data)
1391 {
1392   return (StreamingProtobufs__EUTRAFreqNeighCellList *)
1393      protobuf_c_message_unpack (&streaming_protobufs__eutra__freq_neigh_cell_list__descriptor,
1394                                 allocator, len, data);
1395 }
1396 void   streaming_protobufs__eutra__freq_neigh_cell_list__free_unpacked
1397                      (StreamingProtobufs__EUTRAFreqNeighCellList *message,
1398                       ProtobufCAllocator *allocator)
1399 {
1400   if(!message)
1401     return;
1402   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_list__descriptor);
1403   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1404 }
1405 void   streaming_protobufs__eutra__freq_black_cell_list__init
1406                      (StreamingProtobufs__EUTRAFreqBlackCellList         *message)
1407 {
1408   static const StreamingProtobufs__EUTRAFreqBlackCellList init_value = STREAMING_PROTOBUFS__EUTRA__FREQ_BLACK_CELL_LIST__INIT;
1409   *message = init_value;
1410 }
1411 size_t streaming_protobufs__eutra__freq_black_cell_list__get_packed_size
1412                      (const StreamingProtobufs__EUTRAFreqBlackCellList *message)
1413 {
1414   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_black_cell_list__descriptor);
1415   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1416 }
1417 size_t streaming_protobufs__eutra__freq_black_cell_list__pack
1418                      (const StreamingProtobufs__EUTRAFreqBlackCellList *message,
1419                       uint8_t       *out)
1420 {
1421   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_black_cell_list__descriptor);
1422   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1423 }
1424 size_t streaming_protobufs__eutra__freq_black_cell_list__pack_to_buffer
1425                      (const StreamingProtobufs__EUTRAFreqBlackCellList *message,
1426                       ProtobufCBuffer *buffer)
1427 {
1428   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_black_cell_list__descriptor);
1429   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1430 }
1431 StreamingProtobufs__EUTRAFreqBlackCellList *
1432        streaming_protobufs__eutra__freq_black_cell_list__unpack
1433                      (ProtobufCAllocator  *allocator,
1434                       size_t               len,
1435                       const uint8_t       *data)
1436 {
1437   return (StreamingProtobufs__EUTRAFreqBlackCellList *)
1438      protobuf_c_message_unpack (&streaming_protobufs__eutra__freq_black_cell_list__descriptor,
1439                                 allocator, len, data);
1440 }
1441 void   streaming_protobufs__eutra__freq_black_cell_list__free_unpacked
1442                      (StreamingProtobufs__EUTRAFreqBlackCellList *message,
1443                       ProtobufCAllocator *allocator)
1444 {
1445   if(!message)
1446     return;
1447   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_black_cell_list__descriptor);
1448   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1449 }
1450 void   streaming_protobufs__eutra__freq_neigh_cell_info__init
1451                      (StreamingProtobufs__EUTRAFreqNeighCellInfo         *message)
1452 {
1453   static const StreamingProtobufs__EUTRAFreqNeighCellInfo init_value = STREAMING_PROTOBUFS__EUTRA__FREQ_NEIGH_CELL_INFO__INIT;
1454   *message = init_value;
1455 }
1456 size_t streaming_protobufs__eutra__freq_neigh_cell_info__get_packed_size
1457                      (const StreamingProtobufs__EUTRAFreqNeighCellInfo *message)
1458 {
1459   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_info__descriptor);
1460   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1461 }
1462 size_t streaming_protobufs__eutra__freq_neigh_cell_info__pack
1463                      (const StreamingProtobufs__EUTRAFreqNeighCellInfo *message,
1464                       uint8_t       *out)
1465 {
1466   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_info__descriptor);
1467   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1468 }
1469 size_t streaming_protobufs__eutra__freq_neigh_cell_info__pack_to_buffer
1470                      (const StreamingProtobufs__EUTRAFreqNeighCellInfo *message,
1471                       ProtobufCBuffer *buffer)
1472 {
1473   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_info__descriptor);
1474   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1475 }
1476 StreamingProtobufs__EUTRAFreqNeighCellInfo *
1477        streaming_protobufs__eutra__freq_neigh_cell_info__unpack
1478                      (ProtobufCAllocator  *allocator,
1479                       size_t               len,
1480                       const uint8_t       *data)
1481 {
1482   return (StreamingProtobufs__EUTRAFreqNeighCellInfo *)
1483      protobuf_c_message_unpack (&streaming_protobufs__eutra__freq_neigh_cell_info__descriptor,
1484                                 allocator, len, data);
1485 }
1486 void   streaming_protobufs__eutra__freq_neigh_cell_info__free_unpacked
1487                      (StreamingProtobufs__EUTRAFreqNeighCellInfo *message,
1488                       ProtobufCAllocator *allocator)
1489 {
1490   if(!message)
1491     return;
1492   assert(message->base.descriptor == &streaming_protobufs__eutra__freq_neigh_cell_info__descriptor);
1493   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1494 }
1495 void   streaming_protobufs__carrier_freq_eutrathresh_x__q__init
1496                      (StreamingProtobufs__CarrierFreqEUTRAThreshXQ         *message)
1497 {
1498   static const StreamingProtobufs__CarrierFreqEUTRAThreshXQ init_value = STREAMING_PROTOBUFS__CARRIER_FREQ_EUTRATHRESH_X__Q__INIT;
1499   *message = init_value;
1500 }
1501 size_t streaming_protobufs__carrier_freq_eutrathresh_x__q__get_packed_size
1502                      (const StreamingProtobufs__CarrierFreqEUTRAThreshXQ *message)
1503 {
1504   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor);
1505   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1506 }
1507 size_t streaming_protobufs__carrier_freq_eutrathresh_x__q__pack
1508                      (const StreamingProtobufs__CarrierFreqEUTRAThreshXQ *message,
1509                       uint8_t       *out)
1510 {
1511   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor);
1512   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1513 }
1514 size_t streaming_protobufs__carrier_freq_eutrathresh_x__q__pack_to_buffer
1515                      (const StreamingProtobufs__CarrierFreqEUTRAThreshXQ *message,
1516                       ProtobufCBuffer *buffer)
1517 {
1518   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor);
1519   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1520 }
1521 StreamingProtobufs__CarrierFreqEUTRAThreshXQ *
1522        streaming_protobufs__carrier_freq_eutrathresh_x__q__unpack
1523                      (ProtobufCAllocator  *allocator,
1524                       size_t               len,
1525                       const uint8_t       *data)
1526 {
1527   return (StreamingProtobufs__CarrierFreqEUTRAThreshXQ *)
1528      protobuf_c_message_unpack (&streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor,
1529                                 allocator, len, data);
1530 }
1531 void   streaming_protobufs__carrier_freq_eutrathresh_x__q__free_unpacked
1532                      (StreamingProtobufs__CarrierFreqEUTRAThreshXQ *message,
1533                       ProtobufCAllocator *allocator)
1534 {
1535   if(!message)
1536     return;
1537   assert(message->base.descriptor == &streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor);
1538   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1539 }
1540 void   streaming_protobufs__sib6__init
1541                      (StreamingProtobufs__SIB6         *message)
1542 {
1543   static const StreamingProtobufs__SIB6 init_value = STREAMING_PROTOBUFS__SIB6__INIT;
1544   *message = init_value;
1545 }
1546 size_t streaming_protobufs__sib6__get_packed_size
1547                      (const StreamingProtobufs__SIB6 *message)
1548 {
1549   assert(message->base.descriptor == &streaming_protobufs__sib6__descriptor);
1550   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1551 }
1552 size_t streaming_protobufs__sib6__pack
1553                      (const StreamingProtobufs__SIB6 *message,
1554                       uint8_t       *out)
1555 {
1556   assert(message->base.descriptor == &streaming_protobufs__sib6__descriptor);
1557   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1558 }
1559 size_t streaming_protobufs__sib6__pack_to_buffer
1560                      (const StreamingProtobufs__SIB6 *message,
1561                       ProtobufCBuffer *buffer)
1562 {
1563   assert(message->base.descriptor == &streaming_protobufs__sib6__descriptor);
1564   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1565 }
1566 StreamingProtobufs__SIB6 *
1567        streaming_protobufs__sib6__unpack
1568                      (ProtobufCAllocator  *allocator,
1569                       size_t               len,
1570                       const uint8_t       *data)
1571 {
1572   return (StreamingProtobufs__SIB6 *)
1573      protobuf_c_message_unpack (&streaming_protobufs__sib6__descriptor,
1574                                 allocator, len, data);
1575 }
1576 void   streaming_protobufs__sib6__free_unpacked
1577                      (StreamingProtobufs__SIB6 *message,
1578                       ProtobufCAllocator *allocator)
1579 {
1580   if(!message)
1581     return;
1582   assert(message->base.descriptor == &streaming_protobufs__sib6__descriptor);
1583   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1584 }
1585 void   streaming_protobufs__sib7__init
1586                      (StreamingProtobufs__SIB7         *message)
1587 {
1588   static const StreamingProtobufs__SIB7 init_value = STREAMING_PROTOBUFS__SIB7__INIT;
1589   *message = init_value;
1590 }
1591 size_t streaming_protobufs__sib7__get_packed_size
1592                      (const StreamingProtobufs__SIB7 *message)
1593 {
1594   assert(message->base.descriptor == &streaming_protobufs__sib7__descriptor);
1595   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1596 }
1597 size_t streaming_protobufs__sib7__pack
1598                      (const StreamingProtobufs__SIB7 *message,
1599                       uint8_t       *out)
1600 {
1601   assert(message->base.descriptor == &streaming_protobufs__sib7__descriptor);
1602   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1603 }
1604 size_t streaming_protobufs__sib7__pack_to_buffer
1605                      (const StreamingProtobufs__SIB7 *message,
1606                       ProtobufCBuffer *buffer)
1607 {
1608   assert(message->base.descriptor == &streaming_protobufs__sib7__descriptor);
1609   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1610 }
1611 StreamingProtobufs__SIB7 *
1612        streaming_protobufs__sib7__unpack
1613                      (ProtobufCAllocator  *allocator,
1614                       size_t               len,
1615                       const uint8_t       *data)
1616 {
1617   return (StreamingProtobufs__SIB7 *)
1618      protobuf_c_message_unpack (&streaming_protobufs__sib7__descriptor,
1619                                 allocator, len, data);
1620 }
1621 void   streaming_protobufs__sib7__free_unpacked
1622                      (StreamingProtobufs__SIB7 *message,
1623                       ProtobufCAllocator *allocator)
1624 {
1625   if(!message)
1626     return;
1627   assert(message->base.descriptor == &streaming_protobufs__sib7__descriptor);
1628   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1629 }
1630 void   streaming_protobufs__sib8__init
1631                      (StreamingProtobufs__SIB8         *message)
1632 {
1633   static const StreamingProtobufs__SIB8 init_value = STREAMING_PROTOBUFS__SIB8__INIT;
1634   *message = init_value;
1635 }
1636 size_t streaming_protobufs__sib8__get_packed_size
1637                      (const StreamingProtobufs__SIB8 *message)
1638 {
1639   assert(message->base.descriptor == &streaming_protobufs__sib8__descriptor);
1640   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1641 }
1642 size_t streaming_protobufs__sib8__pack
1643                      (const StreamingProtobufs__SIB8 *message,
1644                       uint8_t       *out)
1645 {
1646   assert(message->base.descriptor == &streaming_protobufs__sib8__descriptor);
1647   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1648 }
1649 size_t streaming_protobufs__sib8__pack_to_buffer
1650                      (const StreamingProtobufs__SIB8 *message,
1651                       ProtobufCBuffer *buffer)
1652 {
1653   assert(message->base.descriptor == &streaming_protobufs__sib8__descriptor);
1654   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1655 }
1656 StreamingProtobufs__SIB8 *
1657        streaming_protobufs__sib8__unpack
1658                      (ProtobufCAllocator  *allocator,
1659                       size_t               len,
1660                       const uint8_t       *data)
1661 {
1662   return (StreamingProtobufs__SIB8 *)
1663      protobuf_c_message_unpack (&streaming_protobufs__sib8__descriptor,
1664                                 allocator, len, data);
1665 }
1666 void   streaming_protobufs__sib8__free_unpacked
1667                      (StreamingProtobufs__SIB8 *message,
1668                       ProtobufCAllocator *allocator)
1669 {
1670   if(!message)
1671     return;
1672   assert(message->base.descriptor == &streaming_protobufs__sib8__descriptor);
1673   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1674 }
1675 void   streaming_protobufs__sib9__init
1676                      (StreamingProtobufs__SIB9         *message)
1677 {
1678   static const StreamingProtobufs__SIB9 init_value = STREAMING_PROTOBUFS__SIB9__INIT;
1679   *message = init_value;
1680 }
1681 size_t streaming_protobufs__sib9__get_packed_size
1682                      (const StreamingProtobufs__SIB9 *message)
1683 {
1684   assert(message->base.descriptor == &streaming_protobufs__sib9__descriptor);
1685   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1686 }
1687 size_t streaming_protobufs__sib9__pack
1688                      (const StreamingProtobufs__SIB9 *message,
1689                       uint8_t       *out)
1690 {
1691   assert(message->base.descriptor == &streaming_protobufs__sib9__descriptor);
1692   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1693 }
1694 size_t streaming_protobufs__sib9__pack_to_buffer
1695                      (const StreamingProtobufs__SIB9 *message,
1696                       ProtobufCBuffer *buffer)
1697 {
1698   assert(message->base.descriptor == &streaming_protobufs__sib9__descriptor);
1699   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1700 }
1701 StreamingProtobufs__SIB9 *
1702        streaming_protobufs__sib9__unpack
1703                      (ProtobufCAllocator  *allocator,
1704                       size_t               len,
1705                       const uint8_t       *data)
1706 {
1707   return (StreamingProtobufs__SIB9 *)
1708      protobuf_c_message_unpack (&streaming_protobufs__sib9__descriptor,
1709                                 allocator, len, data);
1710 }
1711 void   streaming_protobufs__sib9__free_unpacked
1712                      (StreamingProtobufs__SIB9 *message,
1713                       ProtobufCAllocator *allocator)
1714 {
1715   if(!message)
1716     return;
1717   assert(message->base.descriptor == &streaming_protobufs__sib9__descriptor);
1718   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1719 }
1720 void   streaming_protobufs__sib9_time_info__init
1721                      (StreamingProtobufs__SIB9TimeInfo         *message)
1722 {
1723   static const StreamingProtobufs__SIB9TimeInfo init_value = STREAMING_PROTOBUFS__SIB9_TIME_INFO__INIT;
1724   *message = init_value;
1725 }
1726 size_t streaming_protobufs__sib9_time_info__get_packed_size
1727                      (const StreamingProtobufs__SIB9TimeInfo *message)
1728 {
1729   assert(message->base.descriptor == &streaming_protobufs__sib9_time_info__descriptor);
1730   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1731 }
1732 size_t streaming_protobufs__sib9_time_info__pack
1733                      (const StreamingProtobufs__SIB9TimeInfo *message,
1734                       uint8_t       *out)
1735 {
1736   assert(message->base.descriptor == &streaming_protobufs__sib9_time_info__descriptor);
1737   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1738 }
1739 size_t streaming_protobufs__sib9_time_info__pack_to_buffer
1740                      (const StreamingProtobufs__SIB9TimeInfo *message,
1741                       ProtobufCBuffer *buffer)
1742 {
1743   assert(message->base.descriptor == &streaming_protobufs__sib9_time_info__descriptor);
1744   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1745 }
1746 StreamingProtobufs__SIB9TimeInfo *
1747        streaming_protobufs__sib9_time_info__unpack
1748                      (ProtobufCAllocator  *allocator,
1749                       size_t               len,
1750                       const uint8_t       *data)
1751 {
1752   return (StreamingProtobufs__SIB9TimeInfo *)
1753      protobuf_c_message_unpack (&streaming_protobufs__sib9_time_info__descriptor,
1754                                 allocator, len, data);
1755 }
1756 void   streaming_protobufs__sib9_time_info__free_unpacked
1757                      (StreamingProtobufs__SIB9TimeInfo *message,
1758                       ProtobufCAllocator *allocator)
1759 {
1760   if(!message)
1761     return;
1762   assert(message->base.descriptor == &streaming_protobufs__sib9_time_info__descriptor);
1763   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1764 }
1765 static const ProtobufCFieldDescriptor streaming_protobufs__sib1__field_descriptors[11] =
1766 {
1767   {
1768     "cellSelectionInfo",
1769     1,
1770     PROTOBUF_C_LABEL_NONE,
1771     PROTOBUF_C_TYPE_MESSAGE,
1772     0,   /* quantifier_offset */
1773     offsetof(StreamingProtobufs__SIB1, cellselectioninfo),
1774     &streaming_protobufs__sib1_cell_selection_info__descriptor,
1775     NULL,
1776     0,             /* flags */
1777     0,NULL,NULL    /* reserved1,reserved2, etc */
1778   },
1779   {
1780     "cellAccessRelatedInfo",
1781     2,
1782     PROTOBUF_C_LABEL_NONE,
1783     PROTOBUF_C_TYPE_MESSAGE,
1784     0,   /* quantifier_offset */
1785     offsetof(StreamingProtobufs__SIB1, cellaccessrelatedinfo),
1786     &streaming_protobufs__cell_access_related_info__descriptor,
1787     NULL,
1788     0,             /* flags */
1789     0,NULL,NULL    /* reserved1,reserved2, etc */
1790   },
1791   {
1792     "connEstFailureControl",
1793     3,
1794     PROTOBUF_C_LABEL_NONE,
1795     PROTOBUF_C_TYPE_MESSAGE,
1796     0,   /* quantifier_offset */
1797     offsetof(StreamingProtobufs__SIB1, connestfailurecontrol),
1798     &streaming_protobufs__conn_est_failure_control__descriptor,
1799     NULL,
1800     0,             /* flags */
1801     0,NULL,NULL    /* reserved1,reserved2, etc */
1802   },
1803   {
1804     "si_SchedulingInfo",
1805     4,
1806     PROTOBUF_C_LABEL_NONE,
1807     PROTOBUF_C_TYPE_MESSAGE,
1808     0,   /* quantifier_offset */
1809     offsetof(StreamingProtobufs__SIB1, si_schedulinginfo),
1810     &streaming_protobufs__si__scheduling_info__descriptor,
1811     NULL,
1812     0,             /* flags */
1813     0,NULL,NULL    /* reserved1,reserved2, etc */
1814   },
1815   {
1816     "servingCellConfigCommon",
1817     5,
1818     PROTOBUF_C_LABEL_NONE,
1819     PROTOBUF_C_TYPE_MESSAGE,
1820     0,   /* quantifier_offset */
1821     offsetof(StreamingProtobufs__SIB1, servingcellconfigcommon),
1822     &streaming_protobufs__serving_cell_config_common_sib__descriptor,
1823     NULL,
1824     0,             /* flags */
1825     0,NULL,NULL    /* reserved1,reserved2, etc */
1826   },
1827   {
1828     "ims_EmergencySupport",
1829     6,
1830     PROTOBUF_C_LABEL_NONE,
1831     PROTOBUF_C_TYPE_MESSAGE,
1832     0,   /* quantifier_offset */
1833     offsetof(StreamingProtobufs__SIB1, ims_emergencysupport),
1834     &streaming_protobufs__true_opt__descriptor,
1835     NULL,
1836     0,             /* flags */
1837     0,NULL,NULL    /* reserved1,reserved2, etc */
1838   },
1839   {
1840     "eCallOverIMS_Support",
1841     7,
1842     PROTOBUF_C_LABEL_NONE,
1843     PROTOBUF_C_TYPE_MESSAGE,
1844     0,   /* quantifier_offset */
1845     offsetof(StreamingProtobufs__SIB1, ecalloverims_support),
1846     &streaming_protobufs__true_opt__descriptor,
1847     NULL,
1848     0,             /* flags */
1849     0,NULL,NULL    /* reserved1,reserved2, etc */
1850   },
1851   {
1852     "ue_TimersAndConstants",
1853     8,
1854     PROTOBUF_C_LABEL_NONE,
1855     PROTOBUF_C_TYPE_MESSAGE,
1856     0,   /* quantifier_offset */
1857     offsetof(StreamingProtobufs__SIB1, ue_timersandconstants),
1858     &streaming_protobufs__ue__timers_and_constants__descriptor,
1859     NULL,
1860     0,             /* flags */
1861     0,NULL,NULL    /* reserved1,reserved2, etc */
1862   },
1863   {
1864     "uac_BarringInfo",
1865     9,
1866     PROTOBUF_C_LABEL_NONE,
1867     PROTOBUF_C_TYPE_MESSAGE,
1868     0,   /* quantifier_offset */
1869     offsetof(StreamingProtobufs__SIB1, uac_barringinfo),
1870     &streaming_protobufs__sib1_uac__barring_info__descriptor,
1871     NULL,
1872     0,             /* flags */
1873     0,NULL,NULL    /* reserved1,reserved2, etc */
1874   },
1875   {
1876     "useFullResumeID",
1877     10,
1878     PROTOBUF_C_LABEL_NONE,
1879     PROTOBUF_C_TYPE_MESSAGE,
1880     0,   /* quantifier_offset */
1881     offsetof(StreamingProtobufs__SIB1, usefullresumeid),
1882     &streaming_protobufs__true_opt__descriptor,
1883     NULL,
1884     0,             /* flags */
1885     0,NULL,NULL    /* reserved1,reserved2, etc */
1886   },
1887   {
1888     "lateNonCriticalExtension",
1889     11,
1890     PROTOBUF_C_LABEL_NONE,
1891     PROTOBUF_C_TYPE_MESSAGE,
1892     0,   /* quantifier_offset */
1893     offsetof(StreamingProtobufs__SIB1, latenoncriticalextension),
1894     &google__protobuf__bytes_value__descriptor,
1895     NULL,
1896     0,             /* flags */
1897     0,NULL,NULL    /* reserved1,reserved2, etc */
1898   },
1899 };
1900 static const unsigned streaming_protobufs__sib1__field_indices_by_name[] = {
1901   1,   /* field[1] = cellAccessRelatedInfo */
1902   0,   /* field[0] = cellSelectionInfo */
1903   2,   /* field[2] = connEstFailureControl */
1904   6,   /* field[6] = eCallOverIMS_Support */
1905   5,   /* field[5] = ims_EmergencySupport */
1906   10,   /* field[10] = lateNonCriticalExtension */
1907   4,   /* field[4] = servingCellConfigCommon */
1908   3,   /* field[3] = si_SchedulingInfo */
1909   8,   /* field[8] = uac_BarringInfo */
1910   7,   /* field[7] = ue_TimersAndConstants */
1911   9,   /* field[9] = useFullResumeID */
1912 };
1913 static const ProtobufCIntRange streaming_protobufs__sib1__number_ranges[1 + 1] =
1914 {
1915   { 1, 0 },
1916   { 0, 11 }
1917 };
1918 const ProtobufCMessageDescriptor streaming_protobufs__sib1__descriptor =
1919 {
1920   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1921   "streaming_protobufs.SIB1",
1922   "SIB1",
1923   "StreamingProtobufs__SIB1",
1924   "streaming_protobufs",
1925   sizeof(StreamingProtobufs__SIB1),
1926   11,
1927   streaming_protobufs__sib1__field_descriptors,
1928   streaming_protobufs__sib1__field_indices_by_name,
1929   1,  streaming_protobufs__sib1__number_ranges,
1930   (ProtobufCMessageInit) streaming_protobufs__sib1__init,
1931   NULL,NULL,NULL    /* reserved[123] */
1932 };
1933 static const ProtobufCFieldDescriptor streaming_protobufs__sib1_cell_selection_info__field_descriptors[5] =
1934 {
1935   {
1936     "q_RxLevMin",
1937     1,
1938     PROTOBUF_C_LABEL_NONE,
1939     PROTOBUF_C_TYPE_SINT32,
1940     0,   /* quantifier_offset */
1941     offsetof(StreamingProtobufs__SIB1CellSelectionInfo, q_rxlevmin),
1942     NULL,
1943     NULL,
1944     0,             /* flags */
1945     0,NULL,NULL    /* reserved1,reserved2, etc */
1946   },
1947   {
1948     "q_RxLevMinOffset",
1949     2,
1950     PROTOBUF_C_LABEL_NONE,
1951     PROTOBUF_C_TYPE_MESSAGE,
1952     0,   /* quantifier_offset */
1953     offsetof(StreamingProtobufs__SIB1CellSelectionInfo, q_rxlevminoffset),
1954     &google__protobuf__uint32_value__descriptor,
1955     NULL,
1956     0,             /* flags */
1957     0,NULL,NULL    /* reserved1,reserved2, etc */
1958   },
1959   {
1960     "q_RxLevMinSUL",
1961     3,
1962     PROTOBUF_C_LABEL_NONE,
1963     PROTOBUF_C_TYPE_MESSAGE,
1964     0,   /* quantifier_offset */
1965     offsetof(StreamingProtobufs__SIB1CellSelectionInfo, q_rxlevminsul),
1966     &google__protobuf__int32_value__descriptor,
1967     NULL,
1968     0,             /* flags */
1969     0,NULL,NULL    /* reserved1,reserved2, etc */
1970   },
1971   {
1972     "q_QualMin",
1973     4,
1974     PROTOBUF_C_LABEL_NONE,
1975     PROTOBUF_C_TYPE_MESSAGE,
1976     0,   /* quantifier_offset */
1977     offsetof(StreamingProtobufs__SIB1CellSelectionInfo, q_qualmin),
1978     &google__protobuf__int32_value__descriptor,
1979     NULL,
1980     0,             /* flags */
1981     0,NULL,NULL    /* reserved1,reserved2, etc */
1982   },
1983   {
1984     "q_QualMinOffset",
1985     5,
1986     PROTOBUF_C_LABEL_NONE,
1987     PROTOBUF_C_TYPE_MESSAGE,
1988     0,   /* quantifier_offset */
1989     offsetof(StreamingProtobufs__SIB1CellSelectionInfo, q_qualminoffset),
1990     &google__protobuf__uint32_value__descriptor,
1991     NULL,
1992     0,             /* flags */
1993     0,NULL,NULL    /* reserved1,reserved2, etc */
1994   },
1995 };
1996 static const unsigned streaming_protobufs__sib1_cell_selection_info__field_indices_by_name[] = {
1997   3,   /* field[3] = q_QualMin */
1998   4,   /* field[4] = q_QualMinOffset */
1999   0,   /* field[0] = q_RxLevMin */
2000   1,   /* field[1] = q_RxLevMinOffset */
2001   2,   /* field[2] = q_RxLevMinSUL */
2002 };
2003 static const ProtobufCIntRange streaming_protobufs__sib1_cell_selection_info__number_ranges[1 + 1] =
2004 {
2005   { 1, 0 },
2006   { 0, 5 }
2007 };
2008 const ProtobufCMessageDescriptor streaming_protobufs__sib1_cell_selection_info__descriptor =
2009 {
2010   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2011   "streaming_protobufs.SIB1CellSelectionInfo",
2012   "SIB1CellSelectionInfo",
2013   "StreamingProtobufs__SIB1CellSelectionInfo",
2014   "streaming_protobufs",
2015   sizeof(StreamingProtobufs__SIB1CellSelectionInfo),
2016   5,
2017   streaming_protobufs__sib1_cell_selection_info__field_descriptors,
2018   streaming_protobufs__sib1_cell_selection_info__field_indices_by_name,
2019   1,  streaming_protobufs__sib1_cell_selection_info__number_ranges,
2020   (ProtobufCMessageInit) streaming_protobufs__sib1_cell_selection_info__init,
2021   NULL,NULL,NULL    /* reserved[123] */
2022 };
2023 static const ProtobufCFieldDescriptor streaming_protobufs__sib1_uac__barring_info__field_descriptors[5] =
2024 {
2025   {
2026     "uac_BarringForCommon",
2027     1,
2028     PROTOBUF_C_LABEL_NONE,
2029     PROTOBUF_C_TYPE_MESSAGE,
2030     0,   /* quantifier_offset */
2031     offsetof(StreamingProtobufs__SIB1UACBarringInfo, uac_barringforcommon),
2032     &streaming_protobufs__uac__barring_per_cat_list__descriptor,
2033     NULL,
2034     0,             /* flags */
2035     0,NULL,NULL    /* reserved1,reserved2, etc */
2036   },
2037   {
2038     "uac_BarringPerPLMN_List",
2039     2,
2040     PROTOBUF_C_LABEL_NONE,
2041     PROTOBUF_C_TYPE_MESSAGE,
2042     0,   /* quantifier_offset */
2043     offsetof(StreamingProtobufs__SIB1UACBarringInfo, uac_barringperplmn_list),
2044     &streaming_protobufs__uac__barring_per_plmn__list__descriptor,
2045     NULL,
2046     0,             /* flags */
2047     0,NULL,NULL    /* reserved1,reserved2, etc */
2048   },
2049   {
2050     "uac_BarringInfoSetList",
2051     3,
2052     PROTOBUF_C_LABEL_NONE,
2053     PROTOBUF_C_TYPE_MESSAGE,
2054     0,   /* quantifier_offset */
2055     offsetof(StreamingProtobufs__SIB1UACBarringInfo, uac_barringinfosetlist),
2056     &streaming_protobufs__uac__barring_info_set_list__descriptor,
2057     NULL,
2058     0,             /* flags */
2059     0,NULL,NULL    /* reserved1,reserved2, etc */
2060   },
2061   {
2062     "plmnCommon",
2063     4,
2064     PROTOBUF_C_LABEL_NONE,
2065     PROTOBUF_C_TYPE_MESSAGE,
2066     offsetof(StreamingProtobufs__SIB1UACBarringInfo, uac__access_category1__selection_assistance_info_case),
2067     offsetof(StreamingProtobufs__SIB1UACBarringInfo, plmncommon),
2068     &streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor,
2069     NULL,
2070     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
2071     0,NULL,NULL    /* reserved1,reserved2, etc */
2072   },
2073   {
2074     "individualPLMNList",
2075     5,
2076     PROTOBUF_C_LABEL_NONE,
2077     PROTOBUF_C_TYPE_MESSAGE,
2078     offsetof(StreamingProtobufs__SIB1UACBarringInfo, uac__access_category1__selection_assistance_info_case),
2079     offsetof(StreamingProtobufs__SIB1UACBarringInfo, individualplmnlist),
2080     &streaming_protobufs__individual_plmnlist__descriptor,
2081     NULL,
2082     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
2083     0,NULL,NULL    /* reserved1,reserved2, etc */
2084   },
2085 };
2086 static const unsigned streaming_protobufs__sib1_uac__barring_info__field_indices_by_name[] = {
2087   4,   /* field[4] = individualPLMNList */
2088   3,   /* field[3] = plmnCommon */
2089   0,   /* field[0] = uac_BarringForCommon */
2090   2,   /* field[2] = uac_BarringInfoSetList */
2091   1,   /* field[1] = uac_BarringPerPLMN_List */
2092 };
2093 static const ProtobufCIntRange streaming_protobufs__sib1_uac__barring_info__number_ranges[1 + 1] =
2094 {
2095   { 1, 0 },
2096   { 0, 5 }
2097 };
2098 const ProtobufCMessageDescriptor streaming_protobufs__sib1_uac__barring_info__descriptor =
2099 {
2100   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2101   "streaming_protobufs.SIB1UAC_BarringInfo",
2102   "SIB1UACBarringInfo",
2103   "StreamingProtobufs__SIB1UACBarringInfo",
2104   "streaming_protobufs",
2105   sizeof(StreamingProtobufs__SIB1UACBarringInfo),
2106   5,
2107   streaming_protobufs__sib1_uac__barring_info__field_descriptors,
2108   streaming_protobufs__sib1_uac__barring_info__field_indices_by_name,
2109   1,  streaming_protobufs__sib1_uac__barring_info__number_ranges,
2110   (ProtobufCMessageInit) streaming_protobufs__sib1_uac__barring_info__init,
2111   NULL,NULL,NULL    /* reserved[123] */
2112 };
2113 static const ProtobufCEnumValue streaming_protobufs__uac__access_category1__selection_assistance_info__value__enum_values_by_number[4] =
2114 {
2115   { "protobuf_unspecified", "STREAMING_PROTOBUFS__UAC__ACCESS_CATEGORY1__SELECTION_ASSISTANCE_INFO__VALUE__protobuf_unspecified", 0 },
2116   { "a", "STREAMING_PROTOBUFS__UAC__ACCESS_CATEGORY1__SELECTION_ASSISTANCE_INFO__VALUE__a", 1 },
2117   { "b", "STREAMING_PROTOBUFS__UAC__ACCESS_CATEGORY1__SELECTION_ASSISTANCE_INFO__VALUE__b", 2 },
2118   { "c", "STREAMING_PROTOBUFS__UAC__ACCESS_CATEGORY1__SELECTION_ASSISTANCE_INFO__VALUE__c", 3 },
2119 };
2120 static const ProtobufCIntRange streaming_protobufs__uac__access_category1__selection_assistance_info__value__value_ranges[] = {
2121 {0, 0},{0, 4}
2122 };
2123 static const ProtobufCEnumValueIndex streaming_protobufs__uac__access_category1__selection_assistance_info__value__enum_values_by_name[4] =
2124 {
2125   { "a", 1 },
2126   { "b", 2 },
2127   { "c", 3 },
2128   { "protobuf_unspecified", 0 },
2129 };
2130 const ProtobufCEnumDescriptor streaming_protobufs__uac__access_category1__selection_assistance_info__value__descriptor =
2131 {
2132   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2133   "streaming_protobufs.UAC_AccessCategory1_SelectionAssistanceInfo.Value",
2134   "Value",
2135   "StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo__Value",
2136   "streaming_protobufs",
2137   4,
2138   streaming_protobufs__uac__access_category1__selection_assistance_info__value__enum_values_by_number,
2139   4,
2140   streaming_protobufs__uac__access_category1__selection_assistance_info__value__enum_values_by_name,
2141   1,
2142   streaming_protobufs__uac__access_category1__selection_assistance_info__value__value_ranges,
2143   NULL,NULL,NULL,NULL   /* reserved[1234] */
2144 };
2145 static const ProtobufCFieldDescriptor streaming_protobufs__uac__access_category1__selection_assistance_info__field_descriptors[1] =
2146 {
2147   {
2148     "value",
2149     1,
2150     PROTOBUF_C_LABEL_NONE,
2151     PROTOBUF_C_TYPE_ENUM,
2152     0,   /* quantifier_offset */
2153     offsetof(StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo, value),
2154     &streaming_protobufs__uac__access_category1__selection_assistance_info__value__descriptor,
2155     NULL,
2156     0,             /* flags */
2157     0,NULL,NULL    /* reserved1,reserved2, etc */
2158   },
2159 };
2160 static const unsigned streaming_protobufs__uac__access_category1__selection_assistance_info__field_indices_by_name[] = {
2161   0,   /* field[0] = value */
2162 };
2163 static const ProtobufCIntRange streaming_protobufs__uac__access_category1__selection_assistance_info__number_ranges[1 + 1] =
2164 {
2165   { 1, 0 },
2166   { 0, 1 }
2167 };
2168 const ProtobufCMessageDescriptor streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor =
2169 {
2170   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2171   "streaming_protobufs.UAC_AccessCategory1_SelectionAssistanceInfo",
2172   "UACAccessCategory1SelectionAssistanceInfo",
2173   "StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo",
2174   "streaming_protobufs",
2175   sizeof(StreamingProtobufs__UACAccessCategory1SelectionAssistanceInfo),
2176   1,
2177   streaming_protobufs__uac__access_category1__selection_assistance_info__field_descriptors,
2178   streaming_protobufs__uac__access_category1__selection_assistance_info__field_indices_by_name,
2179   1,  streaming_protobufs__uac__access_category1__selection_assistance_info__number_ranges,
2180   (ProtobufCMessageInit) streaming_protobufs__uac__access_category1__selection_assistance_info__init,
2181   NULL,NULL,NULL    /* reserved[123] */
2182 };
2183 static const ProtobufCFieldDescriptor streaming_protobufs__individual_plmnlist__field_descriptors[1] =
2184 {
2185   {
2186     "items",
2187     1,
2188     PROTOBUF_C_LABEL_REPEATED,
2189     PROTOBUF_C_TYPE_MESSAGE,
2190     offsetof(StreamingProtobufs__IndividualPLMNList, n_items),
2191     offsetof(StreamingProtobufs__IndividualPLMNList, items),
2192     &streaming_protobufs__uac__access_category1__selection_assistance_info__descriptor,
2193     NULL,
2194     0,             /* flags */
2195     0,NULL,NULL    /* reserved1,reserved2, etc */
2196   },
2197 };
2198 static const unsigned streaming_protobufs__individual_plmnlist__field_indices_by_name[] = {
2199   0,   /* field[0] = items */
2200 };
2201 static const ProtobufCIntRange streaming_protobufs__individual_plmnlist__number_ranges[1 + 1] =
2202 {
2203   { 1, 0 },
2204   { 0, 1 }
2205 };
2206 const ProtobufCMessageDescriptor streaming_protobufs__individual_plmnlist__descriptor =
2207 {
2208   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2209   "streaming_protobufs.IndividualPLMNList",
2210   "IndividualPLMNList",
2211   "StreamingProtobufs__IndividualPLMNList",
2212   "streaming_protobufs",
2213   sizeof(StreamingProtobufs__IndividualPLMNList),
2214   1,
2215   streaming_protobufs__individual_plmnlist__field_descriptors,
2216   streaming_protobufs__individual_plmnlist__field_indices_by_name,
2217   1,  streaming_protobufs__individual_plmnlist__number_ranges,
2218   (ProtobufCMessageInit) streaming_protobufs__individual_plmnlist__init,
2219   NULL,NULL,NULL    /* reserved[123] */
2220 };
2221 static const ProtobufCFieldDescriptor streaming_protobufs__sib2__field_descriptors[3] =
2222 {
2223   {
2224     "cellReselectionInfoCommon",
2225     1,
2226     PROTOBUF_C_LABEL_NONE,
2227     PROTOBUF_C_TYPE_MESSAGE,
2228     0,   /* quantifier_offset */
2229     offsetof(StreamingProtobufs__SIB2, cellreselectioninfocommon),
2230     &streaming_protobufs__sib2_cell_reselection_info_common__descriptor,
2231     NULL,
2232     0,             /* flags */
2233     0,NULL,NULL    /* reserved1,reserved2, etc */
2234   },
2235   {
2236     "cellReselectionServingFreqInfo",
2237     2,
2238     PROTOBUF_C_LABEL_NONE,
2239     PROTOBUF_C_TYPE_MESSAGE,
2240     0,   /* quantifier_offset */
2241     offsetof(StreamingProtobufs__SIB2, cellreselectionservingfreqinfo),
2242     &streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor,
2243     NULL,
2244     0,             /* flags */
2245     0,NULL,NULL    /* reserved1,reserved2, etc */
2246   },
2247   {
2248     "intraFreqCellReselectionInfo",
2249     3,
2250     PROTOBUF_C_LABEL_NONE,
2251     PROTOBUF_C_TYPE_MESSAGE,
2252     0,   /* quantifier_offset */
2253     offsetof(StreamingProtobufs__SIB2, intrafreqcellreselectioninfo),
2254     &streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor,
2255     NULL,
2256     0,             /* flags */
2257     0,NULL,NULL    /* reserved1,reserved2, etc */
2258   },
2259 };
2260 static const unsigned streaming_protobufs__sib2__field_indices_by_name[] = {
2261   0,   /* field[0] = cellReselectionInfoCommon */
2262   1,   /* field[1] = cellReselectionServingFreqInfo */
2263   2,   /* field[2] = intraFreqCellReselectionInfo */
2264 };
2265 static const ProtobufCIntRange streaming_protobufs__sib2__number_ranges[1 + 1] =
2266 {
2267   { 1, 0 },
2268   { 0, 3 }
2269 };
2270 const ProtobufCMessageDescriptor streaming_protobufs__sib2__descriptor =
2271 {
2272   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2273   "streaming_protobufs.SIB2",
2274   "SIB2",
2275   "StreamingProtobufs__SIB2",
2276   "streaming_protobufs",
2277   sizeof(StreamingProtobufs__SIB2),
2278   3,
2279   streaming_protobufs__sib2__field_descriptors,
2280   streaming_protobufs__sib2__field_indices_by_name,
2281   1,  streaming_protobufs__sib2__number_ranges,
2282   (ProtobufCMessageInit) streaming_protobufs__sib2__init,
2283   NULL,NULL,NULL    /* reserved[123] */
2284 };
2285 static const ProtobufCFieldDescriptor streaming_protobufs__sib2_cell_reselection_info_common__field_descriptors[5] =
2286 {
2287   {
2288     "nrofSS_BlocksToAverage",
2289     1,
2290     PROTOBUF_C_LABEL_NONE,
2291     PROTOBUF_C_TYPE_MESSAGE,
2292     0,   /* quantifier_offset */
2293     offsetof(StreamingProtobufs__SIB2CellReselectionInfoCommon, nrofss_blockstoaverage),
2294     &google__protobuf__uint32_value__descriptor,
2295     NULL,
2296     0,             /* flags */
2297     0,NULL,NULL    /* reserved1,reserved2, etc */
2298   },
2299   {
2300     "absThreshSS_BlocksConsolidation",
2301     2,
2302     PROTOBUF_C_LABEL_NONE,
2303     PROTOBUF_C_TYPE_MESSAGE,
2304     0,   /* quantifier_offset */
2305     offsetof(StreamingProtobufs__SIB2CellReselectionInfoCommon, absthreshss_blocksconsolidation),
2306     &streaming_protobufs__threshold_nr__descriptor,
2307     NULL,
2308     0,             /* flags */
2309     0,NULL,NULL    /* reserved1,reserved2, etc */
2310   },
2311   {
2312     "rangeToBestCell",
2313     3,
2314     PROTOBUF_C_LABEL_NONE,
2315     PROTOBUF_C_TYPE_MESSAGE,
2316     0,   /* quantifier_offset */
2317     offsetof(StreamingProtobufs__SIB2CellReselectionInfoCommon, rangetobestcell),
2318     &streaming_protobufs__q__offset_range__descriptor,
2319     NULL,
2320     0,             /* flags */
2321     0,NULL,NULL    /* reserved1,reserved2, etc */
2322   },
2323   {
2324     "q_Hyst",
2325     4,
2326     PROTOBUF_C_LABEL_NONE,
2327     PROTOBUF_C_TYPE_MESSAGE,
2328     0,   /* quantifier_offset */
2329     offsetof(StreamingProtobufs__SIB2CellReselectionInfoCommon, q_hyst),
2330     &streaming_protobufs__q__hyst__descriptor,
2331     NULL,
2332     0,             /* flags */
2333     0,NULL,NULL    /* reserved1,reserved2, etc */
2334   },
2335   {
2336     "speedStateReselectionPars",
2337     5,
2338     PROTOBUF_C_LABEL_NONE,
2339     PROTOBUF_C_TYPE_MESSAGE,
2340     0,   /* quantifier_offset */
2341     offsetof(StreamingProtobufs__SIB2CellReselectionInfoCommon, speedstatereselectionpars),
2342     &streaming_protobufs__speed_state_reselection_pars__descriptor,
2343     NULL,
2344     0,             /* flags */
2345     0,NULL,NULL    /* reserved1,reserved2, etc */
2346   },
2347 };
2348 static const unsigned streaming_protobufs__sib2_cell_reselection_info_common__field_indices_by_name[] = {
2349   1,   /* field[1] = absThreshSS_BlocksConsolidation */
2350   0,   /* field[0] = nrofSS_BlocksToAverage */
2351   3,   /* field[3] = q_Hyst */
2352   2,   /* field[2] = rangeToBestCell */
2353   4,   /* field[4] = speedStateReselectionPars */
2354 };
2355 static const ProtobufCIntRange streaming_protobufs__sib2_cell_reselection_info_common__number_ranges[1 + 1] =
2356 {
2357   { 1, 0 },
2358   { 0, 5 }
2359 };
2360 const ProtobufCMessageDescriptor streaming_protobufs__sib2_cell_reselection_info_common__descriptor =
2361 {
2362   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2363   "streaming_protobufs.SIB2CellReselectionInfoCommon",
2364   "SIB2CellReselectionInfoCommon",
2365   "StreamingProtobufs__SIB2CellReselectionInfoCommon",
2366   "streaming_protobufs",
2367   sizeof(StreamingProtobufs__SIB2CellReselectionInfoCommon),
2368   5,
2369   streaming_protobufs__sib2_cell_reselection_info_common__field_descriptors,
2370   streaming_protobufs__sib2_cell_reselection_info_common__field_indices_by_name,
2371   1,  streaming_protobufs__sib2_cell_reselection_info_common__number_ranges,
2372   (ProtobufCMessageInit) streaming_protobufs__sib2_cell_reselection_info_common__init,
2373   NULL,NULL,NULL    /* reserved[123] */
2374 };
2375 static const ProtobufCEnumValue streaming_protobufs__q__hyst__value__enum_values_by_number[17] =
2376 {
2377   { "protobuf_unspecified", "STREAMING_PROTOBUFS__Q__HYST__VALUE__protobuf_unspecified", 0 },
2378   { "dB0", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB0", 1 },
2379   { "dB1", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB1", 2 },
2380   { "dB2", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB2", 3 },
2381   { "dB3", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB3", 4 },
2382   { "dB4", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB4", 5 },
2383   { "dB5", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB5", 6 },
2384   { "dB6", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB6", 7 },
2385   { "dB8", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB8", 8 },
2386   { "dB10", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB10", 9 },
2387   { "dB12", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB12", 10 },
2388   { "dB14", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB14", 11 },
2389   { "dB16", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB16", 12 },
2390   { "dB18", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB18", 13 },
2391   { "dB20", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB20", 14 },
2392   { "dB22", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB22", 15 },
2393   { "dB24", "STREAMING_PROTOBUFS__Q__HYST__VALUE__dB24", 16 },
2394 };
2395 static const ProtobufCIntRange streaming_protobufs__q__hyst__value__value_ranges[] = {
2396 {0, 0},{0, 17}
2397 };
2398 static const ProtobufCEnumValueIndex streaming_protobufs__q__hyst__value__enum_values_by_name[17] =
2399 {
2400   { "dB0", 1 },
2401   { "dB1", 2 },
2402   { "dB10", 9 },
2403   { "dB12", 10 },
2404   { "dB14", 11 },
2405   { "dB16", 12 },
2406   { "dB18", 13 },
2407   { "dB2", 3 },
2408   { "dB20", 14 },
2409   { "dB22", 15 },
2410   { "dB24", 16 },
2411   { "dB3", 4 },
2412   { "dB4", 5 },
2413   { "dB5", 6 },
2414   { "dB6", 7 },
2415   { "dB8", 8 },
2416   { "protobuf_unspecified", 0 },
2417 };
2418 const ProtobufCEnumDescriptor streaming_protobufs__q__hyst__value__descriptor =
2419 {
2420   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2421   "streaming_protobufs.Q_Hyst.Value",
2422   "Value",
2423   "StreamingProtobufs__QHyst__Value",
2424   "streaming_protobufs",
2425   17,
2426   streaming_protobufs__q__hyst__value__enum_values_by_number,
2427   17,
2428   streaming_protobufs__q__hyst__value__enum_values_by_name,
2429   1,
2430   streaming_protobufs__q__hyst__value__value_ranges,
2431   NULL,NULL,NULL,NULL   /* reserved[1234] */
2432 };
2433 static const ProtobufCFieldDescriptor streaming_protobufs__q__hyst__field_descriptors[1] =
2434 {
2435   {
2436     "value",
2437     1,
2438     PROTOBUF_C_LABEL_NONE,
2439     PROTOBUF_C_TYPE_ENUM,
2440     0,   /* quantifier_offset */
2441     offsetof(StreamingProtobufs__QHyst, value),
2442     &streaming_protobufs__q__hyst__value__descriptor,
2443     NULL,
2444     0,             /* flags */
2445     0,NULL,NULL    /* reserved1,reserved2, etc */
2446   },
2447 };
2448 static const unsigned streaming_protobufs__q__hyst__field_indices_by_name[] = {
2449   0,   /* field[0] = value */
2450 };
2451 static const ProtobufCIntRange streaming_protobufs__q__hyst__number_ranges[1 + 1] =
2452 {
2453   { 1, 0 },
2454   { 0, 1 }
2455 };
2456 const ProtobufCMessageDescriptor streaming_protobufs__q__hyst__descriptor =
2457 {
2458   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2459   "streaming_protobufs.Q_Hyst",
2460   "QHyst",
2461   "StreamingProtobufs__QHyst",
2462   "streaming_protobufs",
2463   sizeof(StreamingProtobufs__QHyst),
2464   1,
2465   streaming_protobufs__q__hyst__field_descriptors,
2466   streaming_protobufs__q__hyst__field_indices_by_name,
2467   1,  streaming_protobufs__q__hyst__number_ranges,
2468   (ProtobufCMessageInit) streaming_protobufs__q__hyst__init,
2469   NULL,NULL,NULL    /* reserved[123] */
2470 };
2471 static const ProtobufCFieldDescriptor streaming_protobufs__speed_state_reselection_pars__field_descriptors[2] =
2472 {
2473   {
2474     "mobilityStateParameters",
2475     1,
2476     PROTOBUF_C_LABEL_NONE,
2477     PROTOBUF_C_TYPE_MESSAGE,
2478     0,   /* quantifier_offset */
2479     offsetof(StreamingProtobufs__SpeedStateReselectionPars, mobilitystateparameters),
2480     &streaming_protobufs__mobility_state_parameters__descriptor,
2481     NULL,
2482     0,             /* flags */
2483     0,NULL,NULL    /* reserved1,reserved2, etc */
2484   },
2485   {
2486     "q_HystSF",
2487     2,
2488     PROTOBUF_C_LABEL_NONE,
2489     PROTOBUF_C_TYPE_MESSAGE,
2490     0,   /* quantifier_offset */
2491     offsetof(StreamingProtobufs__SpeedStateReselectionPars, q_hystsf),
2492     &streaming_protobufs__q__hyst_sf__descriptor,
2493     NULL,
2494     0,             /* flags */
2495     0,NULL,NULL    /* reserved1,reserved2, etc */
2496   },
2497 };
2498 static const unsigned streaming_protobufs__speed_state_reselection_pars__field_indices_by_name[] = {
2499   0,   /* field[0] = mobilityStateParameters */
2500   1,   /* field[1] = q_HystSF */
2501 };
2502 static const ProtobufCIntRange streaming_protobufs__speed_state_reselection_pars__number_ranges[1 + 1] =
2503 {
2504   { 1, 0 },
2505   { 0, 2 }
2506 };
2507 const ProtobufCMessageDescriptor streaming_protobufs__speed_state_reselection_pars__descriptor =
2508 {
2509   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2510   "streaming_protobufs.SpeedStateReselectionPars",
2511   "SpeedStateReselectionPars",
2512   "StreamingProtobufs__SpeedStateReselectionPars",
2513   "streaming_protobufs",
2514   sizeof(StreamingProtobufs__SpeedStateReselectionPars),
2515   2,
2516   streaming_protobufs__speed_state_reselection_pars__field_descriptors,
2517   streaming_protobufs__speed_state_reselection_pars__field_indices_by_name,
2518   1,  streaming_protobufs__speed_state_reselection_pars__number_ranges,
2519   (ProtobufCMessageInit) streaming_protobufs__speed_state_reselection_pars__init,
2520   NULL,NULL,NULL    /* reserved[123] */
2521 };
2522 static const ProtobufCFieldDescriptor streaming_protobufs__q__hyst_sf__field_descriptors[2] =
2523 {
2524   {
2525     "sf_Medium",
2526     1,
2527     PROTOBUF_C_LABEL_NONE,
2528     PROTOBUF_C_TYPE_MESSAGE,
2529     0,   /* quantifier_offset */
2530     offsetof(StreamingProtobufs__QHystSF, sf_medium),
2531     &streaming_protobufs__sf__medium__high__descriptor,
2532     NULL,
2533     0,             /* flags */
2534     0,NULL,NULL    /* reserved1,reserved2, etc */
2535   },
2536   {
2537     "sf_High",
2538     2,
2539     PROTOBUF_C_LABEL_NONE,
2540     PROTOBUF_C_TYPE_MESSAGE,
2541     0,   /* quantifier_offset */
2542     offsetof(StreamingProtobufs__QHystSF, sf_high),
2543     &streaming_protobufs__sf__medium__high__descriptor,
2544     NULL,
2545     0,             /* flags */
2546     0,NULL,NULL    /* reserved1,reserved2, etc */
2547   },
2548 };
2549 static const unsigned streaming_protobufs__q__hyst_sf__field_indices_by_name[] = {
2550   1,   /* field[1] = sf_High */
2551   0,   /* field[0] = sf_Medium */
2552 };
2553 static const ProtobufCIntRange streaming_protobufs__q__hyst_sf__number_ranges[1 + 1] =
2554 {
2555   { 1, 0 },
2556   { 0, 2 }
2557 };
2558 const ProtobufCMessageDescriptor streaming_protobufs__q__hyst_sf__descriptor =
2559 {
2560   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2561   "streaming_protobufs.Q_HystSF",
2562   "QHystSF",
2563   "StreamingProtobufs__QHystSF",
2564   "streaming_protobufs",
2565   sizeof(StreamingProtobufs__QHystSF),
2566   2,
2567   streaming_protobufs__q__hyst_sf__field_descriptors,
2568   streaming_protobufs__q__hyst_sf__field_indices_by_name,
2569   1,  streaming_protobufs__q__hyst_sf__number_ranges,
2570   (ProtobufCMessageInit) streaming_protobufs__q__hyst_sf__init,
2571   NULL,NULL,NULL    /* reserved[123] */
2572 };
2573 static const ProtobufCEnumValue streaming_protobufs__sf__medium__high__value__enum_values_by_number[5] =
2574 {
2575   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SF__MEDIUM__HIGH__VALUE__protobuf_unspecified", 0 },
2576   { "dB_6", "STREAMING_PROTOBUFS__SF__MEDIUM__HIGH__VALUE__dB_6", 1 },
2577   { "dB_4", "STREAMING_PROTOBUFS__SF__MEDIUM__HIGH__VALUE__dB_4", 2 },
2578   { "dB_2", "STREAMING_PROTOBUFS__SF__MEDIUM__HIGH__VALUE__dB_2", 3 },
2579   { "dB0", "STREAMING_PROTOBUFS__SF__MEDIUM__HIGH__VALUE__dB0", 4 },
2580 };
2581 static const ProtobufCIntRange streaming_protobufs__sf__medium__high__value__value_ranges[] = {
2582 {0, 0},{0, 5}
2583 };
2584 static const ProtobufCEnumValueIndex streaming_protobufs__sf__medium__high__value__enum_values_by_name[5] =
2585 {
2586   { "dB0", 4 },
2587   { "dB_2", 3 },
2588   { "dB_4", 2 },
2589   { "dB_6", 1 },
2590   { "protobuf_unspecified", 0 },
2591 };
2592 const ProtobufCEnumDescriptor streaming_protobufs__sf__medium__high__value__descriptor =
2593 {
2594   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2595   "streaming_protobufs.SF_Medium_High.Value",
2596   "Value",
2597   "StreamingProtobufs__SFMediumHigh__Value",
2598   "streaming_protobufs",
2599   5,
2600   streaming_protobufs__sf__medium__high__value__enum_values_by_number,
2601   5,
2602   streaming_protobufs__sf__medium__high__value__enum_values_by_name,
2603   1,
2604   streaming_protobufs__sf__medium__high__value__value_ranges,
2605   NULL,NULL,NULL,NULL   /* reserved[1234] */
2606 };
2607 static const ProtobufCFieldDescriptor streaming_protobufs__sf__medium__high__field_descriptors[1] =
2608 {
2609   {
2610     "value",
2611     1,
2612     PROTOBUF_C_LABEL_NONE,
2613     PROTOBUF_C_TYPE_ENUM,
2614     0,   /* quantifier_offset */
2615     offsetof(StreamingProtobufs__SFMediumHigh, value),
2616     &streaming_protobufs__sf__medium__high__value__descriptor,
2617     NULL,
2618     0,             /* flags */
2619     0,NULL,NULL    /* reserved1,reserved2, etc */
2620   },
2621 };
2622 static const unsigned streaming_protobufs__sf__medium__high__field_indices_by_name[] = {
2623   0,   /* field[0] = value */
2624 };
2625 static const ProtobufCIntRange streaming_protobufs__sf__medium__high__number_ranges[1 + 1] =
2626 {
2627   { 1, 0 },
2628   { 0, 1 }
2629 };
2630 const ProtobufCMessageDescriptor streaming_protobufs__sf__medium__high__descriptor =
2631 {
2632   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2633   "streaming_protobufs.SF_Medium_High",
2634   "SFMediumHigh",
2635   "StreamingProtobufs__SFMediumHigh",
2636   "streaming_protobufs",
2637   sizeof(StreamingProtobufs__SFMediumHigh),
2638   1,
2639   streaming_protobufs__sf__medium__high__field_descriptors,
2640   streaming_protobufs__sf__medium__high__field_indices_by_name,
2641   1,  streaming_protobufs__sf__medium__high__number_ranges,
2642   (ProtobufCMessageInit) streaming_protobufs__sf__medium__high__init,
2643   NULL,NULL,NULL    /* reserved[123] */
2644 };
2645 static const ProtobufCFieldDescriptor streaming_protobufs__sib2_cell_reselection_serving_freq_info__field_descriptors[6] =
2646 {
2647   {
2648     "s_NonIntraSearchP",
2649     1,
2650     PROTOBUF_C_LABEL_NONE,
2651     PROTOBUF_C_TYPE_MESSAGE,
2652     0,   /* quantifier_offset */
2653     offsetof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo, s_nonintrasearchp),
2654     &google__protobuf__uint32_value__descriptor,
2655     NULL,
2656     0,             /* flags */
2657     0,NULL,NULL    /* reserved1,reserved2, etc */
2658   },
2659   {
2660     "s_NonIntraSearchQ",
2661     2,
2662     PROTOBUF_C_LABEL_NONE,
2663     PROTOBUF_C_TYPE_MESSAGE,
2664     0,   /* quantifier_offset */
2665     offsetof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo, s_nonintrasearchq),
2666     &google__protobuf__uint32_value__descriptor,
2667     NULL,
2668     0,             /* flags */
2669     0,NULL,NULL    /* reserved1,reserved2, etc */
2670   },
2671   {
2672     "threshServingLowP",
2673     3,
2674     PROTOBUF_C_LABEL_NONE,
2675     PROTOBUF_C_TYPE_UINT32,
2676     0,   /* quantifier_offset */
2677     offsetof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo, threshservinglowp),
2678     NULL,
2679     NULL,
2680     0,             /* flags */
2681     0,NULL,NULL    /* reserved1,reserved2, etc */
2682   },
2683   {
2684     "threshServingLowQ",
2685     4,
2686     PROTOBUF_C_LABEL_NONE,
2687     PROTOBUF_C_TYPE_MESSAGE,
2688     0,   /* quantifier_offset */
2689     offsetof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo, threshservinglowq),
2690     &google__protobuf__uint32_value__descriptor,
2691     NULL,
2692     0,             /* flags */
2693     0,NULL,NULL    /* reserved1,reserved2, etc */
2694   },
2695   {
2696     "cellReselectionPriority",
2697     5,
2698     PROTOBUF_C_LABEL_NONE,
2699     PROTOBUF_C_TYPE_UINT32,
2700     0,   /* quantifier_offset */
2701     offsetof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo, cellreselectionpriority),
2702     NULL,
2703     NULL,
2704     0,             /* flags */
2705     0,NULL,NULL    /* reserved1,reserved2, etc */
2706   },
2707   {
2708     "cellReselectionSubPriority",
2709     6,
2710     PROTOBUF_C_LABEL_NONE,
2711     PROTOBUF_C_TYPE_MESSAGE,
2712     0,   /* quantifier_offset */
2713     offsetof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo, cellreselectionsubpriority),
2714     &streaming_protobufs__cell_reselection_sub_priority__descriptor,
2715     NULL,
2716     0,             /* flags */
2717     0,NULL,NULL    /* reserved1,reserved2, etc */
2718   },
2719 };
2720 static const unsigned streaming_protobufs__sib2_cell_reselection_serving_freq_info__field_indices_by_name[] = {
2721   4,   /* field[4] = cellReselectionPriority */
2722   5,   /* field[5] = cellReselectionSubPriority */
2723   0,   /* field[0] = s_NonIntraSearchP */
2724   1,   /* field[1] = s_NonIntraSearchQ */
2725   2,   /* field[2] = threshServingLowP */
2726   3,   /* field[3] = threshServingLowQ */
2727 };
2728 static const ProtobufCIntRange streaming_protobufs__sib2_cell_reselection_serving_freq_info__number_ranges[1 + 1] =
2729 {
2730   { 1, 0 },
2731   { 0, 6 }
2732 };
2733 const ProtobufCMessageDescriptor streaming_protobufs__sib2_cell_reselection_serving_freq_info__descriptor =
2734 {
2735   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2736   "streaming_protobufs.SIB2CellReselectionServingFreqInfo",
2737   "SIB2CellReselectionServingFreqInfo",
2738   "StreamingProtobufs__SIB2CellReselectionServingFreqInfo",
2739   "streaming_protobufs",
2740   sizeof(StreamingProtobufs__SIB2CellReselectionServingFreqInfo),
2741   6,
2742   streaming_protobufs__sib2_cell_reselection_serving_freq_info__field_descriptors,
2743   streaming_protobufs__sib2_cell_reselection_serving_freq_info__field_indices_by_name,
2744   1,  streaming_protobufs__sib2_cell_reselection_serving_freq_info__number_ranges,
2745   (ProtobufCMessageInit) streaming_protobufs__sib2_cell_reselection_serving_freq_info__init,
2746   NULL,NULL,NULL    /* reserved[123] */
2747 };
2748 static const ProtobufCEnumValue streaming_protobufs__cell_reselection_sub_priority__value__enum_values_by_number[5] =
2749 {
2750   { "protobuf_unspecified", "STREAMING_PROTOBUFS__CELL_RESELECTION_SUB_PRIORITY__VALUE__protobuf_unspecified", 0 },
2751   { "oDot2", "STREAMING_PROTOBUFS__CELL_RESELECTION_SUB_PRIORITY__VALUE__oDot2", 1 },
2752   { "oDot4", "STREAMING_PROTOBUFS__CELL_RESELECTION_SUB_PRIORITY__VALUE__oDot4", 2 },
2753   { "oDot6", "STREAMING_PROTOBUFS__CELL_RESELECTION_SUB_PRIORITY__VALUE__oDot6", 3 },
2754   { "oDot8", "STREAMING_PROTOBUFS__CELL_RESELECTION_SUB_PRIORITY__VALUE__oDot8", 4 },
2755 };
2756 static const ProtobufCIntRange streaming_protobufs__cell_reselection_sub_priority__value__value_ranges[] = {
2757 {0, 0},{0, 5}
2758 };
2759 static const ProtobufCEnumValueIndex streaming_protobufs__cell_reselection_sub_priority__value__enum_values_by_name[5] =
2760 {
2761   { "oDot2", 1 },
2762   { "oDot4", 2 },
2763   { "oDot6", 3 },
2764   { "oDot8", 4 },
2765   { "protobuf_unspecified", 0 },
2766 };
2767 const ProtobufCEnumDescriptor streaming_protobufs__cell_reselection_sub_priority__value__descriptor =
2768 {
2769   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2770   "streaming_protobufs.CellReselectionSubPriority.Value",
2771   "Value",
2772   "StreamingProtobufs__CellReselectionSubPriority__Value",
2773   "streaming_protobufs",
2774   5,
2775   streaming_protobufs__cell_reselection_sub_priority__value__enum_values_by_number,
2776   5,
2777   streaming_protobufs__cell_reselection_sub_priority__value__enum_values_by_name,
2778   1,
2779   streaming_protobufs__cell_reselection_sub_priority__value__value_ranges,
2780   NULL,NULL,NULL,NULL   /* reserved[1234] */
2781 };
2782 static const ProtobufCFieldDescriptor streaming_protobufs__cell_reselection_sub_priority__field_descriptors[1] =
2783 {
2784   {
2785     "value",
2786     1,
2787     PROTOBUF_C_LABEL_NONE,
2788     PROTOBUF_C_TYPE_ENUM,
2789     0,   /* quantifier_offset */
2790     offsetof(StreamingProtobufs__CellReselectionSubPriority, value),
2791     &streaming_protobufs__cell_reselection_sub_priority__value__descriptor,
2792     NULL,
2793     0,             /* flags */
2794     0,NULL,NULL    /* reserved1,reserved2, etc */
2795   },
2796 };
2797 static const unsigned streaming_protobufs__cell_reselection_sub_priority__field_indices_by_name[] = {
2798   0,   /* field[0] = value */
2799 };
2800 static const ProtobufCIntRange streaming_protobufs__cell_reselection_sub_priority__number_ranges[1 + 1] =
2801 {
2802   { 1, 0 },
2803   { 0, 1 }
2804 };
2805 const ProtobufCMessageDescriptor streaming_protobufs__cell_reselection_sub_priority__descriptor =
2806 {
2807   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2808   "streaming_protobufs.CellReselectionSubPriority",
2809   "CellReselectionSubPriority",
2810   "StreamingProtobufs__CellReselectionSubPriority",
2811   "streaming_protobufs",
2812   sizeof(StreamingProtobufs__CellReselectionSubPriority),
2813   1,
2814   streaming_protobufs__cell_reselection_sub_priority__field_descriptors,
2815   streaming_protobufs__cell_reselection_sub_priority__field_indices_by_name,
2816   1,  streaming_protobufs__cell_reselection_sub_priority__number_ranges,
2817   (ProtobufCMessageInit) streaming_protobufs__cell_reselection_sub_priority__init,
2818   NULL,NULL,NULL    /* reserved[123] */
2819 };
2820 static const ProtobufCFieldDescriptor streaming_protobufs__sib2_intra_freq_cell_reselection_info__field_descriptors[14] =
2821 {
2822   {
2823     "q_RxLevMin",
2824     1,
2825     PROTOBUF_C_LABEL_NONE,
2826     PROTOBUF_C_TYPE_SINT32,
2827     0,   /* quantifier_offset */
2828     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, q_rxlevmin),
2829     NULL,
2830     NULL,
2831     0,             /* flags */
2832     0,NULL,NULL    /* reserved1,reserved2, etc */
2833   },
2834   {
2835     "q_RxLevMinSUL",
2836     2,
2837     PROTOBUF_C_LABEL_NONE,
2838     PROTOBUF_C_TYPE_MESSAGE,
2839     0,   /* quantifier_offset */
2840     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, q_rxlevminsul),
2841     &google__protobuf__int32_value__descriptor,
2842     NULL,
2843     0,             /* flags */
2844     0,NULL,NULL    /* reserved1,reserved2, etc */
2845   },
2846   {
2847     "q_QualMin",
2848     3,
2849     PROTOBUF_C_LABEL_NONE,
2850     PROTOBUF_C_TYPE_MESSAGE,
2851     0,   /* quantifier_offset */
2852     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, q_qualmin),
2853     &google__protobuf__int32_value__descriptor,
2854     NULL,
2855     0,             /* flags */
2856     0,NULL,NULL    /* reserved1,reserved2, etc */
2857   },
2858   {
2859     "s_IntraSearchP",
2860     4,
2861     PROTOBUF_C_LABEL_NONE,
2862     PROTOBUF_C_TYPE_UINT32,
2863     0,   /* quantifier_offset */
2864     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, s_intrasearchp),
2865     NULL,
2866     NULL,
2867     0,             /* flags */
2868     0,NULL,NULL    /* reserved1,reserved2, etc */
2869   },
2870   {
2871     "s_IntraSearchQ",
2872     5,
2873     PROTOBUF_C_LABEL_NONE,
2874     PROTOBUF_C_TYPE_MESSAGE,
2875     0,   /* quantifier_offset */
2876     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, s_intrasearchq),
2877     &google__protobuf__uint32_value__descriptor,
2878     NULL,
2879     0,             /* flags */
2880     0,NULL,NULL    /* reserved1,reserved2, etc */
2881   },
2882   {
2883     "t_ReselectionNR",
2884     6,
2885     PROTOBUF_C_LABEL_NONE,
2886     PROTOBUF_C_TYPE_UINT32,
2887     0,   /* quantifier_offset */
2888     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, t_reselectionnr),
2889     NULL,
2890     NULL,
2891     0,             /* flags */
2892     0,NULL,NULL    /* reserved1,reserved2, etc */
2893   },
2894   {
2895     "frequencyBandList",
2896     7,
2897     PROTOBUF_C_LABEL_NONE,
2898     PROTOBUF_C_TYPE_MESSAGE,
2899     0,   /* quantifier_offset */
2900     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, frequencybandlist),
2901     &streaming_protobufs__multi_frequency_band_list_nr__sib__descriptor,
2902     NULL,
2903     0,             /* flags */
2904     0,NULL,NULL    /* reserved1,reserved2, etc */
2905   },
2906   {
2907     "frequencyBandListSUL",
2908     8,
2909     PROTOBUF_C_LABEL_NONE,
2910     PROTOBUF_C_TYPE_MESSAGE,
2911     0,   /* quantifier_offset */
2912     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, frequencybandlistsul),
2913     &streaming_protobufs__multi_frequency_band_list_nr__sib__descriptor,
2914     NULL,
2915     0,             /* flags */
2916     0,NULL,NULL    /* reserved1,reserved2, etc */
2917   },
2918   {
2919     "p_Max",
2920     9,
2921     PROTOBUF_C_LABEL_NONE,
2922     PROTOBUF_C_TYPE_MESSAGE,
2923     0,   /* quantifier_offset */
2924     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, p_max),
2925     &google__protobuf__int32_value__descriptor,
2926     NULL,
2927     0,             /* flags */
2928     0,NULL,NULL    /* reserved1,reserved2, etc */
2929   },
2930   {
2931     "smtc",
2932     10,
2933     PROTOBUF_C_LABEL_NONE,
2934     PROTOBUF_C_TYPE_MESSAGE,
2935     0,   /* quantifier_offset */
2936     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, smtc),
2937     &streaming_protobufs__ssb__mtc__descriptor,
2938     NULL,
2939     0,             /* flags */
2940     0,NULL,NULL    /* reserved1,reserved2, etc */
2941   },
2942   {
2943     "ss_RSSI_Measurement",
2944     11,
2945     PROTOBUF_C_LABEL_NONE,
2946     PROTOBUF_C_TYPE_MESSAGE,
2947     0,   /* quantifier_offset */
2948     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, ss_rssi_measurement),
2949     &streaming_protobufs__ss__rssi__measurement__descriptor,
2950     NULL,
2951     0,             /* flags */
2952     0,NULL,NULL    /* reserved1,reserved2, etc */
2953   },
2954   {
2955     "ssb_ToMeasure",
2956     12,
2957     PROTOBUF_C_LABEL_NONE,
2958     PROTOBUF_C_TYPE_MESSAGE,
2959     0,   /* quantifier_offset */
2960     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, ssb_tomeasure),
2961     &streaming_protobufs__ssb__to_measure__descriptor,
2962     NULL,
2963     0,             /* flags */
2964     0,NULL,NULL    /* reserved1,reserved2, etc */
2965   },
2966   {
2967     "deriveSSB_IndexFromCell",
2968     13,
2969     PROTOBUF_C_LABEL_NONE,
2970     PROTOBUF_C_TYPE_BOOL,
2971     0,   /* quantifier_offset */
2972     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, derivessb_indexfromcell),
2973     NULL,
2974     NULL,
2975     0,             /* flags */
2976     0,NULL,NULL    /* reserved1,reserved2, etc */
2977   },
2978   {
2979     "t_ReselectionNR_SF",
2980     14,
2981     PROTOBUF_C_LABEL_NONE,
2982     PROTOBUF_C_TYPE_MESSAGE,
2983     0,   /* quantifier_offset */
2984     offsetof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo, t_reselectionnr_sf),
2985     &streaming_protobufs__speed_state_scale_factors__descriptor,
2986     NULL,
2987     0,             /* flags */
2988     0,NULL,NULL    /* reserved1,reserved2, etc */
2989   },
2990 };
2991 static const unsigned streaming_protobufs__sib2_intra_freq_cell_reselection_info__field_indices_by_name[] = {
2992   12,   /* field[12] = deriveSSB_IndexFromCell */
2993   6,   /* field[6] = frequencyBandList */
2994   7,   /* field[7] = frequencyBandListSUL */
2995   8,   /* field[8] = p_Max */
2996   2,   /* field[2] = q_QualMin */
2997   0,   /* field[0] = q_RxLevMin */
2998   1,   /* field[1] = q_RxLevMinSUL */
2999   3,   /* field[3] = s_IntraSearchP */
3000   4,   /* field[4] = s_IntraSearchQ */
3001   9,   /* field[9] = smtc */
3002   10,   /* field[10] = ss_RSSI_Measurement */
3003   11,   /* field[11] = ssb_ToMeasure */
3004   5,   /* field[5] = t_ReselectionNR */
3005   13,   /* field[13] = t_ReselectionNR_SF */
3006 };
3007 static const ProtobufCIntRange streaming_protobufs__sib2_intra_freq_cell_reselection_info__number_ranges[1 + 1] =
3008 {
3009   { 1, 0 },
3010   { 0, 14 }
3011 };
3012 const ProtobufCMessageDescriptor streaming_protobufs__sib2_intra_freq_cell_reselection_info__descriptor =
3013 {
3014   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3015   "streaming_protobufs.SIB2IntraFreqCellReselectionInfo",
3016   "SIB2IntraFreqCellReselectionInfo",
3017   "StreamingProtobufs__SIB2IntraFreqCellReselectionInfo",
3018   "streaming_protobufs",
3019   sizeof(StreamingProtobufs__SIB2IntraFreqCellReselectionInfo),
3020   14,
3021   streaming_protobufs__sib2_intra_freq_cell_reselection_info__field_descriptors,
3022   streaming_protobufs__sib2_intra_freq_cell_reselection_info__field_indices_by_name,
3023   1,  streaming_protobufs__sib2_intra_freq_cell_reselection_info__number_ranges,
3024   (ProtobufCMessageInit) streaming_protobufs__sib2_intra_freq_cell_reselection_info__init,
3025   NULL,NULL,NULL    /* reserved[123] */
3026 };
3027 static const ProtobufCFieldDescriptor streaming_protobufs__speed_state_scale_factors__field_descriptors[2] =
3028 {
3029   {
3030     "sf_Medium",
3031     1,
3032     PROTOBUF_C_LABEL_NONE,
3033     PROTOBUF_C_TYPE_MESSAGE,
3034     0,   /* quantifier_offset */
3035     offsetof(StreamingProtobufs__SpeedStateScaleFactors, sf_medium),
3036     &streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor,
3037     NULL,
3038     0,             /* flags */
3039     0,NULL,NULL    /* reserved1,reserved2, etc */
3040   },
3041   {
3042     "sf_High",
3043     2,
3044     PROTOBUF_C_LABEL_NONE,
3045     PROTOBUF_C_TYPE_MESSAGE,
3046     0,   /* quantifier_offset */
3047     offsetof(StreamingProtobufs__SpeedStateScaleFactors, sf_high),
3048     &streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor,
3049     NULL,
3050     0,             /* flags */
3051     0,NULL,NULL    /* reserved1,reserved2, etc */
3052   },
3053 };
3054 static const unsigned streaming_protobufs__speed_state_scale_factors__field_indices_by_name[] = {
3055   1,   /* field[1] = sf_High */
3056   0,   /* field[0] = sf_Medium */
3057 };
3058 static const ProtobufCIntRange streaming_protobufs__speed_state_scale_factors__number_ranges[1 + 1] =
3059 {
3060   { 1, 0 },
3061   { 0, 2 }
3062 };
3063 const ProtobufCMessageDescriptor streaming_protobufs__speed_state_scale_factors__descriptor =
3064 {
3065   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3066   "streaming_protobufs.SpeedStateScaleFactors",
3067   "SpeedStateScaleFactors",
3068   "StreamingProtobufs__SpeedStateScaleFactors",
3069   "streaming_protobufs",
3070   sizeof(StreamingProtobufs__SpeedStateScaleFactors),
3071   2,
3072   streaming_protobufs__speed_state_scale_factors__field_descriptors,
3073   streaming_protobufs__speed_state_scale_factors__field_indices_by_name,
3074   1,  streaming_protobufs__speed_state_scale_factors__number_ranges,
3075   (ProtobufCMessageInit) streaming_protobufs__speed_state_scale_factors__init,
3076   NULL,NULL,NULL    /* reserved[123] */
3077 };
3078 static const ProtobufCEnumValue streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__enum_values_by_number[5] =
3079 {
3080   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS_SF__MEDIUM__HIGH__VALUE__protobuf_unspecified", 0 },
3081   { "oDot25", "STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS_SF__MEDIUM__HIGH__VALUE__oDot25", 1 },
3082   { "oDot5", "STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS_SF__MEDIUM__HIGH__VALUE__oDot5", 2 },
3083   { "oDot75", "STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS_SF__MEDIUM__HIGH__VALUE__oDot75", 3 },
3084   { "lDot0", "STREAMING_PROTOBUFS__SPEED_STATE_SCALE_FACTORS_SF__MEDIUM__HIGH__VALUE__lDot0", 4 },
3085 };
3086 static const ProtobufCIntRange streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__value_ranges[] = {
3087 {0, 0},{0, 5}
3088 };
3089 static const ProtobufCEnumValueIndex streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__enum_values_by_name[5] =
3090 {
3091   { "lDot0", 4 },
3092   { "oDot25", 1 },
3093   { "oDot5", 2 },
3094   { "oDot75", 3 },
3095   { "protobuf_unspecified", 0 },
3096 };
3097 const ProtobufCEnumDescriptor streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__descriptor =
3098 {
3099   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3100   "streaming_protobufs.SpeedStateScaleFactorsSF_Medium_High.Value",
3101   "Value",
3102   "StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh__Value",
3103   "streaming_protobufs",
3104   5,
3105   streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__enum_values_by_number,
3106   5,
3107   streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__enum_values_by_name,
3108   1,
3109   streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__value_ranges,
3110   NULL,NULL,NULL,NULL   /* reserved[1234] */
3111 };
3112 static const ProtobufCFieldDescriptor streaming_protobufs__speed_state_scale_factors_sf__medium__high__field_descriptors[1] =
3113 {
3114   {
3115     "value",
3116     1,
3117     PROTOBUF_C_LABEL_NONE,
3118     PROTOBUF_C_TYPE_ENUM,
3119     0,   /* quantifier_offset */
3120     offsetof(StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh, value),
3121     &streaming_protobufs__speed_state_scale_factors_sf__medium__high__value__descriptor,
3122     NULL,
3123     0,             /* flags */
3124     0,NULL,NULL    /* reserved1,reserved2, etc */
3125   },
3126 };
3127 static const unsigned streaming_protobufs__speed_state_scale_factors_sf__medium__high__field_indices_by_name[] = {
3128   0,   /* field[0] = value */
3129 };
3130 static const ProtobufCIntRange streaming_protobufs__speed_state_scale_factors_sf__medium__high__number_ranges[1 + 1] =
3131 {
3132   { 1, 0 },
3133   { 0, 1 }
3134 };
3135 const ProtobufCMessageDescriptor streaming_protobufs__speed_state_scale_factors_sf__medium__high__descriptor =
3136 {
3137   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3138   "streaming_protobufs.SpeedStateScaleFactorsSF_Medium_High",
3139   "SpeedStateScaleFactorsSFMediumHigh",
3140   "StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh",
3141   "streaming_protobufs",
3142   sizeof(StreamingProtobufs__SpeedStateScaleFactorsSFMediumHigh),
3143   1,
3144   streaming_protobufs__speed_state_scale_factors_sf__medium__high__field_descriptors,
3145   streaming_protobufs__speed_state_scale_factors_sf__medium__high__field_indices_by_name,
3146   1,  streaming_protobufs__speed_state_scale_factors_sf__medium__high__number_ranges,
3147   (ProtobufCMessageInit) streaming_protobufs__speed_state_scale_factors_sf__medium__high__init,
3148   NULL,NULL,NULL    /* reserved[123] */
3149 };
3150 static const ProtobufCFieldDescriptor streaming_protobufs__sib3__field_descriptors[3] =
3151 {
3152   {
3153     "intraFreqNeighCellList",
3154     1,
3155     PROTOBUF_C_LABEL_NONE,
3156     PROTOBUF_C_TYPE_MESSAGE,
3157     0,   /* quantifier_offset */
3158     offsetof(StreamingProtobufs__SIB3, intrafreqneighcelllist),
3159     &streaming_protobufs__intra_freq_neigh_cell_list__descriptor,
3160     NULL,
3161     0,             /* flags */
3162     0,NULL,NULL    /* reserved1,reserved2, etc */
3163   },
3164   {
3165     "intraFreqBlackCellList",
3166     2,
3167     PROTOBUF_C_LABEL_NONE,
3168     PROTOBUF_C_TYPE_MESSAGE,
3169     0,   /* quantifier_offset */
3170     offsetof(StreamingProtobufs__SIB3, intrafreqblackcelllist),
3171     &streaming_protobufs__intra_freq_black_cell_list__descriptor,
3172     NULL,
3173     0,             /* flags */
3174     0,NULL,NULL    /* reserved1,reserved2, etc */
3175   },
3176   {
3177     "lateNonCriticalExtension",
3178     3,
3179     PROTOBUF_C_LABEL_NONE,
3180     PROTOBUF_C_TYPE_MESSAGE,
3181     0,   /* quantifier_offset */
3182     offsetof(StreamingProtobufs__SIB3, latenoncriticalextension),
3183     &google__protobuf__bytes_value__descriptor,
3184     NULL,
3185     0,             /* flags */
3186     0,NULL,NULL    /* reserved1,reserved2, etc */
3187   },
3188 };
3189 static const unsigned streaming_protobufs__sib3__field_indices_by_name[] = {
3190   1,   /* field[1] = intraFreqBlackCellList */
3191   0,   /* field[0] = intraFreqNeighCellList */
3192   2,   /* field[2] = lateNonCriticalExtension */
3193 };
3194 static const ProtobufCIntRange streaming_protobufs__sib3__number_ranges[1 + 1] =
3195 {
3196   { 1, 0 },
3197   { 0, 3 }
3198 };
3199 const ProtobufCMessageDescriptor streaming_protobufs__sib3__descriptor =
3200 {
3201   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3202   "streaming_protobufs.SIB3",
3203   "SIB3",
3204   "StreamingProtobufs__SIB3",
3205   "streaming_protobufs",
3206   sizeof(StreamingProtobufs__SIB3),
3207   3,
3208   streaming_protobufs__sib3__field_descriptors,
3209   streaming_protobufs__sib3__field_indices_by_name,
3210   1,  streaming_protobufs__sib3__number_ranges,
3211   (ProtobufCMessageInit) streaming_protobufs__sib3__init,
3212   NULL,NULL,NULL    /* reserved[123] */
3213 };
3214 static const ProtobufCFieldDescriptor streaming_protobufs__intra_freq_neigh_cell_list__field_descriptors[1] =
3215 {
3216   {
3217     "items",
3218     1,
3219     PROTOBUF_C_LABEL_REPEATED,
3220     PROTOBUF_C_TYPE_MESSAGE,
3221     offsetof(StreamingProtobufs__IntraFreqNeighCellList, n_items),
3222     offsetof(StreamingProtobufs__IntraFreqNeighCellList, items),
3223     &streaming_protobufs__intra_freq_neigh_cell_info__descriptor,
3224     NULL,
3225     0,             /* flags */
3226     0,NULL,NULL    /* reserved1,reserved2, etc */
3227   },
3228 };
3229 static const unsigned streaming_protobufs__intra_freq_neigh_cell_list__field_indices_by_name[] = {
3230   0,   /* field[0] = items */
3231 };
3232 static const ProtobufCIntRange streaming_protobufs__intra_freq_neigh_cell_list__number_ranges[1 + 1] =
3233 {
3234   { 1, 0 },
3235   { 0, 1 }
3236 };
3237 const ProtobufCMessageDescriptor streaming_protobufs__intra_freq_neigh_cell_list__descriptor =
3238 {
3239   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3240   "streaming_protobufs.IntraFreqNeighCellList",
3241   "IntraFreqNeighCellList",
3242   "StreamingProtobufs__IntraFreqNeighCellList",
3243   "streaming_protobufs",
3244   sizeof(StreamingProtobufs__IntraFreqNeighCellList),
3245   1,
3246   streaming_protobufs__intra_freq_neigh_cell_list__field_descriptors,
3247   streaming_protobufs__intra_freq_neigh_cell_list__field_indices_by_name,
3248   1,  streaming_protobufs__intra_freq_neigh_cell_list__number_ranges,
3249   (ProtobufCMessageInit) streaming_protobufs__intra_freq_neigh_cell_list__init,
3250   NULL,NULL,NULL    /* reserved[123] */
3251 };
3252 static const ProtobufCFieldDescriptor streaming_protobufs__intra_freq_neigh_cell_info__field_descriptors[5] =
3253 {
3254   {
3255     "physCellId",
3256     1,
3257     PROTOBUF_C_LABEL_NONE,
3258     PROTOBUF_C_TYPE_UINT32,
3259     0,   /* quantifier_offset */
3260     offsetof(StreamingProtobufs__IntraFreqNeighCellInfo, physcellid),
3261     NULL,
3262     NULL,
3263     0,             /* flags */
3264     0,NULL,NULL    /* reserved1,reserved2, etc */
3265   },
3266   {
3267     "q_OffsetCell",
3268     2,
3269     PROTOBUF_C_LABEL_NONE,
3270     PROTOBUF_C_TYPE_MESSAGE,
3271     0,   /* quantifier_offset */
3272     offsetof(StreamingProtobufs__IntraFreqNeighCellInfo, q_offsetcell),
3273     &streaming_protobufs__q__offset_range__descriptor,
3274     NULL,
3275     0,             /* flags */
3276     0,NULL,NULL    /* reserved1,reserved2, etc */
3277   },
3278   {
3279     "q_RxLevMinOffsetCell",
3280     3,
3281     PROTOBUF_C_LABEL_NONE,
3282     PROTOBUF_C_TYPE_MESSAGE,
3283     0,   /* quantifier_offset */
3284     offsetof(StreamingProtobufs__IntraFreqNeighCellInfo, q_rxlevminoffsetcell),
3285     &google__protobuf__uint32_value__descriptor,
3286     NULL,
3287     0,             /* flags */
3288     0,NULL,NULL    /* reserved1,reserved2, etc */
3289   },
3290   {
3291     "q_RxLevMinOffsetCellSUL",
3292     4,
3293     PROTOBUF_C_LABEL_NONE,
3294     PROTOBUF_C_TYPE_MESSAGE,
3295     0,   /* quantifier_offset */
3296     offsetof(StreamingProtobufs__IntraFreqNeighCellInfo, q_rxlevminoffsetcellsul),
3297     &google__protobuf__uint32_value__descriptor,
3298     NULL,
3299     0,             /* flags */
3300     0,NULL,NULL    /* reserved1,reserved2, etc */
3301   },
3302   {
3303     "q_QualMinOffsetCell",
3304     5,
3305     PROTOBUF_C_LABEL_NONE,
3306     PROTOBUF_C_TYPE_MESSAGE,
3307     0,   /* quantifier_offset */
3308     offsetof(StreamingProtobufs__IntraFreqNeighCellInfo, q_qualminoffsetcell),
3309     &google__protobuf__uint32_value__descriptor,
3310     NULL,
3311     0,             /* flags */
3312     0,NULL,NULL    /* reserved1,reserved2, etc */
3313   },
3314 };
3315 static const unsigned streaming_protobufs__intra_freq_neigh_cell_info__field_indices_by_name[] = {
3316   0,   /* field[0] = physCellId */
3317   1,   /* field[1] = q_OffsetCell */
3318   4,   /* field[4] = q_QualMinOffsetCell */
3319   2,   /* field[2] = q_RxLevMinOffsetCell */
3320   3,   /* field[3] = q_RxLevMinOffsetCellSUL */
3321 };
3322 static const ProtobufCIntRange streaming_protobufs__intra_freq_neigh_cell_info__number_ranges[1 + 1] =
3323 {
3324   { 1, 0 },
3325   { 0, 5 }
3326 };
3327 const ProtobufCMessageDescriptor streaming_protobufs__intra_freq_neigh_cell_info__descriptor =
3328 {
3329   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3330   "streaming_protobufs.IntraFreqNeighCellInfo",
3331   "IntraFreqNeighCellInfo",
3332   "StreamingProtobufs__IntraFreqNeighCellInfo",
3333   "streaming_protobufs",
3334   sizeof(StreamingProtobufs__IntraFreqNeighCellInfo),
3335   5,
3336   streaming_protobufs__intra_freq_neigh_cell_info__field_descriptors,
3337   streaming_protobufs__intra_freq_neigh_cell_info__field_indices_by_name,
3338   1,  streaming_protobufs__intra_freq_neigh_cell_info__number_ranges,
3339   (ProtobufCMessageInit) streaming_protobufs__intra_freq_neigh_cell_info__init,
3340   NULL,NULL,NULL    /* reserved[123] */
3341 };
3342 static const ProtobufCFieldDescriptor streaming_protobufs__intra_freq_black_cell_list__field_descriptors[1] =
3343 {
3344   {
3345     "items",
3346     1,
3347     PROTOBUF_C_LABEL_REPEATED,
3348     PROTOBUF_C_TYPE_MESSAGE,
3349     offsetof(StreamingProtobufs__IntraFreqBlackCellList, n_items),
3350     offsetof(StreamingProtobufs__IntraFreqBlackCellList, items),
3351     &streaming_protobufs__pci__range__descriptor,
3352     NULL,
3353     0,             /* flags */
3354     0,NULL,NULL    /* reserved1,reserved2, etc */
3355   },
3356 };
3357 static const unsigned streaming_protobufs__intra_freq_black_cell_list__field_indices_by_name[] = {
3358   0,   /* field[0] = items */
3359 };
3360 static const ProtobufCIntRange streaming_protobufs__intra_freq_black_cell_list__number_ranges[1 + 1] =
3361 {
3362   { 1, 0 },
3363   { 0, 1 }
3364 };
3365 const ProtobufCMessageDescriptor streaming_protobufs__intra_freq_black_cell_list__descriptor =
3366 {
3367   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3368   "streaming_protobufs.IntraFreqBlackCellList",
3369   "IntraFreqBlackCellList",
3370   "StreamingProtobufs__IntraFreqBlackCellList",
3371   "streaming_protobufs",
3372   sizeof(StreamingProtobufs__IntraFreqBlackCellList),
3373   1,
3374   streaming_protobufs__intra_freq_black_cell_list__field_descriptors,
3375   streaming_protobufs__intra_freq_black_cell_list__field_indices_by_name,
3376   1,  streaming_protobufs__intra_freq_black_cell_list__number_ranges,
3377   (ProtobufCMessageInit) streaming_protobufs__intra_freq_black_cell_list__init,
3378   NULL,NULL,NULL    /* reserved[123] */
3379 };
3380 static const ProtobufCFieldDescriptor streaming_protobufs__sib4__field_descriptors[2] =
3381 {
3382   {
3383     "interFreqCarrierFreqList",
3384     1,
3385     PROTOBUF_C_LABEL_NONE,
3386     PROTOBUF_C_TYPE_MESSAGE,
3387     0,   /* quantifier_offset */
3388     offsetof(StreamingProtobufs__SIB4, interfreqcarrierfreqlist),
3389     &streaming_protobufs__inter_freq_carrier_freq_list__descriptor,
3390     NULL,
3391     0,             /* flags */
3392     0,NULL,NULL    /* reserved1,reserved2, etc */
3393   },
3394   {
3395     "lateNonCriticalExtension",
3396     2,
3397     PROTOBUF_C_LABEL_NONE,
3398     PROTOBUF_C_TYPE_MESSAGE,
3399     0,   /* quantifier_offset */
3400     offsetof(StreamingProtobufs__SIB4, latenoncriticalextension),
3401     &google__protobuf__bytes_value__descriptor,
3402     NULL,
3403     0,             /* flags */
3404     0,NULL,NULL    /* reserved1,reserved2, etc */
3405   },
3406 };
3407 static const unsigned streaming_protobufs__sib4__field_indices_by_name[] = {
3408   0,   /* field[0] = interFreqCarrierFreqList */
3409   1,   /* field[1] = lateNonCriticalExtension */
3410 };
3411 static const ProtobufCIntRange streaming_protobufs__sib4__number_ranges[1 + 1] =
3412 {
3413   { 1, 0 },
3414   { 0, 2 }
3415 };
3416 const ProtobufCMessageDescriptor streaming_protobufs__sib4__descriptor =
3417 {
3418   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3419   "streaming_protobufs.SIB4",
3420   "SIB4",
3421   "StreamingProtobufs__SIB4",
3422   "streaming_protobufs",
3423   sizeof(StreamingProtobufs__SIB4),
3424   2,
3425   streaming_protobufs__sib4__field_descriptors,
3426   streaming_protobufs__sib4__field_indices_by_name,
3427   1,  streaming_protobufs__sib4__number_ranges,
3428   (ProtobufCMessageInit) streaming_protobufs__sib4__init,
3429   NULL,NULL,NULL    /* reserved[123] */
3430 };
3431 static const ProtobufCFieldDescriptor streaming_protobufs__inter_freq_carrier_freq_list__field_descriptors[1] =
3432 {
3433   {
3434     "items",
3435     1,
3436     PROTOBUF_C_LABEL_REPEATED,
3437     PROTOBUF_C_TYPE_MESSAGE,
3438     offsetof(StreamingProtobufs__InterFreqCarrierFreqList, n_items),
3439     offsetof(StreamingProtobufs__InterFreqCarrierFreqList, items),
3440     &streaming_protobufs__inter_freq_carrier_freq_info__descriptor,
3441     NULL,
3442     0,             /* flags */
3443     0,NULL,NULL    /* reserved1,reserved2, etc */
3444   },
3445 };
3446 static const unsigned streaming_protobufs__inter_freq_carrier_freq_list__field_indices_by_name[] = {
3447   0,   /* field[0] = items */
3448 };
3449 static const ProtobufCIntRange streaming_protobufs__inter_freq_carrier_freq_list__number_ranges[1 + 1] =
3450 {
3451   { 1, 0 },
3452   { 0, 1 }
3453 };
3454 const ProtobufCMessageDescriptor streaming_protobufs__inter_freq_carrier_freq_list__descriptor =
3455 {
3456   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3457   "streaming_protobufs.InterFreqCarrierFreqList",
3458   "InterFreqCarrierFreqList",
3459   "StreamingProtobufs__InterFreqCarrierFreqList",
3460   "streaming_protobufs",
3461   sizeof(StreamingProtobufs__InterFreqCarrierFreqList),
3462   1,
3463   streaming_protobufs__inter_freq_carrier_freq_list__field_descriptors,
3464   streaming_protobufs__inter_freq_carrier_freq_list__field_indices_by_name,
3465   1,  streaming_protobufs__inter_freq_carrier_freq_list__number_ranges,
3466   (ProtobufCMessageInit) streaming_protobufs__inter_freq_carrier_freq_list__init,
3467   NULL,NULL,NULL    /* reserved[123] */
3468 };
3469 static const ProtobufCFieldDescriptor streaming_protobufs__inter_freq_carrier_freq_info__field_descriptors[24] =
3470 {
3471   {
3472     "dl_CarrierFreq",
3473     1,
3474     PROTOBUF_C_LABEL_NONE,
3475     PROTOBUF_C_TYPE_UINT32,
3476     0,   /* quantifier_offset */
3477     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, dl_carrierfreq),
3478     NULL,
3479     NULL,
3480     0,             /* flags */
3481     0,NULL,NULL    /* reserved1,reserved2, etc */
3482   },
3483   {
3484     "frequencyBandList",
3485     2,
3486     PROTOBUF_C_LABEL_NONE,
3487     PROTOBUF_C_TYPE_MESSAGE,
3488     0,   /* quantifier_offset */
3489     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, frequencybandlist),
3490     &streaming_protobufs__multi_frequency_band_list_nr__sib__descriptor,
3491     NULL,
3492     0,             /* flags */
3493     0,NULL,NULL    /* reserved1,reserved2, etc */
3494   },
3495   {
3496     "frequencyBandListSUL",
3497     3,
3498     PROTOBUF_C_LABEL_NONE,
3499     PROTOBUF_C_TYPE_MESSAGE,
3500     0,   /* quantifier_offset */
3501     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, frequencybandlistsul),
3502     &streaming_protobufs__multi_frequency_band_list_nr__sib__descriptor,
3503     NULL,
3504     0,             /* flags */
3505     0,NULL,NULL    /* reserved1,reserved2, etc */
3506   },
3507   {
3508     "nrofSS_BlocksToAverage",
3509     4,
3510     PROTOBUF_C_LABEL_NONE,
3511     PROTOBUF_C_TYPE_MESSAGE,
3512     0,   /* quantifier_offset */
3513     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, nrofss_blockstoaverage),
3514     &google__protobuf__uint32_value__descriptor,
3515     NULL,
3516     0,             /* flags */
3517     0,NULL,NULL    /* reserved1,reserved2, etc */
3518   },
3519   {
3520     "absThreshSS_BlocksConsolidation",
3521     5,
3522     PROTOBUF_C_LABEL_NONE,
3523     PROTOBUF_C_TYPE_MESSAGE,
3524     0,   /* quantifier_offset */
3525     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, absthreshss_blocksconsolidation),
3526     &streaming_protobufs__threshold_nr__descriptor,
3527     NULL,
3528     0,             /* flags */
3529     0,NULL,NULL    /* reserved1,reserved2, etc */
3530   },
3531   {
3532     "smtc",
3533     6,
3534     PROTOBUF_C_LABEL_NONE,
3535     PROTOBUF_C_TYPE_MESSAGE,
3536     0,   /* quantifier_offset */
3537     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, smtc),
3538     &streaming_protobufs__ssb__mtc__descriptor,
3539     NULL,
3540     0,             /* flags */
3541     0,NULL,NULL    /* reserved1,reserved2, etc */
3542   },
3543   {
3544     "ssbSubcarrierSpacing",
3545     7,
3546     PROTOBUF_C_LABEL_NONE,
3547     PROTOBUF_C_TYPE_MESSAGE,
3548     0,   /* quantifier_offset */
3549     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, ssbsubcarrierspacing),
3550     &streaming_protobufs__subcarrier_spacing__descriptor,
3551     NULL,
3552     0,             /* flags */
3553     0,NULL,NULL    /* reserved1,reserved2, etc */
3554   },
3555   {
3556     "ssb_ToMeasure",
3557     8,
3558     PROTOBUF_C_LABEL_NONE,
3559     PROTOBUF_C_TYPE_MESSAGE,
3560     0,   /* quantifier_offset */
3561     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, ssb_tomeasure),
3562     &streaming_protobufs__ssb__to_measure__descriptor,
3563     NULL,
3564     0,             /* flags */
3565     0,NULL,NULL    /* reserved1,reserved2, etc */
3566   },
3567   {
3568     "deriveSSB_IndexFromCell",
3569     9,
3570     PROTOBUF_C_LABEL_NONE,
3571     PROTOBUF_C_TYPE_BOOL,
3572     0,   /* quantifier_offset */
3573     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, derivessb_indexfromcell),
3574     NULL,
3575     NULL,
3576     0,             /* flags */
3577     0,NULL,NULL    /* reserved1,reserved2, etc */
3578   },
3579   {
3580     "ss_RSSI_Measurement",
3581     10,
3582     PROTOBUF_C_LABEL_NONE,
3583     PROTOBUF_C_TYPE_MESSAGE,
3584     0,   /* quantifier_offset */
3585     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, ss_rssi_measurement),
3586     &streaming_protobufs__ss__rssi__measurement__descriptor,
3587     NULL,
3588     0,             /* flags */
3589     0,NULL,NULL    /* reserved1,reserved2, etc */
3590   },
3591   {
3592     "q_RxLevMin",
3593     11,
3594     PROTOBUF_C_LABEL_NONE,
3595     PROTOBUF_C_TYPE_SINT32,
3596     0,   /* quantifier_offset */
3597     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, q_rxlevmin),
3598     NULL,
3599     NULL,
3600     0,             /* flags */
3601     0,NULL,NULL    /* reserved1,reserved2, etc */
3602   },
3603   {
3604     "q_RxLevMinSUL",
3605     12,
3606     PROTOBUF_C_LABEL_NONE,
3607     PROTOBUF_C_TYPE_MESSAGE,
3608     0,   /* quantifier_offset */
3609     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, q_rxlevminsul),
3610     &google__protobuf__int32_value__descriptor,
3611     NULL,
3612     0,             /* flags */
3613     0,NULL,NULL    /* reserved1,reserved2, etc */
3614   },
3615   {
3616     "q_QualMin",
3617     13,
3618     PROTOBUF_C_LABEL_NONE,
3619     PROTOBUF_C_TYPE_MESSAGE,
3620     0,   /* quantifier_offset */
3621     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, q_qualmin),
3622     &google__protobuf__int32_value__descriptor,
3623     NULL,
3624     0,             /* flags */
3625     0,NULL,NULL    /* reserved1,reserved2, etc */
3626   },
3627   {
3628     "p_Max",
3629     14,
3630     PROTOBUF_C_LABEL_NONE,
3631     PROTOBUF_C_TYPE_MESSAGE,
3632     0,   /* quantifier_offset */
3633     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, p_max),
3634     &google__protobuf__int32_value__descriptor,
3635     NULL,
3636     0,             /* flags */
3637     0,NULL,NULL    /* reserved1,reserved2, etc */
3638   },
3639   {
3640     "t_ReselectionNR",
3641     15,
3642     PROTOBUF_C_LABEL_NONE,
3643     PROTOBUF_C_TYPE_UINT32,
3644     0,   /* quantifier_offset */
3645     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, t_reselectionnr),
3646     NULL,
3647     NULL,
3648     0,             /* flags */
3649     0,NULL,NULL    /* reserved1,reserved2, etc */
3650   },
3651   {
3652     "t_ReselectionNR_SF",
3653     16,
3654     PROTOBUF_C_LABEL_NONE,
3655     PROTOBUF_C_TYPE_MESSAGE,
3656     0,   /* quantifier_offset */
3657     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, t_reselectionnr_sf),
3658     &streaming_protobufs__speed_state_scale_factors__descriptor,
3659     NULL,
3660     0,             /* flags */
3661     0,NULL,NULL    /* reserved1,reserved2, etc */
3662   },
3663   {
3664     "threshX_HighP",
3665     17,
3666     PROTOBUF_C_LABEL_NONE,
3667     PROTOBUF_C_TYPE_UINT32,
3668     0,   /* quantifier_offset */
3669     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, threshx_highp),
3670     NULL,
3671     NULL,
3672     0,             /* flags */
3673     0,NULL,NULL    /* reserved1,reserved2, etc */
3674   },
3675   {
3676     "threshX_LowP",
3677     18,
3678     PROTOBUF_C_LABEL_NONE,
3679     PROTOBUF_C_TYPE_UINT32,
3680     0,   /* quantifier_offset */
3681     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, threshx_lowp),
3682     NULL,
3683     NULL,
3684     0,             /* flags */
3685     0,NULL,NULL    /* reserved1,reserved2, etc */
3686   },
3687   {
3688     "threshX_Q",
3689     19,
3690     PROTOBUF_C_LABEL_NONE,
3691     PROTOBUF_C_TYPE_MESSAGE,
3692     0,   /* quantifier_offset */
3693     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, threshx_q),
3694     &streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor,
3695     NULL,
3696     0,             /* flags */
3697     0,NULL,NULL    /* reserved1,reserved2, etc */
3698   },
3699   {
3700     "cellReselectionPriority",
3701     20,
3702     PROTOBUF_C_LABEL_NONE,
3703     PROTOBUF_C_TYPE_MESSAGE,
3704     0,   /* quantifier_offset */
3705     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, cellreselectionpriority),
3706     &google__protobuf__uint32_value__descriptor,
3707     NULL,
3708     0,             /* flags */
3709     0,NULL,NULL    /* reserved1,reserved2, etc */
3710   },
3711   {
3712     "cellReselectionSubPriority",
3713     21,
3714     PROTOBUF_C_LABEL_NONE,
3715     PROTOBUF_C_TYPE_MESSAGE,
3716     0,   /* quantifier_offset */
3717     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, cellreselectionsubpriority),
3718     &streaming_protobufs__cell_reselection_sub_priority__descriptor,
3719     NULL,
3720     0,             /* flags */
3721     0,NULL,NULL    /* reserved1,reserved2, etc */
3722   },
3723   {
3724     "q_OffsetFreq",
3725     22,
3726     PROTOBUF_C_LABEL_NONE,
3727     PROTOBUF_C_TYPE_MESSAGE,
3728     0,   /* quantifier_offset */
3729     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, q_offsetfreq),
3730     &streaming_protobufs__q__offset_range__descriptor,
3731     NULL,
3732     0,             /* flags */
3733     0,NULL,NULL    /* reserved1,reserved2, etc */
3734   },
3735   {
3736     "interFreqNeighCellList",
3737     23,
3738     PROTOBUF_C_LABEL_NONE,
3739     PROTOBUF_C_TYPE_MESSAGE,
3740     0,   /* quantifier_offset */
3741     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, interfreqneighcelllist),
3742     &streaming_protobufs__inter_freq_neigh_cell_list__descriptor,
3743     NULL,
3744     0,             /* flags */
3745     0,NULL,NULL    /* reserved1,reserved2, etc */
3746   },
3747   {
3748     "interFreqBlackCellList",
3749     24,
3750     PROTOBUF_C_LABEL_NONE,
3751     PROTOBUF_C_TYPE_MESSAGE,
3752     0,   /* quantifier_offset */
3753     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfo, interfreqblackcelllist),
3754     &streaming_protobufs__inter_freq_black_cell_list__descriptor,
3755     NULL,
3756     0,             /* flags */
3757     0,NULL,NULL    /* reserved1,reserved2, etc */
3758   },
3759 };
3760 static const unsigned streaming_protobufs__inter_freq_carrier_freq_info__field_indices_by_name[] = {
3761   4,   /* field[4] = absThreshSS_BlocksConsolidation */
3762   19,   /* field[19] = cellReselectionPriority */
3763   20,   /* field[20] = cellReselectionSubPriority */
3764   8,   /* field[8] = deriveSSB_IndexFromCell */
3765   0,   /* field[0] = dl_CarrierFreq */
3766   1,   /* field[1] = frequencyBandList */
3767   2,   /* field[2] = frequencyBandListSUL */
3768   23,   /* field[23] = interFreqBlackCellList */
3769   22,   /* field[22] = interFreqNeighCellList */
3770   3,   /* field[3] = nrofSS_BlocksToAverage */
3771   13,   /* field[13] = p_Max */
3772   21,   /* field[21] = q_OffsetFreq */
3773   12,   /* field[12] = q_QualMin */
3774   10,   /* field[10] = q_RxLevMin */
3775   11,   /* field[11] = q_RxLevMinSUL */
3776   5,   /* field[5] = smtc */
3777   9,   /* field[9] = ss_RSSI_Measurement */
3778   6,   /* field[6] = ssbSubcarrierSpacing */
3779   7,   /* field[7] = ssb_ToMeasure */
3780   14,   /* field[14] = t_ReselectionNR */
3781   15,   /* field[15] = t_ReselectionNR_SF */
3782   16,   /* field[16] = threshX_HighP */
3783   17,   /* field[17] = threshX_LowP */
3784   18,   /* field[18] = threshX_Q */
3785 };
3786 static const ProtobufCIntRange streaming_protobufs__inter_freq_carrier_freq_info__number_ranges[1 + 1] =
3787 {
3788   { 1, 0 },
3789   { 0, 24 }
3790 };
3791 const ProtobufCMessageDescriptor streaming_protobufs__inter_freq_carrier_freq_info__descriptor =
3792 {
3793   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3794   "streaming_protobufs.InterFreqCarrierFreqInfo",
3795   "InterFreqCarrierFreqInfo",
3796   "StreamingProtobufs__InterFreqCarrierFreqInfo",
3797   "streaming_protobufs",
3798   sizeof(StreamingProtobufs__InterFreqCarrierFreqInfo),
3799   24,
3800   streaming_protobufs__inter_freq_carrier_freq_info__field_descriptors,
3801   streaming_protobufs__inter_freq_carrier_freq_info__field_indices_by_name,
3802   1,  streaming_protobufs__inter_freq_carrier_freq_info__number_ranges,
3803   (ProtobufCMessageInit) streaming_protobufs__inter_freq_carrier_freq_info__init,
3804   NULL,NULL,NULL    /* reserved[123] */
3805 };
3806 static const ProtobufCFieldDescriptor streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__field_descriptors[2] =
3807 {
3808   {
3809     "threshX_HighQ",
3810     1,
3811     PROTOBUF_C_LABEL_NONE,
3812     PROTOBUF_C_TYPE_UINT32,
3813     0,   /* quantifier_offset */
3814     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ, threshx_highq),
3815     NULL,
3816     NULL,
3817     0,             /* flags */
3818     0,NULL,NULL    /* reserved1,reserved2, etc */
3819   },
3820   {
3821     "threshX_LowQ",
3822     2,
3823     PROTOBUF_C_LABEL_NONE,
3824     PROTOBUF_C_TYPE_UINT32,
3825     0,   /* quantifier_offset */
3826     offsetof(StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ, threshx_lowq),
3827     NULL,
3828     NULL,
3829     0,             /* flags */
3830     0,NULL,NULL    /* reserved1,reserved2, etc */
3831   },
3832 };
3833 static const unsigned streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__field_indices_by_name[] = {
3834   0,   /* field[0] = threshX_HighQ */
3835   1,   /* field[1] = threshX_LowQ */
3836 };
3837 static const ProtobufCIntRange streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__number_ranges[1 + 1] =
3838 {
3839   { 1, 0 },
3840   { 0, 2 }
3841 };
3842 const ProtobufCMessageDescriptor streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__descriptor =
3843 {
3844   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3845   "streaming_protobufs.InterFreqCarrierFreqInfoThreshX_Q",
3846   "InterFreqCarrierFreqInfoThreshXQ",
3847   "StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ",
3848   "streaming_protobufs",
3849   sizeof(StreamingProtobufs__InterFreqCarrierFreqInfoThreshXQ),
3850   2,
3851   streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__field_descriptors,
3852   streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__field_indices_by_name,
3853   1,  streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__number_ranges,
3854   (ProtobufCMessageInit) streaming_protobufs__inter_freq_carrier_freq_info_thresh_x__q__init,
3855   NULL,NULL,NULL    /* reserved[123] */
3856 };
3857 static const ProtobufCFieldDescriptor streaming_protobufs__inter_freq_neigh_cell_list__field_descriptors[1] =
3858 {
3859   {
3860     "items",
3861     1,
3862     PROTOBUF_C_LABEL_REPEATED,
3863     PROTOBUF_C_TYPE_MESSAGE,
3864     offsetof(StreamingProtobufs__InterFreqNeighCellList, n_items),
3865     offsetof(StreamingProtobufs__InterFreqNeighCellList, items),
3866     &streaming_protobufs__inter_freq_neigh_cell_info__descriptor,
3867     NULL,
3868     0,             /* flags */
3869     0,NULL,NULL    /* reserved1,reserved2, etc */
3870   },
3871 };
3872 static const unsigned streaming_protobufs__inter_freq_neigh_cell_list__field_indices_by_name[] = {
3873   0,   /* field[0] = items */
3874 };
3875 static const ProtobufCIntRange streaming_protobufs__inter_freq_neigh_cell_list__number_ranges[1 + 1] =
3876 {
3877   { 1, 0 },
3878   { 0, 1 }
3879 };
3880 const ProtobufCMessageDescriptor streaming_protobufs__inter_freq_neigh_cell_list__descriptor =
3881 {
3882   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3883   "streaming_protobufs.InterFreqNeighCellList",
3884   "InterFreqNeighCellList",
3885   "StreamingProtobufs__InterFreqNeighCellList",
3886   "streaming_protobufs",
3887   sizeof(StreamingProtobufs__InterFreqNeighCellList),
3888   1,
3889   streaming_protobufs__inter_freq_neigh_cell_list__field_descriptors,
3890   streaming_protobufs__inter_freq_neigh_cell_list__field_indices_by_name,
3891   1,  streaming_protobufs__inter_freq_neigh_cell_list__number_ranges,
3892   (ProtobufCMessageInit) streaming_protobufs__inter_freq_neigh_cell_list__init,
3893   NULL,NULL,NULL    /* reserved[123] */
3894 };
3895 static const ProtobufCFieldDescriptor streaming_protobufs__inter_freq_neigh_cell_info__field_descriptors[5] =
3896 {
3897   {
3898     "physCellId",
3899     1,
3900     PROTOBUF_C_LABEL_NONE,
3901     PROTOBUF_C_TYPE_UINT32,
3902     0,   /* quantifier_offset */
3903     offsetof(StreamingProtobufs__InterFreqNeighCellInfo, physcellid),
3904     NULL,
3905     NULL,
3906     0,             /* flags */
3907     0,NULL,NULL    /* reserved1,reserved2, etc */
3908   },
3909   {
3910     "q_OffsetCell",
3911     2,
3912     PROTOBUF_C_LABEL_NONE,
3913     PROTOBUF_C_TYPE_MESSAGE,
3914     0,   /* quantifier_offset */
3915     offsetof(StreamingProtobufs__InterFreqNeighCellInfo, q_offsetcell),
3916     &streaming_protobufs__q__offset_range__descriptor,
3917     NULL,
3918     0,             /* flags */
3919     0,NULL,NULL    /* reserved1,reserved2, etc */
3920   },
3921   {
3922     "q_RxLevMinOffsetCell",
3923     3,
3924     PROTOBUF_C_LABEL_NONE,
3925     PROTOBUF_C_TYPE_MESSAGE,
3926     0,   /* quantifier_offset */
3927     offsetof(StreamingProtobufs__InterFreqNeighCellInfo, q_rxlevminoffsetcell),
3928     &google__protobuf__uint32_value__descriptor,
3929     NULL,
3930     0,             /* flags */
3931     0,NULL,NULL    /* reserved1,reserved2, etc */
3932   },
3933   {
3934     "q_RxLevMinOffsetCellSUL",
3935     4,
3936     PROTOBUF_C_LABEL_NONE,
3937     PROTOBUF_C_TYPE_MESSAGE,
3938     0,   /* quantifier_offset */
3939     offsetof(StreamingProtobufs__InterFreqNeighCellInfo, q_rxlevminoffsetcellsul),
3940     &google__protobuf__uint32_value__descriptor,
3941     NULL,
3942     0,             /* flags */
3943     0,NULL,NULL    /* reserved1,reserved2, etc */
3944   },
3945   {
3946     "q_QualMinOffsetCell",
3947     5,
3948     PROTOBUF_C_LABEL_NONE,
3949     PROTOBUF_C_TYPE_MESSAGE,
3950     0,   /* quantifier_offset */
3951     offsetof(StreamingProtobufs__InterFreqNeighCellInfo, q_qualminoffsetcell),
3952     &google__protobuf__uint32_value__descriptor,
3953     NULL,
3954     0,             /* flags */
3955     0,NULL,NULL    /* reserved1,reserved2, etc */
3956   },
3957 };
3958 static const unsigned streaming_protobufs__inter_freq_neigh_cell_info__field_indices_by_name[] = {
3959   0,   /* field[0] = physCellId */
3960   1,   /* field[1] = q_OffsetCell */
3961   4,   /* field[4] = q_QualMinOffsetCell */
3962   2,   /* field[2] = q_RxLevMinOffsetCell */
3963   3,   /* field[3] = q_RxLevMinOffsetCellSUL */
3964 };
3965 static const ProtobufCIntRange streaming_protobufs__inter_freq_neigh_cell_info__number_ranges[1 + 1] =
3966 {
3967   { 1, 0 },
3968   { 0, 5 }
3969 };
3970 const ProtobufCMessageDescriptor streaming_protobufs__inter_freq_neigh_cell_info__descriptor =
3971 {
3972   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3973   "streaming_protobufs.InterFreqNeighCellInfo",
3974   "InterFreqNeighCellInfo",
3975   "StreamingProtobufs__InterFreqNeighCellInfo",
3976   "streaming_protobufs",
3977   sizeof(StreamingProtobufs__InterFreqNeighCellInfo),
3978   5,
3979   streaming_protobufs__inter_freq_neigh_cell_info__field_descriptors,
3980   streaming_protobufs__inter_freq_neigh_cell_info__field_indices_by_name,
3981   1,  streaming_protobufs__inter_freq_neigh_cell_info__number_ranges,
3982   (ProtobufCMessageInit) streaming_protobufs__inter_freq_neigh_cell_info__init,
3983   NULL,NULL,NULL    /* reserved[123] */
3984 };
3985 static const ProtobufCFieldDescriptor streaming_protobufs__inter_freq_black_cell_list__field_descriptors[1] =
3986 {
3987   {
3988     "items",
3989     1,
3990     PROTOBUF_C_LABEL_REPEATED,
3991     PROTOBUF_C_TYPE_MESSAGE,
3992     offsetof(StreamingProtobufs__InterFreqBlackCellList, n_items),
3993     offsetof(StreamingProtobufs__InterFreqBlackCellList, items),
3994     &streaming_protobufs__pci__range__descriptor,
3995     NULL,
3996     0,             /* flags */
3997     0,NULL,NULL    /* reserved1,reserved2, etc */
3998   },
3999 };
4000 static const unsigned streaming_protobufs__inter_freq_black_cell_list__field_indices_by_name[] = {
4001   0,   /* field[0] = items */
4002 };
4003 static const ProtobufCIntRange streaming_protobufs__inter_freq_black_cell_list__number_ranges[1 + 1] =
4004 {
4005   { 1, 0 },
4006   { 0, 1 }
4007 };
4008 const ProtobufCMessageDescriptor streaming_protobufs__inter_freq_black_cell_list__descriptor =
4009 {
4010   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4011   "streaming_protobufs.InterFreqBlackCellList",
4012   "InterFreqBlackCellList",
4013   "StreamingProtobufs__InterFreqBlackCellList",
4014   "streaming_protobufs",
4015   sizeof(StreamingProtobufs__InterFreqBlackCellList),
4016   1,
4017   streaming_protobufs__inter_freq_black_cell_list__field_descriptors,
4018   streaming_protobufs__inter_freq_black_cell_list__field_indices_by_name,
4019   1,  streaming_protobufs__inter_freq_black_cell_list__number_ranges,
4020   (ProtobufCMessageInit) streaming_protobufs__inter_freq_black_cell_list__init,
4021   NULL,NULL,NULL    /* reserved[123] */
4022 };
4023 static const ProtobufCFieldDescriptor streaming_protobufs__sib5__field_descriptors[4] =
4024 {
4025   {
4026     "carrierFreqListEUTRA",
4027     1,
4028     PROTOBUF_C_LABEL_NONE,
4029     PROTOBUF_C_TYPE_MESSAGE,
4030     0,   /* quantifier_offset */
4031     offsetof(StreamingProtobufs__SIB5, carrierfreqlisteutra),
4032     &streaming_protobufs__carrier_freq_list_eutra__descriptor,
4033     NULL,
4034     0,             /* flags */
4035     0,NULL,NULL    /* reserved1,reserved2, etc */
4036   },
4037   {
4038     "t_ReselectionEUTRA",
4039     2,
4040     PROTOBUF_C_LABEL_NONE,
4041     PROTOBUF_C_TYPE_UINT32,
4042     0,   /* quantifier_offset */
4043     offsetof(StreamingProtobufs__SIB5, t_reselectioneutra),
4044     NULL,
4045     NULL,
4046     0,             /* flags */
4047     0,NULL,NULL    /* reserved1,reserved2, etc */
4048   },
4049   {
4050     "t_ReselectionEUTRA_SF",
4051     3,
4052     PROTOBUF_C_LABEL_NONE,
4053     PROTOBUF_C_TYPE_MESSAGE,
4054     0,   /* quantifier_offset */
4055     offsetof(StreamingProtobufs__SIB5, t_reselectioneutra_sf),
4056     &streaming_protobufs__speed_state_scale_factors__descriptor,
4057     NULL,
4058     0,             /* flags */
4059     0,NULL,NULL    /* reserved1,reserved2, etc */
4060   },
4061   {
4062     "lateNonCriticalExtension",
4063     4,
4064     PROTOBUF_C_LABEL_NONE,
4065     PROTOBUF_C_TYPE_MESSAGE,
4066     0,   /* quantifier_offset */
4067     offsetof(StreamingProtobufs__SIB5, latenoncriticalextension),
4068     &google__protobuf__bytes_value__descriptor,
4069     NULL,
4070     0,             /* flags */
4071     0,NULL,NULL    /* reserved1,reserved2, etc */
4072   },
4073 };
4074 static const unsigned streaming_protobufs__sib5__field_indices_by_name[] = {
4075   0,   /* field[0] = carrierFreqListEUTRA */
4076   3,   /* field[3] = lateNonCriticalExtension */
4077   1,   /* field[1] = t_ReselectionEUTRA */
4078   2,   /* field[2] = t_ReselectionEUTRA_SF */
4079 };
4080 static const ProtobufCIntRange streaming_protobufs__sib5__number_ranges[1 + 1] =
4081 {
4082   { 1, 0 },
4083   { 0, 4 }
4084 };
4085 const ProtobufCMessageDescriptor streaming_protobufs__sib5__descriptor =
4086 {
4087   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4088   "streaming_protobufs.SIB5",
4089   "SIB5",
4090   "StreamingProtobufs__SIB5",
4091   "streaming_protobufs",
4092   sizeof(StreamingProtobufs__SIB5),
4093   4,
4094   streaming_protobufs__sib5__field_descriptors,
4095   streaming_protobufs__sib5__field_indices_by_name,
4096   1,  streaming_protobufs__sib5__number_ranges,
4097   (ProtobufCMessageInit) streaming_protobufs__sib5__init,
4098   NULL,NULL,NULL    /* reserved[123] */
4099 };
4100 static const ProtobufCFieldDescriptor streaming_protobufs__carrier_freq_list_eutra__field_descriptors[1] =
4101 {
4102   {
4103     "items",
4104     1,
4105     PROTOBUF_C_LABEL_REPEATED,
4106     PROTOBUF_C_TYPE_MESSAGE,
4107     offsetof(StreamingProtobufs__CarrierFreqListEUTRA, n_items),
4108     offsetof(StreamingProtobufs__CarrierFreqListEUTRA, items),
4109     &streaming_protobufs__carrier_freq_eutra__descriptor,
4110     NULL,
4111     0,             /* flags */
4112     0,NULL,NULL    /* reserved1,reserved2, etc */
4113   },
4114 };
4115 static const unsigned streaming_protobufs__carrier_freq_list_eutra__field_indices_by_name[] = {
4116   0,   /* field[0] = items */
4117 };
4118 static const ProtobufCIntRange streaming_protobufs__carrier_freq_list_eutra__number_ranges[1 + 1] =
4119 {
4120   { 1, 0 },
4121   { 0, 1 }
4122 };
4123 const ProtobufCMessageDescriptor streaming_protobufs__carrier_freq_list_eutra__descriptor =
4124 {
4125   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4126   "streaming_protobufs.CarrierFreqListEUTRA",
4127   "CarrierFreqListEUTRA",
4128   "StreamingProtobufs__CarrierFreqListEUTRA",
4129   "streaming_protobufs",
4130   sizeof(StreamingProtobufs__CarrierFreqListEUTRA),
4131   1,
4132   streaming_protobufs__carrier_freq_list_eutra__field_descriptors,
4133   streaming_protobufs__carrier_freq_list_eutra__field_indices_by_name,
4134   1,  streaming_protobufs__carrier_freq_list_eutra__number_ranges,
4135   (ProtobufCMessageInit) streaming_protobufs__carrier_freq_list_eutra__init,
4136   NULL,NULL,NULL    /* reserved[123] */
4137 };
4138 static const ProtobufCFieldDescriptor streaming_protobufs__carrier_freq_eutra__field_descriptors[14] =
4139 {
4140   {
4141     "carrierFreq",
4142     1,
4143     PROTOBUF_C_LABEL_NONE,
4144     PROTOBUF_C_TYPE_UINT32,
4145     0,   /* quantifier_offset */
4146     offsetof(StreamingProtobufs__CarrierFreqEUTRA, carrierfreq),
4147     NULL,
4148     NULL,
4149     0,             /* flags */
4150     0,NULL,NULL    /* reserved1,reserved2, etc */
4151   },
4152   {
4153     "eutra_multiBandInfoList",
4154     2,
4155     PROTOBUF_C_LABEL_NONE,
4156     PROTOBUF_C_TYPE_MESSAGE,
4157     0,   /* quantifier_offset */
4158     offsetof(StreamingProtobufs__CarrierFreqEUTRA, eutra_multibandinfolist),
4159     &streaming_protobufs__eutra__multi_band_info_list__descriptor,
4160     NULL,
4161     0,             /* flags */
4162     0,NULL,NULL    /* reserved1,reserved2, etc */
4163   },
4164   {
4165     "eutra_FreqNeighCellList",
4166     3,
4167     PROTOBUF_C_LABEL_NONE,
4168     PROTOBUF_C_TYPE_MESSAGE,
4169     0,   /* quantifier_offset */
4170     offsetof(StreamingProtobufs__CarrierFreqEUTRA, eutra_freqneighcelllist),
4171     &streaming_protobufs__eutra__freq_neigh_cell_list__descriptor,
4172     NULL,
4173     0,             /* flags */
4174     0,NULL,NULL    /* reserved1,reserved2, etc */
4175   },
4176   {
4177     "eutra_BlackCellList",
4178     4,
4179     PROTOBUF_C_LABEL_NONE,
4180     PROTOBUF_C_TYPE_MESSAGE,
4181     0,   /* quantifier_offset */
4182     offsetof(StreamingProtobufs__CarrierFreqEUTRA, eutra_blackcelllist),
4183     &streaming_protobufs__eutra__freq_black_cell_list__descriptor,
4184     NULL,
4185     0,             /* flags */
4186     0,NULL,NULL    /* reserved1,reserved2, etc */
4187   },
4188   {
4189     "allowedMeasBandwidth",
4190     5,
4191     PROTOBUF_C_LABEL_NONE,
4192     PROTOBUF_C_TYPE_MESSAGE,
4193     0,   /* quantifier_offset */
4194     offsetof(StreamingProtobufs__CarrierFreqEUTRA, allowedmeasbandwidth),
4195     &streaming_protobufs__eutra__allowed_meas_bandwidth__descriptor,
4196     NULL,
4197     0,             /* flags */
4198     0,NULL,NULL    /* reserved1,reserved2, etc */
4199   },
4200   {
4201     "presenceAntennaPort1",
4202     6,
4203     PROTOBUF_C_LABEL_NONE,
4204     PROTOBUF_C_TYPE_BOOL,
4205     0,   /* quantifier_offset */
4206     offsetof(StreamingProtobufs__CarrierFreqEUTRA, presenceantennaport1),
4207     NULL,
4208     NULL,
4209     0,             /* flags */
4210     0,NULL,NULL    /* reserved1,reserved2, etc */
4211   },
4212   {
4213     "cellReselectionPriority",
4214     7,
4215     PROTOBUF_C_LABEL_NONE,
4216     PROTOBUF_C_TYPE_MESSAGE,
4217     0,   /* quantifier_offset */
4218     offsetof(StreamingProtobufs__CarrierFreqEUTRA, cellreselectionpriority),
4219     &google__protobuf__uint32_value__descriptor,
4220     NULL,
4221     0,             /* flags */
4222     0,NULL,NULL    /* reserved1,reserved2, etc */
4223   },
4224   {
4225     "cellReselectionSubPriority",
4226     8,
4227     PROTOBUF_C_LABEL_NONE,
4228     PROTOBUF_C_TYPE_MESSAGE,
4229     0,   /* quantifier_offset */
4230     offsetof(StreamingProtobufs__CarrierFreqEUTRA, cellreselectionsubpriority),
4231     &streaming_protobufs__cell_reselection_sub_priority__descriptor,
4232     NULL,
4233     0,             /* flags */
4234     0,NULL,NULL    /* reserved1,reserved2, etc */
4235   },
4236   {
4237     "threshX_High",
4238     9,
4239     PROTOBUF_C_LABEL_NONE,
4240     PROTOBUF_C_TYPE_UINT32,
4241     0,   /* quantifier_offset */
4242     offsetof(StreamingProtobufs__CarrierFreqEUTRA, threshx_high),
4243     NULL,
4244     NULL,
4245     0,             /* flags */
4246     0,NULL,NULL    /* reserved1,reserved2, etc */
4247   },
4248   {
4249     "threshX_Low",
4250     10,
4251     PROTOBUF_C_LABEL_NONE,
4252     PROTOBUF_C_TYPE_UINT32,
4253     0,   /* quantifier_offset */
4254     offsetof(StreamingProtobufs__CarrierFreqEUTRA, threshx_low),
4255     NULL,
4256     NULL,
4257     0,             /* flags */
4258     0,NULL,NULL    /* reserved1,reserved2, etc */
4259   },
4260   {
4261     "q_RxLevMin",
4262     11,
4263     PROTOBUF_C_LABEL_NONE,
4264     PROTOBUF_C_TYPE_SINT32,
4265     0,   /* quantifier_offset */
4266     offsetof(StreamingProtobufs__CarrierFreqEUTRA, q_rxlevmin),
4267     NULL,
4268     NULL,
4269     0,             /* flags */
4270     0,NULL,NULL    /* reserved1,reserved2, etc */
4271   },
4272   {
4273     "q_QualMin",
4274     12,
4275     PROTOBUF_C_LABEL_NONE,
4276     PROTOBUF_C_TYPE_SINT32,
4277     0,   /* quantifier_offset */
4278     offsetof(StreamingProtobufs__CarrierFreqEUTRA, q_qualmin),
4279     NULL,
4280     NULL,
4281     0,             /* flags */
4282     0,NULL,NULL    /* reserved1,reserved2, etc */
4283   },
4284   {
4285     "p_MaxEUTRA",
4286     13,
4287     PROTOBUF_C_LABEL_NONE,
4288     PROTOBUF_C_TYPE_SINT32,
4289     0,   /* quantifier_offset */
4290     offsetof(StreamingProtobufs__CarrierFreqEUTRA, p_maxeutra),
4291     NULL,
4292     NULL,
4293     0,             /* flags */
4294     0,NULL,NULL    /* reserved1,reserved2, etc */
4295   },
4296   {
4297     "threshX_Q",
4298     14,
4299     PROTOBUF_C_LABEL_NONE,
4300     PROTOBUF_C_TYPE_MESSAGE,
4301     0,   /* quantifier_offset */
4302     offsetof(StreamingProtobufs__CarrierFreqEUTRA, threshx_q),
4303     &streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor,
4304     NULL,
4305     0,             /* flags */
4306     0,NULL,NULL    /* reserved1,reserved2, etc */
4307   },
4308 };
4309 static const unsigned streaming_protobufs__carrier_freq_eutra__field_indices_by_name[] = {
4310   4,   /* field[4] = allowedMeasBandwidth */
4311   0,   /* field[0] = carrierFreq */
4312   6,   /* field[6] = cellReselectionPriority */
4313   7,   /* field[7] = cellReselectionSubPriority */
4314   3,   /* field[3] = eutra_BlackCellList */
4315   2,   /* field[2] = eutra_FreqNeighCellList */
4316   1,   /* field[1] = eutra_multiBandInfoList */
4317   12,   /* field[12] = p_MaxEUTRA */
4318   5,   /* field[5] = presenceAntennaPort1 */
4319   11,   /* field[11] = q_QualMin */
4320   10,   /* field[10] = q_RxLevMin */
4321   8,   /* field[8] = threshX_High */
4322   9,   /* field[9] = threshX_Low */
4323   13,   /* field[13] = threshX_Q */
4324 };
4325 static const ProtobufCIntRange streaming_protobufs__carrier_freq_eutra__number_ranges[1 + 1] =
4326 {
4327   { 1, 0 },
4328   { 0, 14 }
4329 };
4330 const ProtobufCMessageDescriptor streaming_protobufs__carrier_freq_eutra__descriptor =
4331 {
4332   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4333   "streaming_protobufs.CarrierFreqEUTRA",
4334   "CarrierFreqEUTRA",
4335   "StreamingProtobufs__CarrierFreqEUTRA",
4336   "streaming_protobufs",
4337   sizeof(StreamingProtobufs__CarrierFreqEUTRA),
4338   14,
4339   streaming_protobufs__carrier_freq_eutra__field_descriptors,
4340   streaming_protobufs__carrier_freq_eutra__field_indices_by_name,
4341   1,  streaming_protobufs__carrier_freq_eutra__number_ranges,
4342   (ProtobufCMessageInit) streaming_protobufs__carrier_freq_eutra__init,
4343   NULL,NULL,NULL    /* reserved[123] */
4344 };
4345 static const ProtobufCFieldDescriptor streaming_protobufs__eutra__freq_neigh_cell_list__field_descriptors[1] =
4346 {
4347   {
4348     "items",
4349     1,
4350     PROTOBUF_C_LABEL_REPEATED,
4351     PROTOBUF_C_TYPE_MESSAGE,
4352     offsetof(StreamingProtobufs__EUTRAFreqNeighCellList, n_items),
4353     offsetof(StreamingProtobufs__EUTRAFreqNeighCellList, items),
4354     &streaming_protobufs__eutra__freq_neigh_cell_info__descriptor,
4355     NULL,
4356     0,             /* flags */
4357     0,NULL,NULL    /* reserved1,reserved2, etc */
4358   },
4359 };
4360 static const unsigned streaming_protobufs__eutra__freq_neigh_cell_list__field_indices_by_name[] = {
4361   0,   /* field[0] = items */
4362 };
4363 static const ProtobufCIntRange streaming_protobufs__eutra__freq_neigh_cell_list__number_ranges[1 + 1] =
4364 {
4365   { 1, 0 },
4366   { 0, 1 }
4367 };
4368 const ProtobufCMessageDescriptor streaming_protobufs__eutra__freq_neigh_cell_list__descriptor =
4369 {
4370   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4371   "streaming_protobufs.EUTRA_FreqNeighCellList",
4372   "EUTRAFreqNeighCellList",
4373   "StreamingProtobufs__EUTRAFreqNeighCellList",
4374   "streaming_protobufs",
4375   sizeof(StreamingProtobufs__EUTRAFreqNeighCellList),
4376   1,
4377   streaming_protobufs__eutra__freq_neigh_cell_list__field_descriptors,
4378   streaming_protobufs__eutra__freq_neigh_cell_list__field_indices_by_name,
4379   1,  streaming_protobufs__eutra__freq_neigh_cell_list__number_ranges,
4380   (ProtobufCMessageInit) streaming_protobufs__eutra__freq_neigh_cell_list__init,
4381   NULL,NULL,NULL    /* reserved[123] */
4382 };
4383 static const ProtobufCFieldDescriptor streaming_protobufs__eutra__freq_black_cell_list__field_descriptors[1] =
4384 {
4385   {
4386     "items",
4387     1,
4388     PROTOBUF_C_LABEL_REPEATED,
4389     PROTOBUF_C_TYPE_MESSAGE,
4390     offsetof(StreamingProtobufs__EUTRAFreqBlackCellList, n_items),
4391     offsetof(StreamingProtobufs__EUTRAFreqBlackCellList, items),
4392     &streaming_protobufs__eutra__phys_cell_id_range__descriptor,
4393     NULL,
4394     0,             /* flags */
4395     0,NULL,NULL    /* reserved1,reserved2, etc */
4396   },
4397 };
4398 static const unsigned streaming_protobufs__eutra__freq_black_cell_list__field_indices_by_name[] = {
4399   0,   /* field[0] = items */
4400 };
4401 static const ProtobufCIntRange streaming_protobufs__eutra__freq_black_cell_list__number_ranges[1 + 1] =
4402 {
4403   { 1, 0 },
4404   { 0, 1 }
4405 };
4406 const ProtobufCMessageDescriptor streaming_protobufs__eutra__freq_black_cell_list__descriptor =
4407 {
4408   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4409   "streaming_protobufs.EUTRA_FreqBlackCellList",
4410   "EUTRAFreqBlackCellList",
4411   "StreamingProtobufs__EUTRAFreqBlackCellList",
4412   "streaming_protobufs",
4413   sizeof(StreamingProtobufs__EUTRAFreqBlackCellList),
4414   1,
4415   streaming_protobufs__eutra__freq_black_cell_list__field_descriptors,
4416   streaming_protobufs__eutra__freq_black_cell_list__field_indices_by_name,
4417   1,  streaming_protobufs__eutra__freq_black_cell_list__number_ranges,
4418   (ProtobufCMessageInit) streaming_protobufs__eutra__freq_black_cell_list__init,
4419   NULL,NULL,NULL    /* reserved[123] */
4420 };
4421 static const ProtobufCFieldDescriptor streaming_protobufs__eutra__freq_neigh_cell_info__field_descriptors[4] =
4422 {
4423   {
4424     "physCellId",
4425     1,
4426     PROTOBUF_C_LABEL_NONE,
4427     PROTOBUF_C_TYPE_UINT32,
4428     0,   /* quantifier_offset */
4429     offsetof(StreamingProtobufs__EUTRAFreqNeighCellInfo, physcellid),
4430     NULL,
4431     NULL,
4432     0,             /* flags */
4433     0,NULL,NULL    /* reserved1,reserved2, etc */
4434   },
4435   {
4436     "q_OffsetCell",
4437     2,
4438     PROTOBUF_C_LABEL_NONE,
4439     PROTOBUF_C_TYPE_MESSAGE,
4440     0,   /* quantifier_offset */
4441     offsetof(StreamingProtobufs__EUTRAFreqNeighCellInfo, q_offsetcell),
4442     &streaming_protobufs__eutra__q__offset_range__descriptor,
4443     NULL,
4444     0,             /* flags */
4445     0,NULL,NULL    /* reserved1,reserved2, etc */
4446   },
4447   {
4448     "q_RxLevMinOffsetCell",
4449     3,
4450     PROTOBUF_C_LABEL_NONE,
4451     PROTOBUF_C_TYPE_MESSAGE,
4452     0,   /* quantifier_offset */
4453     offsetof(StreamingProtobufs__EUTRAFreqNeighCellInfo, q_rxlevminoffsetcell),
4454     &google__protobuf__uint32_value__descriptor,
4455     NULL,
4456     0,             /* flags */
4457     0,NULL,NULL    /* reserved1,reserved2, etc */
4458   },
4459   {
4460     "q_QualMinOffsetCell",
4461     4,
4462     PROTOBUF_C_LABEL_NONE,
4463     PROTOBUF_C_TYPE_MESSAGE,
4464     0,   /* quantifier_offset */
4465     offsetof(StreamingProtobufs__EUTRAFreqNeighCellInfo, q_qualminoffsetcell),
4466     &google__protobuf__uint32_value__descriptor,
4467     NULL,
4468     0,             /* flags */
4469     0,NULL,NULL    /* reserved1,reserved2, etc */
4470   },
4471 };
4472 static const unsigned streaming_protobufs__eutra__freq_neigh_cell_info__field_indices_by_name[] = {
4473   0,   /* field[0] = physCellId */
4474   1,   /* field[1] = q_OffsetCell */
4475   3,   /* field[3] = q_QualMinOffsetCell */
4476   2,   /* field[2] = q_RxLevMinOffsetCell */
4477 };
4478 static const ProtobufCIntRange streaming_protobufs__eutra__freq_neigh_cell_info__number_ranges[1 + 1] =
4479 {
4480   { 1, 0 },
4481   { 0, 4 }
4482 };
4483 const ProtobufCMessageDescriptor streaming_protobufs__eutra__freq_neigh_cell_info__descriptor =
4484 {
4485   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4486   "streaming_protobufs.EUTRA_FreqNeighCellInfo",
4487   "EUTRAFreqNeighCellInfo",
4488   "StreamingProtobufs__EUTRAFreqNeighCellInfo",
4489   "streaming_protobufs",
4490   sizeof(StreamingProtobufs__EUTRAFreqNeighCellInfo),
4491   4,
4492   streaming_protobufs__eutra__freq_neigh_cell_info__field_descriptors,
4493   streaming_protobufs__eutra__freq_neigh_cell_info__field_indices_by_name,
4494   1,  streaming_protobufs__eutra__freq_neigh_cell_info__number_ranges,
4495   (ProtobufCMessageInit) streaming_protobufs__eutra__freq_neigh_cell_info__init,
4496   NULL,NULL,NULL    /* reserved[123] */
4497 };
4498 static const ProtobufCFieldDescriptor streaming_protobufs__carrier_freq_eutrathresh_x__q__field_descriptors[2] =
4499 {
4500   {
4501     "threshX_HighQ",
4502     1,
4503     PROTOBUF_C_LABEL_NONE,
4504     PROTOBUF_C_TYPE_UINT32,
4505     0,   /* quantifier_offset */
4506     offsetof(StreamingProtobufs__CarrierFreqEUTRAThreshXQ, threshx_highq),
4507     NULL,
4508     NULL,
4509     0,             /* flags */
4510     0,NULL,NULL    /* reserved1,reserved2, etc */
4511   },
4512   {
4513     "threshX_LowQ",
4514     2,
4515     PROTOBUF_C_LABEL_NONE,
4516     PROTOBUF_C_TYPE_UINT32,
4517     0,   /* quantifier_offset */
4518     offsetof(StreamingProtobufs__CarrierFreqEUTRAThreshXQ, threshx_lowq),
4519     NULL,
4520     NULL,
4521     0,             /* flags */
4522     0,NULL,NULL    /* reserved1,reserved2, etc */
4523   },
4524 };
4525 static const unsigned streaming_protobufs__carrier_freq_eutrathresh_x__q__field_indices_by_name[] = {
4526   0,   /* field[0] = threshX_HighQ */
4527   1,   /* field[1] = threshX_LowQ */
4528 };
4529 static const ProtobufCIntRange streaming_protobufs__carrier_freq_eutrathresh_x__q__number_ranges[1 + 1] =
4530 {
4531   { 1, 0 },
4532   { 0, 2 }
4533 };
4534 const ProtobufCMessageDescriptor streaming_protobufs__carrier_freq_eutrathresh_x__q__descriptor =
4535 {
4536   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4537   "streaming_protobufs.CarrierFreqEUTRAThreshX_Q",
4538   "CarrierFreqEUTRAThreshXQ",
4539   "StreamingProtobufs__CarrierFreqEUTRAThreshXQ",
4540   "streaming_protobufs",
4541   sizeof(StreamingProtobufs__CarrierFreqEUTRAThreshXQ),
4542   2,
4543   streaming_protobufs__carrier_freq_eutrathresh_x__q__field_descriptors,
4544   streaming_protobufs__carrier_freq_eutrathresh_x__q__field_indices_by_name,
4545   1,  streaming_protobufs__carrier_freq_eutrathresh_x__q__number_ranges,
4546   (ProtobufCMessageInit) streaming_protobufs__carrier_freq_eutrathresh_x__q__init,
4547   NULL,NULL,NULL    /* reserved[123] */
4548 };
4549 static const ProtobufCFieldDescriptor streaming_protobufs__sib6__field_descriptors[4] =
4550 {
4551   {
4552     "messageIdentifier",
4553     1,
4554     PROTOBUF_C_LABEL_NONE,
4555     PROTOBUF_C_TYPE_BYTES,
4556     0,   /* quantifier_offset */
4557     offsetof(StreamingProtobufs__SIB6, messageidentifier),
4558     NULL,
4559     NULL,
4560     0,             /* flags */
4561     0,NULL,NULL    /* reserved1,reserved2, etc */
4562   },
4563   {
4564     "serialNumber",
4565     2,
4566     PROTOBUF_C_LABEL_NONE,
4567     PROTOBUF_C_TYPE_BYTES,
4568     0,   /* quantifier_offset */
4569     offsetof(StreamingProtobufs__SIB6, serialnumber),
4570     NULL,
4571     NULL,
4572     0,             /* flags */
4573     0,NULL,NULL    /* reserved1,reserved2, etc */
4574   },
4575   {
4576     "warningType",
4577     3,
4578     PROTOBUF_C_LABEL_NONE,
4579     PROTOBUF_C_TYPE_BYTES,
4580     0,   /* quantifier_offset */
4581     offsetof(StreamingProtobufs__SIB6, warningtype),
4582     NULL,
4583     NULL,
4584     0,             /* flags */
4585     0,NULL,NULL    /* reserved1,reserved2, etc */
4586   },
4587   {
4588     "lateNonCriticalExtension",
4589     4,
4590     PROTOBUF_C_LABEL_NONE,
4591     PROTOBUF_C_TYPE_MESSAGE,
4592     0,   /* quantifier_offset */
4593     offsetof(StreamingProtobufs__SIB6, latenoncriticalextension),
4594     &google__protobuf__bytes_value__descriptor,
4595     NULL,
4596     0,             /* flags */
4597     0,NULL,NULL    /* reserved1,reserved2, etc */
4598   },
4599 };
4600 static const unsigned streaming_protobufs__sib6__field_indices_by_name[] = {
4601   3,   /* field[3] = lateNonCriticalExtension */
4602   0,   /* field[0] = messageIdentifier */
4603   1,   /* field[1] = serialNumber */
4604   2,   /* field[2] = warningType */
4605 };
4606 static const ProtobufCIntRange streaming_protobufs__sib6__number_ranges[1 + 1] =
4607 {
4608   { 1, 0 },
4609   { 0, 4 }
4610 };
4611 const ProtobufCMessageDescriptor streaming_protobufs__sib6__descriptor =
4612 {
4613   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4614   "streaming_protobufs.SIB6",
4615   "SIB6",
4616   "StreamingProtobufs__SIB6",
4617   "streaming_protobufs",
4618   sizeof(StreamingProtobufs__SIB6),
4619   4,
4620   streaming_protobufs__sib6__field_descriptors,
4621   streaming_protobufs__sib6__field_indices_by_name,
4622   1,  streaming_protobufs__sib6__number_ranges,
4623   (ProtobufCMessageInit) streaming_protobufs__sib6__init,
4624   NULL,NULL,NULL    /* reserved[123] */
4625 };
4626 static const ProtobufCEnumValue streaming_protobufs__sib7__warning_message_segment_type__enum_values_by_number[3] =
4627 {
4628   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SIB7__WARNING_MESSAGE_SEGMENT_TYPE__protobuf_unspecified", 0 },
4629   { "notLastSegment", "STREAMING_PROTOBUFS__SIB7__WARNING_MESSAGE_SEGMENT_TYPE__notLastSegment", 1 },
4630   { "lastSegment", "STREAMING_PROTOBUFS__SIB7__WARNING_MESSAGE_SEGMENT_TYPE__lastSegment", 2 },
4631 };
4632 static const ProtobufCIntRange streaming_protobufs__sib7__warning_message_segment_type__value_ranges[] = {
4633 {0, 0},{0, 3}
4634 };
4635 static const ProtobufCEnumValueIndex streaming_protobufs__sib7__warning_message_segment_type__enum_values_by_name[3] =
4636 {
4637   { "lastSegment", 2 },
4638   { "notLastSegment", 1 },
4639   { "protobuf_unspecified", 0 },
4640 };
4641 const ProtobufCEnumDescriptor streaming_protobufs__sib7__warning_message_segment_type__descriptor =
4642 {
4643   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4644   "streaming_protobufs.SIB7.WarningMessageSegmentType",
4645   "WarningMessageSegmentType",
4646   "StreamingProtobufs__SIB7__WarningMessageSegmentType",
4647   "streaming_protobufs",
4648   3,
4649   streaming_protobufs__sib7__warning_message_segment_type__enum_values_by_number,
4650   3,
4651   streaming_protobufs__sib7__warning_message_segment_type__enum_values_by_name,
4652   1,
4653   streaming_protobufs__sib7__warning_message_segment_type__value_ranges,
4654   NULL,NULL,NULL,NULL   /* reserved[1234] */
4655 };
4656 static const ProtobufCFieldDescriptor streaming_protobufs__sib7__field_descriptors[7] =
4657 {
4658   {
4659     "messageIdentifier",
4660     1,
4661     PROTOBUF_C_LABEL_NONE,
4662     PROTOBUF_C_TYPE_BYTES,
4663     0,   /* quantifier_offset */
4664     offsetof(StreamingProtobufs__SIB7, messageidentifier),
4665     NULL,
4666     NULL,
4667     0,             /* flags */
4668     0,NULL,NULL    /* reserved1,reserved2, etc */
4669   },
4670   {
4671     "serialNumber",
4672     2,
4673     PROTOBUF_C_LABEL_NONE,
4674     PROTOBUF_C_TYPE_BYTES,
4675     0,   /* quantifier_offset */
4676     offsetof(StreamingProtobufs__SIB7, serialnumber),
4677     NULL,
4678     NULL,
4679     0,             /* flags */
4680     0,NULL,NULL    /* reserved1,reserved2, etc */
4681   },
4682   {
4683     "warningMessageSegmentType",
4684     3,
4685     PROTOBUF_C_LABEL_NONE,
4686     PROTOBUF_C_TYPE_ENUM,
4687     0,   /* quantifier_offset */
4688     offsetof(StreamingProtobufs__SIB7, warningmessagesegmenttype),
4689     &streaming_protobufs__sib7__warning_message_segment_type__descriptor,
4690     NULL,
4691     0,             /* flags */
4692     0,NULL,NULL    /* reserved1,reserved2, etc */
4693   },
4694   {
4695     "warningMessageSegmentNumber",
4696     4,
4697     PROTOBUF_C_LABEL_NONE,
4698     PROTOBUF_C_TYPE_UINT32,
4699     0,   /* quantifier_offset */
4700     offsetof(StreamingProtobufs__SIB7, warningmessagesegmentnumber),
4701     NULL,
4702     NULL,
4703     0,             /* flags */
4704     0,NULL,NULL    /* reserved1,reserved2, etc */
4705   },
4706   {
4707     "warningMessageSegment",
4708     5,
4709     PROTOBUF_C_LABEL_NONE,
4710     PROTOBUF_C_TYPE_BYTES,
4711     0,   /* quantifier_offset */
4712     offsetof(StreamingProtobufs__SIB7, warningmessagesegment),
4713     NULL,
4714     NULL,
4715     0,             /* flags */
4716     0,NULL,NULL    /* reserved1,reserved2, etc */
4717   },
4718   {
4719     "dataCodingScheme",
4720     6,
4721     PROTOBUF_C_LABEL_NONE,
4722     PROTOBUF_C_TYPE_MESSAGE,
4723     0,   /* quantifier_offset */
4724     offsetof(StreamingProtobufs__SIB7, datacodingscheme),
4725     &google__protobuf__bytes_value__descriptor,
4726     NULL,
4727     0,             /* flags */
4728     0,NULL,NULL    /* reserved1,reserved2, etc */
4729   },
4730   {
4731     "lateNonCriticalExtension",
4732     7,
4733     PROTOBUF_C_LABEL_NONE,
4734     PROTOBUF_C_TYPE_MESSAGE,
4735     0,   /* quantifier_offset */
4736     offsetof(StreamingProtobufs__SIB7, latenoncriticalextension),
4737     &google__protobuf__bytes_value__descriptor,
4738     NULL,
4739     0,             /* flags */
4740     0,NULL,NULL    /* reserved1,reserved2, etc */
4741   },
4742 };
4743 static const unsigned streaming_protobufs__sib7__field_indices_by_name[] = {
4744   5,   /* field[5] = dataCodingScheme */
4745   6,   /* field[6] = lateNonCriticalExtension */
4746   0,   /* field[0] = messageIdentifier */
4747   1,   /* field[1] = serialNumber */
4748   4,   /* field[4] = warningMessageSegment */
4749   3,   /* field[3] = warningMessageSegmentNumber */
4750   2,   /* field[2] = warningMessageSegmentType */
4751 };
4752 static const ProtobufCIntRange streaming_protobufs__sib7__number_ranges[1 + 1] =
4753 {
4754   { 1, 0 },
4755   { 0, 7 }
4756 };
4757 const ProtobufCMessageDescriptor streaming_protobufs__sib7__descriptor =
4758 {
4759   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4760   "streaming_protobufs.SIB7",
4761   "SIB7",
4762   "StreamingProtobufs__SIB7",
4763   "streaming_protobufs",
4764   sizeof(StreamingProtobufs__SIB7),
4765   7,
4766   streaming_protobufs__sib7__field_descriptors,
4767   streaming_protobufs__sib7__field_indices_by_name,
4768   1,  streaming_protobufs__sib7__number_ranges,
4769   (ProtobufCMessageInit) streaming_protobufs__sib7__init,
4770   NULL,NULL,NULL    /* reserved[123] */
4771 };
4772 static const ProtobufCEnumValue streaming_protobufs__sib8__warning_message_segment_type__enum_values_by_number[3] =
4773 {
4774   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SIB8__WARNING_MESSAGE_SEGMENT_TYPE__protobuf_unspecified", 0 },
4775   { "notLastSegment", "STREAMING_PROTOBUFS__SIB8__WARNING_MESSAGE_SEGMENT_TYPE__notLastSegment", 1 },
4776   { "lastSegment", "STREAMING_PROTOBUFS__SIB8__WARNING_MESSAGE_SEGMENT_TYPE__lastSegment", 2 },
4777 };
4778 static const ProtobufCIntRange streaming_protobufs__sib8__warning_message_segment_type__value_ranges[] = {
4779 {0, 0},{0, 3}
4780 };
4781 static const ProtobufCEnumValueIndex streaming_protobufs__sib8__warning_message_segment_type__enum_values_by_name[3] =
4782 {
4783   { "lastSegment", 2 },
4784   { "notLastSegment", 1 },
4785   { "protobuf_unspecified", 0 },
4786 };
4787 const ProtobufCEnumDescriptor streaming_protobufs__sib8__warning_message_segment_type__descriptor =
4788 {
4789   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4790   "streaming_protobufs.SIB8.WarningMessageSegmentType",
4791   "WarningMessageSegmentType",
4792   "StreamingProtobufs__SIB8__WarningMessageSegmentType",
4793   "streaming_protobufs",
4794   3,
4795   streaming_protobufs__sib8__warning_message_segment_type__enum_values_by_number,
4796   3,
4797   streaming_protobufs__sib8__warning_message_segment_type__enum_values_by_name,
4798   1,
4799   streaming_protobufs__sib8__warning_message_segment_type__value_ranges,
4800   NULL,NULL,NULL,NULL   /* reserved[1234] */
4801 };
4802 static const ProtobufCFieldDescriptor streaming_protobufs__sib8__field_descriptors[8] =
4803 {
4804   {
4805     "messageIdentifier",
4806     1,
4807     PROTOBUF_C_LABEL_NONE,
4808     PROTOBUF_C_TYPE_BYTES,
4809     0,   /* quantifier_offset */
4810     offsetof(StreamingProtobufs__SIB8, messageidentifier),
4811     NULL,
4812     NULL,
4813     0,             /* flags */
4814     0,NULL,NULL    /* reserved1,reserved2, etc */
4815   },
4816   {
4817     "serialNumber",
4818     2,
4819     PROTOBUF_C_LABEL_NONE,
4820     PROTOBUF_C_TYPE_BYTES,
4821     0,   /* quantifier_offset */
4822     offsetof(StreamingProtobufs__SIB8, serialnumber),
4823     NULL,
4824     NULL,
4825     0,             /* flags */
4826     0,NULL,NULL    /* reserved1,reserved2, etc */
4827   },
4828   {
4829     "warningMessageSegmentType",
4830     3,
4831     PROTOBUF_C_LABEL_NONE,
4832     PROTOBUF_C_TYPE_ENUM,
4833     0,   /* quantifier_offset */
4834     offsetof(StreamingProtobufs__SIB8, warningmessagesegmenttype),
4835     &streaming_protobufs__sib8__warning_message_segment_type__descriptor,
4836     NULL,
4837     0,             /* flags */
4838     0,NULL,NULL    /* reserved1,reserved2, etc */
4839   },
4840   {
4841     "warningMessageSegmentNumber",
4842     4,
4843     PROTOBUF_C_LABEL_NONE,
4844     PROTOBUF_C_TYPE_UINT32,
4845     0,   /* quantifier_offset */
4846     offsetof(StreamingProtobufs__SIB8, warningmessagesegmentnumber),
4847     NULL,
4848     NULL,
4849     0,             /* flags */
4850     0,NULL,NULL    /* reserved1,reserved2, etc */
4851   },
4852   {
4853     "warningMessageSegment",
4854     5,
4855     PROTOBUF_C_LABEL_NONE,
4856     PROTOBUF_C_TYPE_BYTES,
4857     0,   /* quantifier_offset */
4858     offsetof(StreamingProtobufs__SIB8, warningmessagesegment),
4859     NULL,
4860     NULL,
4861     0,             /* flags */
4862     0,NULL,NULL    /* reserved1,reserved2, etc */
4863   },
4864   {
4865     "dataCodingScheme",
4866     6,
4867     PROTOBUF_C_LABEL_NONE,
4868     PROTOBUF_C_TYPE_MESSAGE,
4869     0,   /* quantifier_offset */
4870     offsetof(StreamingProtobufs__SIB8, datacodingscheme),
4871     &google__protobuf__bytes_value__descriptor,
4872     NULL,
4873     0,             /* flags */
4874     0,NULL,NULL    /* reserved1,reserved2, etc */
4875   },
4876   {
4877     "warningAreaCoordinatesSegment",
4878     7,
4879     PROTOBUF_C_LABEL_NONE,
4880     PROTOBUF_C_TYPE_MESSAGE,
4881     0,   /* quantifier_offset */
4882     offsetof(StreamingProtobufs__SIB8, warningareacoordinatessegment),
4883     &google__protobuf__bytes_value__descriptor,
4884     NULL,
4885     0,             /* flags */
4886     0,NULL,NULL    /* reserved1,reserved2, etc */
4887   },
4888   {
4889     "lateNonCriticalExtension",
4890     8,
4891     PROTOBUF_C_LABEL_NONE,
4892     PROTOBUF_C_TYPE_MESSAGE,
4893     0,   /* quantifier_offset */
4894     offsetof(StreamingProtobufs__SIB8, latenoncriticalextension),
4895     &google__protobuf__bytes_value__descriptor,
4896     NULL,
4897     0,             /* flags */
4898     0,NULL,NULL    /* reserved1,reserved2, etc */
4899   },
4900 };
4901 static const unsigned streaming_protobufs__sib8__field_indices_by_name[] = {
4902   5,   /* field[5] = dataCodingScheme */
4903   7,   /* field[7] = lateNonCriticalExtension */
4904   0,   /* field[0] = messageIdentifier */
4905   1,   /* field[1] = serialNumber */
4906   6,   /* field[6] = warningAreaCoordinatesSegment */
4907   4,   /* field[4] = warningMessageSegment */
4908   3,   /* field[3] = warningMessageSegmentNumber */
4909   2,   /* field[2] = warningMessageSegmentType */
4910 };
4911 static const ProtobufCIntRange streaming_protobufs__sib8__number_ranges[1 + 1] =
4912 {
4913   { 1, 0 },
4914   { 0, 8 }
4915 };
4916 const ProtobufCMessageDescriptor streaming_protobufs__sib8__descriptor =
4917 {
4918   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4919   "streaming_protobufs.SIB8",
4920   "SIB8",
4921   "StreamingProtobufs__SIB8",
4922   "streaming_protobufs",
4923   sizeof(StreamingProtobufs__SIB8),
4924   8,
4925   streaming_protobufs__sib8__field_descriptors,
4926   streaming_protobufs__sib8__field_indices_by_name,
4927   1,  streaming_protobufs__sib8__number_ranges,
4928   (ProtobufCMessageInit) streaming_protobufs__sib8__init,
4929   NULL,NULL,NULL    /* reserved[123] */
4930 };
4931 static const ProtobufCFieldDescriptor streaming_protobufs__sib9__field_descriptors[2] =
4932 {
4933   {
4934     "timeInfo",
4935     1,
4936     PROTOBUF_C_LABEL_NONE,
4937     PROTOBUF_C_TYPE_MESSAGE,
4938     0,   /* quantifier_offset */
4939     offsetof(StreamingProtobufs__SIB9, timeinfo),
4940     &streaming_protobufs__sib9_time_info__descriptor,
4941     NULL,
4942     0,             /* flags */
4943     0,NULL,NULL    /* reserved1,reserved2, etc */
4944   },
4945   {
4946     "lateNonCriticalExtension",
4947     2,
4948     PROTOBUF_C_LABEL_NONE,
4949     PROTOBUF_C_TYPE_MESSAGE,
4950     0,   /* quantifier_offset */
4951     offsetof(StreamingProtobufs__SIB9, latenoncriticalextension),
4952     &google__protobuf__bytes_value__descriptor,
4953     NULL,
4954     0,             /* flags */
4955     0,NULL,NULL    /* reserved1,reserved2, etc */
4956   },
4957 };
4958 static const unsigned streaming_protobufs__sib9__field_indices_by_name[] = {
4959   1,   /* field[1] = lateNonCriticalExtension */
4960   0,   /* field[0] = timeInfo */
4961 };
4962 static const ProtobufCIntRange streaming_protobufs__sib9__number_ranges[1 + 1] =
4963 {
4964   { 1, 0 },
4965   { 0, 2 }
4966 };
4967 const ProtobufCMessageDescriptor streaming_protobufs__sib9__descriptor =
4968 {
4969   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4970   "streaming_protobufs.SIB9",
4971   "SIB9",
4972   "StreamingProtobufs__SIB9",
4973   "streaming_protobufs",
4974   sizeof(StreamingProtobufs__SIB9),
4975   2,
4976   streaming_protobufs__sib9__field_descriptors,
4977   streaming_protobufs__sib9__field_indices_by_name,
4978   1,  streaming_protobufs__sib9__number_ranges,
4979   (ProtobufCMessageInit) streaming_protobufs__sib9__init,
4980   NULL,NULL,NULL    /* reserved[123] */
4981 };
4982 static const ProtobufCFieldDescriptor streaming_protobufs__sib9_time_info__field_descriptors[4] =
4983 {
4984   {
4985     "timeInfoUTC",
4986     1,
4987     PROTOBUF_C_LABEL_NONE,
4988     PROTOBUF_C_TYPE_UINT64,
4989     0,   /* quantifier_offset */
4990     offsetof(StreamingProtobufs__SIB9TimeInfo, timeinfoutc),
4991     NULL,
4992     NULL,
4993     0,             /* flags */
4994     0,NULL,NULL    /* reserved1,reserved2, etc */
4995   },
4996   {
4997     "dayLightSavingTime",
4998     2,
4999     PROTOBUF_C_LABEL_NONE,
5000     PROTOBUF_C_TYPE_MESSAGE,
5001     0,   /* quantifier_offset */
5002     offsetof(StreamingProtobufs__SIB9TimeInfo, daylightsavingtime),
5003     &google__protobuf__bytes_value__descriptor,
5004     NULL,
5005     0,             /* flags */
5006     0,NULL,NULL    /* reserved1,reserved2, etc */
5007   },
5008   {
5009     "leapSeconds",
5010     3,
5011     PROTOBUF_C_LABEL_NONE,
5012     PROTOBUF_C_TYPE_MESSAGE,
5013     0,   /* quantifier_offset */
5014     offsetof(StreamingProtobufs__SIB9TimeInfo, leapseconds),
5015     &google__protobuf__int32_value__descriptor,
5016     NULL,
5017     0,             /* flags */
5018     0,NULL,NULL    /* reserved1,reserved2, etc */
5019   },
5020   {
5021     "localTimeOffset",
5022     4,
5023     PROTOBUF_C_LABEL_NONE,
5024     PROTOBUF_C_TYPE_MESSAGE,
5025     0,   /* quantifier_offset */
5026     offsetof(StreamingProtobufs__SIB9TimeInfo, localtimeoffset),
5027     &google__protobuf__int32_value__descriptor,
5028     NULL,
5029     0,             /* flags */
5030     0,NULL,NULL    /* reserved1,reserved2, etc */
5031   },
5032 };
5033 static const unsigned streaming_protobufs__sib9_time_info__field_indices_by_name[] = {
5034   1,   /* field[1] = dayLightSavingTime */
5035   2,   /* field[2] = leapSeconds */
5036   3,   /* field[3] = localTimeOffset */
5037   0,   /* field[0] = timeInfoUTC */
5038 };
5039 static const ProtobufCIntRange streaming_protobufs__sib9_time_info__number_ranges[1 + 1] =
5040 {
5041   { 1, 0 },
5042   { 0, 4 }
5043 };
5044 const ProtobufCMessageDescriptor streaming_protobufs__sib9_time_info__descriptor =
5045 {
5046   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5047   "streaming_protobufs.SIB9TimeInfo",
5048   "SIB9TimeInfo",
5049   "StreamingProtobufs__SIB9TimeInfo",
5050   "streaming_protobufs",
5051   sizeof(StreamingProtobufs__SIB9TimeInfo),
5052   4,
5053   streaming_protobufs__sib9_time_info__field_descriptors,
5054   streaming_protobufs__sib9_time_info__field_indices_by_name,
5055   1,  streaming_protobufs__sib9_time_info__number_ranges,
5056   (ProtobufCMessageInit) streaming_protobufs__sib9_time_info__init,
5057   NULL,NULL,NULL    /* reserved[123] */
5058 };