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

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: rrc_cg_config_info.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_cg_config_info.pb-c.h"
  10 void   streaming_protobufs__cg__config_info__init
  11                      (StreamingProtobufs__CGConfigInfo         *message)
  12 {
  13   static const StreamingProtobufs__CGConfigInfo init_value = STREAMING_PROTOBUFS__CG__CONFIG_INFO__INIT;
  14   *message = init_value;
  15 }
  16 size_t streaming_protobufs__cg__config_info__get_packed_size
  17                      (const StreamingProtobufs__CGConfigInfo *message)
  18 {
  19   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__descriptor);
  20   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21 }
  22 size_t streaming_protobufs__cg__config_info__pack
  23                      (const StreamingProtobufs__CGConfigInfo *message,
  24                       uint8_t       *out)
  25 {
  26   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__descriptor);
  27   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28 }
  29 size_t streaming_protobufs__cg__config_info__pack_to_buffer
  30                      (const StreamingProtobufs__CGConfigInfo *message,
  31                       ProtobufCBuffer *buffer)
  32 {
  33   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__descriptor);
  34   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35 }
  36 StreamingProtobufs__CGConfigInfo *
  37        streaming_protobufs__cg__config_info__unpack
  38                      (ProtobufCAllocator  *allocator,
  39                       size_t               len,
  40                       const uint8_t       *data)
  41 {
  42   return (StreamingProtobufs__CGConfigInfo *)
  43      protobuf_c_message_unpack (&streaming_protobufs__cg__config_info__descriptor,
  44                                 allocator, len, data);
  45 }
  46 void   streaming_protobufs__cg__config_info__free_unpacked
  47                      (StreamingProtobufs__CGConfigInfo *message,
  48                       ProtobufCAllocator *allocator)
  49 {
  50   if(!message)
  51     return;
  52   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__descriptor);
  53   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  54 }
  55 void   streaming_protobufs__cg__config_info_critical_extensions_choice1__init
  56                      (StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1         *message)
  57 {
  58   static const StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 init_value = STREAMING_PROTOBUFS__CG__CONFIG_INFO_CRITICAL_EXTENSIONS_CHOICE1__INIT;
  59   *message = init_value;
  60 }
  61 size_t streaming_protobufs__cg__config_info_critical_extensions_choice1__get_packed_size
  62                      (const StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 *message)
  63 {
  64   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor);
  65   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  66 }
  67 size_t streaming_protobufs__cg__config_info_critical_extensions_choice1__pack
  68                      (const StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 *message,
  69                       uint8_t       *out)
  70 {
  71   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor);
  72   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  73 }
  74 size_t streaming_protobufs__cg__config_info_critical_extensions_choice1__pack_to_buffer
  75                      (const StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 *message,
  76                       ProtobufCBuffer *buffer)
  77 {
  78   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor);
  79   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  80 }
  81 StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 *
  82        streaming_protobufs__cg__config_info_critical_extensions_choice1__unpack
  83                      (ProtobufCAllocator  *allocator,
  84                       size_t               len,
  85                       const uint8_t       *data)
  86 {
  87   return (StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 *)
  88      protobuf_c_message_unpack (&streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor,
  89                                 allocator, len, data);
  90 }
  91 void   streaming_protobufs__cg__config_info_critical_extensions_choice1__free_unpacked
  92                      (StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1 *message,
  93                       ProtobufCAllocator *allocator)
  94 {
  95   if(!message)
  96     return;
  97   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor);
  98   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  99 }
 100 void   streaming_protobufs__cg__config_info__ies__init
 101                      (StreamingProtobufs__CGConfigInfoIEs         *message)
 102 {
 103   static const StreamingProtobufs__CGConfigInfoIEs init_value = STREAMING_PROTOBUFS__CG__CONFIG_INFO__IES__INIT;
 104   *message = init_value;
 105 }
 106 size_t streaming_protobufs__cg__config_info__ies__get_packed_size
 107                      (const StreamingProtobufs__CGConfigInfoIEs *message)
 108 {
 109   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__ies__descriptor);
 110   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 111 }
 112 size_t streaming_protobufs__cg__config_info__ies__pack
 113                      (const StreamingProtobufs__CGConfigInfoIEs *message,
 114                       uint8_t       *out)
 115 {
 116   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__ies__descriptor);
 117   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 118 }
 119 size_t streaming_protobufs__cg__config_info__ies__pack_to_buffer
 120                      (const StreamingProtobufs__CGConfigInfoIEs *message,
 121                       ProtobufCBuffer *buffer)
 122 {
 123   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__ies__descriptor);
 124   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 125 }
 126 StreamingProtobufs__CGConfigInfoIEs *
 127        streaming_protobufs__cg__config_info__ies__unpack
 128                      (ProtobufCAllocator  *allocator,
 129                       size_t               len,
 130                       const uint8_t       *data)
 131 {
 132   return (StreamingProtobufs__CGConfigInfoIEs *)
 133      protobuf_c_message_unpack (&streaming_protobufs__cg__config_info__ies__descriptor,
 134                                 allocator, len, data);
 135 }
 136 void   streaming_protobufs__cg__config_info__ies__free_unpacked
 137                      (StreamingProtobufs__CGConfigInfoIEs *message,
 138                       ProtobufCAllocator *allocator)
 139 {
 140   if(!message)
 141     return;
 142   assert(message->base.descriptor == &streaming_protobufs__cg__config_info__ies__descriptor);
 143   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 144 }
 145 void   streaming_protobufs__ue__capability_rat__container__init
 146                      (StreamingProtobufs__UECapabilityRATContainer         *message)
 147 {
 148   static const StreamingProtobufs__UECapabilityRATContainer init_value = STREAMING_PROTOBUFS__UE__CAPABILITY_RAT__CONTAINER__INIT;
 149   *message = init_value;
 150 }
 151 size_t streaming_protobufs__ue__capability_rat__container__get_packed_size
 152                      (const StreamingProtobufs__UECapabilityRATContainer *message)
 153 {
 154   assert(message->base.descriptor == &streaming_protobufs__ue__capability_rat__container__descriptor);
 155   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 156 }
 157 size_t streaming_protobufs__ue__capability_rat__container__pack
 158                      (const StreamingProtobufs__UECapabilityRATContainer *message,
 159                       uint8_t       *out)
 160 {
 161   assert(message->base.descriptor == &streaming_protobufs__ue__capability_rat__container__descriptor);
 162   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 163 }
 164 size_t streaming_protobufs__ue__capability_rat__container__pack_to_buffer
 165                      (const StreamingProtobufs__UECapabilityRATContainer *message,
 166                       ProtobufCBuffer *buffer)
 167 {
 168   assert(message->base.descriptor == &streaming_protobufs__ue__capability_rat__container__descriptor);
 169   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 170 }
 171 StreamingProtobufs__UECapabilityRATContainer *
 172        streaming_protobufs__ue__capability_rat__container__unpack
 173                      (ProtobufCAllocator  *allocator,
 174                       size_t               len,
 175                       const uint8_t       *data)
 176 {
 177   return (StreamingProtobufs__UECapabilityRATContainer *)
 178      protobuf_c_message_unpack (&streaming_protobufs__ue__capability_rat__container__descriptor,
 179                                 allocator, len, data);
 180 }
 181 void   streaming_protobufs__ue__capability_rat__container__free_unpacked
 182                      (StreamingProtobufs__UECapabilityRATContainer *message,
 183                       ProtobufCAllocator *allocator)
 184 {
 185   if(!message)
 186     return;
 187   assert(message->base.descriptor == &streaming_protobufs__ue__capability_rat__container__descriptor);
 188   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 189 }
 190 void   streaming_protobufs__rat__type__init
 191                      (StreamingProtobufs__RATType         *message)
 192 {
 193   static const StreamingProtobufs__RATType init_value = STREAMING_PROTOBUFS__RAT__TYPE__INIT;
 194   *message = init_value;
 195 }
 196 size_t streaming_protobufs__rat__type__get_packed_size
 197                      (const StreamingProtobufs__RATType *message)
 198 {
 199   assert(message->base.descriptor == &streaming_protobufs__rat__type__descriptor);
 200   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 201 }
 202 size_t streaming_protobufs__rat__type__pack
 203                      (const StreamingProtobufs__RATType *message,
 204                       uint8_t       *out)
 205 {
 206   assert(message->base.descriptor == &streaming_protobufs__rat__type__descriptor);
 207   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 208 }
 209 size_t streaming_protobufs__rat__type__pack_to_buffer
 210                      (const StreamingProtobufs__RATType *message,
 211                       ProtobufCBuffer *buffer)
 212 {
 213   assert(message->base.descriptor == &streaming_protobufs__rat__type__descriptor);
 214   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 215 }
 216 StreamingProtobufs__RATType *
 217        streaming_protobufs__rat__type__unpack
 218                      (ProtobufCAllocator  *allocator,
 219                       size_t               len,
 220                       const uint8_t       *data)
 221 {
 222   return (StreamingProtobufs__RATType *)
 223      protobuf_c_message_unpack (&streaming_protobufs__rat__type__descriptor,
 224                                 allocator, len, data);
 225 }
 226 void   streaming_protobufs__rat__type__free_unpacked
 227                      (StreamingProtobufs__RATType *message,
 228                       ProtobufCAllocator *allocator)
 229 {
 230   if(!message)
 231     return;
 232   assert(message->base.descriptor == &streaming_protobufs__rat__type__descriptor);
 233   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 234 }
 235 void   streaming_protobufs__scg_failure_info__init
 236                      (StreamingProtobufs__ScgFailureInfo         *message)
 237 {
 238   static const StreamingProtobufs__ScgFailureInfo init_value = STREAMING_PROTOBUFS__SCG_FAILURE_INFO__INIT;
 239   *message = init_value;
 240 }
 241 size_t streaming_protobufs__scg_failure_info__get_packed_size
 242                      (const StreamingProtobufs__ScgFailureInfo *message)
 243 {
 244   assert(message->base.descriptor == &streaming_protobufs__scg_failure_info__descriptor);
 245   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 246 }
 247 size_t streaming_protobufs__scg_failure_info__pack
 248                      (const StreamingProtobufs__ScgFailureInfo *message,
 249                       uint8_t       *out)
 250 {
 251   assert(message->base.descriptor == &streaming_protobufs__scg_failure_info__descriptor);
 252   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 253 }
 254 size_t streaming_protobufs__scg_failure_info__pack_to_buffer
 255                      (const StreamingProtobufs__ScgFailureInfo *message,
 256                       ProtobufCBuffer *buffer)
 257 {
 258   assert(message->base.descriptor == &streaming_protobufs__scg_failure_info__descriptor);
 259   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 260 }
 261 StreamingProtobufs__ScgFailureInfo *
 262        streaming_protobufs__scg_failure_info__unpack
 263                      (ProtobufCAllocator  *allocator,
 264                       size_t               len,
 265                       const uint8_t       *data)
 266 {
 267   return (StreamingProtobufs__ScgFailureInfo *)
 268      protobuf_c_message_unpack (&streaming_protobufs__scg_failure_info__descriptor,
 269                                 allocator, len, data);
 270 }
 271 void   streaming_protobufs__scg_failure_info__free_unpacked
 272                      (StreamingProtobufs__ScgFailureInfo *message,
 273                       ProtobufCAllocator *allocator)
 274 {
 275   if(!message)
 276     return;
 277   assert(message->base.descriptor == &streaming_protobufs__scg_failure_info__descriptor);
 278   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 279 }
 280 void   streaming_protobufs__meas_result_scg__failure__init
 281                      (StreamingProtobufs__MeasResultSCGFailure         *message)
 282 {
 283   static const StreamingProtobufs__MeasResultSCGFailure init_value = STREAMING_PROTOBUFS__MEAS_RESULT_SCG__FAILURE__INIT;
 284   *message = init_value;
 285 }
 286 size_t streaming_protobufs__meas_result_scg__failure__get_packed_size
 287                      (const StreamingProtobufs__MeasResultSCGFailure *message)
 288 {
 289   assert(message->base.descriptor == &streaming_protobufs__meas_result_scg__failure__descriptor);
 290   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 291 }
 292 size_t streaming_protobufs__meas_result_scg__failure__pack
 293                      (const StreamingProtobufs__MeasResultSCGFailure *message,
 294                       uint8_t       *out)
 295 {
 296   assert(message->base.descriptor == &streaming_protobufs__meas_result_scg__failure__descriptor);
 297   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 298 }
 299 size_t streaming_protobufs__meas_result_scg__failure__pack_to_buffer
 300                      (const StreamingProtobufs__MeasResultSCGFailure *message,
 301                       ProtobufCBuffer *buffer)
 302 {
 303   assert(message->base.descriptor == &streaming_protobufs__meas_result_scg__failure__descriptor);
 304   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 305 }
 306 StreamingProtobufs__MeasResultSCGFailure *
 307        streaming_protobufs__meas_result_scg__failure__unpack
 308                      (ProtobufCAllocator  *allocator,
 309                       size_t               len,
 310                       const uint8_t       *data)
 311 {
 312   return (StreamingProtobufs__MeasResultSCGFailure *)
 313      protobuf_c_message_unpack (&streaming_protobufs__meas_result_scg__failure__descriptor,
 314                                 allocator, len, data);
 315 }
 316 void   streaming_protobufs__meas_result_scg__failure__free_unpacked
 317                      (StreamingProtobufs__MeasResultSCGFailure *message,
 318                       ProtobufCAllocator *allocator)
 319 {
 320   if(!message)
 321     return;
 322   assert(message->base.descriptor == &streaming_protobufs__meas_result_scg__failure__descriptor);
 323   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 324 }
 325 void   streaming_protobufs__config_restrict_info_scg__init
 326                      (StreamingProtobufs__ConfigRestrictInfoSCG         *message)
 327 {
 328   static const StreamingProtobufs__ConfigRestrictInfoSCG init_value = STREAMING_PROTOBUFS__CONFIG_RESTRICT_INFO_SCG__INIT;
 329   *message = init_value;
 330 }
 331 size_t streaming_protobufs__config_restrict_info_scg__get_packed_size
 332                      (const StreamingProtobufs__ConfigRestrictInfoSCG *message)
 333 {
 334   assert(message->base.descriptor == &streaming_protobufs__config_restrict_info_scg__descriptor);
 335   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 336 }
 337 size_t streaming_protobufs__config_restrict_info_scg__pack
 338                      (const StreamingProtobufs__ConfigRestrictInfoSCG *message,
 339                       uint8_t       *out)
 340 {
 341   assert(message->base.descriptor == &streaming_protobufs__config_restrict_info_scg__descriptor);
 342   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 343 }
 344 size_t streaming_protobufs__config_restrict_info_scg__pack_to_buffer
 345                      (const StreamingProtobufs__ConfigRestrictInfoSCG *message,
 346                       ProtobufCBuffer *buffer)
 347 {
 348   assert(message->base.descriptor == &streaming_protobufs__config_restrict_info_scg__descriptor);
 349   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 350 }
 351 StreamingProtobufs__ConfigRestrictInfoSCG *
 352        streaming_protobufs__config_restrict_info_scg__unpack
 353                      (ProtobufCAllocator  *allocator,
 354                       size_t               len,
 355                       const uint8_t       *data)
 356 {
 357   return (StreamingProtobufs__ConfigRestrictInfoSCG *)
 358      protobuf_c_message_unpack (&streaming_protobufs__config_restrict_info_scg__descriptor,
 359                                 allocator, len, data);
 360 }
 361 void   streaming_protobufs__config_restrict_info_scg__free_unpacked
 362                      (StreamingProtobufs__ConfigRestrictInfoSCG *message,
 363                       ProtobufCAllocator *allocator)
 364 {
 365   if(!message)
 366     return;
 367   assert(message->base.descriptor == &streaming_protobufs__config_restrict_info_scg__descriptor);
 368   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 369 }
 370 void   streaming_protobufs__band_combination_info_list__init
 371                      (StreamingProtobufs__BandCombinationInfoList         *message)
 372 {
 373   static const StreamingProtobufs__BandCombinationInfoList init_value = STREAMING_PROTOBUFS__BAND_COMBINATION_INFO_LIST__INIT;
 374   *message = init_value;
 375 }
 376 size_t streaming_protobufs__band_combination_info_list__get_packed_size
 377                      (const StreamingProtobufs__BandCombinationInfoList *message)
 378 {
 379   assert(message->base.descriptor == &streaming_protobufs__band_combination_info_list__descriptor);
 380   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 381 }
 382 size_t streaming_protobufs__band_combination_info_list__pack
 383                      (const StreamingProtobufs__BandCombinationInfoList *message,
 384                       uint8_t       *out)
 385 {
 386   assert(message->base.descriptor == &streaming_protobufs__band_combination_info_list__descriptor);
 387   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 388 }
 389 size_t streaming_protobufs__band_combination_info_list__pack_to_buffer
 390                      (const StreamingProtobufs__BandCombinationInfoList *message,
 391                       ProtobufCBuffer *buffer)
 392 {
 393   assert(message->base.descriptor == &streaming_protobufs__band_combination_info_list__descriptor);
 394   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 395 }
 396 StreamingProtobufs__BandCombinationInfoList *
 397        streaming_protobufs__band_combination_info_list__unpack
 398                      (ProtobufCAllocator  *allocator,
 399                       size_t               len,
 400                       const uint8_t       *data)
 401 {
 402   return (StreamingProtobufs__BandCombinationInfoList *)
 403      protobuf_c_message_unpack (&streaming_protobufs__band_combination_info_list__descriptor,
 404                                 allocator, len, data);
 405 }
 406 void   streaming_protobufs__band_combination_info_list__free_unpacked
 407                      (StreamingProtobufs__BandCombinationInfoList *message,
 408                       ProtobufCAllocator *allocator)
 409 {
 410   if(!message)
 411     return;
 412   assert(message->base.descriptor == &streaming_protobufs__band_combination_info_list__descriptor);
 413   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 414 }
 415 void   streaming_protobufs__band_combination_info__init
 416                      (StreamingProtobufs__BandCombinationInfo         *message)
 417 {
 418   static const StreamingProtobufs__BandCombinationInfo init_value = STREAMING_PROTOBUFS__BAND_COMBINATION_INFO__INIT;
 419   *message = init_value;
 420 }
 421 size_t streaming_protobufs__band_combination_info__get_packed_size
 422                      (const StreamingProtobufs__BandCombinationInfo *message)
 423 {
 424   assert(message->base.descriptor == &streaming_protobufs__band_combination_info__descriptor);
 425   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 426 }
 427 size_t streaming_protobufs__band_combination_info__pack
 428                      (const StreamingProtobufs__BandCombinationInfo *message,
 429                       uint8_t       *out)
 430 {
 431   assert(message->base.descriptor == &streaming_protobufs__band_combination_info__descriptor);
 432   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 433 }
 434 size_t streaming_protobufs__band_combination_info__pack_to_buffer
 435                      (const StreamingProtobufs__BandCombinationInfo *message,
 436                       ProtobufCBuffer *buffer)
 437 {
 438   assert(message->base.descriptor == &streaming_protobufs__band_combination_info__descriptor);
 439   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 440 }
 441 StreamingProtobufs__BandCombinationInfo *
 442        streaming_protobufs__band_combination_info__unpack
 443                      (ProtobufCAllocator  *allocator,
 444                       size_t               len,
 445                       const uint8_t       *data)
 446 {
 447   return (StreamingProtobufs__BandCombinationInfo *)
 448      protobuf_c_message_unpack (&streaming_protobufs__band_combination_info__descriptor,
 449                                 allocator, len, data);
 450 }
 451 void   streaming_protobufs__band_combination_info__free_unpacked
 452                      (StreamingProtobufs__BandCombinationInfo *message,
 453                       ProtobufCAllocator *allocator)
 454 {
 455   if(!message)
 456     return;
 457   assert(message->base.descriptor == &streaming_protobufs__band_combination_info__descriptor);
 458   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 459 }
 460 void   streaming_protobufs__power_coordination__fr1__init
 461                      (StreamingProtobufs__PowerCoordinationFR1         *message)
 462 {
 463   static const StreamingProtobufs__PowerCoordinationFR1 init_value = STREAMING_PROTOBUFS__POWER_COORDINATION__FR1__INIT;
 464   *message = init_value;
 465 }
 466 size_t streaming_protobufs__power_coordination__fr1__get_packed_size
 467                      (const StreamingProtobufs__PowerCoordinationFR1 *message)
 468 {
 469   assert(message->base.descriptor == &streaming_protobufs__power_coordination__fr1__descriptor);
 470   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 471 }
 472 size_t streaming_protobufs__power_coordination__fr1__pack
 473                      (const StreamingProtobufs__PowerCoordinationFR1 *message,
 474                       uint8_t       *out)
 475 {
 476   assert(message->base.descriptor == &streaming_protobufs__power_coordination__fr1__descriptor);
 477   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 478 }
 479 size_t streaming_protobufs__power_coordination__fr1__pack_to_buffer
 480                      (const StreamingProtobufs__PowerCoordinationFR1 *message,
 481                       ProtobufCBuffer *buffer)
 482 {
 483   assert(message->base.descriptor == &streaming_protobufs__power_coordination__fr1__descriptor);
 484   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 485 }
 486 StreamingProtobufs__PowerCoordinationFR1 *
 487        streaming_protobufs__power_coordination__fr1__unpack
 488                      (ProtobufCAllocator  *allocator,
 489                       size_t               len,
 490                       const uint8_t       *data)
 491 {
 492   return (StreamingProtobufs__PowerCoordinationFR1 *)
 493      protobuf_c_message_unpack (&streaming_protobufs__power_coordination__fr1__descriptor,
 494                                 allocator, len, data);
 495 }
 496 void   streaming_protobufs__power_coordination__fr1__free_unpacked
 497                      (StreamingProtobufs__PowerCoordinationFR1 *message,
 498                       ProtobufCAllocator *allocator)
 499 {
 500   if(!message)
 501     return;
 502   assert(message->base.descriptor == &streaming_protobufs__power_coordination__fr1__descriptor);
 503   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 504 }
 505 void   streaming_protobufs__serv_cell_index_range_scg__init
 506                      (StreamingProtobufs__ServCellIndexRangeSCG         *message)
 507 {
 508   static const StreamingProtobufs__ServCellIndexRangeSCG init_value = STREAMING_PROTOBUFS__SERV_CELL_INDEX_RANGE_SCG__INIT;
 509   *message = init_value;
 510 }
 511 size_t streaming_protobufs__serv_cell_index_range_scg__get_packed_size
 512                      (const StreamingProtobufs__ServCellIndexRangeSCG *message)
 513 {
 514   assert(message->base.descriptor == &streaming_protobufs__serv_cell_index_range_scg__descriptor);
 515   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 516 }
 517 size_t streaming_protobufs__serv_cell_index_range_scg__pack
 518                      (const StreamingProtobufs__ServCellIndexRangeSCG *message,
 519                       uint8_t       *out)
 520 {
 521   assert(message->base.descriptor == &streaming_protobufs__serv_cell_index_range_scg__descriptor);
 522   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 523 }
 524 size_t streaming_protobufs__serv_cell_index_range_scg__pack_to_buffer
 525                      (const StreamingProtobufs__ServCellIndexRangeSCG *message,
 526                       ProtobufCBuffer *buffer)
 527 {
 528   assert(message->base.descriptor == &streaming_protobufs__serv_cell_index_range_scg__descriptor);
 529   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 530 }
 531 StreamingProtobufs__ServCellIndexRangeSCG *
 532        streaming_protobufs__serv_cell_index_range_scg__unpack
 533                      (ProtobufCAllocator  *allocator,
 534                       size_t               len,
 535                       const uint8_t       *data)
 536 {
 537   return (StreamingProtobufs__ServCellIndexRangeSCG *)
 538      protobuf_c_message_unpack (&streaming_protobufs__serv_cell_index_range_scg__descriptor,
 539                                 allocator, len, data);
 540 }
 541 void   streaming_protobufs__serv_cell_index_range_scg__free_unpacked
 542                      (StreamingProtobufs__ServCellIndexRangeSCG *message,
 543                       ProtobufCAllocator *allocator)
 544 {
 545   if(!message)
 546     return;
 547   assert(message->base.descriptor == &streaming_protobufs__serv_cell_index_range_scg__descriptor);
 548   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 549 }
 550 void   streaming_protobufs__meas_config_mn__init
 551                      (StreamingProtobufs__MeasConfigMN         *message)
 552 {
 553   static const StreamingProtobufs__MeasConfigMN init_value = STREAMING_PROTOBUFS__MEAS_CONFIG_MN__INIT;
 554   *message = init_value;
 555 }
 556 size_t streaming_protobufs__meas_config_mn__get_packed_size
 557                      (const StreamingProtobufs__MeasConfigMN *message)
 558 {
 559   assert(message->base.descriptor == &streaming_protobufs__meas_config_mn__descriptor);
 560   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 561 }
 562 size_t streaming_protobufs__meas_config_mn__pack
 563                      (const StreamingProtobufs__MeasConfigMN *message,
 564                       uint8_t       *out)
 565 {
 566   assert(message->base.descriptor == &streaming_protobufs__meas_config_mn__descriptor);
 567   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 568 }
 569 size_t streaming_protobufs__meas_config_mn__pack_to_buffer
 570                      (const StreamingProtobufs__MeasConfigMN *message,
 571                       ProtobufCBuffer *buffer)
 572 {
 573   assert(message->base.descriptor == &streaming_protobufs__meas_config_mn__descriptor);
 574   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 575 }
 576 StreamingProtobufs__MeasConfigMN *
 577        streaming_protobufs__meas_config_mn__unpack
 578                      (ProtobufCAllocator  *allocator,
 579                       size_t               len,
 580                       const uint8_t       *data)
 581 {
 582   return (StreamingProtobufs__MeasConfigMN *)
 583      protobuf_c_message_unpack (&streaming_protobufs__meas_config_mn__descriptor,
 584                                 allocator, len, data);
 585 }
 586 void   streaming_protobufs__meas_config_mn__free_unpacked
 587                      (StreamingProtobufs__MeasConfigMN *message,
 588                       ProtobufCAllocator *allocator)
 589 {
 590   if(!message)
 591     return;
 592   assert(message->base.descriptor == &streaming_protobufs__meas_config_mn__descriptor);
 593   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 594 }
 595 void   streaming_protobufs__gap_purpose__init
 596                      (StreamingProtobufs__GapPurpose         *message)
 597 {
 598   static const StreamingProtobufs__GapPurpose init_value = STREAMING_PROTOBUFS__GAP_PURPOSE__INIT;
 599   *message = init_value;
 600 }
 601 size_t streaming_protobufs__gap_purpose__get_packed_size
 602                      (const StreamingProtobufs__GapPurpose *message)
 603 {
 604   assert(message->base.descriptor == &streaming_protobufs__gap_purpose__descriptor);
 605   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 606 }
 607 size_t streaming_protobufs__gap_purpose__pack
 608                      (const StreamingProtobufs__GapPurpose *message,
 609                       uint8_t       *out)
 610 {
 611   assert(message->base.descriptor == &streaming_protobufs__gap_purpose__descriptor);
 612   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 613 }
 614 size_t streaming_protobufs__gap_purpose__pack_to_buffer
 615                      (const StreamingProtobufs__GapPurpose *message,
 616                       ProtobufCBuffer *buffer)
 617 {
 618   assert(message->base.descriptor == &streaming_protobufs__gap_purpose__descriptor);
 619   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 620 }
 621 StreamingProtobufs__GapPurpose *
 622        streaming_protobufs__gap_purpose__unpack
 623                      (ProtobufCAllocator  *allocator,
 624                       size_t               len,
 625                       const uint8_t       *data)
 626 {
 627   return (StreamingProtobufs__GapPurpose *)
 628      protobuf_c_message_unpack (&streaming_protobufs__gap_purpose__descriptor,
 629                                 allocator, len, data);
 630 }
 631 void   streaming_protobufs__gap_purpose__free_unpacked
 632                      (StreamingProtobufs__GapPurpose *message,
 633                       ProtobufCAllocator *allocator)
 634 {
 635   if(!message)
 636     return;
 637   assert(message->base.descriptor == &streaming_protobufs__gap_purpose__descriptor);
 638   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 639 }
 640 void   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__init
 641                      (StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC         *message)
 642 {
 643   static const StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC init_value = STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INIT;
 644   *message = init_value;
 645 }
 646 size_t streaming_protobufs__affected_carrier_freq_comb_info_mrdc__get_packed_size
 647                      (const StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC *message)
 648 {
 649   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor);
 650   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 651 }
 652 size_t streaming_protobufs__affected_carrier_freq_comb_info_mrdc__pack
 653                      (const StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC *message,
 654                       uint8_t       *out)
 655 {
 656   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor);
 657   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 658 }
 659 size_t streaming_protobufs__affected_carrier_freq_comb_info_mrdc__pack_to_buffer
 660                      (const StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC *message,
 661                       ProtobufCBuffer *buffer)
 662 {
 663   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor);
 664   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 665 }
 666 StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC *
 667        streaming_protobufs__affected_carrier_freq_comb_info_mrdc__unpack
 668                      (ProtobufCAllocator  *allocator,
 669                       size_t               len,
 670                       const uint8_t       *data)
 671 {
 672   return (StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC *)
 673      protobuf_c_message_unpack (&streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor,
 674                                 allocator, len, data);
 675 }
 676 void   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__free_unpacked
 677                      (StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC *message,
 678                       ProtobufCAllocator *allocator)
 679 {
 680   if(!message)
 681     return;
 682   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor);
 683   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 684 }
 685 void   streaming_protobufs__victim_system_type__init
 686                      (StreamingProtobufs__VictimSystemType         *message)
 687 {
 688   static const StreamingProtobufs__VictimSystemType init_value = STREAMING_PROTOBUFS__VICTIM_SYSTEM_TYPE__INIT;
 689   *message = init_value;
 690 }
 691 size_t streaming_protobufs__victim_system_type__get_packed_size
 692                      (const StreamingProtobufs__VictimSystemType *message)
 693 {
 694   assert(message->base.descriptor == &streaming_protobufs__victim_system_type__descriptor);
 695   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 696 }
 697 size_t streaming_protobufs__victim_system_type__pack
 698                      (const StreamingProtobufs__VictimSystemType *message,
 699                       uint8_t       *out)
 700 {
 701   assert(message->base.descriptor == &streaming_protobufs__victim_system_type__descriptor);
 702   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 703 }
 704 size_t streaming_protobufs__victim_system_type__pack_to_buffer
 705                      (const StreamingProtobufs__VictimSystemType *message,
 706                       ProtobufCBuffer *buffer)
 707 {
 708   assert(message->base.descriptor == &streaming_protobufs__victim_system_type__descriptor);
 709   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 710 }
 711 StreamingProtobufs__VictimSystemType *
 712        streaming_protobufs__victim_system_type__unpack
 713                      (ProtobufCAllocator  *allocator,
 714                       size_t               len,
 715                       const uint8_t       *data)
 716 {
 717   return (StreamingProtobufs__VictimSystemType *)
 718      protobuf_c_message_unpack (&streaming_protobufs__victim_system_type__descriptor,
 719                                 allocator, len, data);
 720 }
 721 void   streaming_protobufs__victim_system_type__free_unpacked
 722                      (StreamingProtobufs__VictimSystemType *message,
 723                       ProtobufCAllocator *allocator)
 724 {
 725   if(!message)
 726     return;
 727   assert(message->base.descriptor == &streaming_protobufs__victim_system_type__descriptor);
 728   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 729 }
 730 void   streaming_protobufs__affected_carrier_freq_comb_mrdc__init
 731                      (StreamingProtobufs__AffectedCarrierFreqCombMRDC         *message)
 732 {
 733   static const StreamingProtobufs__AffectedCarrierFreqCombMRDC init_value = STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_MRDC__INIT;
 734   *message = init_value;
 735 }
 736 size_t streaming_protobufs__affected_carrier_freq_comb_mrdc__get_packed_size
 737                      (const StreamingProtobufs__AffectedCarrierFreqCombMRDC *message)
 738 {
 739   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor);
 740   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 741 }
 742 size_t streaming_protobufs__affected_carrier_freq_comb_mrdc__pack
 743                      (const StreamingProtobufs__AffectedCarrierFreqCombMRDC *message,
 744                       uint8_t       *out)
 745 {
 746   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor);
 747   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 748 }
 749 size_t streaming_protobufs__affected_carrier_freq_comb_mrdc__pack_to_buffer
 750                      (const StreamingProtobufs__AffectedCarrierFreqCombMRDC *message,
 751                       ProtobufCBuffer *buffer)
 752 {
 753   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor);
 754   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 755 }
 756 StreamingProtobufs__AffectedCarrierFreqCombMRDC *
 757        streaming_protobufs__affected_carrier_freq_comb_mrdc__unpack
 758                      (ProtobufCAllocator  *allocator,
 759                       size_t               len,
 760                       const uint8_t       *data)
 761 {
 762   return (StreamingProtobufs__AffectedCarrierFreqCombMRDC *)
 763      protobuf_c_message_unpack (&streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor,
 764                                 allocator, len, data);
 765 }
 766 void   streaming_protobufs__affected_carrier_freq_comb_mrdc__free_unpacked
 767                      (StreamingProtobufs__AffectedCarrierFreqCombMRDC *message,
 768                       ProtobufCAllocator *allocator)
 769 {
 770   if(!message)
 771     return;
 772   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor);
 773   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 774 }
 775 void   streaming_protobufs__affected_carrier_freq_comb_eutra__init
 776                      (StreamingProtobufs__AffectedCarrierFreqCombEUTRA         *message)
 777 {
 778   static const StreamingProtobufs__AffectedCarrierFreqCombEUTRA init_value = STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_EUTRA__INIT;
 779   *message = init_value;
 780 }
 781 size_t streaming_protobufs__affected_carrier_freq_comb_eutra__get_packed_size
 782                      (const StreamingProtobufs__AffectedCarrierFreqCombEUTRA *message)
 783 {
 784   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor);
 785   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 786 }
 787 size_t streaming_protobufs__affected_carrier_freq_comb_eutra__pack
 788                      (const StreamingProtobufs__AffectedCarrierFreqCombEUTRA *message,
 789                       uint8_t       *out)
 790 {
 791   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor);
 792   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 793 }
 794 size_t streaming_protobufs__affected_carrier_freq_comb_eutra__pack_to_buffer
 795                      (const StreamingProtobufs__AffectedCarrierFreqCombEUTRA *message,
 796                       ProtobufCBuffer *buffer)
 797 {
 798   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor);
 799   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 800 }
 801 StreamingProtobufs__AffectedCarrierFreqCombEUTRA *
 802        streaming_protobufs__affected_carrier_freq_comb_eutra__unpack
 803                      (ProtobufCAllocator  *allocator,
 804                       size_t               len,
 805                       const uint8_t       *data)
 806 {
 807   return (StreamingProtobufs__AffectedCarrierFreqCombEUTRA *)
 808      protobuf_c_message_unpack (&streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor,
 809                                 allocator, len, data);
 810 }
 811 void   streaming_protobufs__affected_carrier_freq_comb_eutra__free_unpacked
 812                      (StreamingProtobufs__AffectedCarrierFreqCombEUTRA *message,
 813                       ProtobufCAllocator *allocator)
 814 {
 815   if(!message)
 816     return;
 817   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor);
 818   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 819 }
 820 void   streaming_protobufs__affected_carrier_freq_comb_nr__init
 821                      (StreamingProtobufs__AffectedCarrierFreqCombNR         *message)
 822 {
 823   static const StreamingProtobufs__AffectedCarrierFreqCombNR init_value = STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_NR__INIT;
 824   *message = init_value;
 825 }
 826 size_t streaming_protobufs__affected_carrier_freq_comb_nr__get_packed_size
 827                      (const StreamingProtobufs__AffectedCarrierFreqCombNR *message)
 828 {
 829   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_nr__descriptor);
 830   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 831 }
 832 size_t streaming_protobufs__affected_carrier_freq_comb_nr__pack
 833                      (const StreamingProtobufs__AffectedCarrierFreqCombNR *message,
 834                       uint8_t       *out)
 835 {
 836   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_nr__descriptor);
 837   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 838 }
 839 size_t streaming_protobufs__affected_carrier_freq_comb_nr__pack_to_buffer
 840                      (const StreamingProtobufs__AffectedCarrierFreqCombNR *message,
 841                       ProtobufCBuffer *buffer)
 842 {
 843   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_nr__descriptor);
 844   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 845 }
 846 StreamingProtobufs__AffectedCarrierFreqCombNR *
 847        streaming_protobufs__affected_carrier_freq_comb_nr__unpack
 848                      (ProtobufCAllocator  *allocator,
 849                       size_t               len,
 850                       const uint8_t       *data)
 851 {
 852   return (StreamingProtobufs__AffectedCarrierFreqCombNR *)
 853      protobuf_c_message_unpack (&streaming_protobufs__affected_carrier_freq_comb_nr__descriptor,
 854                                 allocator, len, data);
 855 }
 856 void   streaming_protobufs__affected_carrier_freq_comb_nr__free_unpacked
 857                      (StreamingProtobufs__AffectedCarrierFreqCombNR *message,
 858                       ProtobufCAllocator *allocator)
 859 {
 860   if(!message)
 861     return;
 862   assert(message->base.descriptor == &streaming_protobufs__affected_carrier_freq_comb_nr__descriptor);
 863   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 864 }
 865 void   streaming_protobufs__cg__config_info_v1540__ies__init
 866                      (StreamingProtobufs__CGConfigInfoV1540IEs         *message)
 867 {
 868   static const StreamingProtobufs__CGConfigInfoV1540IEs init_value = STREAMING_PROTOBUFS__CG__CONFIG_INFO_V1540__IES__INIT;
 869   *message = init_value;
 870 }
 871 size_t streaming_protobufs__cg__config_info_v1540__ies__get_packed_size
 872                      (const StreamingProtobufs__CGConfigInfoV1540IEs *message)
 873 {
 874   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_v1540__ies__descriptor);
 875   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 876 }
 877 size_t streaming_protobufs__cg__config_info_v1540__ies__pack
 878                      (const StreamingProtobufs__CGConfigInfoV1540IEs *message,
 879                       uint8_t       *out)
 880 {
 881   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_v1540__ies__descriptor);
 882   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 883 }
 884 size_t streaming_protobufs__cg__config_info_v1540__ies__pack_to_buffer
 885                      (const StreamingProtobufs__CGConfigInfoV1540IEs *message,
 886                       ProtobufCBuffer *buffer)
 887 {
 888   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_v1540__ies__descriptor);
 889   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 890 }
 891 StreamingProtobufs__CGConfigInfoV1540IEs *
 892        streaming_protobufs__cg__config_info_v1540__ies__unpack
 893                      (ProtobufCAllocator  *allocator,
 894                       size_t               len,
 895                       const uint8_t       *data)
 896 {
 897   return (StreamingProtobufs__CGConfigInfoV1540IEs *)
 898      protobuf_c_message_unpack (&streaming_protobufs__cg__config_info_v1540__ies__descriptor,
 899                                 allocator, len, data);
 900 }
 901 void   streaming_protobufs__cg__config_info_v1540__ies__free_unpacked
 902                      (StreamingProtobufs__CGConfigInfoV1540IEs *message,
 903                       ProtobufCAllocator *allocator)
 904 {
 905   if(!message)
 906     return;
 907   assert(message->base.descriptor == &streaming_protobufs__cg__config_info_v1540__ies__descriptor);
 908   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 909 }
 910 void   streaming_protobufs__ph__type_list_mcg__init
 911                      (StreamingProtobufs__PHTypeListMCG         *message)
 912 {
 913   static const StreamingProtobufs__PHTypeListMCG init_value = STREAMING_PROTOBUFS__PH__TYPE_LIST_MCG__INIT;
 914   *message = init_value;
 915 }
 916 size_t streaming_protobufs__ph__type_list_mcg__get_packed_size
 917                      (const StreamingProtobufs__PHTypeListMCG *message)
 918 {
 919   assert(message->base.descriptor == &streaming_protobufs__ph__type_list_mcg__descriptor);
 920   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 921 }
 922 size_t streaming_protobufs__ph__type_list_mcg__pack
 923                      (const StreamingProtobufs__PHTypeListMCG *message,
 924                       uint8_t       *out)
 925 {
 926   assert(message->base.descriptor == &streaming_protobufs__ph__type_list_mcg__descriptor);
 927   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 928 }
 929 size_t streaming_protobufs__ph__type_list_mcg__pack_to_buffer
 930                      (const StreamingProtobufs__PHTypeListMCG *message,
 931                       ProtobufCBuffer *buffer)
 932 {
 933   assert(message->base.descriptor == &streaming_protobufs__ph__type_list_mcg__descriptor);
 934   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 935 }
 936 StreamingProtobufs__PHTypeListMCG *
 937        streaming_protobufs__ph__type_list_mcg__unpack
 938                      (ProtobufCAllocator  *allocator,
 939                       size_t               len,
 940                       const uint8_t       *data)
 941 {
 942   return (StreamingProtobufs__PHTypeListMCG *)
 943      protobuf_c_message_unpack (&streaming_protobufs__ph__type_list_mcg__descriptor,
 944                                 allocator, len, data);
 945 }
 946 void   streaming_protobufs__ph__type_list_mcg__free_unpacked
 947                      (StreamingProtobufs__PHTypeListMCG *message,
 948                       ProtobufCAllocator *allocator)
 949 {
 950   if(!message)
 951     return;
 952   assert(message->base.descriptor == &streaming_protobufs__ph__type_list_mcg__descriptor);
 953   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 954 }
 955 void   streaming_protobufs__ph__info_mcg__init
 956                      (StreamingProtobufs__PHInfoMCG         *message)
 957 {
 958   static const StreamingProtobufs__PHInfoMCG init_value = STREAMING_PROTOBUFS__PH__INFO_MCG__INIT;
 959   *message = init_value;
 960 }
 961 size_t streaming_protobufs__ph__info_mcg__get_packed_size
 962                      (const StreamingProtobufs__PHInfoMCG *message)
 963 {
 964   assert(message->base.descriptor == &streaming_protobufs__ph__info_mcg__descriptor);
 965   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 966 }
 967 size_t streaming_protobufs__ph__info_mcg__pack
 968                      (const StreamingProtobufs__PHInfoMCG *message,
 969                       uint8_t       *out)
 970 {
 971   assert(message->base.descriptor == &streaming_protobufs__ph__info_mcg__descriptor);
 972   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 973 }
 974 size_t streaming_protobufs__ph__info_mcg__pack_to_buffer
 975                      (const StreamingProtobufs__PHInfoMCG *message,
 976                       ProtobufCBuffer *buffer)
 977 {
 978   assert(message->base.descriptor == &streaming_protobufs__ph__info_mcg__descriptor);
 979   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 980 }
 981 StreamingProtobufs__PHInfoMCG *
 982        streaming_protobufs__ph__info_mcg__unpack
 983                      (ProtobufCAllocator  *allocator,
 984                       size_t               len,
 985                       const uint8_t       *data)
 986 {
 987   return (StreamingProtobufs__PHInfoMCG *)
 988      protobuf_c_message_unpack (&streaming_protobufs__ph__info_mcg__descriptor,
 989                                 allocator, len, data);
 990 }
 991 void   streaming_protobufs__ph__info_mcg__free_unpacked
 992                      (StreamingProtobufs__PHInfoMCG *message,
 993                       ProtobufCAllocator *allocator)
 994 {
 995   if(!message)
 996     return;
 997   assert(message->base.descriptor == &streaming_protobufs__ph__info_mcg__descriptor);
 998   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 999 }
1000 void   streaming_protobufs__ph__uplink_carrier_mcg__init
1001                      (StreamingProtobufs__PHUplinkCarrierMCG         *message)
1002 {
1003   static const StreamingProtobufs__PHUplinkCarrierMCG init_value = STREAMING_PROTOBUFS__PH__UPLINK_CARRIER_MCG__INIT;
1004   *message = init_value;
1005 }
1006 size_t streaming_protobufs__ph__uplink_carrier_mcg__get_packed_size
1007                      (const StreamingProtobufs__PHUplinkCarrierMCG *message)
1008 {
1009   assert(message->base.descriptor == &streaming_protobufs__ph__uplink_carrier_mcg__descriptor);
1010   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1011 }
1012 size_t streaming_protobufs__ph__uplink_carrier_mcg__pack
1013                      (const StreamingProtobufs__PHUplinkCarrierMCG *message,
1014                       uint8_t       *out)
1015 {
1016   assert(message->base.descriptor == &streaming_protobufs__ph__uplink_carrier_mcg__descriptor);
1017   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1018 }
1019 size_t streaming_protobufs__ph__uplink_carrier_mcg__pack_to_buffer
1020                      (const StreamingProtobufs__PHUplinkCarrierMCG *message,
1021                       ProtobufCBuffer *buffer)
1022 {
1023   assert(message->base.descriptor == &streaming_protobufs__ph__uplink_carrier_mcg__descriptor);
1024   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1025 }
1026 StreamingProtobufs__PHUplinkCarrierMCG *
1027        streaming_protobufs__ph__uplink_carrier_mcg__unpack
1028                      (ProtobufCAllocator  *allocator,
1029                       size_t               len,
1030                       const uint8_t       *data)
1031 {
1032   return (StreamingProtobufs__PHUplinkCarrierMCG *)
1033      protobuf_c_message_unpack (&streaming_protobufs__ph__uplink_carrier_mcg__descriptor,
1034                                 allocator, len, data);
1035 }
1036 void   streaming_protobufs__ph__uplink_carrier_mcg__free_unpacked
1037                      (StreamingProtobufs__PHUplinkCarrierMCG *message,
1038                       ProtobufCAllocator *allocator)
1039 {
1040   if(!message)
1041     return;
1042   assert(message->base.descriptor == &streaming_protobufs__ph__uplink_carrier_mcg__descriptor);
1043   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1044 }
1045 void   streaming_protobufs__meas_result_report_cgi__init
1046                      (StreamingProtobufs__MeasResultReportCGI         *message)
1047 {
1048   static const StreamingProtobufs__MeasResultReportCGI init_value = STREAMING_PROTOBUFS__MEAS_RESULT_REPORT_CGI__INIT;
1049   *message = init_value;
1050 }
1051 size_t streaming_protobufs__meas_result_report_cgi__get_packed_size
1052                      (const StreamingProtobufs__MeasResultReportCGI *message)
1053 {
1054   assert(message->base.descriptor == &streaming_protobufs__meas_result_report_cgi__descriptor);
1055   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1056 }
1057 size_t streaming_protobufs__meas_result_report_cgi__pack
1058                      (const StreamingProtobufs__MeasResultReportCGI *message,
1059                       uint8_t       *out)
1060 {
1061   assert(message->base.descriptor == &streaming_protobufs__meas_result_report_cgi__descriptor);
1062   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1063 }
1064 size_t streaming_protobufs__meas_result_report_cgi__pack_to_buffer
1065                      (const StreamingProtobufs__MeasResultReportCGI *message,
1066                       ProtobufCBuffer *buffer)
1067 {
1068   assert(message->base.descriptor == &streaming_protobufs__meas_result_report_cgi__descriptor);
1069   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1070 }
1071 StreamingProtobufs__MeasResultReportCGI *
1072        streaming_protobufs__meas_result_report_cgi__unpack
1073                      (ProtobufCAllocator  *allocator,
1074                       size_t               len,
1075                       const uint8_t       *data)
1076 {
1077   return (StreamingProtobufs__MeasResultReportCGI *)
1078      protobuf_c_message_unpack (&streaming_protobufs__meas_result_report_cgi__descriptor,
1079                                 allocator, len, data);
1080 }
1081 void   streaming_protobufs__meas_result_report_cgi__free_unpacked
1082                      (StreamingProtobufs__MeasResultReportCGI *message,
1083                       ProtobufCAllocator *allocator)
1084 {
1085   if(!message)
1086     return;
1087   assert(message->base.descriptor == &streaming_protobufs__meas_result_report_cgi__descriptor);
1088   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1089 }
1090 static const ProtobufCFieldDescriptor streaming_protobufs__cg__config_info__field_descriptors[1] =
1091 {
1092   {
1093     "criticalExtensionsChoice1",
1094     1,
1095     PROTOBUF_C_LABEL_NONE,
1096     PROTOBUF_C_TYPE_MESSAGE,
1097     offsetof(StreamingProtobufs__CGConfigInfo, critical_extensions_case),
1098     offsetof(StreamingProtobufs__CGConfigInfo, criticalextensionschoice1),
1099     &streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor,
1100     NULL,
1101     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
1102     0,NULL,NULL    /* reserved1,reserved2, etc */
1103   },
1104 };
1105 static const unsigned streaming_protobufs__cg__config_info__field_indices_by_name[] = {
1106   0,   /* field[0] = criticalExtensionsChoice1 */
1107 };
1108 static const ProtobufCIntRange streaming_protobufs__cg__config_info__number_ranges[1 + 1] =
1109 {
1110   { 1, 0 },
1111   { 0, 1 }
1112 };
1113 const ProtobufCMessageDescriptor streaming_protobufs__cg__config_info__descriptor =
1114 {
1115   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1116   "streaming_protobufs.CG_ConfigInfo",
1117   "CGConfigInfo",
1118   "StreamingProtobufs__CGConfigInfo",
1119   "streaming_protobufs",
1120   sizeof(StreamingProtobufs__CGConfigInfo),
1121   1,
1122   streaming_protobufs__cg__config_info__field_descriptors,
1123   streaming_protobufs__cg__config_info__field_indices_by_name,
1124   1,  streaming_protobufs__cg__config_info__number_ranges,
1125   (ProtobufCMessageInit) streaming_protobufs__cg__config_info__init,
1126   NULL,NULL,NULL    /* reserved[123] */
1127 };
1128 static const ProtobufCFieldDescriptor streaming_protobufs__cg__config_info_critical_extensions_choice1__field_descriptors[1] =
1129 {
1130   {
1131     "protocolIEs",
1132     1,
1133     PROTOBUF_C_LABEL_NONE,
1134     PROTOBUF_C_TYPE_MESSAGE,
1135     offsetof(StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1, c1_case),
1136     offsetof(StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1, protocolies),
1137     &streaming_protobufs__cg__config_info__ies__descriptor,
1138     NULL,
1139     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
1140     0,NULL,NULL    /* reserved1,reserved2, etc */
1141   },
1142 };
1143 static const unsigned streaming_protobufs__cg__config_info_critical_extensions_choice1__field_indices_by_name[] = {
1144   0,   /* field[0] = protocolIEs */
1145 };
1146 static const ProtobufCIntRange streaming_protobufs__cg__config_info_critical_extensions_choice1__number_ranges[1 + 1] =
1147 {
1148   { 1, 0 },
1149   { 0, 1 }
1150 };
1151 const ProtobufCMessageDescriptor streaming_protobufs__cg__config_info_critical_extensions_choice1__descriptor =
1152 {
1153   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1154   "streaming_protobufs.CG_ConfigInfoCriticalExtensionsChoice1",
1155   "CGConfigInfoCriticalExtensionsChoice1",
1156   "StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1",
1157   "streaming_protobufs",
1158   sizeof(StreamingProtobufs__CGConfigInfoCriticalExtensionsChoice1),
1159   1,
1160   streaming_protobufs__cg__config_info_critical_extensions_choice1__field_descriptors,
1161   streaming_protobufs__cg__config_info_critical_extensions_choice1__field_indices_by_name,
1162   1,  streaming_protobufs__cg__config_info_critical_extensions_choice1__number_ranges,
1163   (ProtobufCMessageInit) streaming_protobufs__cg__config_info_critical_extensions_choice1__init,
1164   NULL,NULL,NULL    /* reserved[123] */
1165 };
1166 static const ProtobufCFieldDescriptor streaming_protobufs__cg__config_info__ies__field_descriptors[13] =
1167 {
1168   {
1169     "ue_CapabilityInfo",
1170     1,
1171     PROTOBUF_C_LABEL_REPEATED,
1172     PROTOBUF_C_TYPE_MESSAGE,
1173     offsetof(StreamingProtobufs__CGConfigInfoIEs, n_ue_capabilityinfo),
1174     offsetof(StreamingProtobufs__CGConfigInfoIEs, ue_capabilityinfo),
1175     &streaming_protobufs__ue__capability_rat__container__descriptor,
1176     NULL,
1177     0,             /* flags */
1178     0,NULL,NULL    /* reserved1,reserved2, etc */
1179   },
1180   {
1181     "candidateCellInfoListMN",
1182     2,
1183     PROTOBUF_C_LABEL_NONE,
1184     PROTOBUF_C_TYPE_MESSAGE,
1185     0,   /* quantifier_offset */
1186     offsetof(StreamingProtobufs__CGConfigInfoIEs, candidatecellinfolistmn),
1187     &streaming_protobufs__meas_result_list2_nr__descriptor,
1188     NULL,
1189     0,             /* flags */
1190     0,NULL,NULL    /* reserved1,reserved2, etc */
1191   },
1192   {
1193     "candidateCellInfoListSN",
1194     3,
1195     PROTOBUF_C_LABEL_NONE,
1196     PROTOBUF_C_TYPE_MESSAGE,
1197     0,   /* quantifier_offset */
1198     offsetof(StreamingProtobufs__CGConfigInfoIEs, candidatecellinfolistsn),
1199     &streaming_protobufs__meas_result_list2_nr__descriptor,
1200     NULL,
1201     0,             /* flags */
1202     0,NULL,NULL    /* reserved1,reserved2, etc */
1203   },
1204   {
1205     "measResultCellListSFTD",
1206     4,
1207     PROTOBUF_C_LABEL_NONE,
1208     PROTOBUF_C_TYPE_MESSAGE,
1209     0,   /* quantifier_offset */
1210     offsetof(StreamingProtobufs__CGConfigInfoIEs, measresultcelllistsftd),
1211     &streaming_protobufs__meas_result_cell_list_sftd__descriptor,
1212     NULL,
1213     0,             /* flags */
1214     0,NULL,NULL    /* reserved1,reserved2, etc */
1215   },
1216   {
1217     "scgFailureInfo",
1218     5,
1219     PROTOBUF_C_LABEL_NONE,
1220     PROTOBUF_C_TYPE_MESSAGE,
1221     0,   /* quantifier_offset */
1222     offsetof(StreamingProtobufs__CGConfigInfoIEs, scgfailureinfo),
1223     &streaming_protobufs__scg_failure_info__descriptor,
1224     NULL,
1225     0,             /* flags */
1226     0,NULL,NULL    /* reserved1,reserved2, etc */
1227   },
1228   {
1229     "configRestrictInfo",
1230     6,
1231     PROTOBUF_C_LABEL_NONE,
1232     PROTOBUF_C_TYPE_MESSAGE,
1233     0,   /* quantifier_offset */
1234     offsetof(StreamingProtobufs__CGConfigInfoIEs, configrestrictinfo),
1235     &streaming_protobufs__config_restrict_info_scg__descriptor,
1236     NULL,
1237     0,             /* flags */
1238     0,NULL,NULL    /* reserved1,reserved2, etc */
1239   },
1240   {
1241     "drx_InfoMCG",
1242     7,
1243     PROTOBUF_C_LABEL_NONE,
1244     PROTOBUF_C_TYPE_MESSAGE,
1245     0,   /* quantifier_offset */
1246     offsetof(StreamingProtobufs__CGConfigInfoIEs, drx_infomcg),
1247     &streaming_protobufs__drx__info__descriptor,
1248     NULL,
1249     0,             /* flags */
1250     0,NULL,NULL    /* reserved1,reserved2, etc */
1251   },
1252   {
1253     "measConfigMN",
1254     8,
1255     PROTOBUF_C_LABEL_NONE,
1256     PROTOBUF_C_TYPE_MESSAGE,
1257     0,   /* quantifier_offset */
1258     offsetof(StreamingProtobufs__CGConfigInfoIEs, measconfigmn),
1259     &streaming_protobufs__meas_config_mn__descriptor,
1260     NULL,
1261     0,             /* flags */
1262     0,NULL,NULL    /* reserved1,reserved2, etc */
1263   },
1264   {
1265     "sourceConfigSCG",
1266     9,
1267     PROTOBUF_C_LABEL_NONE,
1268     PROTOBUF_C_TYPE_MESSAGE,
1269     0,   /* quantifier_offset */
1270     offsetof(StreamingProtobufs__CGConfigInfoIEs, sourceconfigscg),
1271     &google__protobuf__bytes_value__descriptor,
1272     NULL,
1273     0,             /* flags */
1274     0,NULL,NULL    /* reserved1,reserved2, etc */
1275   },
1276   {
1277     "scg_RB_Config",
1278     10,
1279     PROTOBUF_C_LABEL_NONE,
1280     PROTOBUF_C_TYPE_MESSAGE,
1281     0,   /* quantifier_offset */
1282     offsetof(StreamingProtobufs__CGConfigInfoIEs, scg_rb_config),
1283     &streaming_protobufs__radio_bearer_config__descriptor,
1284     NULL,
1285     0,             /* flags */
1286     0,NULL,NULL    /* reserved1,reserved2, etc */
1287   },
1288   {
1289     "mcg_RB_Config",
1290     11,
1291     PROTOBUF_C_LABEL_NONE,
1292     PROTOBUF_C_TYPE_MESSAGE,
1293     0,   /* quantifier_offset */
1294     offsetof(StreamingProtobufs__CGConfigInfoIEs, mcg_rb_config),
1295     &streaming_protobufs__radio_bearer_config__descriptor,
1296     NULL,
1297     0,             /* flags */
1298     0,NULL,NULL    /* reserved1,reserved2, etc */
1299   },
1300   {
1301     "mrdc_AssistanceInfo",
1302     12,
1303     PROTOBUF_C_LABEL_REPEATED,
1304     PROTOBUF_C_TYPE_MESSAGE,
1305     offsetof(StreamingProtobufs__CGConfigInfoIEs, n_mrdc_assistanceinfo),
1306     offsetof(StreamingProtobufs__CGConfigInfoIEs, mrdc_assistanceinfo),
1307     &streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor,
1308     NULL,
1309     0,             /* flags */
1310     0,NULL,NULL    /* reserved1,reserved2, etc */
1311   },
1312   {
1313     "nonCriticalExtension",
1314     13,
1315     PROTOBUF_C_LABEL_NONE,
1316     PROTOBUF_C_TYPE_MESSAGE,
1317     0,   /* quantifier_offset */
1318     offsetof(StreamingProtobufs__CGConfigInfoIEs, noncriticalextension),
1319     &streaming_protobufs__cg__config_info_v1540__ies__descriptor,
1320     NULL,
1321     0,             /* flags */
1322     0,NULL,NULL    /* reserved1,reserved2, etc */
1323   },
1324 };
1325 static const unsigned streaming_protobufs__cg__config_info__ies__field_indices_by_name[] = {
1326   1,   /* field[1] = candidateCellInfoListMN */
1327   2,   /* field[2] = candidateCellInfoListSN */
1328   5,   /* field[5] = configRestrictInfo */
1329   6,   /* field[6] = drx_InfoMCG */
1330   10,   /* field[10] = mcg_RB_Config */
1331   7,   /* field[7] = measConfigMN */
1332   3,   /* field[3] = measResultCellListSFTD */
1333   11,   /* field[11] = mrdc_AssistanceInfo */
1334   12,   /* field[12] = nonCriticalExtension */
1335   4,   /* field[4] = scgFailureInfo */
1336   9,   /* field[9] = scg_RB_Config */
1337   8,   /* field[8] = sourceConfigSCG */
1338   0,   /* field[0] = ue_CapabilityInfo */
1339 };
1340 static const ProtobufCIntRange streaming_protobufs__cg__config_info__ies__number_ranges[1 + 1] =
1341 {
1342   { 1, 0 },
1343   { 0, 13 }
1344 };
1345 const ProtobufCMessageDescriptor streaming_protobufs__cg__config_info__ies__descriptor =
1346 {
1347   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1348   "streaming_protobufs.CG_ConfigInfo_IEs",
1349   "CGConfigInfoIEs",
1350   "StreamingProtobufs__CGConfigInfoIEs",
1351   "streaming_protobufs",
1352   sizeof(StreamingProtobufs__CGConfigInfoIEs),
1353   13,
1354   streaming_protobufs__cg__config_info__ies__field_descriptors,
1355   streaming_protobufs__cg__config_info__ies__field_indices_by_name,
1356   1,  streaming_protobufs__cg__config_info__ies__number_ranges,
1357   (ProtobufCMessageInit) streaming_protobufs__cg__config_info__ies__init,
1358   NULL,NULL,NULL    /* reserved[123] */
1359 };
1360 static const ProtobufCFieldDescriptor streaming_protobufs__ue__capability_rat__container__field_descriptors[2] =
1361 {
1362   {
1363     "rat_Type",
1364     1,
1365     PROTOBUF_C_LABEL_NONE,
1366     PROTOBUF_C_TYPE_MESSAGE,
1367     0,   /* quantifier_offset */
1368     offsetof(StreamingProtobufs__UECapabilityRATContainer, rat_type),
1369     &streaming_protobufs__rat__type__descriptor,
1370     NULL,
1371     0,             /* flags */
1372     0,NULL,NULL    /* reserved1,reserved2, etc */
1373   },
1374   {
1375     "ue_CapabilityRAT_Container",
1376     2,
1377     PROTOBUF_C_LABEL_NONE,
1378     PROTOBUF_C_TYPE_BYTES,
1379     0,   /* quantifier_offset */
1380     offsetof(StreamingProtobufs__UECapabilityRATContainer, ue_capabilityrat_container),
1381     NULL,
1382     NULL,
1383     0,             /* flags */
1384     0,NULL,NULL    /* reserved1,reserved2, etc */
1385   },
1386 };
1387 static const unsigned streaming_protobufs__ue__capability_rat__container__field_indices_by_name[] = {
1388   0,   /* field[0] = rat_Type */
1389   1,   /* field[1] = ue_CapabilityRAT_Container */
1390 };
1391 static const ProtobufCIntRange streaming_protobufs__ue__capability_rat__container__number_ranges[1 + 1] =
1392 {
1393   { 1, 0 },
1394   { 0, 2 }
1395 };
1396 const ProtobufCMessageDescriptor streaming_protobufs__ue__capability_rat__container__descriptor =
1397 {
1398   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1399   "streaming_protobufs.UE_CapabilityRAT_Container",
1400   "UECapabilityRATContainer",
1401   "StreamingProtobufs__UECapabilityRATContainer",
1402   "streaming_protobufs",
1403   sizeof(StreamingProtobufs__UECapabilityRATContainer),
1404   2,
1405   streaming_protobufs__ue__capability_rat__container__field_descriptors,
1406   streaming_protobufs__ue__capability_rat__container__field_indices_by_name,
1407   1,  streaming_protobufs__ue__capability_rat__container__number_ranges,
1408   (ProtobufCMessageInit) streaming_protobufs__ue__capability_rat__container__init,
1409   NULL,NULL,NULL    /* reserved[123] */
1410 };
1411 static const ProtobufCEnumValue streaming_protobufs__rat__type__value__enum_values_by_number[4] =
1412 {
1413   { "protobuf_unspecified", "STREAMING_PROTOBUFS__RAT__TYPE__VALUE__protobuf_unspecified", 0 },
1414   { "nr", "STREAMING_PROTOBUFS__RAT__TYPE__VALUE__nr", 1 },
1415   { "eutra_nr", "STREAMING_PROTOBUFS__RAT__TYPE__VALUE__eutra_nr", 2 },
1416   { "eutra", "STREAMING_PROTOBUFS__RAT__TYPE__VALUE__eutra", 3 },
1417 };
1418 static const ProtobufCIntRange streaming_protobufs__rat__type__value__value_ranges[] = {
1419 {0, 0},{0, 4}
1420 };
1421 static const ProtobufCEnumValueIndex streaming_protobufs__rat__type__value__enum_values_by_name[4] =
1422 {
1423   { "eutra", 3 },
1424   { "eutra_nr", 2 },
1425   { "nr", 1 },
1426   { "protobuf_unspecified", 0 },
1427 };
1428 const ProtobufCEnumDescriptor streaming_protobufs__rat__type__value__descriptor =
1429 {
1430   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
1431   "streaming_protobufs.RAT_Type.Value",
1432   "Value",
1433   "StreamingProtobufs__RATType__Value",
1434   "streaming_protobufs",
1435   4,
1436   streaming_protobufs__rat__type__value__enum_values_by_number,
1437   4,
1438   streaming_protobufs__rat__type__value__enum_values_by_name,
1439   1,
1440   streaming_protobufs__rat__type__value__value_ranges,
1441   NULL,NULL,NULL,NULL   /* reserved[1234] */
1442 };
1443 static const ProtobufCFieldDescriptor streaming_protobufs__rat__type__field_descriptors[1] =
1444 {
1445   {
1446     "value",
1447     1,
1448     PROTOBUF_C_LABEL_NONE,
1449     PROTOBUF_C_TYPE_ENUM,
1450     0,   /* quantifier_offset */
1451     offsetof(StreamingProtobufs__RATType, value),
1452     &streaming_protobufs__rat__type__value__descriptor,
1453     NULL,
1454     0,             /* flags */
1455     0,NULL,NULL    /* reserved1,reserved2, etc */
1456   },
1457 };
1458 static const unsigned streaming_protobufs__rat__type__field_indices_by_name[] = {
1459   0,   /* field[0] = value */
1460 };
1461 static const ProtobufCIntRange streaming_protobufs__rat__type__number_ranges[1 + 1] =
1462 {
1463   { 1, 0 },
1464   { 0, 1 }
1465 };
1466 const ProtobufCMessageDescriptor streaming_protobufs__rat__type__descriptor =
1467 {
1468   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1469   "streaming_protobufs.RAT_Type",
1470   "RATType",
1471   "StreamingProtobufs__RATType",
1472   "streaming_protobufs",
1473   sizeof(StreamingProtobufs__RATType),
1474   1,
1475   streaming_protobufs__rat__type__field_descriptors,
1476   streaming_protobufs__rat__type__field_indices_by_name,
1477   1,  streaming_protobufs__rat__type__number_ranges,
1478   (ProtobufCMessageInit) streaming_protobufs__rat__type__init,
1479   NULL,NULL,NULL    /* reserved[123] */
1480 };
1481 static const ProtobufCEnumValue streaming_protobufs__scg_failure_info__failure_type__enum_values_by_number[7] =
1482 {
1483   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__protobuf_unspecified", 0 },
1484   { "t310_Expiry", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__t310_Expiry", 1 },
1485   { "randomAccessProblem", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__randomAccessProblem", 2 },
1486   { "rlc_MaxNumRetx", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__rlc_MaxNumRetx", 3 },
1487   { "synchReconfigFailure_SCG", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__synchReconfigFailure_SCG", 4 },
1488   { "scg_reconfigFailure", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__scg_reconfigFailure", 5 },
1489   { "srb3_IntegrityFailure", "STREAMING_PROTOBUFS__SCG_FAILURE_INFO__FAILURE_TYPE__srb3_IntegrityFailure", 6 },
1490 };
1491 static const ProtobufCIntRange streaming_protobufs__scg_failure_info__failure_type__value_ranges[] = {
1492 {0, 0},{0, 7}
1493 };
1494 static const ProtobufCEnumValueIndex streaming_protobufs__scg_failure_info__failure_type__enum_values_by_name[7] =
1495 {
1496   { "protobuf_unspecified", 0 },
1497   { "randomAccessProblem", 2 },
1498   { "rlc_MaxNumRetx", 3 },
1499   { "scg_reconfigFailure", 5 },
1500   { "srb3_IntegrityFailure", 6 },
1501   { "synchReconfigFailure_SCG", 4 },
1502   { "t310_Expiry", 1 },
1503 };
1504 const ProtobufCEnumDescriptor streaming_protobufs__scg_failure_info__failure_type__descriptor =
1505 {
1506   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
1507   "streaming_protobufs.ScgFailureInfo.FailureType",
1508   "FailureType",
1509   "StreamingProtobufs__ScgFailureInfo__FailureType",
1510   "streaming_protobufs",
1511   7,
1512   streaming_protobufs__scg_failure_info__failure_type__enum_values_by_number,
1513   7,
1514   streaming_protobufs__scg_failure_info__failure_type__enum_values_by_name,
1515   1,
1516   streaming_protobufs__scg_failure_info__failure_type__value_ranges,
1517   NULL,NULL,NULL,NULL   /* reserved[1234] */
1518 };
1519 static const ProtobufCFieldDescriptor streaming_protobufs__scg_failure_info__field_descriptors[2] =
1520 {
1521   {
1522     "failureType",
1523     1,
1524     PROTOBUF_C_LABEL_NONE,
1525     PROTOBUF_C_TYPE_ENUM,
1526     0,   /* quantifier_offset */
1527     offsetof(StreamingProtobufs__ScgFailureInfo, failuretype),
1528     &streaming_protobufs__scg_failure_info__failure_type__descriptor,
1529     NULL,
1530     0,             /* flags */
1531     0,NULL,NULL    /* reserved1,reserved2, etc */
1532   },
1533   {
1534     "measResultSCG",
1535     2,
1536     PROTOBUF_C_LABEL_NONE,
1537     PROTOBUF_C_TYPE_MESSAGE,
1538     0,   /* quantifier_offset */
1539     offsetof(StreamingProtobufs__ScgFailureInfo, measresultscg),
1540     &streaming_protobufs__meas_result_scg__failure__descriptor,
1541     NULL,
1542     0,             /* flags */
1543     0,NULL,NULL    /* reserved1,reserved2, etc */
1544   },
1545 };
1546 static const unsigned streaming_protobufs__scg_failure_info__field_indices_by_name[] = {
1547   0,   /* field[0] = failureType */
1548   1,   /* field[1] = measResultSCG */
1549 };
1550 static const ProtobufCIntRange streaming_protobufs__scg_failure_info__number_ranges[1 + 1] =
1551 {
1552   { 1, 0 },
1553   { 0, 2 }
1554 };
1555 const ProtobufCMessageDescriptor streaming_protobufs__scg_failure_info__descriptor =
1556 {
1557   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1558   "streaming_protobufs.ScgFailureInfo",
1559   "ScgFailureInfo",
1560   "StreamingProtobufs__ScgFailureInfo",
1561   "streaming_protobufs",
1562   sizeof(StreamingProtobufs__ScgFailureInfo),
1563   2,
1564   streaming_protobufs__scg_failure_info__field_descriptors,
1565   streaming_protobufs__scg_failure_info__field_indices_by_name,
1566   1,  streaming_protobufs__scg_failure_info__number_ranges,
1567   (ProtobufCMessageInit) streaming_protobufs__scg_failure_info__init,
1568   NULL,NULL,NULL    /* reserved[123] */
1569 };
1570 static const ProtobufCFieldDescriptor streaming_protobufs__meas_result_scg__failure__field_descriptors[1] =
1571 {
1572   {
1573     "measResultPerMOList",
1574     1,
1575     PROTOBUF_C_LABEL_NONE,
1576     PROTOBUF_C_TYPE_MESSAGE,
1577     0,   /* quantifier_offset */
1578     offsetof(StreamingProtobufs__MeasResultSCGFailure, measresultpermolist),
1579     &streaming_protobufs__meas_result_list2_nr__descriptor,
1580     NULL,
1581     0,             /* flags */
1582     0,NULL,NULL    /* reserved1,reserved2, etc */
1583   },
1584 };
1585 static const unsigned streaming_protobufs__meas_result_scg__failure__field_indices_by_name[] = {
1586   0,   /* field[0] = measResultPerMOList */
1587 };
1588 static const ProtobufCIntRange streaming_protobufs__meas_result_scg__failure__number_ranges[1 + 1] =
1589 {
1590   { 1, 0 },
1591   { 0, 1 }
1592 };
1593 const ProtobufCMessageDescriptor streaming_protobufs__meas_result_scg__failure__descriptor =
1594 {
1595   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1596   "streaming_protobufs.MeasResultSCG_Failure",
1597   "MeasResultSCGFailure",
1598   "StreamingProtobufs__MeasResultSCGFailure",
1599   "streaming_protobufs",
1600   sizeof(StreamingProtobufs__MeasResultSCGFailure),
1601   1,
1602   streaming_protobufs__meas_result_scg__failure__field_descriptors,
1603   streaming_protobufs__meas_result_scg__failure__field_indices_by_name,
1604   1,  streaming_protobufs__meas_result_scg__failure__number_ranges,
1605   (ProtobufCMessageInit) streaming_protobufs__meas_result_scg__failure__init,
1606   NULL,NULL,NULL    /* reserved[123] */
1607 };
1608 static const ProtobufCFieldDescriptor streaming_protobufs__config_restrict_info_scg__field_descriptors[5] =
1609 {
1610   {
1611     "allowedBC_ListMRDC",
1612     1,
1613     PROTOBUF_C_LABEL_NONE,
1614     PROTOBUF_C_TYPE_MESSAGE,
1615     0,   /* quantifier_offset */
1616     offsetof(StreamingProtobufs__ConfigRestrictInfoSCG, allowedbc_listmrdc),
1617     &streaming_protobufs__band_combination_info_list__descriptor,
1618     NULL,
1619     0,             /* flags */
1620     0,NULL,NULL    /* reserved1,reserved2, etc */
1621   },
1622   {
1623     "powerCoordination_FR1",
1624     2,
1625     PROTOBUF_C_LABEL_NONE,
1626     PROTOBUF_C_TYPE_MESSAGE,
1627     0,   /* quantifier_offset */
1628     offsetof(StreamingProtobufs__ConfigRestrictInfoSCG, powercoordination_fr1),
1629     &streaming_protobufs__power_coordination__fr1__descriptor,
1630     NULL,
1631     0,             /* flags */
1632     0,NULL,NULL    /* reserved1,reserved2, etc */
1633   },
1634   {
1635     "servCellIndexRangeSCG",
1636     3,
1637     PROTOBUF_C_LABEL_NONE,
1638     PROTOBUF_C_TYPE_MESSAGE,
1639     0,   /* quantifier_offset */
1640     offsetof(StreamingProtobufs__ConfigRestrictInfoSCG, servcellindexrangescg),
1641     &streaming_protobufs__serv_cell_index_range_scg__descriptor,
1642     NULL,
1643     0,             /* flags */
1644     0,NULL,NULL    /* reserved1,reserved2, etc */
1645   },
1646   {
1647     "maxMeasFreqsSCG_NR",
1648     4,
1649     PROTOBUF_C_LABEL_NONE,
1650     PROTOBUF_C_TYPE_MESSAGE,
1651     0,   /* quantifier_offset */
1652     offsetof(StreamingProtobufs__ConfigRestrictInfoSCG, maxmeasfreqsscg_nr),
1653     &google__protobuf__uint32_value__descriptor,
1654     NULL,
1655     0,             /* flags */
1656     0,NULL,NULL    /* reserved1,reserved2, etc */
1657   },
1658   {
1659     "maxMeasIdentitiesSCG_NR",
1660     5,
1661     PROTOBUF_C_LABEL_NONE,
1662     PROTOBUF_C_TYPE_MESSAGE,
1663     0,   /* quantifier_offset */
1664     offsetof(StreamingProtobufs__ConfigRestrictInfoSCG, maxmeasidentitiesscg_nr),
1665     &google__protobuf__uint32_value__descriptor,
1666     NULL,
1667     0,             /* flags */
1668     0,NULL,NULL    /* reserved1,reserved2, etc */
1669   },
1670 };
1671 static const unsigned streaming_protobufs__config_restrict_info_scg__field_indices_by_name[] = {
1672   0,   /* field[0] = allowedBC_ListMRDC */
1673   3,   /* field[3] = maxMeasFreqsSCG_NR */
1674   4,   /* field[4] = maxMeasIdentitiesSCG_NR */
1675   1,   /* field[1] = powerCoordination_FR1 */
1676   2,   /* field[2] = servCellIndexRangeSCG */
1677 };
1678 static const ProtobufCIntRange streaming_protobufs__config_restrict_info_scg__number_ranges[1 + 1] =
1679 {
1680   { 1, 0 },
1681   { 0, 5 }
1682 };
1683 const ProtobufCMessageDescriptor streaming_protobufs__config_restrict_info_scg__descriptor =
1684 {
1685   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1686   "streaming_protobufs.ConfigRestrictInfoSCG",
1687   "ConfigRestrictInfoSCG",
1688   "StreamingProtobufs__ConfigRestrictInfoSCG",
1689   "streaming_protobufs",
1690   sizeof(StreamingProtobufs__ConfigRestrictInfoSCG),
1691   5,
1692   streaming_protobufs__config_restrict_info_scg__field_descriptors,
1693   streaming_protobufs__config_restrict_info_scg__field_indices_by_name,
1694   1,  streaming_protobufs__config_restrict_info_scg__number_ranges,
1695   (ProtobufCMessageInit) streaming_protobufs__config_restrict_info_scg__init,
1696   NULL,NULL,NULL    /* reserved[123] */
1697 };
1698 static const ProtobufCFieldDescriptor streaming_protobufs__band_combination_info_list__field_descriptors[1] =
1699 {
1700   {
1701     "items",
1702     1,
1703     PROTOBUF_C_LABEL_REPEATED,
1704     PROTOBUF_C_TYPE_MESSAGE,
1705     offsetof(StreamingProtobufs__BandCombinationInfoList, n_items),
1706     offsetof(StreamingProtobufs__BandCombinationInfoList, items),
1707     &streaming_protobufs__band_combination_info__descriptor,
1708     NULL,
1709     0,             /* flags */
1710     0,NULL,NULL    /* reserved1,reserved2, etc */
1711   },
1712 };
1713 static const unsigned streaming_protobufs__band_combination_info_list__field_indices_by_name[] = {
1714   0,   /* field[0] = items */
1715 };
1716 static const ProtobufCIntRange streaming_protobufs__band_combination_info_list__number_ranges[1 + 1] =
1717 {
1718   { 1, 0 },
1719   { 0, 1 }
1720 };
1721 const ProtobufCMessageDescriptor streaming_protobufs__band_combination_info_list__descriptor =
1722 {
1723   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1724   "streaming_protobufs.BandCombinationInfoList",
1725   "BandCombinationInfoList",
1726   "StreamingProtobufs__BandCombinationInfoList",
1727   "streaming_protobufs",
1728   sizeof(StreamingProtobufs__BandCombinationInfoList),
1729   1,
1730   streaming_protobufs__band_combination_info_list__field_descriptors,
1731   streaming_protobufs__band_combination_info_list__field_indices_by_name,
1732   1,  streaming_protobufs__band_combination_info_list__number_ranges,
1733   (ProtobufCMessageInit) streaming_protobufs__band_combination_info_list__init,
1734   NULL,NULL,NULL    /* reserved[123] */
1735 };
1736 static const ProtobufCFieldDescriptor streaming_protobufs__band_combination_info__field_descriptors[2] =
1737 {
1738   {
1739     "bandCombinationIndex",
1740     1,
1741     PROTOBUF_C_LABEL_NONE,
1742     PROTOBUF_C_TYPE_UINT32,
1743     0,   /* quantifier_offset */
1744     offsetof(StreamingProtobufs__BandCombinationInfo, bandcombinationindex),
1745     NULL,
1746     NULL,
1747     0,             /* flags */
1748     0,NULL,NULL    /* reserved1,reserved2, etc */
1749   },
1750   {
1751     "allowedFeatureSetsList",
1752     2,
1753     PROTOBUF_C_LABEL_REPEATED,
1754     PROTOBUF_C_TYPE_UINT32,
1755     offsetof(StreamingProtobufs__BandCombinationInfo, n_allowedfeaturesetslist),
1756     offsetof(StreamingProtobufs__BandCombinationInfo, allowedfeaturesetslist),
1757     NULL,
1758     NULL,
1759     0 | PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
1760     0,NULL,NULL    /* reserved1,reserved2, etc */
1761   },
1762 };
1763 static const unsigned streaming_protobufs__band_combination_info__field_indices_by_name[] = {
1764   1,   /* field[1] = allowedFeatureSetsList */
1765   0,   /* field[0] = bandCombinationIndex */
1766 };
1767 static const ProtobufCIntRange streaming_protobufs__band_combination_info__number_ranges[1 + 1] =
1768 {
1769   { 1, 0 },
1770   { 0, 2 }
1771 };
1772 const ProtobufCMessageDescriptor streaming_protobufs__band_combination_info__descriptor =
1773 {
1774   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1775   "streaming_protobufs.BandCombinationInfo",
1776   "BandCombinationInfo",
1777   "StreamingProtobufs__BandCombinationInfo",
1778   "streaming_protobufs",
1779   sizeof(StreamingProtobufs__BandCombinationInfo),
1780   2,
1781   streaming_protobufs__band_combination_info__field_descriptors,
1782   streaming_protobufs__band_combination_info__field_indices_by_name,
1783   1,  streaming_protobufs__band_combination_info__number_ranges,
1784   (ProtobufCMessageInit) streaming_protobufs__band_combination_info__init,
1785   NULL,NULL,NULL    /* reserved[123] */
1786 };
1787 static const ProtobufCFieldDescriptor streaming_protobufs__power_coordination__fr1__field_descriptors[3] =
1788 {
1789   {
1790     "p_maxNR_FR1",
1791     1,
1792     PROTOBUF_C_LABEL_NONE,
1793     PROTOBUF_C_TYPE_MESSAGE,
1794     0,   /* quantifier_offset */
1795     offsetof(StreamingProtobufs__PowerCoordinationFR1, p_maxnr_fr1),
1796     &google__protobuf__int32_value__descriptor,
1797     NULL,
1798     0,             /* flags */
1799     0,NULL,NULL    /* reserved1,reserved2, etc */
1800   },
1801   {
1802     "p_maxEUTRA",
1803     2,
1804     PROTOBUF_C_LABEL_NONE,
1805     PROTOBUF_C_TYPE_MESSAGE,
1806     0,   /* quantifier_offset */
1807     offsetof(StreamingProtobufs__PowerCoordinationFR1, p_maxeutra),
1808     &google__protobuf__int32_value__descriptor,
1809     NULL,
1810     0,             /* flags */
1811     0,NULL,NULL    /* reserved1,reserved2, etc */
1812   },
1813   {
1814     "p_maxUE_FR1",
1815     3,
1816     PROTOBUF_C_LABEL_NONE,
1817     PROTOBUF_C_TYPE_MESSAGE,
1818     0,   /* quantifier_offset */
1819     offsetof(StreamingProtobufs__PowerCoordinationFR1, p_maxue_fr1),
1820     &google__protobuf__int32_value__descriptor,
1821     NULL,
1822     0,             /* flags */
1823     0,NULL,NULL    /* reserved1,reserved2, etc */
1824   },
1825 };
1826 static const unsigned streaming_protobufs__power_coordination__fr1__field_indices_by_name[] = {
1827   1,   /* field[1] = p_maxEUTRA */
1828   0,   /* field[0] = p_maxNR_FR1 */
1829   2,   /* field[2] = p_maxUE_FR1 */
1830 };
1831 static const ProtobufCIntRange streaming_protobufs__power_coordination__fr1__number_ranges[1 + 1] =
1832 {
1833   { 1, 0 },
1834   { 0, 3 }
1835 };
1836 const ProtobufCMessageDescriptor streaming_protobufs__power_coordination__fr1__descriptor =
1837 {
1838   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1839   "streaming_protobufs.PowerCoordination_FR1",
1840   "PowerCoordinationFR1",
1841   "StreamingProtobufs__PowerCoordinationFR1",
1842   "streaming_protobufs",
1843   sizeof(StreamingProtobufs__PowerCoordinationFR1),
1844   3,
1845   streaming_protobufs__power_coordination__fr1__field_descriptors,
1846   streaming_protobufs__power_coordination__fr1__field_indices_by_name,
1847   1,  streaming_protobufs__power_coordination__fr1__number_ranges,
1848   (ProtobufCMessageInit) streaming_protobufs__power_coordination__fr1__init,
1849   NULL,NULL,NULL    /* reserved[123] */
1850 };
1851 static const ProtobufCFieldDescriptor streaming_protobufs__serv_cell_index_range_scg__field_descriptors[2] =
1852 {
1853   {
1854     "lowBound",
1855     1,
1856     PROTOBUF_C_LABEL_NONE,
1857     PROTOBUF_C_TYPE_UINT32,
1858     0,   /* quantifier_offset */
1859     offsetof(StreamingProtobufs__ServCellIndexRangeSCG, lowbound),
1860     NULL,
1861     NULL,
1862     0,             /* flags */
1863     0,NULL,NULL    /* reserved1,reserved2, etc */
1864   },
1865   {
1866     "upBound",
1867     2,
1868     PROTOBUF_C_LABEL_NONE,
1869     PROTOBUF_C_TYPE_UINT32,
1870     0,   /* quantifier_offset */
1871     offsetof(StreamingProtobufs__ServCellIndexRangeSCG, upbound),
1872     NULL,
1873     NULL,
1874     0,             /* flags */
1875     0,NULL,NULL    /* reserved1,reserved2, etc */
1876   },
1877 };
1878 static const unsigned streaming_protobufs__serv_cell_index_range_scg__field_indices_by_name[] = {
1879   0,   /* field[0] = lowBound */
1880   1,   /* field[1] = upBound */
1881 };
1882 static const ProtobufCIntRange streaming_protobufs__serv_cell_index_range_scg__number_ranges[1 + 1] =
1883 {
1884   { 1, 0 },
1885   { 0, 2 }
1886 };
1887 const ProtobufCMessageDescriptor streaming_protobufs__serv_cell_index_range_scg__descriptor =
1888 {
1889   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1890   "streaming_protobufs.ServCellIndexRangeSCG",
1891   "ServCellIndexRangeSCG",
1892   "StreamingProtobufs__ServCellIndexRangeSCG",
1893   "streaming_protobufs",
1894   sizeof(StreamingProtobufs__ServCellIndexRangeSCG),
1895   2,
1896   streaming_protobufs__serv_cell_index_range_scg__field_descriptors,
1897   streaming_protobufs__serv_cell_index_range_scg__field_indices_by_name,
1898   1,  streaming_protobufs__serv_cell_index_range_scg__number_ranges,
1899   (ProtobufCMessageInit) streaming_protobufs__serv_cell_index_range_scg__init,
1900   NULL,NULL,NULL    /* reserved[123] */
1901 };
1902 static const ProtobufCFieldDescriptor streaming_protobufs__meas_config_mn__field_descriptors[4] =
1903 {
1904   {
1905     "measuredFrequenciesMN",
1906     1,
1907     PROTOBUF_C_LABEL_REPEATED,
1908     PROTOBUF_C_TYPE_MESSAGE,
1909     offsetof(StreamingProtobufs__MeasConfigMN, n_measuredfrequenciesmn),
1910     offsetof(StreamingProtobufs__MeasConfigMN, measuredfrequenciesmn),
1911     &streaming_protobufs__nr__freq_info__descriptor,
1912     NULL,
1913     0,             /* flags */
1914     0,NULL,NULL    /* reserved1,reserved2, etc */
1915   },
1916   {
1917     "release_measGapConfig",
1918     2,
1919     PROTOBUF_C_LABEL_NONE,
1920     PROTOBUF_C_TYPE_MESSAGE,
1921     offsetof(StreamingProtobufs__MeasConfigMN, meas_gap_config_case),
1922     offsetof(StreamingProtobufs__MeasConfigMN, release_measgapconfig),
1923     &streaming_protobufs__null__descriptor,
1924     NULL,
1925     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
1926     0,NULL,NULL    /* reserved1,reserved2, etc */
1927   },
1928   {
1929     "setup_measGapConfig",
1930     3,
1931     PROTOBUF_C_LABEL_NONE,
1932     PROTOBUF_C_TYPE_MESSAGE,
1933     offsetof(StreamingProtobufs__MeasConfigMN, meas_gap_config_case),
1934     offsetof(StreamingProtobufs__MeasConfigMN, setup_measgapconfig),
1935     &streaming_protobufs__gap_config__descriptor,
1936     NULL,
1937     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
1938     0,NULL,NULL    /* reserved1,reserved2, etc */
1939   },
1940   {
1941     "gapPurpose",
1942     4,
1943     PROTOBUF_C_LABEL_NONE,
1944     PROTOBUF_C_TYPE_MESSAGE,
1945     0,   /* quantifier_offset */
1946     offsetof(StreamingProtobufs__MeasConfigMN, gappurpose),
1947     &streaming_protobufs__gap_purpose__descriptor,
1948     NULL,
1949     0,             /* flags */
1950     0,NULL,NULL    /* reserved1,reserved2, etc */
1951   },
1952 };
1953 static const unsigned streaming_protobufs__meas_config_mn__field_indices_by_name[] = {
1954   3,   /* field[3] = gapPurpose */
1955   0,   /* field[0] = measuredFrequenciesMN */
1956   1,   /* field[1] = release_measGapConfig */
1957   2,   /* field[2] = setup_measGapConfig */
1958 };
1959 static const ProtobufCIntRange streaming_protobufs__meas_config_mn__number_ranges[1 + 1] =
1960 {
1961   { 1, 0 },
1962   { 0, 4 }
1963 };
1964 const ProtobufCMessageDescriptor streaming_protobufs__meas_config_mn__descriptor =
1965 {
1966   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1967   "streaming_protobufs.MeasConfigMN",
1968   "MeasConfigMN",
1969   "StreamingProtobufs__MeasConfigMN",
1970   "streaming_protobufs",
1971   sizeof(StreamingProtobufs__MeasConfigMN),
1972   4,
1973   streaming_protobufs__meas_config_mn__field_descriptors,
1974   streaming_protobufs__meas_config_mn__field_indices_by_name,
1975   1,  streaming_protobufs__meas_config_mn__number_ranges,
1976   (ProtobufCMessageInit) streaming_protobufs__meas_config_mn__init,
1977   NULL,NULL,NULL    /* reserved[123] */
1978 };
1979 static const ProtobufCEnumValue streaming_protobufs__gap_purpose__value__enum_values_by_number[3] =
1980 {
1981   { "protobuf_unspecified", "STREAMING_PROTOBUFS__GAP_PURPOSE__VALUE__protobuf_unspecified", 0 },
1982   { "perUE", "STREAMING_PROTOBUFS__GAP_PURPOSE__VALUE__perUE", 1 },
1983   { "perFR1", "STREAMING_PROTOBUFS__GAP_PURPOSE__VALUE__perFR1", 2 },
1984 };
1985 static const ProtobufCIntRange streaming_protobufs__gap_purpose__value__value_ranges[] = {
1986 {0, 0},{0, 3}
1987 };
1988 static const ProtobufCEnumValueIndex streaming_protobufs__gap_purpose__value__enum_values_by_name[3] =
1989 {
1990   { "perFR1", 2 },
1991   { "perUE", 1 },
1992   { "protobuf_unspecified", 0 },
1993 };
1994 const ProtobufCEnumDescriptor streaming_protobufs__gap_purpose__value__descriptor =
1995 {
1996   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
1997   "streaming_protobufs.GapPurpose.Value",
1998   "Value",
1999   "StreamingProtobufs__GapPurpose__Value",
2000   "streaming_protobufs",
2001   3,
2002   streaming_protobufs__gap_purpose__value__enum_values_by_number,
2003   3,
2004   streaming_protobufs__gap_purpose__value__enum_values_by_name,
2005   1,
2006   streaming_protobufs__gap_purpose__value__value_ranges,
2007   NULL,NULL,NULL,NULL   /* reserved[1234] */
2008 };
2009 static const ProtobufCFieldDescriptor streaming_protobufs__gap_purpose__field_descriptors[1] =
2010 {
2011   {
2012     "value",
2013     1,
2014     PROTOBUF_C_LABEL_NONE,
2015     PROTOBUF_C_TYPE_ENUM,
2016     0,   /* quantifier_offset */
2017     offsetof(StreamingProtobufs__GapPurpose, value),
2018     &streaming_protobufs__gap_purpose__value__descriptor,
2019     NULL,
2020     0,             /* flags */
2021     0,NULL,NULL    /* reserved1,reserved2, etc */
2022   },
2023 };
2024 static const unsigned streaming_protobufs__gap_purpose__field_indices_by_name[] = {
2025   0,   /* field[0] = value */
2026 };
2027 static const ProtobufCIntRange streaming_protobufs__gap_purpose__number_ranges[1 + 1] =
2028 {
2029   { 1, 0 },
2030   { 0, 1 }
2031 };
2032 const ProtobufCMessageDescriptor streaming_protobufs__gap_purpose__descriptor =
2033 {
2034   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2035   "streaming_protobufs.GapPurpose",
2036   "GapPurpose",
2037   "StreamingProtobufs__GapPurpose",
2038   "streaming_protobufs",
2039   sizeof(StreamingProtobufs__GapPurpose),
2040   1,
2041   streaming_protobufs__gap_purpose__field_descriptors,
2042   streaming_protobufs__gap_purpose__field_indices_by_name,
2043   1,  streaming_protobufs__gap_purpose__number_ranges,
2044   (ProtobufCMessageInit) streaming_protobufs__gap_purpose__init,
2045   NULL,NULL,NULL    /* reserved[123] */
2046 };
2047 static const ProtobufCEnumValue streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__enum_values_by_number[6] =
2048 {
2049   { "protobuf_unspecified", "STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INTERFERENCE_DIRECTION_MRDC__protobuf_unspecified", 0 },
2050   { "eutra_nr", "STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INTERFERENCE_DIRECTION_MRDC__eutra_nr", 1 },
2051   { "nr", "STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INTERFERENCE_DIRECTION_MRDC__nr", 2 },
2052   { "other", "STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INTERFERENCE_DIRECTION_MRDC__other", 3 },
2053   { "utra_nr_other", "STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INTERFERENCE_DIRECTION_MRDC__utra_nr_other", 4 },
2054   { "nr_other", "STREAMING_PROTOBUFS__AFFECTED_CARRIER_FREQ_COMB_INFO_MRDC__INTERFERENCE_DIRECTION_MRDC__nr_other", 5 },
2055 };
2056 static const ProtobufCIntRange streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__value_ranges[] = {
2057 {0, 0},{0, 6}
2058 };
2059 static const ProtobufCEnumValueIndex streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__enum_values_by_name[6] =
2060 {
2061   { "eutra_nr", 1 },
2062   { "nr", 2 },
2063   { "nr_other", 5 },
2064   { "other", 3 },
2065   { "protobuf_unspecified", 0 },
2066   { "utra_nr_other", 4 },
2067 };
2068 const ProtobufCEnumDescriptor streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__descriptor =
2069 {
2070   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2071   "streaming_protobufs.AffectedCarrierFreqCombInfoMRDC.InterferenceDirectionMRDC",
2072   "InterferenceDirectionMRDC",
2073   "StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC__InterferenceDirectionMRDC",
2074   "streaming_protobufs",
2075   6,
2076   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__enum_values_by_number,
2077   6,
2078   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__enum_values_by_name,
2079   1,
2080   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__value_ranges,
2081   NULL,NULL,NULL,NULL   /* reserved[1234] */
2082 };
2083 static const ProtobufCFieldDescriptor streaming_protobufs__affected_carrier_freq_comb_info_mrdc__field_descriptors[3] =
2084 {
2085   {
2086     "victimSystemType",
2087     1,
2088     PROTOBUF_C_LABEL_NONE,
2089     PROTOBUF_C_TYPE_MESSAGE,
2090     0,   /* quantifier_offset */
2091     offsetof(StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC, victimsystemtype),
2092     &streaming_protobufs__victim_system_type__descriptor,
2093     NULL,
2094     0,             /* flags */
2095     0,NULL,NULL    /* reserved1,reserved2, etc */
2096   },
2097   {
2098     "interferenceDirectionMRDC",
2099     2,
2100     PROTOBUF_C_LABEL_NONE,
2101     PROTOBUF_C_TYPE_ENUM,
2102     0,   /* quantifier_offset */
2103     offsetof(StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC, interferencedirectionmrdc),
2104     &streaming_protobufs__affected_carrier_freq_comb_info_mrdc__interference_direction_mrdc__descriptor,
2105     NULL,
2106     0,             /* flags */
2107     0,NULL,NULL    /* reserved1,reserved2, etc */
2108   },
2109   {
2110     "affectedCarrierFreqCombMRDC",
2111     3,
2112     PROTOBUF_C_LABEL_NONE,
2113     PROTOBUF_C_TYPE_MESSAGE,
2114     0,   /* quantifier_offset */
2115     offsetof(StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC, affectedcarrierfreqcombmrdc),
2116     &streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor,
2117     NULL,
2118     0,             /* flags */
2119     0,NULL,NULL    /* reserved1,reserved2, etc */
2120   },
2121 };
2122 static const unsigned streaming_protobufs__affected_carrier_freq_comb_info_mrdc__field_indices_by_name[] = {
2123   2,   /* field[2] = affectedCarrierFreqCombMRDC */
2124   1,   /* field[1] = interferenceDirectionMRDC */
2125   0,   /* field[0] = victimSystemType */
2126 };
2127 static const ProtobufCIntRange streaming_protobufs__affected_carrier_freq_comb_info_mrdc__number_ranges[1 + 1] =
2128 {
2129   { 1, 0 },
2130   { 0, 3 }
2131 };
2132 const ProtobufCMessageDescriptor streaming_protobufs__affected_carrier_freq_comb_info_mrdc__descriptor =
2133 {
2134   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2135   "streaming_protobufs.AffectedCarrierFreqCombInfoMRDC",
2136   "AffectedCarrierFreqCombInfoMRDC",
2137   "StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC",
2138   "streaming_protobufs",
2139   sizeof(StreamingProtobufs__AffectedCarrierFreqCombInfoMRDC),
2140   3,
2141   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__field_descriptors,
2142   streaming_protobufs__affected_carrier_freq_comb_info_mrdc__field_indices_by_name,
2143   1,  streaming_protobufs__affected_carrier_freq_comb_info_mrdc__number_ranges,
2144   (ProtobufCMessageInit) streaming_protobufs__affected_carrier_freq_comb_info_mrdc__init,
2145   NULL,NULL,NULL    /* reserved[123] */
2146 };
2147 static const ProtobufCFieldDescriptor streaming_protobufs__victim_system_type__field_descriptors[6] =
2148 {
2149   {
2150     "gps",
2151     1,
2152     PROTOBUF_C_LABEL_NONE,
2153     PROTOBUF_C_TYPE_MESSAGE,
2154     0,   /* quantifier_offset */
2155     offsetof(StreamingProtobufs__VictimSystemType, gps),
2156     &streaming_protobufs__true_opt__descriptor,
2157     NULL,
2158     0,             /* flags */
2159     0,NULL,NULL    /* reserved1,reserved2, etc */
2160   },
2161   {
2162     "glonass",
2163     2,
2164     PROTOBUF_C_LABEL_NONE,
2165     PROTOBUF_C_TYPE_MESSAGE,
2166     0,   /* quantifier_offset */
2167     offsetof(StreamingProtobufs__VictimSystemType, glonass),
2168     &streaming_protobufs__true_opt__descriptor,
2169     NULL,
2170     0,             /* flags */
2171     0,NULL,NULL    /* reserved1,reserved2, etc */
2172   },
2173   {
2174     "bds",
2175     3,
2176     PROTOBUF_C_LABEL_NONE,
2177     PROTOBUF_C_TYPE_MESSAGE,
2178     0,   /* quantifier_offset */
2179     offsetof(StreamingProtobufs__VictimSystemType, bds),
2180     &streaming_protobufs__true_opt__descriptor,
2181     NULL,
2182     0,             /* flags */
2183     0,NULL,NULL    /* reserved1,reserved2, etc */
2184   },
2185   {
2186     "galileo",
2187     4,
2188     PROTOBUF_C_LABEL_NONE,
2189     PROTOBUF_C_TYPE_MESSAGE,
2190     0,   /* quantifier_offset */
2191     offsetof(StreamingProtobufs__VictimSystemType, galileo),
2192     &streaming_protobufs__true_opt__descriptor,
2193     NULL,
2194     0,             /* flags */
2195     0,NULL,NULL    /* reserved1,reserved2, etc */
2196   },
2197   {
2198     "wlan",
2199     5,
2200     PROTOBUF_C_LABEL_NONE,
2201     PROTOBUF_C_TYPE_MESSAGE,
2202     0,   /* quantifier_offset */
2203     offsetof(StreamingProtobufs__VictimSystemType, wlan),
2204     &streaming_protobufs__true_opt__descriptor,
2205     NULL,
2206     0,             /* flags */
2207     0,NULL,NULL    /* reserved1,reserved2, etc */
2208   },
2209   {
2210     "bluetooth",
2211     6,
2212     PROTOBUF_C_LABEL_NONE,
2213     PROTOBUF_C_TYPE_MESSAGE,
2214     0,   /* quantifier_offset */
2215     offsetof(StreamingProtobufs__VictimSystemType, bluetooth),
2216     &streaming_protobufs__true_opt__descriptor,
2217     NULL,
2218     0,             /* flags */
2219     0,NULL,NULL    /* reserved1,reserved2, etc */
2220   },
2221 };
2222 static const unsigned streaming_protobufs__victim_system_type__field_indices_by_name[] = {
2223   2,   /* field[2] = bds */
2224   5,   /* field[5] = bluetooth */
2225   3,   /* field[3] = galileo */
2226   1,   /* field[1] = glonass */
2227   0,   /* field[0] = gps */
2228   4,   /* field[4] = wlan */
2229 };
2230 static const ProtobufCIntRange streaming_protobufs__victim_system_type__number_ranges[1 + 1] =
2231 {
2232   { 1, 0 },
2233   { 0, 6 }
2234 };
2235 const ProtobufCMessageDescriptor streaming_protobufs__victim_system_type__descriptor =
2236 {
2237   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2238   "streaming_protobufs.VictimSystemType",
2239   "VictimSystemType",
2240   "StreamingProtobufs__VictimSystemType",
2241   "streaming_protobufs",
2242   sizeof(StreamingProtobufs__VictimSystemType),
2243   6,
2244   streaming_protobufs__victim_system_type__field_descriptors,
2245   streaming_protobufs__victim_system_type__field_indices_by_name,
2246   1,  streaming_protobufs__victim_system_type__number_ranges,
2247   (ProtobufCMessageInit) streaming_protobufs__victim_system_type__init,
2248   NULL,NULL,NULL    /* reserved[123] */
2249 };
2250 static const ProtobufCFieldDescriptor streaming_protobufs__affected_carrier_freq_comb_mrdc__field_descriptors[2] =
2251 {
2252   {
2253     "affectedCarrierFreqCombEUTRA",
2254     1,
2255     PROTOBUF_C_LABEL_NONE,
2256     PROTOBUF_C_TYPE_MESSAGE,
2257     0,   /* quantifier_offset */
2258     offsetof(StreamingProtobufs__AffectedCarrierFreqCombMRDC, affectedcarrierfreqcombeutra),
2259     &streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor,
2260     NULL,
2261     0,             /* flags */
2262     0,NULL,NULL    /* reserved1,reserved2, etc */
2263   },
2264   {
2265     "affectedCarrierFreqCombNR",
2266     2,
2267     PROTOBUF_C_LABEL_NONE,
2268     PROTOBUF_C_TYPE_MESSAGE,
2269     0,   /* quantifier_offset */
2270     offsetof(StreamingProtobufs__AffectedCarrierFreqCombMRDC, affectedcarrierfreqcombnr),
2271     &streaming_protobufs__affected_carrier_freq_comb_nr__descriptor,
2272     NULL,
2273     0,             /* flags */
2274     0,NULL,NULL    /* reserved1,reserved2, etc */
2275   },
2276 };
2277 static const unsigned streaming_protobufs__affected_carrier_freq_comb_mrdc__field_indices_by_name[] = {
2278   0,   /* field[0] = affectedCarrierFreqCombEUTRA */
2279   1,   /* field[1] = affectedCarrierFreqCombNR */
2280 };
2281 static const ProtobufCIntRange streaming_protobufs__affected_carrier_freq_comb_mrdc__number_ranges[1 + 1] =
2282 {
2283   { 1, 0 },
2284   { 0, 2 }
2285 };
2286 const ProtobufCMessageDescriptor streaming_protobufs__affected_carrier_freq_comb_mrdc__descriptor =
2287 {
2288   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2289   "streaming_protobufs.AffectedCarrierFreqCombMRDC",
2290   "AffectedCarrierFreqCombMRDC",
2291   "StreamingProtobufs__AffectedCarrierFreqCombMRDC",
2292   "streaming_protobufs",
2293   sizeof(StreamingProtobufs__AffectedCarrierFreqCombMRDC),
2294   2,
2295   streaming_protobufs__affected_carrier_freq_comb_mrdc__field_descriptors,
2296   streaming_protobufs__affected_carrier_freq_comb_mrdc__field_indices_by_name,
2297   1,  streaming_protobufs__affected_carrier_freq_comb_mrdc__number_ranges,
2298   (ProtobufCMessageInit) streaming_protobufs__affected_carrier_freq_comb_mrdc__init,
2299   NULL,NULL,NULL    /* reserved[123] */
2300 };
2301 static const ProtobufCFieldDescriptor streaming_protobufs__affected_carrier_freq_comb_eutra__field_descriptors[1] =
2302 {
2303   {
2304     "items",
2305     1,
2306     PROTOBUF_C_LABEL_REPEATED,
2307     PROTOBUF_C_TYPE_UINT32,
2308     offsetof(StreamingProtobufs__AffectedCarrierFreqCombEUTRA, n_items),
2309     offsetof(StreamingProtobufs__AffectedCarrierFreqCombEUTRA, items),
2310     NULL,
2311     NULL,
2312     0 | PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2313     0,NULL,NULL    /* reserved1,reserved2, etc */
2314   },
2315 };
2316 static const unsigned streaming_protobufs__affected_carrier_freq_comb_eutra__field_indices_by_name[] = {
2317   0,   /* field[0] = items */
2318 };
2319 static const ProtobufCIntRange streaming_protobufs__affected_carrier_freq_comb_eutra__number_ranges[1 + 1] =
2320 {
2321   { 1, 0 },
2322   { 0, 1 }
2323 };
2324 const ProtobufCMessageDescriptor streaming_protobufs__affected_carrier_freq_comb_eutra__descriptor =
2325 {
2326   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2327   "streaming_protobufs.AffectedCarrierFreqCombEUTRA",
2328   "AffectedCarrierFreqCombEUTRA",
2329   "StreamingProtobufs__AffectedCarrierFreqCombEUTRA",
2330   "streaming_protobufs",
2331   sizeof(StreamingProtobufs__AffectedCarrierFreqCombEUTRA),
2332   1,
2333   streaming_protobufs__affected_carrier_freq_comb_eutra__field_descriptors,
2334   streaming_protobufs__affected_carrier_freq_comb_eutra__field_indices_by_name,
2335   1,  streaming_protobufs__affected_carrier_freq_comb_eutra__number_ranges,
2336   (ProtobufCMessageInit) streaming_protobufs__affected_carrier_freq_comb_eutra__init,
2337   NULL,NULL,NULL    /* reserved[123] */
2338 };
2339 static const ProtobufCFieldDescriptor streaming_protobufs__affected_carrier_freq_comb_nr__field_descriptors[1] =
2340 {
2341   {
2342     "items",
2343     1,
2344     PROTOBUF_C_LABEL_REPEATED,
2345     PROTOBUF_C_TYPE_UINT32,
2346     offsetof(StreamingProtobufs__AffectedCarrierFreqCombNR, n_items),
2347     offsetof(StreamingProtobufs__AffectedCarrierFreqCombNR, items),
2348     NULL,
2349     NULL,
2350     0 | PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2351     0,NULL,NULL    /* reserved1,reserved2, etc */
2352   },
2353 };
2354 static const unsigned streaming_protobufs__affected_carrier_freq_comb_nr__field_indices_by_name[] = {
2355   0,   /* field[0] = items */
2356 };
2357 static const ProtobufCIntRange streaming_protobufs__affected_carrier_freq_comb_nr__number_ranges[1 + 1] =
2358 {
2359   { 1, 0 },
2360   { 0, 1 }
2361 };
2362 const ProtobufCMessageDescriptor streaming_protobufs__affected_carrier_freq_comb_nr__descriptor =
2363 {
2364   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2365   "streaming_protobufs.AffectedCarrierFreqCombNR",
2366   "AffectedCarrierFreqCombNR",
2367   "StreamingProtobufs__AffectedCarrierFreqCombNR",
2368   "streaming_protobufs",
2369   sizeof(StreamingProtobufs__AffectedCarrierFreqCombNR),
2370   1,
2371   streaming_protobufs__affected_carrier_freq_comb_nr__field_descriptors,
2372   streaming_protobufs__affected_carrier_freq_comb_nr__field_indices_by_name,
2373   1,  streaming_protobufs__affected_carrier_freq_comb_nr__number_ranges,
2374   (ProtobufCMessageInit) streaming_protobufs__affected_carrier_freq_comb_nr__init,
2375   NULL,NULL,NULL    /* reserved[123] */
2376 };
2377 static const ProtobufCFieldDescriptor streaming_protobufs__cg__config_info_v1540__ies__field_descriptors[2] =
2378 {
2379   {
2380     "ph_InfoMCG",
2381     1,
2382     PROTOBUF_C_LABEL_NONE,
2383     PROTOBUF_C_TYPE_MESSAGE,
2384     0,   /* quantifier_offset */
2385     offsetof(StreamingProtobufs__CGConfigInfoV1540IEs, ph_infomcg),
2386     &streaming_protobufs__ph__type_list_mcg__descriptor,
2387     NULL,
2388     0,             /* flags */
2389     0,NULL,NULL    /* reserved1,reserved2, etc */
2390   },
2391   {
2392     "measResultReportCGI",
2393     2,
2394     PROTOBUF_C_LABEL_NONE,
2395     PROTOBUF_C_TYPE_MESSAGE,
2396     0,   /* quantifier_offset */
2397     offsetof(StreamingProtobufs__CGConfigInfoV1540IEs, measresultreportcgi),
2398     &streaming_protobufs__meas_result_report_cgi__descriptor,
2399     NULL,
2400     0,             /* flags */
2401     0,NULL,NULL    /* reserved1,reserved2, etc */
2402   },
2403 };
2404 static const unsigned streaming_protobufs__cg__config_info_v1540__ies__field_indices_by_name[] = {
2405   1,   /* field[1] = measResultReportCGI */
2406   0,   /* field[0] = ph_InfoMCG */
2407 };
2408 static const ProtobufCIntRange streaming_protobufs__cg__config_info_v1540__ies__number_ranges[1 + 1] =
2409 {
2410   { 1, 0 },
2411   { 0, 2 }
2412 };
2413 const ProtobufCMessageDescriptor streaming_protobufs__cg__config_info_v1540__ies__descriptor =
2414 {
2415   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2416   "streaming_protobufs.CG_ConfigInfo_v1540_IEs",
2417   "CGConfigInfoV1540IEs",
2418   "StreamingProtobufs__CGConfigInfoV1540IEs",
2419   "streaming_protobufs",
2420   sizeof(StreamingProtobufs__CGConfigInfoV1540IEs),
2421   2,
2422   streaming_protobufs__cg__config_info_v1540__ies__field_descriptors,
2423   streaming_protobufs__cg__config_info_v1540__ies__field_indices_by_name,
2424   1,  streaming_protobufs__cg__config_info_v1540__ies__number_ranges,
2425   (ProtobufCMessageInit) streaming_protobufs__cg__config_info_v1540__ies__init,
2426   NULL,NULL,NULL    /* reserved[123] */
2427 };
2428 static const ProtobufCFieldDescriptor streaming_protobufs__ph__type_list_mcg__field_descriptors[1] =
2429 {
2430   {
2431     "items",
2432     1,
2433     PROTOBUF_C_LABEL_REPEATED,
2434     PROTOBUF_C_TYPE_MESSAGE,
2435     offsetof(StreamingProtobufs__PHTypeListMCG, n_items),
2436     offsetof(StreamingProtobufs__PHTypeListMCG, items),
2437     &streaming_protobufs__ph__info_mcg__descriptor,
2438     NULL,
2439     0,             /* flags */
2440     0,NULL,NULL    /* reserved1,reserved2, etc */
2441   },
2442 };
2443 static const unsigned streaming_protobufs__ph__type_list_mcg__field_indices_by_name[] = {
2444   0,   /* field[0] = items */
2445 };
2446 static const ProtobufCIntRange streaming_protobufs__ph__type_list_mcg__number_ranges[1 + 1] =
2447 {
2448   { 1, 0 },
2449   { 0, 1 }
2450 };
2451 const ProtobufCMessageDescriptor streaming_protobufs__ph__type_list_mcg__descriptor =
2452 {
2453   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2454   "streaming_protobufs.PH_TypeListMCG",
2455   "PHTypeListMCG",
2456   "StreamingProtobufs__PHTypeListMCG",
2457   "streaming_protobufs",
2458   sizeof(StreamingProtobufs__PHTypeListMCG),
2459   1,
2460   streaming_protobufs__ph__type_list_mcg__field_descriptors,
2461   streaming_protobufs__ph__type_list_mcg__field_indices_by_name,
2462   1,  streaming_protobufs__ph__type_list_mcg__number_ranges,
2463   (ProtobufCMessageInit) streaming_protobufs__ph__type_list_mcg__init,
2464   NULL,NULL,NULL    /* reserved[123] */
2465 };
2466 static const ProtobufCFieldDescriptor streaming_protobufs__ph__info_mcg__field_descriptors[3] =
2467 {
2468   {
2469     "servCellIndex",
2470     1,
2471     PROTOBUF_C_LABEL_NONE,
2472     PROTOBUF_C_TYPE_UINT32,
2473     0,   /* quantifier_offset */
2474     offsetof(StreamingProtobufs__PHInfoMCG, servcellindex),
2475     NULL,
2476     NULL,
2477     0,             /* flags */
2478     0,NULL,NULL    /* reserved1,reserved2, etc */
2479   },
2480   {
2481     "ph_Uplink",
2482     2,
2483     PROTOBUF_C_LABEL_NONE,
2484     PROTOBUF_C_TYPE_MESSAGE,
2485     0,   /* quantifier_offset */
2486     offsetof(StreamingProtobufs__PHInfoMCG, ph_uplink),
2487     &streaming_protobufs__ph__uplink_carrier_mcg__descriptor,
2488     NULL,
2489     0,             /* flags */
2490     0,NULL,NULL    /* reserved1,reserved2, etc */
2491   },
2492   {
2493     "ph_SupplementaryUplink",
2494     3,
2495     PROTOBUF_C_LABEL_NONE,
2496     PROTOBUF_C_TYPE_MESSAGE,
2497     0,   /* quantifier_offset */
2498     offsetof(StreamingProtobufs__PHInfoMCG, ph_supplementaryuplink),
2499     &streaming_protobufs__ph__uplink_carrier_mcg__descriptor,
2500     NULL,
2501     0,             /* flags */
2502     0,NULL,NULL    /* reserved1,reserved2, etc */
2503   },
2504 };
2505 static const unsigned streaming_protobufs__ph__info_mcg__field_indices_by_name[] = {
2506   2,   /* field[2] = ph_SupplementaryUplink */
2507   1,   /* field[1] = ph_Uplink */
2508   0,   /* field[0] = servCellIndex */
2509 };
2510 static const ProtobufCIntRange streaming_protobufs__ph__info_mcg__number_ranges[1 + 1] =
2511 {
2512   { 1, 0 },
2513   { 0, 3 }
2514 };
2515 const ProtobufCMessageDescriptor streaming_protobufs__ph__info_mcg__descriptor =
2516 {
2517   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2518   "streaming_protobufs.PH_InfoMCG",
2519   "PHInfoMCG",
2520   "StreamingProtobufs__PHInfoMCG",
2521   "streaming_protobufs",
2522   sizeof(StreamingProtobufs__PHInfoMCG),
2523   3,
2524   streaming_protobufs__ph__info_mcg__field_descriptors,
2525   streaming_protobufs__ph__info_mcg__field_indices_by_name,
2526   1,  streaming_protobufs__ph__info_mcg__number_ranges,
2527   (ProtobufCMessageInit) streaming_protobufs__ph__info_mcg__init,
2528   NULL,NULL,NULL    /* reserved[123] */
2529 };
2530 static const ProtobufCEnumValue streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__enum_values_by_number[3] =
2531 {
2532   { "protobuf_unspecified", "STREAMING_PROTOBUFS__PH__UPLINK_CARRIER_MCG__PH__TYPE1OR3__protobuf_unspecified", 0 },
2533   { "type1", "STREAMING_PROTOBUFS__PH__UPLINK_CARRIER_MCG__PH__TYPE1OR3__type1", 1 },
2534   { "type3", "STREAMING_PROTOBUFS__PH__UPLINK_CARRIER_MCG__PH__TYPE1OR3__type3", 2 },
2535 };
2536 static const ProtobufCIntRange streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__value_ranges[] = {
2537 {0, 0},{0, 3}
2538 };
2539 static const ProtobufCEnumValueIndex streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__enum_values_by_name[3] =
2540 {
2541   { "protobuf_unspecified", 0 },
2542   { "type1", 1 },
2543   { "type3", 2 },
2544 };
2545 const ProtobufCEnumDescriptor streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__descriptor =
2546 {
2547   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2548   "streaming_protobufs.PH_UplinkCarrierMCG.PH_Type1or3",
2549   "PH_Type1or3",
2550   "StreamingProtobufs__PHUplinkCarrierMCG__PHType1or3",
2551   "streaming_protobufs",
2552   3,
2553   streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__enum_values_by_number,
2554   3,
2555   streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__enum_values_by_name,
2556   1,
2557   streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__value_ranges,
2558   NULL,NULL,NULL,NULL   /* reserved[1234] */
2559 };
2560 static const ProtobufCFieldDescriptor streaming_protobufs__ph__uplink_carrier_mcg__field_descriptors[1] =
2561 {
2562   {
2563     "ph_Type1or3",
2564     1,
2565     PROTOBUF_C_LABEL_NONE,
2566     PROTOBUF_C_TYPE_ENUM,
2567     0,   /* quantifier_offset */
2568     offsetof(StreamingProtobufs__PHUplinkCarrierMCG, ph_type1or3),
2569     &streaming_protobufs__ph__uplink_carrier_mcg__ph__type1or3__descriptor,
2570     NULL,
2571     0,             /* flags */
2572     0,NULL,NULL    /* reserved1,reserved2, etc */
2573   },
2574 };
2575 static const unsigned streaming_protobufs__ph__uplink_carrier_mcg__field_indices_by_name[] = {
2576   0,   /* field[0] = ph_Type1or3 */
2577 };
2578 static const ProtobufCIntRange streaming_protobufs__ph__uplink_carrier_mcg__number_ranges[1 + 1] =
2579 {
2580   { 1, 0 },
2581   { 0, 1 }
2582 };
2583 const ProtobufCMessageDescriptor streaming_protobufs__ph__uplink_carrier_mcg__descriptor =
2584 {
2585   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2586   "streaming_protobufs.PH_UplinkCarrierMCG",
2587   "PHUplinkCarrierMCG",
2588   "StreamingProtobufs__PHUplinkCarrierMCG",
2589   "streaming_protobufs",
2590   sizeof(StreamingProtobufs__PHUplinkCarrierMCG),
2591   1,
2592   streaming_protobufs__ph__uplink_carrier_mcg__field_descriptors,
2593   streaming_protobufs__ph__uplink_carrier_mcg__field_indices_by_name,
2594   1,  streaming_protobufs__ph__uplink_carrier_mcg__number_ranges,
2595   (ProtobufCMessageInit) streaming_protobufs__ph__uplink_carrier_mcg__init,
2596   NULL,NULL,NULL    /* reserved[123] */
2597 };
2598 static const ProtobufCFieldDescriptor streaming_protobufs__meas_result_report_cgi__field_descriptors[3] =
2599 {
2600   {
2601     "ssbFrequency",
2602     1,
2603     PROTOBUF_C_LABEL_NONE,
2604     PROTOBUF_C_TYPE_UINT32,
2605     0,   /* quantifier_offset */
2606     offsetof(StreamingProtobufs__MeasResultReportCGI, ssbfrequency),
2607     NULL,
2608     NULL,
2609     0,             /* flags */
2610     0,NULL,NULL    /* reserved1,reserved2, etc */
2611   },
2612   {
2613     "cellForWhichToReportCGI",
2614     2,
2615     PROTOBUF_C_LABEL_NONE,
2616     PROTOBUF_C_TYPE_UINT32,
2617     0,   /* quantifier_offset */
2618     offsetof(StreamingProtobufs__MeasResultReportCGI, cellforwhichtoreportcgi),
2619     NULL,
2620     NULL,
2621     0,             /* flags */
2622     0,NULL,NULL    /* reserved1,reserved2, etc */
2623   },
2624   {
2625     "cgi_Info",
2626     3,
2627     PROTOBUF_C_LABEL_NONE,
2628     PROTOBUF_C_TYPE_MESSAGE,
2629     0,   /* quantifier_offset */
2630     offsetof(StreamingProtobufs__MeasResultReportCGI, cgi_info),
2631     &streaming_protobufs__cgi__info__descriptor,
2632     NULL,
2633     0,             /* flags */
2634     0,NULL,NULL    /* reserved1,reserved2, etc */
2635   },
2636 };
2637 static const unsigned streaming_protobufs__meas_result_report_cgi__field_indices_by_name[] = {
2638   1,   /* field[1] = cellForWhichToReportCGI */
2639   2,   /* field[2] = cgi_Info */
2640   0,   /* field[0] = ssbFrequency */
2641 };
2642 static const ProtobufCIntRange streaming_protobufs__meas_result_report_cgi__number_ranges[1 + 1] =
2643 {
2644   { 1, 0 },
2645   { 0, 3 }
2646 };
2647 const ProtobufCMessageDescriptor streaming_protobufs__meas_result_report_cgi__descriptor =
2648 {
2649   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2650   "streaming_protobufs.MeasResultReportCGI",
2651   "MeasResultReportCGI",
2652   "StreamingProtobufs__MeasResultReportCGI",
2653   "streaming_protobufs",
2654   sizeof(StreamingProtobufs__MeasResultReportCGI),
2655   3,
2656   streaming_protobufs__meas_result_report_cgi__field_descriptors,
2657   streaming_protobufs__meas_result_report_cgi__field_indices_by_name,
2658   1,  streaming_protobufs__meas_result_report_cgi__number_ranges,
2659   (ProtobufCMessageInit) streaming_protobufs__meas_result_report_cgi__init,
2660   NULL,NULL,NULL    /* reserved[123] */
2661 };