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

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: x2ap_common_types.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 "x2ap_common_types.pb-c.h"
  10 void   streaming_protobufs__en__dc__resource_configuration__init
  11                      (StreamingProtobufs__ENDCResourceConfiguration         *message)
  12 {
  13   static const StreamingProtobufs__ENDCResourceConfiguration init_value = STREAMING_PROTOBUFS__EN__DC__RESOURCE_CONFIGURATION__INIT;
  14   *message = init_value;
  15 }
  16 size_t streaming_protobufs__en__dc__resource_configuration__get_packed_size
  17                      (const StreamingProtobufs__ENDCResourceConfiguration *message)
  18 {
  19   assert(message->base.descriptor == &streaming_protobufs__en__dc__resource_configuration__descriptor);
  20   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21 }
  22 size_t streaming_protobufs__en__dc__resource_configuration__pack
  23                      (const StreamingProtobufs__ENDCResourceConfiguration *message,
  24                       uint8_t       *out)
  25 {
  26   assert(message->base.descriptor == &streaming_protobufs__en__dc__resource_configuration__descriptor);
  27   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28 }
  29 size_t streaming_protobufs__en__dc__resource_configuration__pack_to_buffer
  30                      (const StreamingProtobufs__ENDCResourceConfiguration *message,
  31                       ProtobufCBuffer *buffer)
  32 {
  33   assert(message->base.descriptor == &streaming_protobufs__en__dc__resource_configuration__descriptor);
  34   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35 }
  36 StreamingProtobufs__ENDCResourceConfiguration *
  37        streaming_protobufs__en__dc__resource_configuration__unpack
  38                      (ProtobufCAllocator  *allocator,
  39                       size_t               len,
  40                       const uint8_t       *data)
  41 {
  42   return (StreamingProtobufs__ENDCResourceConfiguration *)
  43      protobuf_c_message_unpack (&streaming_protobufs__en__dc__resource_configuration__descriptor,
  44                                 allocator, len, data);
  45 }
  46 void   streaming_protobufs__en__dc__resource_configuration__free_unpacked
  47                      (StreamingProtobufs__ENDCResourceConfiguration *message,
  48                       ProtobufCAllocator *allocator)
  49 {
  50   if(!message)
  51     return;
  52   assert(message->base.descriptor == &streaming_protobufs__en__dc__resource_configuration__descriptor);
  53   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  54 }
  55 void   streaming_protobufs__e__rab__level__qo_s__parameters__init
  56                      (StreamingProtobufs__ERABLevelQoSParameters         *message)
  57 {
  58   static const StreamingProtobufs__ERABLevelQoSParameters init_value = STREAMING_PROTOBUFS__E__RAB__LEVEL__QO_S__PARAMETERS__INIT;
  59   *message = init_value;
  60 }
  61 size_t streaming_protobufs__e__rab__level__qo_s__parameters__get_packed_size
  62                      (const StreamingProtobufs__ERABLevelQoSParameters *message)
  63 {
  64   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__descriptor);
  65   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  66 }
  67 size_t streaming_protobufs__e__rab__level__qo_s__parameters__pack
  68                      (const StreamingProtobufs__ERABLevelQoSParameters *message,
  69                       uint8_t       *out)
  70 {
  71   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__descriptor);
  72   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  73 }
  74 size_t streaming_protobufs__e__rab__level__qo_s__parameters__pack_to_buffer
  75                      (const StreamingProtobufs__ERABLevelQoSParameters *message,
  76                       ProtobufCBuffer *buffer)
  77 {
  78   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__descriptor);
  79   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  80 }
  81 StreamingProtobufs__ERABLevelQoSParameters *
  82        streaming_protobufs__e__rab__level__qo_s__parameters__unpack
  83                      (ProtobufCAllocator  *allocator,
  84                       size_t               len,
  85                       const uint8_t       *data)
  86 {
  87   return (StreamingProtobufs__ERABLevelQoSParameters *)
  88      protobuf_c_message_unpack (&streaming_protobufs__e__rab__level__qo_s__parameters__descriptor,
  89                                 allocator, len, data);
  90 }
  91 void   streaming_protobufs__e__rab__level__qo_s__parameters__free_unpacked
  92                      (StreamingProtobufs__ERABLevelQoSParameters *message,
  93                       ProtobufCAllocator *allocator)
  94 {
  95   if(!message)
  96     return;
  97   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__descriptor);
  98   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  99 }
 100 void   streaming_protobufs__allocation_and_retention_priority__init
 101                      (StreamingProtobufs__AllocationAndRetentionPriority         *message)
 102 {
 103   static const StreamingProtobufs__AllocationAndRetentionPriority init_value = STREAMING_PROTOBUFS__ALLOCATION_AND_RETENTION_PRIORITY__INIT;
 104   *message = init_value;
 105 }
 106 size_t streaming_protobufs__allocation_and_retention_priority__get_packed_size
 107                      (const StreamingProtobufs__AllocationAndRetentionPriority *message)
 108 {
 109   assert(message->base.descriptor == &streaming_protobufs__allocation_and_retention_priority__descriptor);
 110   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 111 }
 112 size_t streaming_protobufs__allocation_and_retention_priority__pack
 113                      (const StreamingProtobufs__AllocationAndRetentionPriority *message,
 114                       uint8_t       *out)
 115 {
 116   assert(message->base.descriptor == &streaming_protobufs__allocation_and_retention_priority__descriptor);
 117   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 118 }
 119 size_t streaming_protobufs__allocation_and_retention_priority__pack_to_buffer
 120                      (const StreamingProtobufs__AllocationAndRetentionPriority *message,
 121                       ProtobufCBuffer *buffer)
 122 {
 123   assert(message->base.descriptor == &streaming_protobufs__allocation_and_retention_priority__descriptor);
 124   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 125 }
 126 StreamingProtobufs__AllocationAndRetentionPriority *
 127        streaming_protobufs__allocation_and_retention_priority__unpack
 128                      (ProtobufCAllocator  *allocator,
 129                       size_t               len,
 130                       const uint8_t       *data)
 131 {
 132   return (StreamingProtobufs__AllocationAndRetentionPriority *)
 133      protobuf_c_message_unpack (&streaming_protobufs__allocation_and_retention_priority__descriptor,
 134                                 allocator, len, data);
 135 }
 136 void   streaming_protobufs__allocation_and_retention_priority__free_unpacked
 137                      (StreamingProtobufs__AllocationAndRetentionPriority *message,
 138                       ProtobufCAllocator *allocator)
 139 {
 140   if(!message)
 141     return;
 142   assert(message->base.descriptor == &streaming_protobufs__allocation_and_retention_priority__descriptor);
 143   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 144 }
 145 void   streaming_protobufs__pre_emption_vulnerability__init
 146                      (StreamingProtobufs__PreEmptionVulnerability         *message)
 147 {
 148   static const StreamingProtobufs__PreEmptionVulnerability init_value = STREAMING_PROTOBUFS__PRE_EMPTION_VULNERABILITY__INIT;
 149   *message = init_value;
 150 }
 151 size_t streaming_protobufs__pre_emption_vulnerability__get_packed_size
 152                      (const StreamingProtobufs__PreEmptionVulnerability *message)
 153 {
 154   assert(message->base.descriptor == &streaming_protobufs__pre_emption_vulnerability__descriptor);
 155   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 156 }
 157 size_t streaming_protobufs__pre_emption_vulnerability__pack
 158                      (const StreamingProtobufs__PreEmptionVulnerability *message,
 159                       uint8_t       *out)
 160 {
 161   assert(message->base.descriptor == &streaming_protobufs__pre_emption_vulnerability__descriptor);
 162   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 163 }
 164 size_t streaming_protobufs__pre_emption_vulnerability__pack_to_buffer
 165                      (const StreamingProtobufs__PreEmptionVulnerability *message,
 166                       ProtobufCBuffer *buffer)
 167 {
 168   assert(message->base.descriptor == &streaming_protobufs__pre_emption_vulnerability__descriptor);
 169   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 170 }
 171 StreamingProtobufs__PreEmptionVulnerability *
 172        streaming_protobufs__pre_emption_vulnerability__unpack
 173                      (ProtobufCAllocator  *allocator,
 174                       size_t               len,
 175                       const uint8_t       *data)
 176 {
 177   return (StreamingProtobufs__PreEmptionVulnerability *)
 178      protobuf_c_message_unpack (&streaming_protobufs__pre_emption_vulnerability__descriptor,
 179                                 allocator, len, data);
 180 }
 181 void   streaming_protobufs__pre_emption_vulnerability__free_unpacked
 182                      (StreamingProtobufs__PreEmptionVulnerability *message,
 183                       ProtobufCAllocator *allocator)
 184 {
 185   if(!message)
 186     return;
 187   assert(message->base.descriptor == &streaming_protobufs__pre_emption_vulnerability__descriptor);
 188   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 189 }
 190 void   streaming_protobufs__pre_emption_capability__init
 191                      (StreamingProtobufs__PreEmptionCapability         *message)
 192 {
 193   static const StreamingProtobufs__PreEmptionCapability init_value = STREAMING_PROTOBUFS__PRE_EMPTION_CAPABILITY__INIT;
 194   *message = init_value;
 195 }
 196 size_t streaming_protobufs__pre_emption_capability__get_packed_size
 197                      (const StreamingProtobufs__PreEmptionCapability *message)
 198 {
 199   assert(message->base.descriptor == &streaming_protobufs__pre_emption_capability__descriptor);
 200   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 201 }
 202 size_t streaming_protobufs__pre_emption_capability__pack
 203                      (const StreamingProtobufs__PreEmptionCapability *message,
 204                       uint8_t       *out)
 205 {
 206   assert(message->base.descriptor == &streaming_protobufs__pre_emption_capability__descriptor);
 207   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 208 }
 209 size_t streaming_protobufs__pre_emption_capability__pack_to_buffer
 210                      (const StreamingProtobufs__PreEmptionCapability *message,
 211                       ProtobufCBuffer *buffer)
 212 {
 213   assert(message->base.descriptor == &streaming_protobufs__pre_emption_capability__descriptor);
 214   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 215 }
 216 StreamingProtobufs__PreEmptionCapability *
 217        streaming_protobufs__pre_emption_capability__unpack
 218                      (ProtobufCAllocator  *allocator,
 219                       size_t               len,
 220                       const uint8_t       *data)
 221 {
 222   return (StreamingProtobufs__PreEmptionCapability *)
 223      protobuf_c_message_unpack (&streaming_protobufs__pre_emption_capability__descriptor,
 224                                 allocator, len, data);
 225 }
 226 void   streaming_protobufs__pre_emption_capability__free_unpacked
 227                      (StreamingProtobufs__PreEmptionCapability *message,
 228                       ProtobufCAllocator *allocator)
 229 {
 230   if(!message)
 231     return;
 232   assert(message->base.descriptor == &streaming_protobufs__pre_emption_capability__descriptor);
 233   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 234 }
 235 void   streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__init
 236                      (StreamingProtobufs__ERABLevelQoSParametersExtIEs         *message)
 237 {
 238   static const StreamingProtobufs__ERABLevelQoSParametersExtIEs init_value = STREAMING_PROTOBUFS__E__RAB__LEVEL__QO_S__PARAMETERS__EXT_IES__INIT;
 239   *message = init_value;
 240 }
 241 size_t streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__get_packed_size
 242                      (const StreamingProtobufs__ERABLevelQoSParametersExtIEs *message)
 243 {
 244   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor);
 245   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 246 }
 247 size_t streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__pack
 248                      (const StreamingProtobufs__ERABLevelQoSParametersExtIEs *message,
 249                       uint8_t       *out)
 250 {
 251   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor);
 252   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 253 }
 254 size_t streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__pack_to_buffer
 255                      (const StreamingProtobufs__ERABLevelQoSParametersExtIEs *message,
 256                       ProtobufCBuffer *buffer)
 257 {
 258   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor);
 259   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 260 }
 261 StreamingProtobufs__ERABLevelQoSParametersExtIEs *
 262        streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__unpack
 263                      (ProtobufCAllocator  *allocator,
 264                       size_t               len,
 265                       const uint8_t       *data)
 266 {
 267   return (StreamingProtobufs__ERABLevelQoSParametersExtIEs *)
 268      protobuf_c_message_unpack (&streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor,
 269                                 allocator, len, data);
 270 }
 271 void   streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__free_unpacked
 272                      (StreamingProtobufs__ERABLevelQoSParametersExtIEs *message,
 273                       ProtobufCAllocator *allocator)
 274 {
 275   if(!message)
 276     return;
 277   assert(message->base.descriptor == &streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor);
 278   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 279 }
 280 void   streaming_protobufs__gbr__qos_information__init
 281                      (StreamingProtobufs__GBRQosInformation         *message)
 282 {
 283   static const StreamingProtobufs__GBRQosInformation init_value = STREAMING_PROTOBUFS__GBR__QOS_INFORMATION__INIT;
 284   *message = init_value;
 285 }
 286 size_t streaming_protobufs__gbr__qos_information__get_packed_size
 287                      (const StreamingProtobufs__GBRQosInformation *message)
 288 {
 289   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__descriptor);
 290   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 291 }
 292 size_t streaming_protobufs__gbr__qos_information__pack
 293                      (const StreamingProtobufs__GBRQosInformation *message,
 294                       uint8_t       *out)
 295 {
 296   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__descriptor);
 297   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 298 }
 299 size_t streaming_protobufs__gbr__qos_information__pack_to_buffer
 300                      (const StreamingProtobufs__GBRQosInformation *message,
 301                       ProtobufCBuffer *buffer)
 302 {
 303   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__descriptor);
 304   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 305 }
 306 StreamingProtobufs__GBRQosInformation *
 307        streaming_protobufs__gbr__qos_information__unpack
 308                      (ProtobufCAllocator  *allocator,
 309                       size_t               len,
 310                       const uint8_t       *data)
 311 {
 312   return (StreamingProtobufs__GBRQosInformation *)
 313      protobuf_c_message_unpack (&streaming_protobufs__gbr__qos_information__descriptor,
 314                                 allocator, len, data);
 315 }
 316 void   streaming_protobufs__gbr__qos_information__free_unpacked
 317                      (StreamingProtobufs__GBRQosInformation *message,
 318                       ProtobufCAllocator *allocator)
 319 {
 320   if(!message)
 321     return;
 322   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__descriptor);
 323   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 324 }
 325 void   streaming_protobufs__gbr__qos_information__ext_ies__init
 326                      (StreamingProtobufs__GBRQosInformationExtIEs         *message)
 327 {
 328   static const StreamingProtobufs__GBRQosInformationExtIEs init_value = STREAMING_PROTOBUFS__GBR__QOS_INFORMATION__EXT_IES__INIT;
 329   *message = init_value;
 330 }
 331 size_t streaming_protobufs__gbr__qos_information__ext_ies__get_packed_size
 332                      (const StreamingProtobufs__GBRQosInformationExtIEs *message)
 333 {
 334   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__ext_ies__descriptor);
 335   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 336 }
 337 size_t streaming_protobufs__gbr__qos_information__ext_ies__pack
 338                      (const StreamingProtobufs__GBRQosInformationExtIEs *message,
 339                       uint8_t       *out)
 340 {
 341   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__ext_ies__descriptor);
 342   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 343 }
 344 size_t streaming_protobufs__gbr__qos_information__ext_ies__pack_to_buffer
 345                      (const StreamingProtobufs__GBRQosInformationExtIEs *message,
 346                       ProtobufCBuffer *buffer)
 347 {
 348   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__ext_ies__descriptor);
 349   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 350 }
 351 StreamingProtobufs__GBRQosInformationExtIEs *
 352        streaming_protobufs__gbr__qos_information__ext_ies__unpack
 353                      (ProtobufCAllocator  *allocator,
 354                       size_t               len,
 355                       const uint8_t       *data)
 356 {
 357   return (StreamingProtobufs__GBRQosInformationExtIEs *)
 358      protobuf_c_message_unpack (&streaming_protobufs__gbr__qos_information__ext_ies__descriptor,
 359                                 allocator, len, data);
 360 }
 361 void   streaming_protobufs__gbr__qos_information__ext_ies__free_unpacked
 362                      (StreamingProtobufs__GBRQosInformationExtIEs *message,
 363                       ProtobufCAllocator *allocator)
 364 {
 365   if(!message)
 366     return;
 367   assert(message->base.descriptor == &streaming_protobufs__gbr__qos_information__ext_ies__descriptor);
 368   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 369 }
 370 void   streaming_protobufs__global_gnb__id__init
 371                      (StreamingProtobufs__GlobalGNBID         *message)
 372 {
 373   static const StreamingProtobufs__GlobalGNBID init_value = STREAMING_PROTOBUFS__GLOBAL_GNB__ID__INIT;
 374   *message = init_value;
 375 }
 376 size_t streaming_protobufs__global_gnb__id__get_packed_size
 377                      (const StreamingProtobufs__GlobalGNBID *message)
 378 {
 379   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__descriptor);
 380   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 381 }
 382 size_t streaming_protobufs__global_gnb__id__pack
 383                      (const StreamingProtobufs__GlobalGNBID *message,
 384                       uint8_t       *out)
 385 {
 386   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__descriptor);
 387   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 388 }
 389 size_t streaming_protobufs__global_gnb__id__pack_to_buffer
 390                      (const StreamingProtobufs__GlobalGNBID *message,
 391                       ProtobufCBuffer *buffer)
 392 {
 393   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__descriptor);
 394   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 395 }
 396 StreamingProtobufs__GlobalGNBID *
 397        streaming_protobufs__global_gnb__id__unpack
 398                      (ProtobufCAllocator  *allocator,
 399                       size_t               len,
 400                       const uint8_t       *data)
 401 {
 402   return (StreamingProtobufs__GlobalGNBID *)
 403      protobuf_c_message_unpack (&streaming_protobufs__global_gnb__id__descriptor,
 404                                 allocator, len, data);
 405 }
 406 void   streaming_protobufs__global_gnb__id__free_unpacked
 407                      (StreamingProtobufs__GlobalGNBID *message,
 408                       ProtobufCAllocator *allocator)
 409 {
 410   if(!message)
 411     return;
 412   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__descriptor);
 413   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 414 }
 415 void   streaming_protobufs__gnb__id__init
 416                      (StreamingProtobufs__GNBID         *message)
 417 {
 418   static const StreamingProtobufs__GNBID init_value = STREAMING_PROTOBUFS__GNB__ID__INIT;
 419   *message = init_value;
 420 }
 421 size_t streaming_protobufs__gnb__id__get_packed_size
 422                      (const StreamingProtobufs__GNBID *message)
 423 {
 424   assert(message->base.descriptor == &streaming_protobufs__gnb__id__descriptor);
 425   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 426 }
 427 size_t streaming_protobufs__gnb__id__pack
 428                      (const StreamingProtobufs__GNBID *message,
 429                       uint8_t       *out)
 430 {
 431   assert(message->base.descriptor == &streaming_protobufs__gnb__id__descriptor);
 432   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 433 }
 434 size_t streaming_protobufs__gnb__id__pack_to_buffer
 435                      (const StreamingProtobufs__GNBID *message,
 436                       ProtobufCBuffer *buffer)
 437 {
 438   assert(message->base.descriptor == &streaming_protobufs__gnb__id__descriptor);
 439   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 440 }
 441 StreamingProtobufs__GNBID *
 442        streaming_protobufs__gnb__id__unpack
 443                      (ProtobufCAllocator  *allocator,
 444                       size_t               len,
 445                       const uint8_t       *data)
 446 {
 447   return (StreamingProtobufs__GNBID *)
 448      protobuf_c_message_unpack (&streaming_protobufs__gnb__id__descriptor,
 449                                 allocator, len, data);
 450 }
 451 void   streaming_protobufs__gnb__id__free_unpacked
 452                      (StreamingProtobufs__GNBID *message,
 453                       ProtobufCAllocator *allocator)
 454 {
 455   if(!message)
 456     return;
 457   assert(message->base.descriptor == &streaming_protobufs__gnb__id__descriptor);
 458   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 459 }
 460 void   streaming_protobufs__global_gnb__id__ext_ies__init
 461                      (StreamingProtobufs__GlobalGNBIDExtIEs         *message)
 462 {
 463   static const StreamingProtobufs__GlobalGNBIDExtIEs init_value = STREAMING_PROTOBUFS__GLOBAL_GNB__ID__EXT_IES__INIT;
 464   *message = init_value;
 465 }
 466 size_t streaming_protobufs__global_gnb__id__ext_ies__get_packed_size
 467                      (const StreamingProtobufs__GlobalGNBIDExtIEs *message)
 468 {
 469   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__ext_ies__descriptor);
 470   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 471 }
 472 size_t streaming_protobufs__global_gnb__id__ext_ies__pack
 473                      (const StreamingProtobufs__GlobalGNBIDExtIEs *message,
 474                       uint8_t       *out)
 475 {
 476   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__ext_ies__descriptor);
 477   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 478 }
 479 size_t streaming_protobufs__global_gnb__id__ext_ies__pack_to_buffer
 480                      (const StreamingProtobufs__GlobalGNBIDExtIEs *message,
 481                       ProtobufCBuffer *buffer)
 482 {
 483   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__ext_ies__descriptor);
 484   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 485 }
 486 StreamingProtobufs__GlobalGNBIDExtIEs *
 487        streaming_protobufs__global_gnb__id__ext_ies__unpack
 488                      (ProtobufCAllocator  *allocator,
 489                       size_t               len,
 490                       const uint8_t       *data)
 491 {
 492   return (StreamingProtobufs__GlobalGNBIDExtIEs *)
 493      protobuf_c_message_unpack (&streaming_protobufs__global_gnb__id__ext_ies__descriptor,
 494                                 allocator, len, data);
 495 }
 496 void   streaming_protobufs__global_gnb__id__ext_ies__free_unpacked
 497                      (StreamingProtobufs__GlobalGNBIDExtIEs *message,
 498                       ProtobufCAllocator *allocator)
 499 {
 500   if(!message)
 501     return;
 502   assert(message->base.descriptor == &streaming_protobufs__global_gnb__id__ext_ies__descriptor);
 503   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 504 }
 505 void   streaming_protobufs__gtptunnel_endpoint__init
 506                      (StreamingProtobufs__GTPtunnelEndpoint         *message)
 507 {
 508   static const StreamingProtobufs__GTPtunnelEndpoint init_value = STREAMING_PROTOBUFS__GTPTUNNEL_ENDPOINT__INIT;
 509   *message = init_value;
 510 }
 511 size_t streaming_protobufs__gtptunnel_endpoint__get_packed_size
 512                      (const StreamingProtobufs__GTPtunnelEndpoint *message)
 513 {
 514   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__descriptor);
 515   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 516 }
 517 size_t streaming_protobufs__gtptunnel_endpoint__pack
 518                      (const StreamingProtobufs__GTPtunnelEndpoint *message,
 519                       uint8_t       *out)
 520 {
 521   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__descriptor);
 522   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 523 }
 524 size_t streaming_protobufs__gtptunnel_endpoint__pack_to_buffer
 525                      (const StreamingProtobufs__GTPtunnelEndpoint *message,
 526                       ProtobufCBuffer *buffer)
 527 {
 528   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__descriptor);
 529   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 530 }
 531 StreamingProtobufs__GTPtunnelEndpoint *
 532        streaming_protobufs__gtptunnel_endpoint__unpack
 533                      (ProtobufCAllocator  *allocator,
 534                       size_t               len,
 535                       const uint8_t       *data)
 536 {
 537   return (StreamingProtobufs__GTPtunnelEndpoint *)
 538      protobuf_c_message_unpack (&streaming_protobufs__gtptunnel_endpoint__descriptor,
 539                                 allocator, len, data);
 540 }
 541 void   streaming_protobufs__gtptunnel_endpoint__free_unpacked
 542                      (StreamingProtobufs__GTPtunnelEndpoint *message,
 543                       ProtobufCAllocator *allocator)
 544 {
 545   if(!message)
 546     return;
 547   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__descriptor);
 548   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 549 }
 550 void   streaming_protobufs__gtptunnel_endpoint__ext_ies__init
 551                      (StreamingProtobufs__GTPtunnelEndpointExtIEs         *message)
 552 {
 553   static const StreamingProtobufs__GTPtunnelEndpointExtIEs init_value = STREAMING_PROTOBUFS__GTPTUNNEL_ENDPOINT__EXT_IES__INIT;
 554   *message = init_value;
 555 }
 556 size_t streaming_protobufs__gtptunnel_endpoint__ext_ies__get_packed_size
 557                      (const StreamingProtobufs__GTPtunnelEndpointExtIEs *message)
 558 {
 559   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor);
 560   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 561 }
 562 size_t streaming_protobufs__gtptunnel_endpoint__ext_ies__pack
 563                      (const StreamingProtobufs__GTPtunnelEndpointExtIEs *message,
 564                       uint8_t       *out)
 565 {
 566   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor);
 567   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 568 }
 569 size_t streaming_protobufs__gtptunnel_endpoint__ext_ies__pack_to_buffer
 570                      (const StreamingProtobufs__GTPtunnelEndpointExtIEs *message,
 571                       ProtobufCBuffer *buffer)
 572 {
 573   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor);
 574   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 575 }
 576 StreamingProtobufs__GTPtunnelEndpointExtIEs *
 577        streaming_protobufs__gtptunnel_endpoint__ext_ies__unpack
 578                      (ProtobufCAllocator  *allocator,
 579                       size_t               len,
 580                       const uint8_t       *data)
 581 {
 582   return (StreamingProtobufs__GTPtunnelEndpointExtIEs *)
 583      protobuf_c_message_unpack (&streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor,
 584                                 allocator, len, data);
 585 }
 586 void   streaming_protobufs__gtptunnel_endpoint__ext_ies__free_unpacked
 587                      (StreamingProtobufs__GTPtunnelEndpointExtIEs *message,
 588                       ProtobufCAllocator *allocator)
 589 {
 590   if(!message)
 591     return;
 592   assert(message->base.descriptor == &streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor);
 593   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 594 }
 595 void   streaming_protobufs__rlcmode__init
 596                      (StreamingProtobufs__RLCMode         *message)
 597 {
 598   static const StreamingProtobufs__RLCMode init_value = STREAMING_PROTOBUFS__RLCMODE__INIT;
 599   *message = init_value;
 600 }
 601 size_t streaming_protobufs__rlcmode__get_packed_size
 602                      (const StreamingProtobufs__RLCMode *message)
 603 {
 604   assert(message->base.descriptor == &streaming_protobufs__rlcmode__descriptor);
 605   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 606 }
 607 size_t streaming_protobufs__rlcmode__pack
 608                      (const StreamingProtobufs__RLCMode *message,
 609                       uint8_t       *out)
 610 {
 611   assert(message->base.descriptor == &streaming_protobufs__rlcmode__descriptor);
 612   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 613 }
 614 size_t streaming_protobufs__rlcmode__pack_to_buffer
 615                      (const StreamingProtobufs__RLCMode *message,
 616                       ProtobufCBuffer *buffer)
 617 {
 618   assert(message->base.descriptor == &streaming_protobufs__rlcmode__descriptor);
 619   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 620 }
 621 StreamingProtobufs__RLCMode *
 622        streaming_protobufs__rlcmode__unpack
 623                      (ProtobufCAllocator  *allocator,
 624                       size_t               len,
 625                       const uint8_t       *data)
 626 {
 627   return (StreamingProtobufs__RLCMode *)
 628      protobuf_c_message_unpack (&streaming_protobufs__rlcmode__descriptor,
 629                                 allocator, len, data);
 630 }
 631 void   streaming_protobufs__rlcmode__free_unpacked
 632                      (StreamingProtobufs__RLCMode *message,
 633                       ProtobufCAllocator *allocator)
 634 {
 635   if(!message)
 636     return;
 637   assert(message->base.descriptor == &streaming_protobufs__rlcmode__descriptor);
 638   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 639 }
 640 void   streaming_protobufs__rlc__status__init
 641                      (StreamingProtobufs__RLCStatus         *message)
 642 {
 643   static const StreamingProtobufs__RLCStatus init_value = STREAMING_PROTOBUFS__RLC__STATUS__INIT;
 644   *message = init_value;
 645 }
 646 size_t streaming_protobufs__rlc__status__get_packed_size
 647                      (const StreamingProtobufs__RLCStatus *message)
 648 {
 649   assert(message->base.descriptor == &streaming_protobufs__rlc__status__descriptor);
 650   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 651 }
 652 size_t streaming_protobufs__rlc__status__pack
 653                      (const StreamingProtobufs__RLCStatus *message,
 654                       uint8_t       *out)
 655 {
 656   assert(message->base.descriptor == &streaming_protobufs__rlc__status__descriptor);
 657   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 658 }
 659 size_t streaming_protobufs__rlc__status__pack_to_buffer
 660                      (const StreamingProtobufs__RLCStatus *message,
 661                       ProtobufCBuffer *buffer)
 662 {
 663   assert(message->base.descriptor == &streaming_protobufs__rlc__status__descriptor);
 664   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 665 }
 666 StreamingProtobufs__RLCStatus *
 667        streaming_protobufs__rlc__status__unpack
 668                      (ProtobufCAllocator  *allocator,
 669                       size_t               len,
 670                       const uint8_t       *data)
 671 {
 672   return (StreamingProtobufs__RLCStatus *)
 673      protobuf_c_message_unpack (&streaming_protobufs__rlc__status__descriptor,
 674                                 allocator, len, data);
 675 }
 676 void   streaming_protobufs__rlc__status__free_unpacked
 677                      (StreamingProtobufs__RLCStatus *message,
 678                       ProtobufCAllocator *allocator)
 679 {
 680   if(!message)
 681     return;
 682   assert(message->base.descriptor == &streaming_protobufs__rlc__status__descriptor);
 683   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 684 }
 685 void   streaming_protobufs__ulconfiguration__init
 686                      (StreamingProtobufs__ULConfiguration         *message)
 687 {
 688   static const StreamingProtobufs__ULConfiguration init_value = STREAMING_PROTOBUFS__ULCONFIGURATION__INIT;
 689   *message = init_value;
 690 }
 691 size_t streaming_protobufs__ulconfiguration__get_packed_size
 692                      (const StreamingProtobufs__ULConfiguration *message)
 693 {
 694   assert(message->base.descriptor == &streaming_protobufs__ulconfiguration__descriptor);
 695   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 696 }
 697 size_t streaming_protobufs__ulconfiguration__pack
 698                      (const StreamingProtobufs__ULConfiguration *message,
 699                       uint8_t       *out)
 700 {
 701   assert(message->base.descriptor == &streaming_protobufs__ulconfiguration__descriptor);
 702   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 703 }
 704 size_t streaming_protobufs__ulconfiguration__pack_to_buffer
 705                      (const StreamingProtobufs__ULConfiguration *message,
 706                       ProtobufCBuffer *buffer)
 707 {
 708   assert(message->base.descriptor == &streaming_protobufs__ulconfiguration__descriptor);
 709   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 710 }
 711 StreamingProtobufs__ULConfiguration *
 712        streaming_protobufs__ulconfiguration__unpack
 713                      (ProtobufCAllocator  *allocator,
 714                       size_t               len,
 715                       const uint8_t       *data)
 716 {
 717   return (StreamingProtobufs__ULConfiguration *)
 718      protobuf_c_message_unpack (&streaming_protobufs__ulconfiguration__descriptor,
 719                                 allocator, len, data);
 720 }
 721 void   streaming_protobufs__ulconfiguration__free_unpacked
 722                      (StreamingProtobufs__ULConfiguration *message,
 723                       ProtobufCAllocator *allocator)
 724 {
 725   if(!message)
 726     return;
 727   assert(message->base.descriptor == &streaming_protobufs__ulconfiguration__descriptor);
 728   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 729 }
 730 void   streaming_protobufs__pdcpsn_length__init
 731                      (StreamingProtobufs__PDCPSnLength         *message)
 732 {
 733   static const StreamingProtobufs__PDCPSnLength init_value = STREAMING_PROTOBUFS__PDCPSN_LENGTH__INIT;
 734   *message = init_value;
 735 }
 736 size_t streaming_protobufs__pdcpsn_length__get_packed_size
 737                      (const StreamingProtobufs__PDCPSnLength *message)
 738 {
 739   assert(message->base.descriptor == &streaming_protobufs__pdcpsn_length__descriptor);
 740   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 741 }
 742 size_t streaming_protobufs__pdcpsn_length__pack
 743                      (const StreamingProtobufs__PDCPSnLength *message,
 744                       uint8_t       *out)
 745 {
 746   assert(message->base.descriptor == &streaming_protobufs__pdcpsn_length__descriptor);
 747   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 748 }
 749 size_t streaming_protobufs__pdcpsn_length__pack_to_buffer
 750                      (const StreamingProtobufs__PDCPSnLength *message,
 751                       ProtobufCBuffer *buffer)
 752 {
 753   assert(message->base.descriptor == &streaming_protobufs__pdcpsn_length__descriptor);
 754   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 755 }
 756 StreamingProtobufs__PDCPSnLength *
 757        streaming_protobufs__pdcpsn_length__unpack
 758                      (ProtobufCAllocator  *allocator,
 759                       size_t               len,
 760                       const uint8_t       *data)
 761 {
 762   return (StreamingProtobufs__PDCPSnLength *)
 763      protobuf_c_message_unpack (&streaming_protobufs__pdcpsn_length__descriptor,
 764                                 allocator, len, data);
 765 }
 766 void   streaming_protobufs__pdcpsn_length__free_unpacked
 767                      (StreamingProtobufs__PDCPSnLength *message,
 768                       ProtobufCAllocator *allocator)
 769 {
 770   if(!message)
 771     return;
 772   assert(message->base.descriptor == &streaming_protobufs__pdcpsn_length__descriptor);
 773   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 774 }
 775 void   streaming_protobufs__pdcpchange_indication__init
 776                      (StreamingProtobufs__PDCPChangeIndication         *message)
 777 {
 778   static const StreamingProtobufs__PDCPChangeIndication init_value = STREAMING_PROTOBUFS__PDCPCHANGE_INDICATION__INIT;
 779   *message = init_value;
 780 }
 781 size_t streaming_protobufs__pdcpchange_indication__get_packed_size
 782                      (const StreamingProtobufs__PDCPChangeIndication *message)
 783 {
 784   assert(message->base.descriptor == &streaming_protobufs__pdcpchange_indication__descriptor);
 785   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 786 }
 787 size_t streaming_protobufs__pdcpchange_indication__pack
 788                      (const StreamingProtobufs__PDCPChangeIndication *message,
 789                       uint8_t       *out)
 790 {
 791   assert(message->base.descriptor == &streaming_protobufs__pdcpchange_indication__descriptor);
 792   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 793 }
 794 size_t streaming_protobufs__pdcpchange_indication__pack_to_buffer
 795                      (const StreamingProtobufs__PDCPChangeIndication *message,
 796                       ProtobufCBuffer *buffer)
 797 {
 798   assert(message->base.descriptor == &streaming_protobufs__pdcpchange_indication__descriptor);
 799   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 800 }
 801 StreamingProtobufs__PDCPChangeIndication *
 802        streaming_protobufs__pdcpchange_indication__unpack
 803                      (ProtobufCAllocator  *allocator,
 804                       size_t               len,
 805                       const uint8_t       *data)
 806 {
 807   return (StreamingProtobufs__PDCPChangeIndication *)
 808      protobuf_c_message_unpack (&streaming_protobufs__pdcpchange_indication__descriptor,
 809                                 allocator, len, data);
 810 }
 811 void   streaming_protobufs__pdcpchange_indication__free_unpacked
 812                      (StreamingProtobufs__PDCPChangeIndication *message,
 813                       ProtobufCAllocator *allocator)
 814 {
 815   if(!message)
 816     return;
 817   assert(message->base.descriptor == &streaming_protobufs__pdcpchange_indication__descriptor);
 818   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 819 }
 820 void   streaming_protobufs__split_srbs__init
 821                      (StreamingProtobufs__SplitSRBs         *message)
 822 {
 823   static const StreamingProtobufs__SplitSRBs init_value = STREAMING_PROTOBUFS__SPLIT_SRBS__INIT;
 824   *message = init_value;
 825 }
 826 size_t streaming_protobufs__split_srbs__get_packed_size
 827                      (const StreamingProtobufs__SplitSRBs *message)
 828 {
 829   assert(message->base.descriptor == &streaming_protobufs__split_srbs__descriptor);
 830   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 831 }
 832 size_t streaming_protobufs__split_srbs__pack
 833                      (const StreamingProtobufs__SplitSRBs *message,
 834                       uint8_t       *out)
 835 {
 836   assert(message->base.descriptor == &streaming_protobufs__split_srbs__descriptor);
 837   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 838 }
 839 size_t streaming_protobufs__split_srbs__pack_to_buffer
 840                      (const StreamingProtobufs__SplitSRBs *message,
 841                       ProtobufCBuffer *buffer)
 842 {
 843   assert(message->base.descriptor == &streaming_protobufs__split_srbs__descriptor);
 844   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 845 }
 846 StreamingProtobufs__SplitSRBs *
 847        streaming_protobufs__split_srbs__unpack
 848                      (ProtobufCAllocator  *allocator,
 849                       size_t               len,
 850                       const uint8_t       *data)
 851 {
 852   return (StreamingProtobufs__SplitSRBs *)
 853      protobuf_c_message_unpack (&streaming_protobufs__split_srbs__descriptor,
 854                                 allocator, len, data);
 855 }
 856 void   streaming_protobufs__split_srbs__free_unpacked
 857                      (StreamingProtobufs__SplitSRBs *message,
 858                       ProtobufCAllocator *allocator)
 859 {
 860   if(!message)
 861     return;
 862   assert(message->base.descriptor == &streaming_protobufs__split_srbs__descriptor);
 863   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 864 }
 865 void   streaming_protobufs__nrcgi__init
 866                      (StreamingProtobufs__NRCGI         *message)
 867 {
 868   static const StreamingProtobufs__NRCGI init_value = STREAMING_PROTOBUFS__NRCGI__INIT;
 869   *message = init_value;
 870 }
 871 size_t streaming_protobufs__nrcgi__get_packed_size
 872                      (const StreamingProtobufs__NRCGI *message)
 873 {
 874   assert(message->base.descriptor == &streaming_protobufs__nrcgi__descriptor);
 875   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 876 }
 877 size_t streaming_protobufs__nrcgi__pack
 878                      (const StreamingProtobufs__NRCGI *message,
 879                       uint8_t       *out)
 880 {
 881   assert(message->base.descriptor == &streaming_protobufs__nrcgi__descriptor);
 882   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 883 }
 884 size_t streaming_protobufs__nrcgi__pack_to_buffer
 885                      (const StreamingProtobufs__NRCGI *message,
 886                       ProtobufCBuffer *buffer)
 887 {
 888   assert(message->base.descriptor == &streaming_protobufs__nrcgi__descriptor);
 889   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 890 }
 891 StreamingProtobufs__NRCGI *
 892        streaming_protobufs__nrcgi__unpack
 893                      (ProtobufCAllocator  *allocator,
 894                       size_t               len,
 895                       const uint8_t       *data)
 896 {
 897   return (StreamingProtobufs__NRCGI *)
 898      protobuf_c_message_unpack (&streaming_protobufs__nrcgi__descriptor,
 899                                 allocator, len, data);
 900 }
 901 void   streaming_protobufs__nrcgi__free_unpacked
 902                      (StreamingProtobufs__NRCGI *message,
 903                       ProtobufCAllocator *allocator)
 904 {
 905   if(!message)
 906     return;
 907   assert(message->base.descriptor == &streaming_protobufs__nrcgi__descriptor);
 908   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 909 }
 910 void   streaming_protobufs__nrcgi__ext_ies__init
 911                      (StreamingProtobufs__NRCGIExtIEs         *message)
 912 {
 913   static const StreamingProtobufs__NRCGIExtIEs init_value = STREAMING_PROTOBUFS__NRCGI__EXT_IES__INIT;
 914   *message = init_value;
 915 }
 916 size_t streaming_protobufs__nrcgi__ext_ies__get_packed_size
 917                      (const StreamingProtobufs__NRCGIExtIEs *message)
 918 {
 919   assert(message->base.descriptor == &streaming_protobufs__nrcgi__ext_ies__descriptor);
 920   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 921 }
 922 size_t streaming_protobufs__nrcgi__ext_ies__pack
 923                      (const StreamingProtobufs__NRCGIExtIEs *message,
 924                       uint8_t       *out)
 925 {
 926   assert(message->base.descriptor == &streaming_protobufs__nrcgi__ext_ies__descriptor);
 927   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 928 }
 929 size_t streaming_protobufs__nrcgi__ext_ies__pack_to_buffer
 930                      (const StreamingProtobufs__NRCGIExtIEs *message,
 931                       ProtobufCBuffer *buffer)
 932 {
 933   assert(message->base.descriptor == &streaming_protobufs__nrcgi__ext_ies__descriptor);
 934   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 935 }
 936 StreamingProtobufs__NRCGIExtIEs *
 937        streaming_protobufs__nrcgi__ext_ies__unpack
 938                      (ProtobufCAllocator  *allocator,
 939                       size_t               len,
 940                       const uint8_t       *data)
 941 {
 942   return (StreamingProtobufs__NRCGIExtIEs *)
 943      protobuf_c_message_unpack (&streaming_protobufs__nrcgi__ext_ies__descriptor,
 944                                 allocator, len, data);
 945 }
 946 void   streaming_protobufs__nrcgi__ext_ies__free_unpacked
 947                      (StreamingProtobufs__NRCGIExtIEs *message,
 948                       ProtobufCAllocator *allocator)
 949 {
 950   if(!message)
 951     return;
 952   assert(message->base.descriptor == &streaming_protobufs__nrcgi__ext_ies__descriptor);
 953   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 954 }
 955 void   streaming_protobufs__ecgi__init
 956                      (StreamingProtobufs__ECGI         *message)
 957 {
 958   static const StreamingProtobufs__ECGI init_value = STREAMING_PROTOBUFS__ECGI__INIT;
 959   *message = init_value;
 960 }
 961 size_t streaming_protobufs__ecgi__get_packed_size
 962                      (const StreamingProtobufs__ECGI *message)
 963 {
 964   assert(message->base.descriptor == &streaming_protobufs__ecgi__descriptor);
 965   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 966 }
 967 size_t streaming_protobufs__ecgi__pack
 968                      (const StreamingProtobufs__ECGI *message,
 969                       uint8_t       *out)
 970 {
 971   assert(message->base.descriptor == &streaming_protobufs__ecgi__descriptor);
 972   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 973 }
 974 size_t streaming_protobufs__ecgi__pack_to_buffer
 975                      (const StreamingProtobufs__ECGI *message,
 976                       ProtobufCBuffer *buffer)
 977 {
 978   assert(message->base.descriptor == &streaming_protobufs__ecgi__descriptor);
 979   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 980 }
 981 StreamingProtobufs__ECGI *
 982        streaming_protobufs__ecgi__unpack
 983                      (ProtobufCAllocator  *allocator,
 984                       size_t               len,
 985                       const uint8_t       *data)
 986 {
 987   return (StreamingProtobufs__ECGI *)
 988      protobuf_c_message_unpack (&streaming_protobufs__ecgi__descriptor,
 989                                 allocator, len, data);
 990 }
 991 void   streaming_protobufs__ecgi__free_unpacked
 992                      (StreamingProtobufs__ECGI *message,
 993                       ProtobufCAllocator *allocator)
 994 {
 995   if(!message)
 996     return;
 997   assert(message->base.descriptor == &streaming_protobufs__ecgi__descriptor);
 998   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 999 }
1000 void   streaming_protobufs__e__rab__list__init
1001                      (StreamingProtobufs__ERABList         *message)
1002 {
1003   static const StreamingProtobufs__ERABList init_value = STREAMING_PROTOBUFS__E__RAB__LIST__INIT;
1004   *message = init_value;
1005 }
1006 size_t streaming_protobufs__e__rab__list__get_packed_size
1007                      (const StreamingProtobufs__ERABList *message)
1008 {
1009   assert(message->base.descriptor == &streaming_protobufs__e__rab__list__descriptor);
1010   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1011 }
1012 size_t streaming_protobufs__e__rab__list__pack
1013                      (const StreamingProtobufs__ERABList *message,
1014                       uint8_t       *out)
1015 {
1016   assert(message->base.descriptor == &streaming_protobufs__e__rab__list__descriptor);
1017   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1018 }
1019 size_t streaming_protobufs__e__rab__list__pack_to_buffer
1020                      (const StreamingProtobufs__ERABList *message,
1021                       ProtobufCBuffer *buffer)
1022 {
1023   assert(message->base.descriptor == &streaming_protobufs__e__rab__list__descriptor);
1024   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1025 }
1026 StreamingProtobufs__ERABList *
1027        streaming_protobufs__e__rab__list__unpack
1028                      (ProtobufCAllocator  *allocator,
1029                       size_t               len,
1030                       const uint8_t       *data)
1031 {
1032   return (StreamingProtobufs__ERABList *)
1033      protobuf_c_message_unpack (&streaming_protobufs__e__rab__list__descriptor,
1034                                 allocator, len, data);
1035 }
1036 void   streaming_protobufs__e__rab__list__free_unpacked
1037                      (StreamingProtobufs__ERABList *message,
1038                       ProtobufCAllocator *allocator)
1039 {
1040   if(!message)
1041     return;
1042   assert(message->base.descriptor == &streaming_protobufs__e__rab__list__descriptor);
1043   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1044 }
1045 void   streaming_protobufs__e__rab__item_ies__init
1046                      (StreamingProtobufs__ERABItemIEs         *message)
1047 {
1048   static const StreamingProtobufs__ERABItemIEs init_value = STREAMING_PROTOBUFS__E__RAB__ITEM_IES__INIT;
1049   *message = init_value;
1050 }
1051 size_t streaming_protobufs__e__rab__item_ies__get_packed_size
1052                      (const StreamingProtobufs__ERABItemIEs *message)
1053 {
1054   assert(message->base.descriptor == &streaming_protobufs__e__rab__item_ies__descriptor);
1055   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1056 }
1057 size_t streaming_protobufs__e__rab__item_ies__pack
1058                      (const StreamingProtobufs__ERABItemIEs *message,
1059                       uint8_t       *out)
1060 {
1061   assert(message->base.descriptor == &streaming_protobufs__e__rab__item_ies__descriptor);
1062   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1063 }
1064 size_t streaming_protobufs__e__rab__item_ies__pack_to_buffer
1065                      (const StreamingProtobufs__ERABItemIEs *message,
1066                       ProtobufCBuffer *buffer)
1067 {
1068   assert(message->base.descriptor == &streaming_protobufs__e__rab__item_ies__descriptor);
1069   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1070 }
1071 StreamingProtobufs__ERABItemIEs *
1072        streaming_protobufs__e__rab__item_ies__unpack
1073                      (ProtobufCAllocator  *allocator,
1074                       size_t               len,
1075                       const uint8_t       *data)
1076 {
1077   return (StreamingProtobufs__ERABItemIEs *)
1078      protobuf_c_message_unpack (&streaming_protobufs__e__rab__item_ies__descriptor,
1079                                 allocator, len, data);
1080 }
1081 void   streaming_protobufs__e__rab__item_ies__free_unpacked
1082                      (StreamingProtobufs__ERABItemIEs *message,
1083                       ProtobufCAllocator *allocator)
1084 {
1085   if(!message)
1086     return;
1087   assert(message->base.descriptor == &streaming_protobufs__e__rab__item_ies__descriptor);
1088   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1089 }
1090 void   streaming_protobufs__e__rab__item__init
1091                      (StreamingProtobufs__ERABItem         *message)
1092 {
1093   static const StreamingProtobufs__ERABItem init_value = STREAMING_PROTOBUFS__E__RAB__ITEM__INIT;
1094   *message = init_value;
1095 }
1096 size_t streaming_protobufs__e__rab__item__get_packed_size
1097                      (const StreamingProtobufs__ERABItem *message)
1098 {
1099   assert(message->base.descriptor == &streaming_protobufs__e__rab__item__descriptor);
1100   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1101 }
1102 size_t streaming_protobufs__e__rab__item__pack
1103                      (const StreamingProtobufs__ERABItem *message,
1104                       uint8_t       *out)
1105 {
1106   assert(message->base.descriptor == &streaming_protobufs__e__rab__item__descriptor);
1107   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1108 }
1109 size_t streaming_protobufs__e__rab__item__pack_to_buffer
1110                      (const StreamingProtobufs__ERABItem *message,
1111                       ProtobufCBuffer *buffer)
1112 {
1113   assert(message->base.descriptor == &streaming_protobufs__e__rab__item__descriptor);
1114   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1115 }
1116 StreamingProtobufs__ERABItem *
1117        streaming_protobufs__e__rab__item__unpack
1118                      (ProtobufCAllocator  *allocator,
1119                       size_t               len,
1120                       const uint8_t       *data)
1121 {
1122   return (StreamingProtobufs__ERABItem *)
1123      protobuf_c_message_unpack (&streaming_protobufs__e__rab__item__descriptor,
1124                                 allocator, len, data);
1125 }
1126 void   streaming_protobufs__e__rab__item__free_unpacked
1127                      (StreamingProtobufs__ERABItem *message,
1128                       ProtobufCAllocator *allocator)
1129 {
1130   if(!message)
1131     return;
1132   assert(message->base.descriptor == &streaming_protobufs__e__rab__item__descriptor);
1133   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1134 }
1135 void   streaming_protobufs__erabactivity_notify_item_list__init
1136                      (StreamingProtobufs__ERABActivityNotifyItemList         *message)
1137 {
1138   static const StreamingProtobufs__ERABActivityNotifyItemList init_value = STREAMING_PROTOBUFS__ERABACTIVITY_NOTIFY_ITEM_LIST__INIT;
1139   *message = init_value;
1140 }
1141 size_t streaming_protobufs__erabactivity_notify_item_list__get_packed_size
1142                      (const StreamingProtobufs__ERABActivityNotifyItemList *message)
1143 {
1144   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item_list__descriptor);
1145   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1146 }
1147 size_t streaming_protobufs__erabactivity_notify_item_list__pack
1148                      (const StreamingProtobufs__ERABActivityNotifyItemList *message,
1149                       uint8_t       *out)
1150 {
1151   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item_list__descriptor);
1152   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1153 }
1154 size_t streaming_protobufs__erabactivity_notify_item_list__pack_to_buffer
1155                      (const StreamingProtobufs__ERABActivityNotifyItemList *message,
1156                       ProtobufCBuffer *buffer)
1157 {
1158   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item_list__descriptor);
1159   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1160 }
1161 StreamingProtobufs__ERABActivityNotifyItemList *
1162        streaming_protobufs__erabactivity_notify_item_list__unpack
1163                      (ProtobufCAllocator  *allocator,
1164                       size_t               len,
1165                       const uint8_t       *data)
1166 {
1167   return (StreamingProtobufs__ERABActivityNotifyItemList *)
1168      protobuf_c_message_unpack (&streaming_protobufs__erabactivity_notify_item_list__descriptor,
1169                                 allocator, len, data);
1170 }
1171 void   streaming_protobufs__erabactivity_notify_item_list__free_unpacked
1172                      (StreamingProtobufs__ERABActivityNotifyItemList *message,
1173                       ProtobufCAllocator *allocator)
1174 {
1175   if(!message)
1176     return;
1177   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item_list__descriptor);
1178   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1179 }
1180 void   streaming_protobufs__erabactivity_notify_item__init
1181                      (StreamingProtobufs__ERABActivityNotifyItem         *message)
1182 {
1183   static const StreamingProtobufs__ERABActivityNotifyItem init_value = STREAMING_PROTOBUFS__ERABACTIVITY_NOTIFY_ITEM__INIT;
1184   *message = init_value;
1185 }
1186 size_t streaming_protobufs__erabactivity_notify_item__get_packed_size
1187                      (const StreamingProtobufs__ERABActivityNotifyItem *message)
1188 {
1189   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__descriptor);
1190   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1191 }
1192 size_t streaming_protobufs__erabactivity_notify_item__pack
1193                      (const StreamingProtobufs__ERABActivityNotifyItem *message,
1194                       uint8_t       *out)
1195 {
1196   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__descriptor);
1197   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1198 }
1199 size_t streaming_protobufs__erabactivity_notify_item__pack_to_buffer
1200                      (const StreamingProtobufs__ERABActivityNotifyItem *message,
1201                       ProtobufCBuffer *buffer)
1202 {
1203   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__descriptor);
1204   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1205 }
1206 StreamingProtobufs__ERABActivityNotifyItem *
1207        streaming_protobufs__erabactivity_notify_item__unpack
1208                      (ProtobufCAllocator  *allocator,
1209                       size_t               len,
1210                       const uint8_t       *data)
1211 {
1212   return (StreamingProtobufs__ERABActivityNotifyItem *)
1213      protobuf_c_message_unpack (&streaming_protobufs__erabactivity_notify_item__descriptor,
1214                                 allocator, len, data);
1215 }
1216 void   streaming_protobufs__erabactivity_notify_item__free_unpacked
1217                      (StreamingProtobufs__ERABActivityNotifyItem *message,
1218                       ProtobufCAllocator *allocator)
1219 {
1220   if(!message)
1221     return;
1222   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__descriptor);
1223   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1224 }
1225 void   streaming_protobufs__erabactivity_notify_item__ext_ies__init
1226                      (StreamingProtobufs__ERABActivityNotifyItemExtIEs         *message)
1227 {
1228   static const StreamingProtobufs__ERABActivityNotifyItemExtIEs init_value = STREAMING_PROTOBUFS__ERABACTIVITY_NOTIFY_ITEM__EXT_IES__INIT;
1229   *message = init_value;
1230 }
1231 size_t streaming_protobufs__erabactivity_notify_item__ext_ies__get_packed_size
1232                      (const StreamingProtobufs__ERABActivityNotifyItemExtIEs *message)
1233 {
1234   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor);
1235   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1236 }
1237 size_t streaming_protobufs__erabactivity_notify_item__ext_ies__pack
1238                      (const StreamingProtobufs__ERABActivityNotifyItemExtIEs *message,
1239                       uint8_t       *out)
1240 {
1241   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor);
1242   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1243 }
1244 size_t streaming_protobufs__erabactivity_notify_item__ext_ies__pack_to_buffer
1245                      (const StreamingProtobufs__ERABActivityNotifyItemExtIEs *message,
1246                       ProtobufCBuffer *buffer)
1247 {
1248   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor);
1249   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1250 }
1251 StreamingProtobufs__ERABActivityNotifyItemExtIEs *
1252        streaming_protobufs__erabactivity_notify_item__ext_ies__unpack
1253                      (ProtobufCAllocator  *allocator,
1254                       size_t               len,
1255                       const uint8_t       *data)
1256 {
1257   return (StreamingProtobufs__ERABActivityNotifyItemExtIEs *)
1258      protobuf_c_message_unpack (&streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor,
1259                                 allocator, len, data);
1260 }
1261 void   streaming_protobufs__erabactivity_notify_item__ext_ies__free_unpacked
1262                      (StreamingProtobufs__ERABActivityNotifyItemExtIEs *message,
1263                       ProtobufCAllocator *allocator)
1264 {
1265   if(!message)
1266     return;
1267   assert(message->base.descriptor == &streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor);
1268   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1269 }
1270 void   streaming_protobufs__user_plane_traffic_activity_report__init
1271                      (StreamingProtobufs__UserPlaneTrafficActivityReport         *message)
1272 {
1273   static const StreamingProtobufs__UserPlaneTrafficActivityReport init_value = STREAMING_PROTOBUFS__USER_PLANE_TRAFFIC_ACTIVITY_REPORT__INIT;
1274   *message = init_value;
1275 }
1276 size_t streaming_protobufs__user_plane_traffic_activity_report__get_packed_size
1277                      (const StreamingProtobufs__UserPlaneTrafficActivityReport *message)
1278 {
1279   assert(message->base.descriptor == &streaming_protobufs__user_plane_traffic_activity_report__descriptor);
1280   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1281 }
1282 size_t streaming_protobufs__user_plane_traffic_activity_report__pack
1283                      (const StreamingProtobufs__UserPlaneTrafficActivityReport *message,
1284                       uint8_t       *out)
1285 {
1286   assert(message->base.descriptor == &streaming_protobufs__user_plane_traffic_activity_report__descriptor);
1287   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1288 }
1289 size_t streaming_protobufs__user_plane_traffic_activity_report__pack_to_buffer
1290                      (const StreamingProtobufs__UserPlaneTrafficActivityReport *message,
1291                       ProtobufCBuffer *buffer)
1292 {
1293   assert(message->base.descriptor == &streaming_protobufs__user_plane_traffic_activity_report__descriptor);
1294   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1295 }
1296 StreamingProtobufs__UserPlaneTrafficActivityReport *
1297        streaming_protobufs__user_plane_traffic_activity_report__unpack
1298                      (ProtobufCAllocator  *allocator,
1299                       size_t               len,
1300                       const uint8_t       *data)
1301 {
1302   return (StreamingProtobufs__UserPlaneTrafficActivityReport *)
1303      protobuf_c_message_unpack (&streaming_protobufs__user_plane_traffic_activity_report__descriptor,
1304                                 allocator, len, data);
1305 }
1306 void   streaming_protobufs__user_plane_traffic_activity_report__free_unpacked
1307                      (StreamingProtobufs__UserPlaneTrafficActivityReport *message,
1308                       ProtobufCAllocator *allocator)
1309 {
1310   if(!message)
1311     return;
1312   assert(message->base.descriptor == &streaming_protobufs__user_plane_traffic_activity_report__descriptor);
1313   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1314 }
1315 void   streaming_protobufs__gnboverload_information__init
1316                      (StreamingProtobufs__GNBOverloadInformation         *message)
1317 {
1318   static const StreamingProtobufs__GNBOverloadInformation init_value = STREAMING_PROTOBUFS__GNBOVERLOAD_INFORMATION__INIT;
1319   *message = init_value;
1320 }
1321 size_t streaming_protobufs__gnboverload_information__get_packed_size
1322                      (const StreamingProtobufs__GNBOverloadInformation *message)
1323 {
1324   assert(message->base.descriptor == &streaming_protobufs__gnboverload_information__descriptor);
1325   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1326 }
1327 size_t streaming_protobufs__gnboverload_information__pack
1328                      (const StreamingProtobufs__GNBOverloadInformation *message,
1329                       uint8_t       *out)
1330 {
1331   assert(message->base.descriptor == &streaming_protobufs__gnboverload_information__descriptor);
1332   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1333 }
1334 size_t streaming_protobufs__gnboverload_information__pack_to_buffer
1335                      (const StreamingProtobufs__GNBOverloadInformation *message,
1336                       ProtobufCBuffer *buffer)
1337 {
1338   assert(message->base.descriptor == &streaming_protobufs__gnboverload_information__descriptor);
1339   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1340 }
1341 StreamingProtobufs__GNBOverloadInformation *
1342        streaming_protobufs__gnboverload_information__unpack
1343                      (ProtobufCAllocator  *allocator,
1344                       size_t               len,
1345                       const uint8_t       *data)
1346 {
1347   return (StreamingProtobufs__GNBOverloadInformation *)
1348      protobuf_c_message_unpack (&streaming_protobufs__gnboverload_information__descriptor,
1349                                 allocator, len, data);
1350 }
1351 void   streaming_protobufs__gnboverload_information__free_unpacked
1352                      (StreamingProtobufs__GNBOverloadInformation *message,
1353                       ProtobufCAllocator *allocator)
1354 {
1355   if(!message)
1356     return;
1357   assert(message->base.descriptor == &streaming_protobufs__gnboverload_information__descriptor);
1358   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1359 }
1360 void   streaming_protobufs__criticality_diagnostics__init
1361                      (StreamingProtobufs__CriticalityDiagnostics         *message)
1362 {
1363   static const StreamingProtobufs__CriticalityDiagnostics init_value = STREAMING_PROTOBUFS__CRITICALITY_DIAGNOSTICS__INIT;
1364   *message = init_value;
1365 }
1366 size_t streaming_protobufs__criticality_diagnostics__get_packed_size
1367                      (const StreamingProtobufs__CriticalityDiagnostics *message)
1368 {
1369   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__descriptor);
1370   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1371 }
1372 size_t streaming_protobufs__criticality_diagnostics__pack
1373                      (const StreamingProtobufs__CriticalityDiagnostics *message,
1374                       uint8_t       *out)
1375 {
1376   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__descriptor);
1377   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1378 }
1379 size_t streaming_protobufs__criticality_diagnostics__pack_to_buffer
1380                      (const StreamingProtobufs__CriticalityDiagnostics *message,
1381                       ProtobufCBuffer *buffer)
1382 {
1383   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__descriptor);
1384   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1385 }
1386 StreamingProtobufs__CriticalityDiagnostics *
1387        streaming_protobufs__criticality_diagnostics__unpack
1388                      (ProtobufCAllocator  *allocator,
1389                       size_t               len,
1390                       const uint8_t       *data)
1391 {
1392   return (StreamingProtobufs__CriticalityDiagnostics *)
1393      protobuf_c_message_unpack (&streaming_protobufs__criticality_diagnostics__descriptor,
1394                                 allocator, len, data);
1395 }
1396 void   streaming_protobufs__criticality_diagnostics__free_unpacked
1397                      (StreamingProtobufs__CriticalityDiagnostics *message,
1398                       ProtobufCAllocator *allocator)
1399 {
1400   if(!message)
1401     return;
1402   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__descriptor);
1403   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1404 }
1405 void   streaming_protobufs__triggering_message__init
1406                      (StreamingProtobufs__TriggeringMessage         *message)
1407 {
1408   static const StreamingProtobufs__TriggeringMessage init_value = STREAMING_PROTOBUFS__TRIGGERING_MESSAGE__INIT;
1409   *message = init_value;
1410 }
1411 size_t streaming_protobufs__triggering_message__get_packed_size
1412                      (const StreamingProtobufs__TriggeringMessage *message)
1413 {
1414   assert(message->base.descriptor == &streaming_protobufs__triggering_message__descriptor);
1415   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1416 }
1417 size_t streaming_protobufs__triggering_message__pack
1418                      (const StreamingProtobufs__TriggeringMessage *message,
1419                       uint8_t       *out)
1420 {
1421   assert(message->base.descriptor == &streaming_protobufs__triggering_message__descriptor);
1422   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1423 }
1424 size_t streaming_protobufs__triggering_message__pack_to_buffer
1425                      (const StreamingProtobufs__TriggeringMessage *message,
1426                       ProtobufCBuffer *buffer)
1427 {
1428   assert(message->base.descriptor == &streaming_protobufs__triggering_message__descriptor);
1429   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1430 }
1431 StreamingProtobufs__TriggeringMessage *
1432        streaming_protobufs__triggering_message__unpack
1433                      (ProtobufCAllocator  *allocator,
1434                       size_t               len,
1435                       const uint8_t       *data)
1436 {
1437   return (StreamingProtobufs__TriggeringMessage *)
1438      protobuf_c_message_unpack (&streaming_protobufs__triggering_message__descriptor,
1439                                 allocator, len, data);
1440 }
1441 void   streaming_protobufs__triggering_message__free_unpacked
1442                      (StreamingProtobufs__TriggeringMessage *message,
1443                       ProtobufCAllocator *allocator)
1444 {
1445   if(!message)
1446     return;
1447   assert(message->base.descriptor == &streaming_protobufs__triggering_message__descriptor);
1448   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1449 }
1450 void   streaming_protobufs__criticality__init
1451                      (StreamingProtobufs__Criticality         *message)
1452 {
1453   static const StreamingProtobufs__Criticality init_value = STREAMING_PROTOBUFS__CRITICALITY__INIT;
1454   *message = init_value;
1455 }
1456 size_t streaming_protobufs__criticality__get_packed_size
1457                      (const StreamingProtobufs__Criticality *message)
1458 {
1459   assert(message->base.descriptor == &streaming_protobufs__criticality__descriptor);
1460   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1461 }
1462 size_t streaming_protobufs__criticality__pack
1463                      (const StreamingProtobufs__Criticality *message,
1464                       uint8_t       *out)
1465 {
1466   assert(message->base.descriptor == &streaming_protobufs__criticality__descriptor);
1467   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1468 }
1469 size_t streaming_protobufs__criticality__pack_to_buffer
1470                      (const StreamingProtobufs__Criticality *message,
1471                       ProtobufCBuffer *buffer)
1472 {
1473   assert(message->base.descriptor == &streaming_protobufs__criticality__descriptor);
1474   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1475 }
1476 StreamingProtobufs__Criticality *
1477        streaming_protobufs__criticality__unpack
1478                      (ProtobufCAllocator  *allocator,
1479                       size_t               len,
1480                       const uint8_t       *data)
1481 {
1482   return (StreamingProtobufs__Criticality *)
1483      protobuf_c_message_unpack (&streaming_protobufs__criticality__descriptor,
1484                                 allocator, len, data);
1485 }
1486 void   streaming_protobufs__criticality__free_unpacked
1487                      (StreamingProtobufs__Criticality *message,
1488                       ProtobufCAllocator *allocator)
1489 {
1490   if(!message)
1491     return;
1492   assert(message->base.descriptor == &streaming_protobufs__criticality__descriptor);
1493   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1494 }
1495 void   streaming_protobufs__criticality_diagnostics__ie__list__init
1496                      (StreamingProtobufs__CriticalityDiagnosticsIEList         *message)
1497 {
1498   static const StreamingProtobufs__CriticalityDiagnosticsIEList init_value = STREAMING_PROTOBUFS__CRITICALITY_DIAGNOSTICS__IE__LIST__INIT;
1499   *message = init_value;
1500 }
1501 size_t streaming_protobufs__criticality_diagnostics__ie__list__get_packed_size
1502                      (const StreamingProtobufs__CriticalityDiagnosticsIEList *message)
1503 {
1504   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__descriptor);
1505   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1506 }
1507 size_t streaming_protobufs__criticality_diagnostics__ie__list__pack
1508                      (const StreamingProtobufs__CriticalityDiagnosticsIEList *message,
1509                       uint8_t       *out)
1510 {
1511   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__descriptor);
1512   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1513 }
1514 size_t streaming_protobufs__criticality_diagnostics__ie__list__pack_to_buffer
1515                      (const StreamingProtobufs__CriticalityDiagnosticsIEList *message,
1516                       ProtobufCBuffer *buffer)
1517 {
1518   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__descriptor);
1519   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1520 }
1521 StreamingProtobufs__CriticalityDiagnosticsIEList *
1522        streaming_protobufs__criticality_diagnostics__ie__list__unpack
1523                      (ProtobufCAllocator  *allocator,
1524                       size_t               len,
1525                       const uint8_t       *data)
1526 {
1527   return (StreamingProtobufs__CriticalityDiagnosticsIEList *)
1528      protobuf_c_message_unpack (&streaming_protobufs__criticality_diagnostics__ie__list__descriptor,
1529                                 allocator, len, data);
1530 }
1531 void   streaming_protobufs__criticality_diagnostics__ie__list__free_unpacked
1532                      (StreamingProtobufs__CriticalityDiagnosticsIEList *message,
1533                       ProtobufCAllocator *allocator)
1534 {
1535   if(!message)
1536     return;
1537   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__descriptor);
1538   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1539 }
1540 void   streaming_protobufs__criticality_diagnostics__ie__list__item__init
1541                      (StreamingProtobufs__CriticalityDiagnosticsIEListItem         *message)
1542 {
1543   static const StreamingProtobufs__CriticalityDiagnosticsIEListItem init_value = STREAMING_PROTOBUFS__CRITICALITY_DIAGNOSTICS__IE__LIST__ITEM__INIT;
1544   *message = init_value;
1545 }
1546 size_t streaming_protobufs__criticality_diagnostics__ie__list__item__get_packed_size
1547                      (const StreamingProtobufs__CriticalityDiagnosticsIEListItem *message)
1548 {
1549   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor);
1550   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1551 }
1552 size_t streaming_protobufs__criticality_diagnostics__ie__list__item__pack
1553                      (const StreamingProtobufs__CriticalityDiagnosticsIEListItem *message,
1554                       uint8_t       *out)
1555 {
1556   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor);
1557   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1558 }
1559 size_t streaming_protobufs__criticality_diagnostics__ie__list__item__pack_to_buffer
1560                      (const StreamingProtobufs__CriticalityDiagnosticsIEListItem *message,
1561                       ProtobufCBuffer *buffer)
1562 {
1563   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor);
1564   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1565 }
1566 StreamingProtobufs__CriticalityDiagnosticsIEListItem *
1567        streaming_protobufs__criticality_diagnostics__ie__list__item__unpack
1568                      (ProtobufCAllocator  *allocator,
1569                       size_t               len,
1570                       const uint8_t       *data)
1571 {
1572   return (StreamingProtobufs__CriticalityDiagnosticsIEListItem *)
1573      protobuf_c_message_unpack (&streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor,
1574                                 allocator, len, data);
1575 }
1576 void   streaming_protobufs__criticality_diagnostics__ie__list__item__free_unpacked
1577                      (StreamingProtobufs__CriticalityDiagnosticsIEListItem *message,
1578                       ProtobufCAllocator *allocator)
1579 {
1580   if(!message)
1581     return;
1582   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor);
1583   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1584 }
1585 void   streaming_protobufs__type_of_error__init
1586                      (StreamingProtobufs__TypeOfError         *message)
1587 {
1588   static const StreamingProtobufs__TypeOfError init_value = STREAMING_PROTOBUFS__TYPE_OF_ERROR__INIT;
1589   *message = init_value;
1590 }
1591 size_t streaming_protobufs__type_of_error__get_packed_size
1592                      (const StreamingProtobufs__TypeOfError *message)
1593 {
1594   assert(message->base.descriptor == &streaming_protobufs__type_of_error__descriptor);
1595   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1596 }
1597 size_t streaming_protobufs__type_of_error__pack
1598                      (const StreamingProtobufs__TypeOfError *message,
1599                       uint8_t       *out)
1600 {
1601   assert(message->base.descriptor == &streaming_protobufs__type_of_error__descriptor);
1602   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1603 }
1604 size_t streaming_protobufs__type_of_error__pack_to_buffer
1605                      (const StreamingProtobufs__TypeOfError *message,
1606                       ProtobufCBuffer *buffer)
1607 {
1608   assert(message->base.descriptor == &streaming_protobufs__type_of_error__descriptor);
1609   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1610 }
1611 StreamingProtobufs__TypeOfError *
1612        streaming_protobufs__type_of_error__unpack
1613                      (ProtobufCAllocator  *allocator,
1614                       size_t               len,
1615                       const uint8_t       *data)
1616 {
1617   return (StreamingProtobufs__TypeOfError *)
1618      protobuf_c_message_unpack (&streaming_protobufs__type_of_error__descriptor,
1619                                 allocator, len, data);
1620 }
1621 void   streaming_protobufs__type_of_error__free_unpacked
1622                      (StreamingProtobufs__TypeOfError *message,
1623                       ProtobufCAllocator *allocator)
1624 {
1625   if(!message)
1626     return;
1627   assert(message->base.descriptor == &streaming_protobufs__type_of_error__descriptor);
1628   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1629 }
1630 void   streaming_protobufs__criticality_diagnostics__ext_ies__init
1631                      (StreamingProtobufs__CriticalityDiagnosticsExtIEs         *message)
1632 {
1633   static const StreamingProtobufs__CriticalityDiagnosticsExtIEs init_value = STREAMING_PROTOBUFS__CRITICALITY_DIAGNOSTICS__EXT_IES__INIT;
1634   *message = init_value;
1635 }
1636 size_t streaming_protobufs__criticality_diagnostics__ext_ies__get_packed_size
1637                      (const StreamingProtobufs__CriticalityDiagnosticsExtIEs *message)
1638 {
1639   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ext_ies__descriptor);
1640   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1641 }
1642 size_t streaming_protobufs__criticality_diagnostics__ext_ies__pack
1643                      (const StreamingProtobufs__CriticalityDiagnosticsExtIEs *message,
1644                       uint8_t       *out)
1645 {
1646   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ext_ies__descriptor);
1647   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1648 }
1649 size_t streaming_protobufs__criticality_diagnostics__ext_ies__pack_to_buffer
1650                      (const StreamingProtobufs__CriticalityDiagnosticsExtIEs *message,
1651                       ProtobufCBuffer *buffer)
1652 {
1653   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ext_ies__descriptor);
1654   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1655 }
1656 StreamingProtobufs__CriticalityDiagnosticsExtIEs *
1657        streaming_protobufs__criticality_diagnostics__ext_ies__unpack
1658                      (ProtobufCAllocator  *allocator,
1659                       size_t               len,
1660                       const uint8_t       *data)
1661 {
1662   return (StreamingProtobufs__CriticalityDiagnosticsExtIEs *)
1663      protobuf_c_message_unpack (&streaming_protobufs__criticality_diagnostics__ext_ies__descriptor,
1664                                 allocator, len, data);
1665 }
1666 void   streaming_protobufs__criticality_diagnostics__ext_ies__free_unpacked
1667                      (StreamingProtobufs__CriticalityDiagnosticsExtIEs *message,
1668                       ProtobufCAllocator *allocator)
1669 {
1670   if(!message)
1671     return;
1672   assert(message->base.descriptor == &streaming_protobufs__criticality_diagnostics__ext_ies__descriptor);
1673   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1674 }
1675 void   streaming_protobufs__sg_nbresource_coordination_information__init
1676                      (StreamingProtobufs__SgNBResourceCoordinationInformation         *message)
1677 {
1678   static const StreamingProtobufs__SgNBResourceCoordinationInformation init_value = STREAMING_PROTOBUFS__SG_NBRESOURCE_COORDINATION_INFORMATION__INIT;
1679   *message = init_value;
1680 }
1681 size_t streaming_protobufs__sg_nbresource_coordination_information__get_packed_size
1682                      (const StreamingProtobufs__SgNBResourceCoordinationInformation *message)
1683 {
1684   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information__descriptor);
1685   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1686 }
1687 size_t streaming_protobufs__sg_nbresource_coordination_information__pack
1688                      (const StreamingProtobufs__SgNBResourceCoordinationInformation *message,
1689                       uint8_t       *out)
1690 {
1691   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information__descriptor);
1692   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1693 }
1694 size_t streaming_protobufs__sg_nbresource_coordination_information__pack_to_buffer
1695                      (const StreamingProtobufs__SgNBResourceCoordinationInformation *message,
1696                       ProtobufCBuffer *buffer)
1697 {
1698   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information__descriptor);
1699   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1700 }
1701 StreamingProtobufs__SgNBResourceCoordinationInformation *
1702        streaming_protobufs__sg_nbresource_coordination_information__unpack
1703                      (ProtobufCAllocator  *allocator,
1704                       size_t               len,
1705                       const uint8_t       *data)
1706 {
1707   return (StreamingProtobufs__SgNBResourceCoordinationInformation *)
1708      protobuf_c_message_unpack (&streaming_protobufs__sg_nbresource_coordination_information__descriptor,
1709                                 allocator, len, data);
1710 }
1711 void   streaming_protobufs__sg_nbresource_coordination_information__free_unpacked
1712                      (StreamingProtobufs__SgNBResourceCoordinationInformation *message,
1713                       ProtobufCAllocator *allocator)
1714 {
1715   if(!message)
1716     return;
1717   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information__descriptor);
1718   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1719 }
1720 void   streaming_protobufs__sg_nbresource_coordination_information_ext_ies__init
1721                      (StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs         *message)
1722 {
1723   static const StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs init_value = STREAMING_PROTOBUFS__SG_NBRESOURCE_COORDINATION_INFORMATION_EXT_IES__INIT;
1724   *message = init_value;
1725 }
1726 size_t streaming_protobufs__sg_nbresource_coordination_information_ext_ies__get_packed_size
1727                      (const StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs *message)
1728 {
1729   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor);
1730   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1731 }
1732 size_t streaming_protobufs__sg_nbresource_coordination_information_ext_ies__pack
1733                      (const StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs *message,
1734                       uint8_t       *out)
1735 {
1736   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor);
1737   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1738 }
1739 size_t streaming_protobufs__sg_nbresource_coordination_information_ext_ies__pack_to_buffer
1740                      (const StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs *message,
1741                       ProtobufCBuffer *buffer)
1742 {
1743   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor);
1744   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1745 }
1746 StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs *
1747        streaming_protobufs__sg_nbresource_coordination_information_ext_ies__unpack
1748                      (ProtobufCAllocator  *allocator,
1749                       size_t               len,
1750                       const uint8_t       *data)
1751 {
1752   return (StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs *)
1753      protobuf_c_message_unpack (&streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor,
1754                                 allocator, len, data);
1755 }
1756 void   streaming_protobufs__sg_nbresource_coordination_information_ext_ies__free_unpacked
1757                      (StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs *message,
1758                       ProtobufCAllocator *allocator)
1759 {
1760   if(!message)
1761     return;
1762   assert(message->base.descriptor == &streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor);
1763   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1764 }
1765 void   streaming_protobufs__sg_nbcoordination_assistance_information__init
1766                      (StreamingProtobufs__SgNBCoordinationAssistanceInformation         *message)
1767 {
1768   static const StreamingProtobufs__SgNBCoordinationAssistanceInformation init_value = STREAMING_PROTOBUFS__SG_NBCOORDINATION_ASSISTANCE_INFORMATION__INIT;
1769   *message = init_value;
1770 }
1771 size_t streaming_protobufs__sg_nbcoordination_assistance_information__get_packed_size
1772                      (const StreamingProtobufs__SgNBCoordinationAssistanceInformation *message)
1773 {
1774   assert(message->base.descriptor == &streaming_protobufs__sg_nbcoordination_assistance_information__descriptor);
1775   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1776 }
1777 size_t streaming_protobufs__sg_nbcoordination_assistance_information__pack
1778                      (const StreamingProtobufs__SgNBCoordinationAssistanceInformation *message,
1779                       uint8_t       *out)
1780 {
1781   assert(message->base.descriptor == &streaming_protobufs__sg_nbcoordination_assistance_information__descriptor);
1782   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1783 }
1784 size_t streaming_protobufs__sg_nbcoordination_assistance_information__pack_to_buffer
1785                      (const StreamingProtobufs__SgNBCoordinationAssistanceInformation *message,
1786                       ProtobufCBuffer *buffer)
1787 {
1788   assert(message->base.descriptor == &streaming_protobufs__sg_nbcoordination_assistance_information__descriptor);
1789   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1790 }
1791 StreamingProtobufs__SgNBCoordinationAssistanceInformation *
1792        streaming_protobufs__sg_nbcoordination_assistance_information__unpack
1793                      (ProtobufCAllocator  *allocator,
1794                       size_t               len,
1795                       const uint8_t       *data)
1796 {
1797   return (StreamingProtobufs__SgNBCoordinationAssistanceInformation *)
1798      protobuf_c_message_unpack (&streaming_protobufs__sg_nbcoordination_assistance_information__descriptor,
1799                                 allocator, len, data);
1800 }
1801 void   streaming_protobufs__sg_nbcoordination_assistance_information__free_unpacked
1802                      (StreamingProtobufs__SgNBCoordinationAssistanceInformation *message,
1803                       ProtobufCAllocator *allocator)
1804 {
1805   if(!message)
1806     return;
1807   assert(message->base.descriptor == &streaming_protobufs__sg_nbcoordination_assistance_information__descriptor);
1808   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1809 }
1810 void   streaming_protobufs__rrc__config__ind__init
1811                      (StreamingProtobufs__RRCConfigInd         *message)
1812 {
1813   static const StreamingProtobufs__RRCConfigInd init_value = STREAMING_PROTOBUFS__RRC__CONFIG__IND__INIT;
1814   *message = init_value;
1815 }
1816 size_t streaming_protobufs__rrc__config__ind__get_packed_size
1817                      (const StreamingProtobufs__RRCConfigInd *message)
1818 {
1819   assert(message->base.descriptor == &streaming_protobufs__rrc__config__ind__descriptor);
1820   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1821 }
1822 size_t streaming_protobufs__rrc__config__ind__pack
1823                      (const StreamingProtobufs__RRCConfigInd *message,
1824                       uint8_t       *out)
1825 {
1826   assert(message->base.descriptor == &streaming_protobufs__rrc__config__ind__descriptor);
1827   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1828 }
1829 size_t streaming_protobufs__rrc__config__ind__pack_to_buffer
1830                      (const StreamingProtobufs__RRCConfigInd *message,
1831                       ProtobufCBuffer *buffer)
1832 {
1833   assert(message->base.descriptor == &streaming_protobufs__rrc__config__ind__descriptor);
1834   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1835 }
1836 StreamingProtobufs__RRCConfigInd *
1837        streaming_protobufs__rrc__config__ind__unpack
1838                      (ProtobufCAllocator  *allocator,
1839                       size_t               len,
1840                       const uint8_t       *data)
1841 {
1842   return (StreamingProtobufs__RRCConfigInd *)
1843      protobuf_c_message_unpack (&streaming_protobufs__rrc__config__ind__descriptor,
1844                                 allocator, len, data);
1845 }
1846 void   streaming_protobufs__rrc__config__ind__free_unpacked
1847                      (StreamingProtobufs__RRCConfigInd *message,
1848                       ProtobufCAllocator *allocator)
1849 {
1850   if(!message)
1851     return;
1852   assert(message->base.descriptor == &streaming_protobufs__rrc__config__ind__descriptor);
1853   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1854 }
1855 void   streaming_protobufs__handover_restriction_list__init
1856                      (StreamingProtobufs__HandoverRestrictionList         *message)
1857 {
1858   static const StreamingProtobufs__HandoverRestrictionList init_value = STREAMING_PROTOBUFS__HANDOVER_RESTRICTION_LIST__INIT;
1859   *message = init_value;
1860 }
1861 size_t streaming_protobufs__handover_restriction_list__get_packed_size
1862                      (const StreamingProtobufs__HandoverRestrictionList *message)
1863 {
1864   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__descriptor);
1865   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1866 }
1867 size_t streaming_protobufs__handover_restriction_list__pack
1868                      (const StreamingProtobufs__HandoverRestrictionList *message,
1869                       uint8_t       *out)
1870 {
1871   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__descriptor);
1872   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1873 }
1874 size_t streaming_protobufs__handover_restriction_list__pack_to_buffer
1875                      (const StreamingProtobufs__HandoverRestrictionList *message,
1876                       ProtobufCBuffer *buffer)
1877 {
1878   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__descriptor);
1879   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1880 }
1881 StreamingProtobufs__HandoverRestrictionList *
1882        streaming_protobufs__handover_restriction_list__unpack
1883                      (ProtobufCAllocator  *allocator,
1884                       size_t               len,
1885                       const uint8_t       *data)
1886 {
1887   return (StreamingProtobufs__HandoverRestrictionList *)
1888      protobuf_c_message_unpack (&streaming_protobufs__handover_restriction_list__descriptor,
1889                                 allocator, len, data);
1890 }
1891 void   streaming_protobufs__handover_restriction_list__free_unpacked
1892                      (StreamingProtobufs__HandoverRestrictionList *message,
1893                       ProtobufCAllocator *allocator)
1894 {
1895   if(!message)
1896     return;
1897   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__descriptor);
1898   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1899 }
1900 void   streaming_protobufs__eplmns__init
1901                      (StreamingProtobufs__EPLMNs         *message)
1902 {
1903   static const StreamingProtobufs__EPLMNs init_value = STREAMING_PROTOBUFS__EPLMNS__INIT;
1904   *message = init_value;
1905 }
1906 size_t streaming_protobufs__eplmns__get_packed_size
1907                      (const StreamingProtobufs__EPLMNs *message)
1908 {
1909   assert(message->base.descriptor == &streaming_protobufs__eplmns__descriptor);
1910   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1911 }
1912 size_t streaming_protobufs__eplmns__pack
1913                      (const StreamingProtobufs__EPLMNs *message,
1914                       uint8_t       *out)
1915 {
1916   assert(message->base.descriptor == &streaming_protobufs__eplmns__descriptor);
1917   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1918 }
1919 size_t streaming_protobufs__eplmns__pack_to_buffer
1920                      (const StreamingProtobufs__EPLMNs *message,
1921                       ProtobufCBuffer *buffer)
1922 {
1923   assert(message->base.descriptor == &streaming_protobufs__eplmns__descriptor);
1924   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1925 }
1926 StreamingProtobufs__EPLMNs *
1927        streaming_protobufs__eplmns__unpack
1928                      (ProtobufCAllocator  *allocator,
1929                       size_t               len,
1930                       const uint8_t       *data)
1931 {
1932   return (StreamingProtobufs__EPLMNs *)
1933      protobuf_c_message_unpack (&streaming_protobufs__eplmns__descriptor,
1934                                 allocator, len, data);
1935 }
1936 void   streaming_protobufs__eplmns__free_unpacked
1937                      (StreamingProtobufs__EPLMNs *message,
1938                       ProtobufCAllocator *allocator)
1939 {
1940   if(!message)
1941     return;
1942   assert(message->base.descriptor == &streaming_protobufs__eplmns__descriptor);
1943   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1944 }
1945 void   streaming_protobufs__forbidden_tas__init
1946                      (StreamingProtobufs__ForbiddenTAs         *message)
1947 {
1948   static const StreamingProtobufs__ForbiddenTAs init_value = STREAMING_PROTOBUFS__FORBIDDEN_TAS__INIT;
1949   *message = init_value;
1950 }
1951 size_t streaming_protobufs__forbidden_tas__get_packed_size
1952                      (const StreamingProtobufs__ForbiddenTAs *message)
1953 {
1954   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__descriptor);
1955   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1956 }
1957 size_t streaming_protobufs__forbidden_tas__pack
1958                      (const StreamingProtobufs__ForbiddenTAs *message,
1959                       uint8_t       *out)
1960 {
1961   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__descriptor);
1962   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1963 }
1964 size_t streaming_protobufs__forbidden_tas__pack_to_buffer
1965                      (const StreamingProtobufs__ForbiddenTAs *message,
1966                       ProtobufCBuffer *buffer)
1967 {
1968   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__descriptor);
1969   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1970 }
1971 StreamingProtobufs__ForbiddenTAs *
1972        streaming_protobufs__forbidden_tas__unpack
1973                      (ProtobufCAllocator  *allocator,
1974                       size_t               len,
1975                       const uint8_t       *data)
1976 {
1977   return (StreamingProtobufs__ForbiddenTAs *)
1978      protobuf_c_message_unpack (&streaming_protobufs__forbidden_tas__descriptor,
1979                                 allocator, len, data);
1980 }
1981 void   streaming_protobufs__forbidden_tas__free_unpacked
1982                      (StreamingProtobufs__ForbiddenTAs *message,
1983                       ProtobufCAllocator *allocator)
1984 {
1985   if(!message)
1986     return;
1987   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__descriptor);
1988   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1989 }
1990 void   streaming_protobufs__forbidden_tas__item__init
1991                      (StreamingProtobufs__ForbiddenTAsItem         *message)
1992 {
1993   static const StreamingProtobufs__ForbiddenTAsItem init_value = STREAMING_PROTOBUFS__FORBIDDEN_TAS__ITEM__INIT;
1994   *message = init_value;
1995 }
1996 size_t streaming_protobufs__forbidden_tas__item__get_packed_size
1997                      (const StreamingProtobufs__ForbiddenTAsItem *message)
1998 {
1999   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__item__descriptor);
2000   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2001 }
2002 size_t streaming_protobufs__forbidden_tas__item__pack
2003                      (const StreamingProtobufs__ForbiddenTAsItem *message,
2004                       uint8_t       *out)
2005 {
2006   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__item__descriptor);
2007   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2008 }
2009 size_t streaming_protobufs__forbidden_tas__item__pack_to_buffer
2010                      (const StreamingProtobufs__ForbiddenTAsItem *message,
2011                       ProtobufCBuffer *buffer)
2012 {
2013   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__item__descriptor);
2014   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2015 }
2016 StreamingProtobufs__ForbiddenTAsItem *
2017        streaming_protobufs__forbidden_tas__item__unpack
2018                      (ProtobufCAllocator  *allocator,
2019                       size_t               len,
2020                       const uint8_t       *data)
2021 {
2022   return (StreamingProtobufs__ForbiddenTAsItem *)
2023      protobuf_c_message_unpack (&streaming_protobufs__forbidden_tas__item__descriptor,
2024                                 allocator, len, data);
2025 }
2026 void   streaming_protobufs__forbidden_tas__item__free_unpacked
2027                      (StreamingProtobufs__ForbiddenTAsItem *message,
2028                       ProtobufCAllocator *allocator)
2029 {
2030   if(!message)
2031     return;
2032   assert(message->base.descriptor == &streaming_protobufs__forbidden_tas__item__descriptor);
2033   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2034 }
2035 void   streaming_protobufs__forbidden_tacs__init
2036                      (StreamingProtobufs__ForbiddenTACs         *message)
2037 {
2038   static const StreamingProtobufs__ForbiddenTACs init_value = STREAMING_PROTOBUFS__FORBIDDEN_TACS__INIT;
2039   *message = init_value;
2040 }
2041 size_t streaming_protobufs__forbidden_tacs__get_packed_size
2042                      (const StreamingProtobufs__ForbiddenTACs *message)
2043 {
2044   assert(message->base.descriptor == &streaming_protobufs__forbidden_tacs__descriptor);
2045   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2046 }
2047 size_t streaming_protobufs__forbidden_tacs__pack
2048                      (const StreamingProtobufs__ForbiddenTACs *message,
2049                       uint8_t       *out)
2050 {
2051   assert(message->base.descriptor == &streaming_protobufs__forbidden_tacs__descriptor);
2052   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2053 }
2054 size_t streaming_protobufs__forbidden_tacs__pack_to_buffer
2055                      (const StreamingProtobufs__ForbiddenTACs *message,
2056                       ProtobufCBuffer *buffer)
2057 {
2058   assert(message->base.descriptor == &streaming_protobufs__forbidden_tacs__descriptor);
2059   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2060 }
2061 StreamingProtobufs__ForbiddenTACs *
2062        streaming_protobufs__forbidden_tacs__unpack
2063                      (ProtobufCAllocator  *allocator,
2064                       size_t               len,
2065                       const uint8_t       *data)
2066 {
2067   return (StreamingProtobufs__ForbiddenTACs *)
2068      protobuf_c_message_unpack (&streaming_protobufs__forbidden_tacs__descriptor,
2069                                 allocator, len, data);
2070 }
2071 void   streaming_protobufs__forbidden_tacs__free_unpacked
2072                      (StreamingProtobufs__ForbiddenTACs *message,
2073                       ProtobufCAllocator *allocator)
2074 {
2075   if(!message)
2076     return;
2077   assert(message->base.descriptor == &streaming_protobufs__forbidden_tacs__descriptor);
2078   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2079 }
2080 void   streaming_protobufs__forbidden_las__init
2081                      (StreamingProtobufs__ForbiddenLAs         *message)
2082 {
2083   static const StreamingProtobufs__ForbiddenLAs init_value = STREAMING_PROTOBUFS__FORBIDDEN_LAS__INIT;
2084   *message = init_value;
2085 }
2086 size_t streaming_protobufs__forbidden_las__get_packed_size
2087                      (const StreamingProtobufs__ForbiddenLAs *message)
2088 {
2089   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__descriptor);
2090   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2091 }
2092 size_t streaming_protobufs__forbidden_las__pack
2093                      (const StreamingProtobufs__ForbiddenLAs *message,
2094                       uint8_t       *out)
2095 {
2096   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__descriptor);
2097   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2098 }
2099 size_t streaming_protobufs__forbidden_las__pack_to_buffer
2100                      (const StreamingProtobufs__ForbiddenLAs *message,
2101                       ProtobufCBuffer *buffer)
2102 {
2103   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__descriptor);
2104   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2105 }
2106 StreamingProtobufs__ForbiddenLAs *
2107        streaming_protobufs__forbidden_las__unpack
2108                      (ProtobufCAllocator  *allocator,
2109                       size_t               len,
2110                       const uint8_t       *data)
2111 {
2112   return (StreamingProtobufs__ForbiddenLAs *)
2113      protobuf_c_message_unpack (&streaming_protobufs__forbidden_las__descriptor,
2114                                 allocator, len, data);
2115 }
2116 void   streaming_protobufs__forbidden_las__free_unpacked
2117                      (StreamingProtobufs__ForbiddenLAs *message,
2118                       ProtobufCAllocator *allocator)
2119 {
2120   if(!message)
2121     return;
2122   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__descriptor);
2123   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2124 }
2125 void   streaming_protobufs__forbidden_las__item__init
2126                      (StreamingProtobufs__ForbiddenLAsItem         *message)
2127 {
2128   static const StreamingProtobufs__ForbiddenLAsItem init_value = STREAMING_PROTOBUFS__FORBIDDEN_LAS__ITEM__INIT;
2129   *message = init_value;
2130 }
2131 size_t streaming_protobufs__forbidden_las__item__get_packed_size
2132                      (const StreamingProtobufs__ForbiddenLAsItem *message)
2133 {
2134   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__item__descriptor);
2135   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2136 }
2137 size_t streaming_protobufs__forbidden_las__item__pack
2138                      (const StreamingProtobufs__ForbiddenLAsItem *message,
2139                       uint8_t       *out)
2140 {
2141   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__item__descriptor);
2142   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2143 }
2144 size_t streaming_protobufs__forbidden_las__item__pack_to_buffer
2145                      (const StreamingProtobufs__ForbiddenLAsItem *message,
2146                       ProtobufCBuffer *buffer)
2147 {
2148   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__item__descriptor);
2149   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2150 }
2151 StreamingProtobufs__ForbiddenLAsItem *
2152        streaming_protobufs__forbidden_las__item__unpack
2153                      (ProtobufCAllocator  *allocator,
2154                       size_t               len,
2155                       const uint8_t       *data)
2156 {
2157   return (StreamingProtobufs__ForbiddenLAsItem *)
2158      protobuf_c_message_unpack (&streaming_protobufs__forbidden_las__item__descriptor,
2159                                 allocator, len, data);
2160 }
2161 void   streaming_protobufs__forbidden_las__item__free_unpacked
2162                      (StreamingProtobufs__ForbiddenLAsItem *message,
2163                       ProtobufCAllocator *allocator)
2164 {
2165   if(!message)
2166     return;
2167   assert(message->base.descriptor == &streaming_protobufs__forbidden_las__item__descriptor);
2168   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2169 }
2170 void   streaming_protobufs__forbidden_lacs__init
2171                      (StreamingProtobufs__ForbiddenLACs         *message)
2172 {
2173   static const StreamingProtobufs__ForbiddenLACs init_value = STREAMING_PROTOBUFS__FORBIDDEN_LACS__INIT;
2174   *message = init_value;
2175 }
2176 size_t streaming_protobufs__forbidden_lacs__get_packed_size
2177                      (const StreamingProtobufs__ForbiddenLACs *message)
2178 {
2179   assert(message->base.descriptor == &streaming_protobufs__forbidden_lacs__descriptor);
2180   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2181 }
2182 size_t streaming_protobufs__forbidden_lacs__pack
2183                      (const StreamingProtobufs__ForbiddenLACs *message,
2184                       uint8_t       *out)
2185 {
2186   assert(message->base.descriptor == &streaming_protobufs__forbidden_lacs__descriptor);
2187   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2188 }
2189 size_t streaming_protobufs__forbidden_lacs__pack_to_buffer
2190                      (const StreamingProtobufs__ForbiddenLACs *message,
2191                       ProtobufCBuffer *buffer)
2192 {
2193   assert(message->base.descriptor == &streaming_protobufs__forbidden_lacs__descriptor);
2194   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2195 }
2196 StreamingProtobufs__ForbiddenLACs *
2197        streaming_protobufs__forbidden_lacs__unpack
2198                      (ProtobufCAllocator  *allocator,
2199                       size_t               len,
2200                       const uint8_t       *data)
2201 {
2202   return (StreamingProtobufs__ForbiddenLACs *)
2203      protobuf_c_message_unpack (&streaming_protobufs__forbidden_lacs__descriptor,
2204                                 allocator, len, data);
2205 }
2206 void   streaming_protobufs__forbidden_lacs__free_unpacked
2207                      (StreamingProtobufs__ForbiddenLACs *message,
2208                       ProtobufCAllocator *allocator)
2209 {
2210   if(!message)
2211     return;
2212   assert(message->base.descriptor == &streaming_protobufs__forbidden_lacs__descriptor);
2213   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2214 }
2215 void   streaming_protobufs__forbidden_inter_rats__init
2216                      (StreamingProtobufs__ForbiddenInterRATs         *message)
2217 {
2218   static const StreamingProtobufs__ForbiddenInterRATs init_value = STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__INIT;
2219   *message = init_value;
2220 }
2221 size_t streaming_protobufs__forbidden_inter_rats__get_packed_size
2222                      (const StreamingProtobufs__ForbiddenInterRATs *message)
2223 {
2224   assert(message->base.descriptor == &streaming_protobufs__forbidden_inter_rats__descriptor);
2225   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2226 }
2227 size_t streaming_protobufs__forbidden_inter_rats__pack
2228                      (const StreamingProtobufs__ForbiddenInterRATs *message,
2229                       uint8_t       *out)
2230 {
2231   assert(message->base.descriptor == &streaming_protobufs__forbidden_inter_rats__descriptor);
2232   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2233 }
2234 size_t streaming_protobufs__forbidden_inter_rats__pack_to_buffer
2235                      (const StreamingProtobufs__ForbiddenInterRATs *message,
2236                       ProtobufCBuffer *buffer)
2237 {
2238   assert(message->base.descriptor == &streaming_protobufs__forbidden_inter_rats__descriptor);
2239   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2240 }
2241 StreamingProtobufs__ForbiddenInterRATs *
2242        streaming_protobufs__forbidden_inter_rats__unpack
2243                      (ProtobufCAllocator  *allocator,
2244                       size_t               len,
2245                       const uint8_t       *data)
2246 {
2247   return (StreamingProtobufs__ForbiddenInterRATs *)
2248      protobuf_c_message_unpack (&streaming_protobufs__forbidden_inter_rats__descriptor,
2249                                 allocator, len, data);
2250 }
2251 void   streaming_protobufs__forbidden_inter_rats__free_unpacked
2252                      (StreamingProtobufs__ForbiddenInterRATs *message,
2253                       ProtobufCAllocator *allocator)
2254 {
2255   if(!message)
2256     return;
2257   assert(message->base.descriptor == &streaming_protobufs__forbidden_inter_rats__descriptor);
2258   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2259 }
2260 void   streaming_protobufs__handover_restriction_list__ext_ies__init
2261                      (StreamingProtobufs__HandoverRestrictionListExtIEs         *message)
2262 {
2263   static const StreamingProtobufs__HandoverRestrictionListExtIEs init_value = STREAMING_PROTOBUFS__HANDOVER_RESTRICTION_LIST__EXT_IES__INIT;
2264   *message = init_value;
2265 }
2266 size_t streaming_protobufs__handover_restriction_list__ext_ies__get_packed_size
2267                      (const StreamingProtobufs__HandoverRestrictionListExtIEs *message)
2268 {
2269   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__ext_ies__descriptor);
2270   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2271 }
2272 size_t streaming_protobufs__handover_restriction_list__ext_ies__pack
2273                      (const StreamingProtobufs__HandoverRestrictionListExtIEs *message,
2274                       uint8_t       *out)
2275 {
2276   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__ext_ies__descriptor);
2277   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2278 }
2279 size_t streaming_protobufs__handover_restriction_list__ext_ies__pack_to_buffer
2280                      (const StreamingProtobufs__HandoverRestrictionListExtIEs *message,
2281                       ProtobufCBuffer *buffer)
2282 {
2283   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__ext_ies__descriptor);
2284   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2285 }
2286 StreamingProtobufs__HandoverRestrictionListExtIEs *
2287        streaming_protobufs__handover_restriction_list__ext_ies__unpack
2288                      (ProtobufCAllocator  *allocator,
2289                       size_t               len,
2290                       const uint8_t       *data)
2291 {
2292   return (StreamingProtobufs__HandoverRestrictionListExtIEs *)
2293      protobuf_c_message_unpack (&streaming_protobufs__handover_restriction_list__ext_ies__descriptor,
2294                                 allocator, len, data);
2295 }
2296 void   streaming_protobufs__handover_restriction_list__ext_ies__free_unpacked
2297                      (StreamingProtobufs__HandoverRestrictionListExtIEs *message,
2298                       ProtobufCAllocator *allocator)
2299 {
2300   if(!message)
2301     return;
2302   assert(message->base.descriptor == &streaming_protobufs__handover_restriction_list__ext_ies__descriptor);
2303   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2304 }
2305 void   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__init
2306                      (StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT         *message)
2307 {
2308   static const StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT init_value = STREAMING_PROTOBUFS__NRRESTRICTIONIN_EPSAS_SECONDARY_RAT__INIT;
2309   *message = init_value;
2310 }
2311 size_t streaming_protobufs__nrrestrictionin_epsas_secondary_rat__get_packed_size
2312                      (const StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT *message)
2313 {
2314   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor);
2315   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2316 }
2317 size_t streaming_protobufs__nrrestrictionin_epsas_secondary_rat__pack
2318                      (const StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT *message,
2319                       uint8_t       *out)
2320 {
2321   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor);
2322   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2323 }
2324 size_t streaming_protobufs__nrrestrictionin_epsas_secondary_rat__pack_to_buffer
2325                      (const StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT *message,
2326                       ProtobufCBuffer *buffer)
2327 {
2328   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor);
2329   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2330 }
2331 StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT *
2332        streaming_protobufs__nrrestrictionin_epsas_secondary_rat__unpack
2333                      (ProtobufCAllocator  *allocator,
2334                       size_t               len,
2335                       const uint8_t       *data)
2336 {
2337   return (StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT *)
2338      protobuf_c_message_unpack (&streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor,
2339                                 allocator, len, data);
2340 }
2341 void   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__free_unpacked
2342                      (StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT *message,
2343                       ProtobufCAllocator *allocator)
2344 {
2345   if(!message)
2346     return;
2347   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor);
2348   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2349 }
2350 void   streaming_protobufs__cntype_restrictions__init
2351                      (StreamingProtobufs__CNTypeRestrictions         *message)
2352 {
2353   static const StreamingProtobufs__CNTypeRestrictions init_value = STREAMING_PROTOBUFS__CNTYPE_RESTRICTIONS__INIT;
2354   *message = init_value;
2355 }
2356 size_t streaming_protobufs__cntype_restrictions__get_packed_size
2357                      (const StreamingProtobufs__CNTypeRestrictions *message)
2358 {
2359   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions__descriptor);
2360   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2361 }
2362 size_t streaming_protobufs__cntype_restrictions__pack
2363                      (const StreamingProtobufs__CNTypeRestrictions *message,
2364                       uint8_t       *out)
2365 {
2366   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions__descriptor);
2367   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2368 }
2369 size_t streaming_protobufs__cntype_restrictions__pack_to_buffer
2370                      (const StreamingProtobufs__CNTypeRestrictions *message,
2371                       ProtobufCBuffer *buffer)
2372 {
2373   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions__descriptor);
2374   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2375 }
2376 StreamingProtobufs__CNTypeRestrictions *
2377        streaming_protobufs__cntype_restrictions__unpack
2378                      (ProtobufCAllocator  *allocator,
2379                       size_t               len,
2380                       const uint8_t       *data)
2381 {
2382   return (StreamingProtobufs__CNTypeRestrictions *)
2383      protobuf_c_message_unpack (&streaming_protobufs__cntype_restrictions__descriptor,
2384                                 allocator, len, data);
2385 }
2386 void   streaming_protobufs__cntype_restrictions__free_unpacked
2387                      (StreamingProtobufs__CNTypeRestrictions *message,
2388                       ProtobufCAllocator *allocator)
2389 {
2390   if(!message)
2391     return;
2392   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions__descriptor);
2393   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2394 }
2395 void   streaming_protobufs__cntype_restrictions_item__init
2396                      (StreamingProtobufs__CNTypeRestrictionsItem         *message)
2397 {
2398   static const StreamingProtobufs__CNTypeRestrictionsItem init_value = STREAMING_PROTOBUFS__CNTYPE_RESTRICTIONS_ITEM__INIT;
2399   *message = init_value;
2400 }
2401 size_t streaming_protobufs__cntype_restrictions_item__get_packed_size
2402                      (const StreamingProtobufs__CNTypeRestrictionsItem *message)
2403 {
2404   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions_item__descriptor);
2405   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2406 }
2407 size_t streaming_protobufs__cntype_restrictions_item__pack
2408                      (const StreamingProtobufs__CNTypeRestrictionsItem *message,
2409                       uint8_t       *out)
2410 {
2411   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions_item__descriptor);
2412   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2413 }
2414 size_t streaming_protobufs__cntype_restrictions_item__pack_to_buffer
2415                      (const StreamingProtobufs__CNTypeRestrictionsItem *message,
2416                       ProtobufCBuffer *buffer)
2417 {
2418   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions_item__descriptor);
2419   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2420 }
2421 StreamingProtobufs__CNTypeRestrictionsItem *
2422        streaming_protobufs__cntype_restrictions_item__unpack
2423                      (ProtobufCAllocator  *allocator,
2424                       size_t               len,
2425                       const uint8_t       *data)
2426 {
2427   return (StreamingProtobufs__CNTypeRestrictionsItem *)
2428      protobuf_c_message_unpack (&streaming_protobufs__cntype_restrictions_item__descriptor,
2429                                 allocator, len, data);
2430 }
2431 void   streaming_protobufs__cntype_restrictions_item__free_unpacked
2432                      (StreamingProtobufs__CNTypeRestrictionsItem *message,
2433                       ProtobufCAllocator *allocator)
2434 {
2435   if(!message)
2436     return;
2437   assert(message->base.descriptor == &streaming_protobufs__cntype_restrictions_item__descriptor);
2438   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2439 }
2440 void   streaming_protobufs__nrrestrictionin5_gs__init
2441                      (StreamingProtobufs__NRrestrictionin5GS         *message)
2442 {
2443   static const StreamingProtobufs__NRrestrictionin5GS init_value = STREAMING_PROTOBUFS__NRRESTRICTIONIN5_GS__INIT;
2444   *message = init_value;
2445 }
2446 size_t streaming_protobufs__nrrestrictionin5_gs__get_packed_size
2447                      (const StreamingProtobufs__NRrestrictionin5GS *message)
2448 {
2449   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin5_gs__descriptor);
2450   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2451 }
2452 size_t streaming_protobufs__nrrestrictionin5_gs__pack
2453                      (const StreamingProtobufs__NRrestrictionin5GS *message,
2454                       uint8_t       *out)
2455 {
2456   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin5_gs__descriptor);
2457   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2458 }
2459 size_t streaming_protobufs__nrrestrictionin5_gs__pack_to_buffer
2460                      (const StreamingProtobufs__NRrestrictionin5GS *message,
2461                       ProtobufCBuffer *buffer)
2462 {
2463   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin5_gs__descriptor);
2464   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2465 }
2466 StreamingProtobufs__NRrestrictionin5GS *
2467        streaming_protobufs__nrrestrictionin5_gs__unpack
2468                      (ProtobufCAllocator  *allocator,
2469                       size_t               len,
2470                       const uint8_t       *data)
2471 {
2472   return (StreamingProtobufs__NRrestrictionin5GS *)
2473      protobuf_c_message_unpack (&streaming_protobufs__nrrestrictionin5_gs__descriptor,
2474                                 allocator, len, data);
2475 }
2476 void   streaming_protobufs__nrrestrictionin5_gs__free_unpacked
2477                      (StreamingProtobufs__NRrestrictionin5GS *message,
2478                       ProtobufCAllocator *allocator)
2479 {
2480   if(!message)
2481     return;
2482   assert(message->base.descriptor == &streaming_protobufs__nrrestrictionin5_gs__descriptor);
2483   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2484 }
2485 void   streaming_protobufs__nruesecurity_capabilities__init
2486                      (StreamingProtobufs__NRUESecurityCapabilities         *message)
2487 {
2488   static const StreamingProtobufs__NRUESecurityCapabilities init_value = STREAMING_PROTOBUFS__NRUESECURITY_CAPABILITIES__INIT;
2489   *message = init_value;
2490 }
2491 size_t streaming_protobufs__nruesecurity_capabilities__get_packed_size
2492                      (const StreamingProtobufs__NRUESecurityCapabilities *message)
2493 {
2494   assert(message->base.descriptor == &streaming_protobufs__nruesecurity_capabilities__descriptor);
2495   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2496 }
2497 size_t streaming_protobufs__nruesecurity_capabilities__pack
2498                      (const StreamingProtobufs__NRUESecurityCapabilities *message,
2499                       uint8_t       *out)
2500 {
2501   assert(message->base.descriptor == &streaming_protobufs__nruesecurity_capabilities__descriptor);
2502   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2503 }
2504 size_t streaming_protobufs__nruesecurity_capabilities__pack_to_buffer
2505                      (const StreamingProtobufs__NRUESecurityCapabilities *message,
2506                       ProtobufCBuffer *buffer)
2507 {
2508   assert(message->base.descriptor == &streaming_protobufs__nruesecurity_capabilities__descriptor);
2509   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2510 }
2511 StreamingProtobufs__NRUESecurityCapabilities *
2512        streaming_protobufs__nruesecurity_capabilities__unpack
2513                      (ProtobufCAllocator  *allocator,
2514                       size_t               len,
2515                       const uint8_t       *data)
2516 {
2517   return (StreamingProtobufs__NRUESecurityCapabilities *)
2518      protobuf_c_message_unpack (&streaming_protobufs__nruesecurity_capabilities__descriptor,
2519                                 allocator, len, data);
2520 }
2521 void   streaming_protobufs__nruesecurity_capabilities__free_unpacked
2522                      (StreamingProtobufs__NRUESecurityCapabilities *message,
2523                       ProtobufCAllocator *allocator)
2524 {
2525   if(!message)
2526     return;
2527   assert(message->base.descriptor == &streaming_protobufs__nruesecurity_capabilities__descriptor);
2528   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2529 }
2530 void   streaming_protobufs__ueaggregate_maximum_bit_rate__init
2531                      (StreamingProtobufs__UEAggregateMaximumBitRate         *message)
2532 {
2533   static const StreamingProtobufs__UEAggregateMaximumBitRate init_value = STREAMING_PROTOBUFS__UEAGGREGATE_MAXIMUM_BIT_RATE__INIT;
2534   *message = init_value;
2535 }
2536 size_t streaming_protobufs__ueaggregate_maximum_bit_rate__get_packed_size
2537                      (const StreamingProtobufs__UEAggregateMaximumBitRate *message)
2538 {
2539   assert(message->base.descriptor == &streaming_protobufs__ueaggregate_maximum_bit_rate__descriptor);
2540   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2541 }
2542 size_t streaming_protobufs__ueaggregate_maximum_bit_rate__pack
2543                      (const StreamingProtobufs__UEAggregateMaximumBitRate *message,
2544                       uint8_t       *out)
2545 {
2546   assert(message->base.descriptor == &streaming_protobufs__ueaggregate_maximum_bit_rate__descriptor);
2547   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2548 }
2549 size_t streaming_protobufs__ueaggregate_maximum_bit_rate__pack_to_buffer
2550                      (const StreamingProtobufs__UEAggregateMaximumBitRate *message,
2551                       ProtobufCBuffer *buffer)
2552 {
2553   assert(message->base.descriptor == &streaming_protobufs__ueaggregate_maximum_bit_rate__descriptor);
2554   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2555 }
2556 StreamingProtobufs__UEAggregateMaximumBitRate *
2557        streaming_protobufs__ueaggregate_maximum_bit_rate__unpack
2558                      (ProtobufCAllocator  *allocator,
2559                       size_t               len,
2560                       const uint8_t       *data)
2561 {
2562   return (StreamingProtobufs__UEAggregateMaximumBitRate *)
2563      protobuf_c_message_unpack (&streaming_protobufs__ueaggregate_maximum_bit_rate__descriptor,
2564                                 allocator, len, data);
2565 }
2566 void   streaming_protobufs__ueaggregate_maximum_bit_rate__free_unpacked
2567                      (StreamingProtobufs__UEAggregateMaximumBitRate *message,
2568                       ProtobufCAllocator *allocator)
2569 {
2570   if(!message)
2571     return;
2572   assert(message->base.descriptor == &streaming_protobufs__ueaggregate_maximum_bit_rate__descriptor);
2573   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2574 }
2575 void   streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__init
2576                      (StreamingProtobufs__UEAggregateMaximumBitrateExtIEs         *message)
2577 {
2578   static const StreamingProtobufs__UEAggregateMaximumBitrateExtIEs init_value = STREAMING_PROTOBUFS__UEAGGREGATE__MAXIMUM_BITRATE__EXT_IES__INIT;
2579   *message = init_value;
2580 }
2581 size_t streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__get_packed_size
2582                      (const StreamingProtobufs__UEAggregateMaximumBitrateExtIEs *message)
2583 {
2584   assert(message->base.descriptor == &streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor);
2585   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2586 }
2587 size_t streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__pack
2588                      (const StreamingProtobufs__UEAggregateMaximumBitrateExtIEs *message,
2589                       uint8_t       *out)
2590 {
2591   assert(message->base.descriptor == &streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor);
2592   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2593 }
2594 size_t streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__pack_to_buffer
2595                      (const StreamingProtobufs__UEAggregateMaximumBitrateExtIEs *message,
2596                       ProtobufCBuffer *buffer)
2597 {
2598   assert(message->base.descriptor == &streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor);
2599   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2600 }
2601 StreamingProtobufs__UEAggregateMaximumBitrateExtIEs *
2602        streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__unpack
2603                      (ProtobufCAllocator  *allocator,
2604                       size_t               len,
2605                       const uint8_t       *data)
2606 {
2607   return (StreamingProtobufs__UEAggregateMaximumBitrateExtIEs *)
2608      protobuf_c_message_unpack (&streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor,
2609                                 allocator, len, data);
2610 }
2611 void   streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__free_unpacked
2612                      (StreamingProtobufs__UEAggregateMaximumBitrateExtIEs *message,
2613                       ProtobufCAllocator *allocator)
2614 {
2615   if(!message)
2616     return;
2617   assert(message->base.descriptor == &streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor);
2618   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2619 }
2620 void   streaming_protobufs__dl__forwarding__init
2621                      (StreamingProtobufs__DLForwarding         *message)
2622 {
2623   static const StreamingProtobufs__DLForwarding init_value = STREAMING_PROTOBUFS__DL__FORWARDING__INIT;
2624   *message = init_value;
2625 }
2626 size_t streaming_protobufs__dl__forwarding__get_packed_size
2627                      (const StreamingProtobufs__DLForwarding *message)
2628 {
2629   assert(message->base.descriptor == &streaming_protobufs__dl__forwarding__descriptor);
2630   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2631 }
2632 size_t streaming_protobufs__dl__forwarding__pack
2633                      (const StreamingProtobufs__DLForwarding *message,
2634                       uint8_t       *out)
2635 {
2636   assert(message->base.descriptor == &streaming_protobufs__dl__forwarding__descriptor);
2637   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2638 }
2639 size_t streaming_protobufs__dl__forwarding__pack_to_buffer
2640                      (const StreamingProtobufs__DLForwarding *message,
2641                       ProtobufCBuffer *buffer)
2642 {
2643   assert(message->base.descriptor == &streaming_protobufs__dl__forwarding__descriptor);
2644   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2645 }
2646 StreamingProtobufs__DLForwarding *
2647        streaming_protobufs__dl__forwarding__unpack
2648                      (ProtobufCAllocator  *allocator,
2649                       size_t               len,
2650                       const uint8_t       *data)
2651 {
2652   return (StreamingProtobufs__DLForwarding *)
2653      protobuf_c_message_unpack (&streaming_protobufs__dl__forwarding__descriptor,
2654                                 allocator, len, data);
2655 }
2656 void   streaming_protobufs__dl__forwarding__free_unpacked
2657                      (StreamingProtobufs__DLForwarding *message,
2658                       ProtobufCAllocator *allocator)
2659 {
2660   if(!message)
2661     return;
2662   assert(message->base.descriptor == &streaming_protobufs__dl__forwarding__descriptor);
2663   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2664 }
2665 void   streaming_protobufs__duplication_activation__init
2666                      (StreamingProtobufs__DuplicationActivation         *message)
2667 {
2668   static const StreamingProtobufs__DuplicationActivation init_value = STREAMING_PROTOBUFS__DUPLICATION_ACTIVATION__INIT;
2669   *message = init_value;
2670 }
2671 size_t streaming_protobufs__duplication_activation__get_packed_size
2672                      (const StreamingProtobufs__DuplicationActivation *message)
2673 {
2674   assert(message->base.descriptor == &streaming_protobufs__duplication_activation__descriptor);
2675   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2676 }
2677 size_t streaming_protobufs__duplication_activation__pack
2678                      (const StreamingProtobufs__DuplicationActivation *message,
2679                       uint8_t       *out)
2680 {
2681   assert(message->base.descriptor == &streaming_protobufs__duplication_activation__descriptor);
2682   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2683 }
2684 size_t streaming_protobufs__duplication_activation__pack_to_buffer
2685                      (const StreamingProtobufs__DuplicationActivation *message,
2686                       ProtobufCBuffer *buffer)
2687 {
2688   assert(message->base.descriptor == &streaming_protobufs__duplication_activation__descriptor);
2689   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2690 }
2691 StreamingProtobufs__DuplicationActivation *
2692        streaming_protobufs__duplication_activation__unpack
2693                      (ProtobufCAllocator  *allocator,
2694                       size_t               len,
2695                       const uint8_t       *data)
2696 {
2697   return (StreamingProtobufs__DuplicationActivation *)
2698      protobuf_c_message_unpack (&streaming_protobufs__duplication_activation__descriptor,
2699                                 allocator, len, data);
2700 }
2701 void   streaming_protobufs__duplication_activation__free_unpacked
2702                      (StreamingProtobufs__DuplicationActivation *message,
2703                       ProtobufCAllocator *allocator)
2704 {
2705   if(!message)
2706     return;
2707   assert(message->base.descriptor == &streaming_protobufs__duplication_activation__descriptor);
2708   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2709 }
2710 void   streaming_protobufs__me_nbresource_coordination_information__init
2711                      (StreamingProtobufs__MeNBResourceCoordinationInformation         *message)
2712 {
2713   static const StreamingProtobufs__MeNBResourceCoordinationInformation init_value = STREAMING_PROTOBUFS__ME_NBRESOURCE_COORDINATION_INFORMATION__INIT;
2714   *message = init_value;
2715 }
2716 size_t streaming_protobufs__me_nbresource_coordination_information__get_packed_size
2717                      (const StreamingProtobufs__MeNBResourceCoordinationInformation *message)
2718 {
2719   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information__descriptor);
2720   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2721 }
2722 size_t streaming_protobufs__me_nbresource_coordination_information__pack
2723                      (const StreamingProtobufs__MeNBResourceCoordinationInformation *message,
2724                       uint8_t       *out)
2725 {
2726   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information__descriptor);
2727   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2728 }
2729 size_t streaming_protobufs__me_nbresource_coordination_information__pack_to_buffer
2730                      (const StreamingProtobufs__MeNBResourceCoordinationInformation *message,
2731                       ProtobufCBuffer *buffer)
2732 {
2733   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information__descriptor);
2734   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2735 }
2736 StreamingProtobufs__MeNBResourceCoordinationInformation *
2737        streaming_protobufs__me_nbresource_coordination_information__unpack
2738                      (ProtobufCAllocator  *allocator,
2739                       size_t               len,
2740                       const uint8_t       *data)
2741 {
2742   return (StreamingProtobufs__MeNBResourceCoordinationInformation *)
2743      protobuf_c_message_unpack (&streaming_protobufs__me_nbresource_coordination_information__descriptor,
2744                                 allocator, len, data);
2745 }
2746 void   streaming_protobufs__me_nbresource_coordination_information__free_unpacked
2747                      (StreamingProtobufs__MeNBResourceCoordinationInformation *message,
2748                       ProtobufCAllocator *allocator)
2749 {
2750   if(!message)
2751     return;
2752   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information__descriptor);
2753   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2754 }
2755 void   streaming_protobufs__me_nbresource_coordination_information_ext_ies__init
2756                      (StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs         *message)
2757 {
2758   static const StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs init_value = STREAMING_PROTOBUFS__ME_NBRESOURCE_COORDINATION_INFORMATION_EXT_IES__INIT;
2759   *message = init_value;
2760 }
2761 size_t streaming_protobufs__me_nbresource_coordination_information_ext_ies__get_packed_size
2762                      (const StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs *message)
2763 {
2764   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor);
2765   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2766 }
2767 size_t streaming_protobufs__me_nbresource_coordination_information_ext_ies__pack
2768                      (const StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs *message,
2769                       uint8_t       *out)
2770 {
2771   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor);
2772   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2773 }
2774 size_t streaming_protobufs__me_nbresource_coordination_information_ext_ies__pack_to_buffer
2775                      (const StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs *message,
2776                       ProtobufCBuffer *buffer)
2777 {
2778   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor);
2779   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2780 }
2781 StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs *
2782        streaming_protobufs__me_nbresource_coordination_information_ext_ies__unpack
2783                      (ProtobufCAllocator  *allocator,
2784                       size_t               len,
2785                       const uint8_t       *data)
2786 {
2787   return (StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs *)
2788      protobuf_c_message_unpack (&streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor,
2789                                 allocator, len, data);
2790 }
2791 void   streaming_protobufs__me_nbresource_coordination_information_ext_ies__free_unpacked
2792                      (StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs *message,
2793                       ProtobufCAllocator *allocator)
2794 {
2795   if(!message)
2796     return;
2797   assert(message->base.descriptor == &streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor);
2798   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2799 }
2800 void   streaming_protobufs__me_nbcoordination_assistance_information__init
2801                      (StreamingProtobufs__MeNBCoordinationAssistanceInformation         *message)
2802 {
2803   static const StreamingProtobufs__MeNBCoordinationAssistanceInformation init_value = STREAMING_PROTOBUFS__ME_NBCOORDINATION_ASSISTANCE_INFORMATION__INIT;
2804   *message = init_value;
2805 }
2806 size_t streaming_protobufs__me_nbcoordination_assistance_information__get_packed_size
2807                      (const StreamingProtobufs__MeNBCoordinationAssistanceInformation *message)
2808 {
2809   assert(message->base.descriptor == &streaming_protobufs__me_nbcoordination_assistance_information__descriptor);
2810   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2811 }
2812 size_t streaming_protobufs__me_nbcoordination_assistance_information__pack
2813                      (const StreamingProtobufs__MeNBCoordinationAssistanceInformation *message,
2814                       uint8_t       *out)
2815 {
2816   assert(message->base.descriptor == &streaming_protobufs__me_nbcoordination_assistance_information__descriptor);
2817   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2818 }
2819 size_t streaming_protobufs__me_nbcoordination_assistance_information__pack_to_buffer
2820                      (const StreamingProtobufs__MeNBCoordinationAssistanceInformation *message,
2821                       ProtobufCBuffer *buffer)
2822 {
2823   assert(message->base.descriptor == &streaming_protobufs__me_nbcoordination_assistance_information__descriptor);
2824   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2825 }
2826 StreamingProtobufs__MeNBCoordinationAssistanceInformation *
2827        streaming_protobufs__me_nbcoordination_assistance_information__unpack
2828                      (ProtobufCAllocator  *allocator,
2829                       size_t               len,
2830                       const uint8_t       *data)
2831 {
2832   return (StreamingProtobufs__MeNBCoordinationAssistanceInformation *)
2833      protobuf_c_message_unpack (&streaming_protobufs__me_nbcoordination_assistance_information__descriptor,
2834                                 allocator, len, data);
2835 }
2836 void   streaming_protobufs__me_nbcoordination_assistance_information__free_unpacked
2837                      (StreamingProtobufs__MeNBCoordinationAssistanceInformation *message,
2838                       ProtobufCAllocator *allocator)
2839 {
2840   if(!message)
2841     return;
2842   assert(message->base.descriptor == &streaming_protobufs__me_nbcoordination_assistance_information__descriptor);
2843   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2844 }
2845 void   streaming_protobufs__countvalue__init
2846                      (StreamingProtobufs__COUNTvalue         *message)
2847 {
2848   static const StreamingProtobufs__COUNTvalue init_value = STREAMING_PROTOBUFS__COUNTVALUE__INIT;
2849   *message = init_value;
2850 }
2851 size_t streaming_protobufs__countvalue__get_packed_size
2852                      (const StreamingProtobufs__COUNTvalue *message)
2853 {
2854   assert(message->base.descriptor == &streaming_protobufs__countvalue__descriptor);
2855   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2856 }
2857 size_t streaming_protobufs__countvalue__pack
2858                      (const StreamingProtobufs__COUNTvalue *message,
2859                       uint8_t       *out)
2860 {
2861   assert(message->base.descriptor == &streaming_protobufs__countvalue__descriptor);
2862   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2863 }
2864 size_t streaming_protobufs__countvalue__pack_to_buffer
2865                      (const StreamingProtobufs__COUNTvalue *message,
2866                       ProtobufCBuffer *buffer)
2867 {
2868   assert(message->base.descriptor == &streaming_protobufs__countvalue__descriptor);
2869   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2870 }
2871 StreamingProtobufs__COUNTvalue *
2872        streaming_protobufs__countvalue__unpack
2873                      (ProtobufCAllocator  *allocator,
2874                       size_t               len,
2875                       const uint8_t       *data)
2876 {
2877   return (StreamingProtobufs__COUNTvalue *)
2878      protobuf_c_message_unpack (&streaming_protobufs__countvalue__descriptor,
2879                                 allocator, len, data);
2880 }
2881 void   streaming_protobufs__countvalue__free_unpacked
2882                      (StreamingProtobufs__COUNTvalue *message,
2883                       ProtobufCAllocator *allocator)
2884 {
2885   if(!message)
2886     return;
2887   assert(message->base.descriptor == &streaming_protobufs__countvalue__descriptor);
2888   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2889 }
2890 void   streaming_protobufs__countvalue_extended__init
2891                      (StreamingProtobufs__COUNTValueExtended         *message)
2892 {
2893   static const StreamingProtobufs__COUNTValueExtended init_value = STREAMING_PROTOBUFS__COUNTVALUE_EXTENDED__INIT;
2894   *message = init_value;
2895 }
2896 size_t streaming_protobufs__countvalue_extended__get_packed_size
2897                      (const StreamingProtobufs__COUNTValueExtended *message)
2898 {
2899   assert(message->base.descriptor == &streaming_protobufs__countvalue_extended__descriptor);
2900   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2901 }
2902 size_t streaming_protobufs__countvalue_extended__pack
2903                      (const StreamingProtobufs__COUNTValueExtended *message,
2904                       uint8_t       *out)
2905 {
2906   assert(message->base.descriptor == &streaming_protobufs__countvalue_extended__descriptor);
2907   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2908 }
2909 size_t streaming_protobufs__countvalue_extended__pack_to_buffer
2910                      (const StreamingProtobufs__COUNTValueExtended *message,
2911                       ProtobufCBuffer *buffer)
2912 {
2913   assert(message->base.descriptor == &streaming_protobufs__countvalue_extended__descriptor);
2914   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2915 }
2916 StreamingProtobufs__COUNTValueExtended *
2917        streaming_protobufs__countvalue_extended__unpack
2918                      (ProtobufCAllocator  *allocator,
2919                       size_t               len,
2920                       const uint8_t       *data)
2921 {
2922   return (StreamingProtobufs__COUNTValueExtended *)
2923      protobuf_c_message_unpack (&streaming_protobufs__countvalue_extended__descriptor,
2924                                 allocator, len, data);
2925 }
2926 void   streaming_protobufs__countvalue_extended__free_unpacked
2927                      (StreamingProtobufs__COUNTValueExtended *message,
2928                       ProtobufCAllocator *allocator)
2929 {
2930   if(!message)
2931     return;
2932   assert(message->base.descriptor == &streaming_protobufs__countvalue_extended__descriptor);
2933   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2934 }
2935 void   streaming_protobufs__countvalue_pdcp__snlength18__init
2936                      (StreamingProtobufs__COUNTvaluePDCPSNlength18         *message)
2937 {
2938   static const StreamingProtobufs__COUNTvaluePDCPSNlength18 init_value = STREAMING_PROTOBUFS__COUNTVALUE_PDCP__SNLENGTH18__INIT;
2939   *message = init_value;
2940 }
2941 size_t streaming_protobufs__countvalue_pdcp__snlength18__get_packed_size
2942                      (const StreamingProtobufs__COUNTvaluePDCPSNlength18 *message)
2943 {
2944   assert(message->base.descriptor == &streaming_protobufs__countvalue_pdcp__snlength18__descriptor);
2945   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2946 }
2947 size_t streaming_protobufs__countvalue_pdcp__snlength18__pack
2948                      (const StreamingProtobufs__COUNTvaluePDCPSNlength18 *message,
2949                       uint8_t       *out)
2950 {
2951   assert(message->base.descriptor == &streaming_protobufs__countvalue_pdcp__snlength18__descriptor);
2952   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2953 }
2954 size_t streaming_protobufs__countvalue_pdcp__snlength18__pack_to_buffer
2955                      (const StreamingProtobufs__COUNTvaluePDCPSNlength18 *message,
2956                       ProtobufCBuffer *buffer)
2957 {
2958   assert(message->base.descriptor == &streaming_protobufs__countvalue_pdcp__snlength18__descriptor);
2959   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2960 }
2961 StreamingProtobufs__COUNTvaluePDCPSNlength18 *
2962        streaming_protobufs__countvalue_pdcp__snlength18__unpack
2963                      (ProtobufCAllocator  *allocator,
2964                       size_t               len,
2965                       const uint8_t       *data)
2966 {
2967   return (StreamingProtobufs__COUNTvaluePDCPSNlength18 *)
2968      protobuf_c_message_unpack (&streaming_protobufs__countvalue_pdcp__snlength18__descriptor,
2969                                 allocator, len, data);
2970 }
2971 void   streaming_protobufs__countvalue_pdcp__snlength18__free_unpacked
2972                      (StreamingProtobufs__COUNTvaluePDCPSNlength18 *message,
2973                       ProtobufCAllocator *allocator)
2974 {
2975   if(!message)
2976     return;
2977   assert(message->base.descriptor == &streaming_protobufs__countvalue_pdcp__snlength18__descriptor);
2978   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2979 }
2980 void   streaming_protobufs__expected_uebehaviour__init
2981                      (StreamingProtobufs__ExpectedUEBehaviour         *message)
2982 {
2983   static const StreamingProtobufs__ExpectedUEBehaviour init_value = STREAMING_PROTOBUFS__EXPECTED_UEBEHAVIOUR__INIT;
2984   *message = init_value;
2985 }
2986 size_t streaming_protobufs__expected_uebehaviour__get_packed_size
2987                      (const StreamingProtobufs__ExpectedUEBehaviour *message)
2988 {
2989   assert(message->base.descriptor == &streaming_protobufs__expected_uebehaviour__descriptor);
2990   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2991 }
2992 size_t streaming_protobufs__expected_uebehaviour__pack
2993                      (const StreamingProtobufs__ExpectedUEBehaviour *message,
2994                       uint8_t       *out)
2995 {
2996   assert(message->base.descriptor == &streaming_protobufs__expected_uebehaviour__descriptor);
2997   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2998 }
2999 size_t streaming_protobufs__expected_uebehaviour__pack_to_buffer
3000                      (const StreamingProtobufs__ExpectedUEBehaviour *message,
3001                       ProtobufCBuffer *buffer)
3002 {
3003   assert(message->base.descriptor == &streaming_protobufs__expected_uebehaviour__descriptor);
3004   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3005 }
3006 StreamingProtobufs__ExpectedUEBehaviour *
3007        streaming_protobufs__expected_uebehaviour__unpack
3008                      (ProtobufCAllocator  *allocator,
3009                       size_t               len,
3010                       const uint8_t       *data)
3011 {
3012   return (StreamingProtobufs__ExpectedUEBehaviour *)
3013      protobuf_c_message_unpack (&streaming_protobufs__expected_uebehaviour__descriptor,
3014                                 allocator, len, data);
3015 }
3016 void   streaming_protobufs__expected_uebehaviour__free_unpacked
3017                      (StreamingProtobufs__ExpectedUEBehaviour *message,
3018                       ProtobufCAllocator *allocator)
3019 {
3020   if(!message)
3021     return;
3022   assert(message->base.descriptor == &streaming_protobufs__expected_uebehaviour__descriptor);
3023   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3024 }
3025 void   streaming_protobufs__expected_ueactivity_behaviour__init
3026                      (StreamingProtobufs__ExpectedUEActivityBehaviour         *message)
3027 {
3028   static const StreamingProtobufs__ExpectedUEActivityBehaviour init_value = STREAMING_PROTOBUFS__EXPECTED_UEACTIVITY_BEHAVIOUR__INIT;
3029   *message = init_value;
3030 }
3031 size_t streaming_protobufs__expected_ueactivity_behaviour__get_packed_size
3032                      (const StreamingProtobufs__ExpectedUEActivityBehaviour *message)
3033 {
3034   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__descriptor);
3035   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3036 }
3037 size_t streaming_protobufs__expected_ueactivity_behaviour__pack
3038                      (const StreamingProtobufs__ExpectedUEActivityBehaviour *message,
3039                       uint8_t       *out)
3040 {
3041   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__descriptor);
3042   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3043 }
3044 size_t streaming_protobufs__expected_ueactivity_behaviour__pack_to_buffer
3045                      (const StreamingProtobufs__ExpectedUEActivityBehaviour *message,
3046                       ProtobufCBuffer *buffer)
3047 {
3048   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__descriptor);
3049   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3050 }
3051 StreamingProtobufs__ExpectedUEActivityBehaviour *
3052        streaming_protobufs__expected_ueactivity_behaviour__unpack
3053                      (ProtobufCAllocator  *allocator,
3054                       size_t               len,
3055                       const uint8_t       *data)
3056 {
3057   return (StreamingProtobufs__ExpectedUEActivityBehaviour *)
3058      protobuf_c_message_unpack (&streaming_protobufs__expected_ueactivity_behaviour__descriptor,
3059                                 allocator, len, data);
3060 }
3061 void   streaming_protobufs__expected_ueactivity_behaviour__free_unpacked
3062                      (StreamingProtobufs__ExpectedUEActivityBehaviour *message,
3063                       ProtobufCAllocator *allocator)
3064 {
3065   if(!message)
3066     return;
3067   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__descriptor);
3068   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3069 }
3070 void   streaming_protobufs__expected_ueactivity_behaviour__ext_ies__init
3071                      (StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs         *message)
3072 {
3073   static const StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs init_value = STREAMING_PROTOBUFS__EXPECTED_UEACTIVITY_BEHAVIOUR__EXT_IES__INIT;
3074   *message = init_value;
3075 }
3076 size_t streaming_protobufs__expected_ueactivity_behaviour__ext_ies__get_packed_size
3077                      (const StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs *message)
3078 {
3079   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor);
3080   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3081 }
3082 size_t streaming_protobufs__expected_ueactivity_behaviour__ext_ies__pack
3083                      (const StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs *message,
3084                       uint8_t       *out)
3085 {
3086   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor);
3087   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3088 }
3089 size_t streaming_protobufs__expected_ueactivity_behaviour__ext_ies__pack_to_buffer
3090                      (const StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs *message,
3091                       ProtobufCBuffer *buffer)
3092 {
3093   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor);
3094   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3095 }
3096 StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs *
3097        streaming_protobufs__expected_ueactivity_behaviour__ext_ies__unpack
3098                      (ProtobufCAllocator  *allocator,
3099                       size_t               len,
3100                       const uint8_t       *data)
3101 {
3102   return (StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs *)
3103      protobuf_c_message_unpack (&streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor,
3104                                 allocator, len, data);
3105 }
3106 void   streaming_protobufs__expected_ueactivity_behaviour__ext_ies__free_unpacked
3107                      (StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs *message,
3108                       ProtobufCAllocator *allocator)
3109 {
3110   if(!message)
3111     return;
3112   assert(message->base.descriptor == &streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor);
3113   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3114 }
3115 void   streaming_protobufs__expected_hointerval__init
3116                      (StreamingProtobufs__ExpectedHOInterval         *message)
3117 {
3118   static const StreamingProtobufs__ExpectedHOInterval init_value = STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__INIT;
3119   *message = init_value;
3120 }
3121 size_t streaming_protobufs__expected_hointerval__get_packed_size
3122                      (const StreamingProtobufs__ExpectedHOInterval *message)
3123 {
3124   assert(message->base.descriptor == &streaming_protobufs__expected_hointerval__descriptor);
3125   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3126 }
3127 size_t streaming_protobufs__expected_hointerval__pack
3128                      (const StreamingProtobufs__ExpectedHOInterval *message,
3129                       uint8_t       *out)
3130 {
3131   assert(message->base.descriptor == &streaming_protobufs__expected_hointerval__descriptor);
3132   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3133 }
3134 size_t streaming_protobufs__expected_hointerval__pack_to_buffer
3135                      (const StreamingProtobufs__ExpectedHOInterval *message,
3136                       ProtobufCBuffer *buffer)
3137 {
3138   assert(message->base.descriptor == &streaming_protobufs__expected_hointerval__descriptor);
3139   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3140 }
3141 StreamingProtobufs__ExpectedHOInterval *
3142        streaming_protobufs__expected_hointerval__unpack
3143                      (ProtobufCAllocator  *allocator,
3144                       size_t               len,
3145                       const uint8_t       *data)
3146 {
3147   return (StreamingProtobufs__ExpectedHOInterval *)
3148      protobuf_c_message_unpack (&streaming_protobufs__expected_hointerval__descriptor,
3149                                 allocator, len, data);
3150 }
3151 void   streaming_protobufs__expected_hointerval__free_unpacked
3152                      (StreamingProtobufs__ExpectedHOInterval *message,
3153                       ProtobufCAllocator *allocator)
3154 {
3155   if(!message)
3156     return;
3157   assert(message->base.descriptor == &streaming_protobufs__expected_hointerval__descriptor);
3158   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3159 }
3160 void   streaming_protobufs__source_of_ueactivity_behaviour_information__init
3161                      (StreamingProtobufs__SourceOfUEActivityBehaviourInformation         *message)
3162 {
3163   static const StreamingProtobufs__SourceOfUEActivityBehaviourInformation init_value = STREAMING_PROTOBUFS__SOURCE_OF_UEACTIVITY_BEHAVIOUR_INFORMATION__INIT;
3164   *message = init_value;
3165 }
3166 size_t streaming_protobufs__source_of_ueactivity_behaviour_information__get_packed_size
3167                      (const StreamingProtobufs__SourceOfUEActivityBehaviourInformation *message)
3168 {
3169   assert(message->base.descriptor == &streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor);
3170   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3171 }
3172 size_t streaming_protobufs__source_of_ueactivity_behaviour_information__pack
3173                      (const StreamingProtobufs__SourceOfUEActivityBehaviourInformation *message,
3174                       uint8_t       *out)
3175 {
3176   assert(message->base.descriptor == &streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor);
3177   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3178 }
3179 size_t streaming_protobufs__source_of_ueactivity_behaviour_information__pack_to_buffer
3180                      (const StreamingProtobufs__SourceOfUEActivityBehaviourInformation *message,
3181                       ProtobufCBuffer *buffer)
3182 {
3183   assert(message->base.descriptor == &streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor);
3184   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3185 }
3186 StreamingProtobufs__SourceOfUEActivityBehaviourInformation *
3187        streaming_protobufs__source_of_ueactivity_behaviour_information__unpack
3188                      (ProtobufCAllocator  *allocator,
3189                       size_t               len,
3190                       const uint8_t       *data)
3191 {
3192   return (StreamingProtobufs__SourceOfUEActivityBehaviourInformation *)
3193      protobuf_c_message_unpack (&streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor,
3194                                 allocator, len, data);
3195 }
3196 void   streaming_protobufs__source_of_ueactivity_behaviour_information__free_unpacked
3197                      (StreamingProtobufs__SourceOfUEActivityBehaviourInformation *message,
3198                       ProtobufCAllocator *allocator)
3199 {
3200   if(!message)
3201     return;
3202   assert(message->base.descriptor == &streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor);
3203   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3204 }
3205 void   streaming_protobufs__sgnb__addition__trigger__ind__init
3206                      (StreamingProtobufs__SGNBAdditionTriggerInd         *message)
3207 {
3208   static const StreamingProtobufs__SGNBAdditionTriggerInd init_value = STREAMING_PROTOBUFS__SGNB__ADDITION__TRIGGER__IND__INIT;
3209   *message = init_value;
3210 }
3211 size_t streaming_protobufs__sgnb__addition__trigger__ind__get_packed_size
3212                      (const StreamingProtobufs__SGNBAdditionTriggerInd *message)
3213 {
3214   assert(message->base.descriptor == &streaming_protobufs__sgnb__addition__trigger__ind__descriptor);
3215   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3216 }
3217 size_t streaming_protobufs__sgnb__addition__trigger__ind__pack
3218                      (const StreamingProtobufs__SGNBAdditionTriggerInd *message,
3219                       uint8_t       *out)
3220 {
3221   assert(message->base.descriptor == &streaming_protobufs__sgnb__addition__trigger__ind__descriptor);
3222   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3223 }
3224 size_t streaming_protobufs__sgnb__addition__trigger__ind__pack_to_buffer
3225                      (const StreamingProtobufs__SGNBAdditionTriggerInd *message,
3226                       ProtobufCBuffer *buffer)
3227 {
3228   assert(message->base.descriptor == &streaming_protobufs__sgnb__addition__trigger__ind__descriptor);
3229   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3230 }
3231 StreamingProtobufs__SGNBAdditionTriggerInd *
3232        streaming_protobufs__sgnb__addition__trigger__ind__unpack
3233                      (ProtobufCAllocator  *allocator,
3234                       size_t               len,
3235                       const uint8_t       *data)
3236 {
3237   return (StreamingProtobufs__SGNBAdditionTriggerInd *)
3238      protobuf_c_message_unpack (&streaming_protobufs__sgnb__addition__trigger__ind__descriptor,
3239                                 allocator, len, data);
3240 }
3241 void   streaming_protobufs__sgnb__addition__trigger__ind__free_unpacked
3242                      (StreamingProtobufs__SGNBAdditionTriggerInd *message,
3243                       ProtobufCAllocator *allocator)
3244 {
3245   if(!message)
3246     return;
3247   assert(message->base.descriptor == &streaming_protobufs__sgnb__addition__trigger__ind__descriptor);
3248   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3249 }
3250 static const ProtobufCEnumValue streaming_protobufs__en__dc__resource_configuration__status__enum_values_by_number[3] =
3251 {
3252   { "protobuf_unspecified", "STREAMING_PROTOBUFS__EN__DC__RESOURCE_CONFIGURATION__STATUS__protobuf_unspecified", 0 },
3253   { "present", "STREAMING_PROTOBUFS__EN__DC__RESOURCE_CONFIGURATION__STATUS__present", 1 },
3254   { "not_present", "STREAMING_PROTOBUFS__EN__DC__RESOURCE_CONFIGURATION__STATUS__not_present", 2 },
3255 };
3256 static const ProtobufCIntRange streaming_protobufs__en__dc__resource_configuration__status__value_ranges[] = {
3257 {0, 0},{0, 3}
3258 };
3259 static const ProtobufCEnumValueIndex streaming_protobufs__en__dc__resource_configuration__status__enum_values_by_name[3] =
3260 {
3261   { "not_present", 2 },
3262   { "present", 1 },
3263   { "protobuf_unspecified", 0 },
3264 };
3265 const ProtobufCEnumDescriptor streaming_protobufs__en__dc__resource_configuration__status__descriptor =
3266 {
3267   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3268   "streaming_protobufs.EN_DC_ResourceConfiguration.Status",
3269   "Status",
3270   "StreamingProtobufs__ENDCResourceConfiguration__Status",
3271   "streaming_protobufs",
3272   3,
3273   streaming_protobufs__en__dc__resource_configuration__status__enum_values_by_number,
3274   3,
3275   streaming_protobufs__en__dc__resource_configuration__status__enum_values_by_name,
3276   1,
3277   streaming_protobufs__en__dc__resource_configuration__status__value_ranges,
3278   NULL,NULL,NULL,NULL   /* reserved[1234] */
3279 };
3280 static const ProtobufCFieldDescriptor streaming_protobufs__en__dc__resource_configuration__field_descriptors[3] =
3281 {
3282   {
3283     "pDCPatSgNB",
3284     1,
3285     PROTOBUF_C_LABEL_NONE,
3286     PROTOBUF_C_TYPE_ENUM,
3287     0,   /* quantifier_offset */
3288     offsetof(StreamingProtobufs__ENDCResourceConfiguration, pdcpatsgnb),
3289     &streaming_protobufs__en__dc__resource_configuration__status__descriptor,
3290     NULL,
3291     0,             /* flags */
3292     0,NULL,NULL    /* reserved1,reserved2, etc */
3293   },
3294   {
3295     "mCGresources",
3296     2,
3297     PROTOBUF_C_LABEL_NONE,
3298     PROTOBUF_C_TYPE_ENUM,
3299     0,   /* quantifier_offset */
3300     offsetof(StreamingProtobufs__ENDCResourceConfiguration, mcgresources),
3301     &streaming_protobufs__en__dc__resource_configuration__status__descriptor,
3302     NULL,
3303     0,             /* flags */
3304     0,NULL,NULL    /* reserved1,reserved2, etc */
3305   },
3306   {
3307     "sCGresources",
3308     3,
3309     PROTOBUF_C_LABEL_NONE,
3310     PROTOBUF_C_TYPE_ENUM,
3311     0,   /* quantifier_offset */
3312     offsetof(StreamingProtobufs__ENDCResourceConfiguration, scgresources),
3313     &streaming_protobufs__en__dc__resource_configuration__status__descriptor,
3314     NULL,
3315     0,             /* flags */
3316     0,NULL,NULL    /* reserved1,reserved2, etc */
3317   },
3318 };
3319 static const unsigned streaming_protobufs__en__dc__resource_configuration__field_indices_by_name[] = {
3320   1,   /* field[1] = mCGresources */
3321   0,   /* field[0] = pDCPatSgNB */
3322   2,   /* field[2] = sCGresources */
3323 };
3324 static const ProtobufCIntRange streaming_protobufs__en__dc__resource_configuration__number_ranges[1 + 1] =
3325 {
3326   { 1, 0 },
3327   { 0, 3 }
3328 };
3329 const ProtobufCMessageDescriptor streaming_protobufs__en__dc__resource_configuration__descriptor =
3330 {
3331   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3332   "streaming_protobufs.EN_DC_ResourceConfiguration",
3333   "ENDCResourceConfiguration",
3334   "StreamingProtobufs__ENDCResourceConfiguration",
3335   "streaming_protobufs",
3336   sizeof(StreamingProtobufs__ENDCResourceConfiguration),
3337   3,
3338   streaming_protobufs__en__dc__resource_configuration__field_descriptors,
3339   streaming_protobufs__en__dc__resource_configuration__field_indices_by_name,
3340   1,  streaming_protobufs__en__dc__resource_configuration__number_ranges,
3341   (ProtobufCMessageInit) streaming_protobufs__en__dc__resource_configuration__init,
3342   NULL,NULL,NULL    /* reserved[123] */
3343 };
3344 static const ProtobufCFieldDescriptor streaming_protobufs__e__rab__level__qo_s__parameters__field_descriptors[4] =
3345 {
3346   {
3347     "qCI",
3348     1,
3349     PROTOBUF_C_LABEL_NONE,
3350     PROTOBUF_C_TYPE_UINT32,
3351     0,   /* quantifier_offset */
3352     offsetof(StreamingProtobufs__ERABLevelQoSParameters, qci),
3353     NULL,
3354     NULL,
3355     0,             /* flags */
3356     0,NULL,NULL    /* reserved1,reserved2, etc */
3357   },
3358   {
3359     "allocationAndRetentionPriority",
3360     2,
3361     PROTOBUF_C_LABEL_NONE,
3362     PROTOBUF_C_TYPE_MESSAGE,
3363     0,   /* quantifier_offset */
3364     offsetof(StreamingProtobufs__ERABLevelQoSParameters, allocationandretentionpriority),
3365     &streaming_protobufs__allocation_and_retention_priority__descriptor,
3366     NULL,
3367     0,             /* flags */
3368     0,NULL,NULL    /* reserved1,reserved2, etc */
3369   },
3370   {
3371     "gbrQosInformation",
3372     3,
3373     PROTOBUF_C_LABEL_NONE,
3374     PROTOBUF_C_TYPE_MESSAGE,
3375     0,   /* quantifier_offset */
3376     offsetof(StreamingProtobufs__ERABLevelQoSParameters, gbrqosinformation),
3377     &streaming_protobufs__gbr__qos_information__descriptor,
3378     NULL,
3379     0,             /* flags */
3380     0,NULL,NULL    /* reserved1,reserved2, etc */
3381   },
3382   {
3383     "iE_Extensions",
3384     4,
3385     PROTOBUF_C_LABEL_REPEATED,
3386     PROTOBUF_C_TYPE_MESSAGE,
3387     offsetof(StreamingProtobufs__ERABLevelQoSParameters, n_ie_extensions),
3388     offsetof(StreamingProtobufs__ERABLevelQoSParameters, ie_extensions),
3389     &streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor,
3390     NULL,
3391     0,             /* flags */
3392     0,NULL,NULL    /* reserved1,reserved2, etc */
3393   },
3394 };
3395 static const unsigned streaming_protobufs__e__rab__level__qo_s__parameters__field_indices_by_name[] = {
3396   1,   /* field[1] = allocationAndRetentionPriority */
3397   2,   /* field[2] = gbrQosInformation */
3398   3,   /* field[3] = iE_Extensions */
3399   0,   /* field[0] = qCI */
3400 };
3401 static const ProtobufCIntRange streaming_protobufs__e__rab__level__qo_s__parameters__number_ranges[1 + 1] =
3402 {
3403   { 1, 0 },
3404   { 0, 4 }
3405 };
3406 const ProtobufCMessageDescriptor streaming_protobufs__e__rab__level__qo_s__parameters__descriptor =
3407 {
3408   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3409   "streaming_protobufs.E_RAB_Level_QoS_Parameters",
3410   "ERABLevelQoSParameters",
3411   "StreamingProtobufs__ERABLevelQoSParameters",
3412   "streaming_protobufs",
3413   sizeof(StreamingProtobufs__ERABLevelQoSParameters),
3414   4,
3415   streaming_protobufs__e__rab__level__qo_s__parameters__field_descriptors,
3416   streaming_protobufs__e__rab__level__qo_s__parameters__field_indices_by_name,
3417   1,  streaming_protobufs__e__rab__level__qo_s__parameters__number_ranges,
3418   (ProtobufCMessageInit) streaming_protobufs__e__rab__level__qo_s__parameters__init,
3419   NULL,NULL,NULL    /* reserved[123] */
3420 };
3421 static const ProtobufCFieldDescriptor streaming_protobufs__allocation_and_retention_priority__field_descriptors[3] =
3422 {
3423   {
3424     "priorityLevel",
3425     1,
3426     PROTOBUF_C_LABEL_NONE,
3427     PROTOBUF_C_TYPE_UINT32,
3428     0,   /* quantifier_offset */
3429     offsetof(StreamingProtobufs__AllocationAndRetentionPriority, prioritylevel),
3430     NULL,
3431     NULL,
3432     0,             /* flags */
3433     0,NULL,NULL    /* reserved1,reserved2, etc */
3434   },
3435   {
3436     "pre_emptionCapability",
3437     2,
3438     PROTOBUF_C_LABEL_NONE,
3439     PROTOBUF_C_TYPE_MESSAGE,
3440     0,   /* quantifier_offset */
3441     offsetof(StreamingProtobufs__AllocationAndRetentionPriority, pre_emptioncapability),
3442     &streaming_protobufs__pre_emption_capability__descriptor,
3443     NULL,
3444     0,             /* flags */
3445     0,NULL,NULL    /* reserved1,reserved2, etc */
3446   },
3447   {
3448     "pre_emptionVulnerability",
3449     3,
3450     PROTOBUF_C_LABEL_NONE,
3451     PROTOBUF_C_TYPE_MESSAGE,
3452     0,   /* quantifier_offset */
3453     offsetof(StreamingProtobufs__AllocationAndRetentionPriority, pre_emptionvulnerability),
3454     &streaming_protobufs__pre_emption_vulnerability__descriptor,
3455     NULL,
3456     0,             /* flags */
3457     0,NULL,NULL    /* reserved1,reserved2, etc */
3458   },
3459 };
3460 static const unsigned streaming_protobufs__allocation_and_retention_priority__field_indices_by_name[] = {
3461   1,   /* field[1] = pre_emptionCapability */
3462   2,   /* field[2] = pre_emptionVulnerability */
3463   0,   /* field[0] = priorityLevel */
3464 };
3465 static const ProtobufCIntRange streaming_protobufs__allocation_and_retention_priority__number_ranges[1 + 1] =
3466 {
3467   { 1, 0 },
3468   { 0, 3 }
3469 };
3470 const ProtobufCMessageDescriptor streaming_protobufs__allocation_and_retention_priority__descriptor =
3471 {
3472   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3473   "streaming_protobufs.AllocationAndRetentionPriority",
3474   "AllocationAndRetentionPriority",
3475   "StreamingProtobufs__AllocationAndRetentionPriority",
3476   "streaming_protobufs",
3477   sizeof(StreamingProtobufs__AllocationAndRetentionPriority),
3478   3,
3479   streaming_protobufs__allocation_and_retention_priority__field_descriptors,
3480   streaming_protobufs__allocation_and_retention_priority__field_indices_by_name,
3481   1,  streaming_protobufs__allocation_and_retention_priority__number_ranges,
3482   (ProtobufCMessageInit) streaming_protobufs__allocation_and_retention_priority__init,
3483   NULL,NULL,NULL    /* reserved[123] */
3484 };
3485 static const ProtobufCEnumValue streaming_protobufs__pre_emption_vulnerability__value__enum_values_by_number[3] =
3486 {
3487   { "protobuf_unspecified", "STREAMING_PROTOBUFS__PRE_EMPTION_VULNERABILITY__VALUE__protobuf_unspecified", 0 },
3488   { "not_pre_emptable", "STREAMING_PROTOBUFS__PRE_EMPTION_VULNERABILITY__VALUE__not_pre_emptable", 1 },
3489   { "pre_emptable", "STREAMING_PROTOBUFS__PRE_EMPTION_VULNERABILITY__VALUE__pre_emptable", 2 },
3490 };
3491 static const ProtobufCIntRange streaming_protobufs__pre_emption_vulnerability__value__value_ranges[] = {
3492 {0, 0},{0, 3}
3493 };
3494 static const ProtobufCEnumValueIndex streaming_protobufs__pre_emption_vulnerability__value__enum_values_by_name[3] =
3495 {
3496   { "not_pre_emptable", 1 },
3497   { "pre_emptable", 2 },
3498   { "protobuf_unspecified", 0 },
3499 };
3500 const ProtobufCEnumDescriptor streaming_protobufs__pre_emption_vulnerability__value__descriptor =
3501 {
3502   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3503   "streaming_protobufs.Pre_emptionVulnerability.Value",
3504   "Value",
3505   "StreamingProtobufs__PreEmptionVulnerability__Value",
3506   "streaming_protobufs",
3507   3,
3508   streaming_protobufs__pre_emption_vulnerability__value__enum_values_by_number,
3509   3,
3510   streaming_protobufs__pre_emption_vulnerability__value__enum_values_by_name,
3511   1,
3512   streaming_protobufs__pre_emption_vulnerability__value__value_ranges,
3513   NULL,NULL,NULL,NULL   /* reserved[1234] */
3514 };
3515 static const ProtobufCFieldDescriptor streaming_protobufs__pre_emption_vulnerability__field_descriptors[1] =
3516 {
3517   {
3518     "value",
3519     1,
3520     PROTOBUF_C_LABEL_NONE,
3521     PROTOBUF_C_TYPE_ENUM,
3522     0,   /* quantifier_offset */
3523     offsetof(StreamingProtobufs__PreEmptionVulnerability, value),
3524     &streaming_protobufs__pre_emption_vulnerability__value__descriptor,
3525     NULL,
3526     0,             /* flags */
3527     0,NULL,NULL    /* reserved1,reserved2, etc */
3528   },
3529 };
3530 static const unsigned streaming_protobufs__pre_emption_vulnerability__field_indices_by_name[] = {
3531   0,   /* field[0] = value */
3532 };
3533 static const ProtobufCIntRange streaming_protobufs__pre_emption_vulnerability__number_ranges[1 + 1] =
3534 {
3535   { 1, 0 },
3536   { 0, 1 }
3537 };
3538 const ProtobufCMessageDescriptor streaming_protobufs__pre_emption_vulnerability__descriptor =
3539 {
3540   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3541   "streaming_protobufs.Pre_emptionVulnerability",
3542   "PreEmptionVulnerability",
3543   "StreamingProtobufs__PreEmptionVulnerability",
3544   "streaming_protobufs",
3545   sizeof(StreamingProtobufs__PreEmptionVulnerability),
3546   1,
3547   streaming_protobufs__pre_emption_vulnerability__field_descriptors,
3548   streaming_protobufs__pre_emption_vulnerability__field_indices_by_name,
3549   1,  streaming_protobufs__pre_emption_vulnerability__number_ranges,
3550   (ProtobufCMessageInit) streaming_protobufs__pre_emption_vulnerability__init,
3551   NULL,NULL,NULL    /* reserved[123] */
3552 };
3553 static const ProtobufCEnumValue streaming_protobufs__pre_emption_capability__value__enum_values_by_number[3] =
3554 {
3555   { "protobuf_unspecified", "STREAMING_PROTOBUFS__PRE_EMPTION_CAPABILITY__VALUE__protobuf_unspecified", 0 },
3556   { "shall_not_trigger_pre_emption", "STREAMING_PROTOBUFS__PRE_EMPTION_CAPABILITY__VALUE__shall_not_trigger_pre_emption", 1 },
3557   { "may_trigger_pre_emption", "STREAMING_PROTOBUFS__PRE_EMPTION_CAPABILITY__VALUE__may_trigger_pre_emption", 2 },
3558 };
3559 static const ProtobufCIntRange streaming_protobufs__pre_emption_capability__value__value_ranges[] = {
3560 {0, 0},{0, 3}
3561 };
3562 static const ProtobufCEnumValueIndex streaming_protobufs__pre_emption_capability__value__enum_values_by_name[3] =
3563 {
3564   { "may_trigger_pre_emption", 2 },
3565   { "protobuf_unspecified", 0 },
3566   { "shall_not_trigger_pre_emption", 1 },
3567 };
3568 const ProtobufCEnumDescriptor streaming_protobufs__pre_emption_capability__value__descriptor =
3569 {
3570   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3571   "streaming_protobufs.Pre_emptionCapability.Value",
3572   "Value",
3573   "StreamingProtobufs__PreEmptionCapability__Value",
3574   "streaming_protobufs",
3575   3,
3576   streaming_protobufs__pre_emption_capability__value__enum_values_by_number,
3577   3,
3578   streaming_protobufs__pre_emption_capability__value__enum_values_by_name,
3579   1,
3580   streaming_protobufs__pre_emption_capability__value__value_ranges,
3581   NULL,NULL,NULL,NULL   /* reserved[1234] */
3582 };
3583 static const ProtobufCFieldDescriptor streaming_protobufs__pre_emption_capability__field_descriptors[1] =
3584 {
3585   {
3586     "value",
3587     1,
3588     PROTOBUF_C_LABEL_NONE,
3589     PROTOBUF_C_TYPE_ENUM,
3590     0,   /* quantifier_offset */
3591     offsetof(StreamingProtobufs__PreEmptionCapability, value),
3592     &streaming_protobufs__pre_emption_capability__value__descriptor,
3593     NULL,
3594     0,             /* flags */
3595     0,NULL,NULL    /* reserved1,reserved2, etc */
3596   },
3597 };
3598 static const unsigned streaming_protobufs__pre_emption_capability__field_indices_by_name[] = {
3599   0,   /* field[0] = value */
3600 };
3601 static const ProtobufCIntRange streaming_protobufs__pre_emption_capability__number_ranges[1 + 1] =
3602 {
3603   { 1, 0 },
3604   { 0, 1 }
3605 };
3606 const ProtobufCMessageDescriptor streaming_protobufs__pre_emption_capability__descriptor =
3607 {
3608   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3609   "streaming_protobufs.Pre_emptionCapability",
3610   "PreEmptionCapability",
3611   "StreamingProtobufs__PreEmptionCapability",
3612   "streaming_protobufs",
3613   sizeof(StreamingProtobufs__PreEmptionCapability),
3614   1,
3615   streaming_protobufs__pre_emption_capability__field_descriptors,
3616   streaming_protobufs__pre_emption_capability__field_indices_by_name,
3617   1,  streaming_protobufs__pre_emption_capability__number_ranges,
3618   (ProtobufCMessageInit) streaming_protobufs__pre_emption_capability__init,
3619   NULL,NULL,NULL    /* reserved[123] */
3620 };
3621 static const ProtobufCFieldDescriptor streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__field_descriptors[2] =
3622 {
3623   {
3624     "id_DownlinkPacketLossRate",
3625     1,
3626     PROTOBUF_C_LABEL_NONE,
3627     PROTOBUF_C_TYPE_MESSAGE,
3628     0,   /* quantifier_offset */
3629     offsetof(StreamingProtobufs__ERABLevelQoSParametersExtIEs, id_downlinkpacketlossrate),
3630     &google__protobuf__uint32_value__descriptor,
3631     NULL,
3632     0,             /* flags */
3633     0,NULL,NULL    /* reserved1,reserved2, etc */
3634   },
3635   {
3636     "id_UplinkPacketLossRate",
3637     2,
3638     PROTOBUF_C_LABEL_NONE,
3639     PROTOBUF_C_TYPE_MESSAGE,
3640     0,   /* quantifier_offset */
3641     offsetof(StreamingProtobufs__ERABLevelQoSParametersExtIEs, id_uplinkpacketlossrate),
3642     &google__protobuf__uint32_value__descriptor,
3643     NULL,
3644     0,             /* flags */
3645     0,NULL,NULL    /* reserved1,reserved2, etc */
3646   },
3647 };
3648 static const unsigned streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__field_indices_by_name[] = {
3649   0,   /* field[0] = id_DownlinkPacketLossRate */
3650   1,   /* field[1] = id_UplinkPacketLossRate */
3651 };
3652 static const ProtobufCIntRange streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__number_ranges[1 + 1] =
3653 {
3654   { 1, 0 },
3655   { 0, 2 }
3656 };
3657 const ProtobufCMessageDescriptor streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__descriptor =
3658 {
3659   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3660   "streaming_protobufs.E_RAB_Level_QoS_Parameters_ExtIEs",
3661   "ERABLevelQoSParametersExtIEs",
3662   "StreamingProtobufs__ERABLevelQoSParametersExtIEs",
3663   "streaming_protobufs",
3664   sizeof(StreamingProtobufs__ERABLevelQoSParametersExtIEs),
3665   2,
3666   streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__field_descriptors,
3667   streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__field_indices_by_name,
3668   1,  streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__number_ranges,
3669   (ProtobufCMessageInit) streaming_protobufs__e__rab__level__qo_s__parameters__ext_ies__init,
3670   NULL,NULL,NULL    /* reserved[123] */
3671 };
3672 static const ProtobufCFieldDescriptor streaming_protobufs__gbr__qos_information__field_descriptors[5] =
3673 {
3674   {
3675     "e_RAB_MaximumBitrateDL",
3676     1,
3677     PROTOBUF_C_LABEL_NONE,
3678     PROTOBUF_C_TYPE_UINT64,
3679     0,   /* quantifier_offset */
3680     offsetof(StreamingProtobufs__GBRQosInformation, e_rab_maximumbitratedl),
3681     NULL,
3682     NULL,
3683     0,             /* flags */
3684     0,NULL,NULL    /* reserved1,reserved2, etc */
3685   },
3686   {
3687     "e_RAB_MaximumBitrateUL",
3688     2,
3689     PROTOBUF_C_LABEL_NONE,
3690     PROTOBUF_C_TYPE_UINT64,
3691     0,   /* quantifier_offset */
3692     offsetof(StreamingProtobufs__GBRQosInformation, e_rab_maximumbitrateul),
3693     NULL,
3694     NULL,
3695     0,             /* flags */
3696     0,NULL,NULL    /* reserved1,reserved2, etc */
3697   },
3698   {
3699     "e_RAB_GuaranteedBitrateDL",
3700     3,
3701     PROTOBUF_C_LABEL_NONE,
3702     PROTOBUF_C_TYPE_UINT64,
3703     0,   /* quantifier_offset */
3704     offsetof(StreamingProtobufs__GBRQosInformation, e_rab_guaranteedbitratedl),
3705     NULL,
3706     NULL,
3707     0,             /* flags */
3708     0,NULL,NULL    /* reserved1,reserved2, etc */
3709   },
3710   {
3711     "e_RAB_GuaranteedBitrateUL",
3712     4,
3713     PROTOBUF_C_LABEL_NONE,
3714     PROTOBUF_C_TYPE_UINT64,
3715     0,   /* quantifier_offset */
3716     offsetof(StreamingProtobufs__GBRQosInformation, e_rab_guaranteedbitrateul),
3717     NULL,
3718     NULL,
3719     0,             /* flags */
3720     0,NULL,NULL    /* reserved1,reserved2, etc */
3721   },
3722   {
3723     "iE_Extensions",
3724     5,
3725     PROTOBUF_C_LABEL_REPEATED,
3726     PROTOBUF_C_TYPE_MESSAGE,
3727     offsetof(StreamingProtobufs__GBRQosInformation, n_ie_extensions),
3728     offsetof(StreamingProtobufs__GBRQosInformation, ie_extensions),
3729     &streaming_protobufs__gbr__qos_information__ext_ies__descriptor,
3730     NULL,
3731     0,             /* flags */
3732     0,NULL,NULL    /* reserved1,reserved2, etc */
3733   },
3734 };
3735 static const unsigned streaming_protobufs__gbr__qos_information__field_indices_by_name[] = {
3736   2,   /* field[2] = e_RAB_GuaranteedBitrateDL */
3737   3,   /* field[3] = e_RAB_GuaranteedBitrateUL */
3738   0,   /* field[0] = e_RAB_MaximumBitrateDL */
3739   1,   /* field[1] = e_RAB_MaximumBitrateUL */
3740   4,   /* field[4] = iE_Extensions */
3741 };
3742 static const ProtobufCIntRange streaming_protobufs__gbr__qos_information__number_ranges[1 + 1] =
3743 {
3744   { 1, 0 },
3745   { 0, 5 }
3746 };
3747 const ProtobufCMessageDescriptor streaming_protobufs__gbr__qos_information__descriptor =
3748 {
3749   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3750   "streaming_protobufs.GBR_QosInformation",
3751   "GBRQosInformation",
3752   "StreamingProtobufs__GBRQosInformation",
3753   "streaming_protobufs",
3754   sizeof(StreamingProtobufs__GBRQosInformation),
3755   5,
3756   streaming_protobufs__gbr__qos_information__field_descriptors,
3757   streaming_protobufs__gbr__qos_information__field_indices_by_name,
3758   1,  streaming_protobufs__gbr__qos_information__number_ranges,
3759   (ProtobufCMessageInit) streaming_protobufs__gbr__qos_information__init,
3760   NULL,NULL,NULL    /* reserved[123] */
3761 };
3762 static const ProtobufCFieldDescriptor streaming_protobufs__gbr__qos_information__ext_ies__field_descriptors[4] =
3763 {
3764   {
3765     "id_extended_e_RAB_MaximumBitrateDL",
3766     1,
3767     PROTOBUF_C_LABEL_NONE,
3768     PROTOBUF_C_TYPE_MESSAGE,
3769     0,   /* quantifier_offset */
3770     offsetof(StreamingProtobufs__GBRQosInformationExtIEs, id_extended_e_rab_maximumbitratedl),
3771     &google__protobuf__uint64_value__descriptor,
3772     NULL,
3773     0,             /* flags */
3774     0,NULL,NULL    /* reserved1,reserved2, etc */
3775   },
3776   {
3777     "id_extended_e_RAB_MaximumBitrateUL",
3778     2,
3779     PROTOBUF_C_LABEL_NONE,
3780     PROTOBUF_C_TYPE_MESSAGE,
3781     0,   /* quantifier_offset */
3782     offsetof(StreamingProtobufs__GBRQosInformationExtIEs, id_extended_e_rab_maximumbitrateul),
3783     &google__protobuf__uint64_value__descriptor,
3784     NULL,
3785     0,             /* flags */
3786     0,NULL,NULL    /* reserved1,reserved2, etc */
3787   },
3788   {
3789     "id_extended_e_RAB_GuaranteedBitrateDL",
3790     3,
3791     PROTOBUF_C_LABEL_NONE,
3792     PROTOBUF_C_TYPE_MESSAGE,
3793     0,   /* quantifier_offset */
3794     offsetof(StreamingProtobufs__GBRQosInformationExtIEs, id_extended_e_rab_guaranteedbitratedl),
3795     &google__protobuf__uint64_value__descriptor,
3796     NULL,
3797     0,             /* flags */
3798     0,NULL,NULL    /* reserved1,reserved2, etc */
3799   },
3800   {
3801     "id_extended_e_RAB_GuaranteedBitrateUL",
3802     4,
3803     PROTOBUF_C_LABEL_NONE,
3804     PROTOBUF_C_TYPE_MESSAGE,
3805     0,   /* quantifier_offset */
3806     offsetof(StreamingProtobufs__GBRQosInformationExtIEs, id_extended_e_rab_guaranteedbitrateul),
3807     &google__protobuf__uint64_value__descriptor,
3808     NULL,
3809     0,             /* flags */
3810     0,NULL,NULL    /* reserved1,reserved2, etc */
3811   },
3812 };
3813 static const unsigned streaming_protobufs__gbr__qos_information__ext_ies__field_indices_by_name[] = {
3814   2,   /* field[2] = id_extended_e_RAB_GuaranteedBitrateDL */
3815   3,   /* field[3] = id_extended_e_RAB_GuaranteedBitrateUL */
3816   0,   /* field[0] = id_extended_e_RAB_MaximumBitrateDL */
3817   1,   /* field[1] = id_extended_e_RAB_MaximumBitrateUL */
3818 };
3819 static const ProtobufCIntRange streaming_protobufs__gbr__qos_information__ext_ies__number_ranges[1 + 1] =
3820 {
3821   { 1, 0 },
3822   { 0, 4 }
3823 };
3824 const ProtobufCMessageDescriptor streaming_protobufs__gbr__qos_information__ext_ies__descriptor =
3825 {
3826   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3827   "streaming_protobufs.GBR_QosInformation_ExtIEs",
3828   "GBRQosInformationExtIEs",
3829   "StreamingProtobufs__GBRQosInformationExtIEs",
3830   "streaming_protobufs",
3831   sizeof(StreamingProtobufs__GBRQosInformationExtIEs),
3832   4,
3833   streaming_protobufs__gbr__qos_information__ext_ies__field_descriptors,
3834   streaming_protobufs__gbr__qos_information__ext_ies__field_indices_by_name,
3835   1,  streaming_protobufs__gbr__qos_information__ext_ies__number_ranges,
3836   (ProtobufCMessageInit) streaming_protobufs__gbr__qos_information__ext_ies__init,
3837   NULL,NULL,NULL    /* reserved[123] */
3838 };
3839 static const ProtobufCFieldDescriptor streaming_protobufs__global_gnb__id__field_descriptors[3] =
3840 {
3841   {
3842     "pLMN_Identity",
3843     1,
3844     PROTOBUF_C_LABEL_NONE,
3845     PROTOBUF_C_TYPE_BYTES,
3846     0,   /* quantifier_offset */
3847     offsetof(StreamingProtobufs__GlobalGNBID, plmn_identity),
3848     NULL,
3849     NULL,
3850     0,             /* flags */
3851     0,NULL,NULL    /* reserved1,reserved2, etc */
3852   },
3853   {
3854     "gNB_ID",
3855     2,
3856     PROTOBUF_C_LABEL_NONE,
3857     PROTOBUF_C_TYPE_MESSAGE,
3858     0,   /* quantifier_offset */
3859     offsetof(StreamingProtobufs__GlobalGNBID, gnb_id),
3860     &streaming_protobufs__gnb__id__descriptor,
3861     NULL,
3862     0,             /* flags */
3863     0,NULL,NULL    /* reserved1,reserved2, etc */
3864   },
3865   {
3866     "iE_Extensions",
3867     3,
3868     PROTOBUF_C_LABEL_REPEATED,
3869     PROTOBUF_C_TYPE_MESSAGE,
3870     offsetof(StreamingProtobufs__GlobalGNBID, n_ie_extensions),
3871     offsetof(StreamingProtobufs__GlobalGNBID, ie_extensions),
3872     &streaming_protobufs__global_gnb__id__ext_ies__descriptor,
3873     NULL,
3874     0,             /* flags */
3875     0,NULL,NULL    /* reserved1,reserved2, etc */
3876   },
3877 };
3878 static const unsigned streaming_protobufs__global_gnb__id__field_indices_by_name[] = {
3879   1,   /* field[1] = gNB_ID */
3880   2,   /* field[2] = iE_Extensions */
3881   0,   /* field[0] = pLMN_Identity */
3882 };
3883 static const ProtobufCIntRange streaming_protobufs__global_gnb__id__number_ranges[1 + 1] =
3884 {
3885   { 1, 0 },
3886   { 0, 3 }
3887 };
3888 const ProtobufCMessageDescriptor streaming_protobufs__global_gnb__id__descriptor =
3889 {
3890   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3891   "streaming_protobufs.GlobalGNB_ID",
3892   "GlobalGNBID",
3893   "StreamingProtobufs__GlobalGNBID",
3894   "streaming_protobufs",
3895   sizeof(StreamingProtobufs__GlobalGNBID),
3896   3,
3897   streaming_protobufs__global_gnb__id__field_descriptors,
3898   streaming_protobufs__global_gnb__id__field_indices_by_name,
3899   1,  streaming_protobufs__global_gnb__id__number_ranges,
3900   (ProtobufCMessageInit) streaming_protobufs__global_gnb__id__init,
3901   NULL,NULL,NULL    /* reserved[123] */
3902 };
3903 static const ProtobufCFieldDescriptor streaming_protobufs__gnb__id__field_descriptors[1] =
3904 {
3905   {
3906     "gNB_ID",
3907     1,
3908     PROTOBUF_C_LABEL_NONE,
3909     PROTOBUF_C_TYPE_BYTES,
3910     offsetof(StreamingProtobufs__GNBID, c_case),
3911     offsetof(StreamingProtobufs__GNBID, gnb_id),
3912     NULL,
3913     NULL,
3914     0 | PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3915     0,NULL,NULL    /* reserved1,reserved2, etc */
3916   },
3917 };
3918 static const unsigned streaming_protobufs__gnb__id__field_indices_by_name[] = {
3919   0,   /* field[0] = gNB_ID */
3920 };
3921 static const ProtobufCIntRange streaming_protobufs__gnb__id__number_ranges[1 + 1] =
3922 {
3923   { 1, 0 },
3924   { 0, 1 }
3925 };
3926 const ProtobufCMessageDescriptor streaming_protobufs__gnb__id__descriptor =
3927 {
3928   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3929   "streaming_protobufs.GNB_ID",
3930   "GNBID",
3931   "StreamingProtobufs__GNBID",
3932   "streaming_protobufs",
3933   sizeof(StreamingProtobufs__GNBID),
3934   1,
3935   streaming_protobufs__gnb__id__field_descriptors,
3936   streaming_protobufs__gnb__id__field_indices_by_name,
3937   1,  streaming_protobufs__gnb__id__number_ranges,
3938   (ProtobufCMessageInit) streaming_protobufs__gnb__id__init,
3939   NULL,NULL,NULL    /* reserved[123] */
3940 };
3941 #define streaming_protobufs__global_gnb__id__ext_ies__field_descriptors NULL
3942 #define streaming_protobufs__global_gnb__id__ext_ies__field_indices_by_name NULL
3943 #define streaming_protobufs__global_gnb__id__ext_ies__number_ranges NULL
3944 const ProtobufCMessageDescriptor streaming_protobufs__global_gnb__id__ext_ies__descriptor =
3945 {
3946   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3947   "streaming_protobufs.GlobalGNB_ID_ExtIEs",
3948   "GlobalGNBIDExtIEs",
3949   "StreamingProtobufs__GlobalGNBIDExtIEs",
3950   "streaming_protobufs",
3951   sizeof(StreamingProtobufs__GlobalGNBIDExtIEs),
3952   0,
3953   streaming_protobufs__global_gnb__id__ext_ies__field_descriptors,
3954   streaming_protobufs__global_gnb__id__ext_ies__field_indices_by_name,
3955   0,  streaming_protobufs__global_gnb__id__ext_ies__number_ranges,
3956   (ProtobufCMessageInit) streaming_protobufs__global_gnb__id__ext_ies__init,
3957   NULL,NULL,NULL    /* reserved[123] */
3958 };
3959 static const ProtobufCFieldDescriptor streaming_protobufs__gtptunnel_endpoint__field_descriptors[3] =
3960 {
3961   {
3962     "transportLayerAddress",
3963     1,
3964     PROTOBUF_C_LABEL_NONE,
3965     PROTOBUF_C_TYPE_BYTES,
3966     0,   /* quantifier_offset */
3967     offsetof(StreamingProtobufs__GTPtunnelEndpoint, transportlayeraddress),
3968     NULL,
3969     NULL,
3970     0,             /* flags */
3971     0,NULL,NULL    /* reserved1,reserved2, etc */
3972   },
3973   {
3974     "gTP_TEID",
3975     2,
3976     PROTOBUF_C_LABEL_NONE,
3977     PROTOBUF_C_TYPE_BYTES,
3978     0,   /* quantifier_offset */
3979     offsetof(StreamingProtobufs__GTPtunnelEndpoint, gtp_teid),
3980     NULL,
3981     NULL,
3982     0,             /* flags */
3983     0,NULL,NULL    /* reserved1,reserved2, etc */
3984   },
3985   {
3986     "iE_Extensions",
3987     3,
3988     PROTOBUF_C_LABEL_REPEATED,
3989     PROTOBUF_C_TYPE_MESSAGE,
3990     offsetof(StreamingProtobufs__GTPtunnelEndpoint, n_ie_extensions),
3991     offsetof(StreamingProtobufs__GTPtunnelEndpoint, ie_extensions),
3992     &streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor,
3993     NULL,
3994     0,             /* flags */
3995     0,NULL,NULL    /* reserved1,reserved2, etc */
3996   },
3997 };
3998 static const unsigned streaming_protobufs__gtptunnel_endpoint__field_indices_by_name[] = {
3999   1,   /* field[1] = gTP_TEID */
4000   2,   /* field[2] = iE_Extensions */
4001   0,   /* field[0] = transportLayerAddress */
4002 };
4003 static const ProtobufCIntRange streaming_protobufs__gtptunnel_endpoint__number_ranges[1 + 1] =
4004 {
4005   { 1, 0 },
4006   { 0, 3 }
4007 };
4008 const ProtobufCMessageDescriptor streaming_protobufs__gtptunnel_endpoint__descriptor =
4009 {
4010   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4011   "streaming_protobufs.GTPtunnelEndpoint",
4012   "GTPtunnelEndpoint",
4013   "StreamingProtobufs__GTPtunnelEndpoint",
4014   "streaming_protobufs",
4015   sizeof(StreamingProtobufs__GTPtunnelEndpoint),
4016   3,
4017   streaming_protobufs__gtptunnel_endpoint__field_descriptors,
4018   streaming_protobufs__gtptunnel_endpoint__field_indices_by_name,
4019   1,  streaming_protobufs__gtptunnel_endpoint__number_ranges,
4020   (ProtobufCMessageInit) streaming_protobufs__gtptunnel_endpoint__init,
4021   NULL,NULL,NULL    /* reserved[123] */
4022 };
4023 #define streaming_protobufs__gtptunnel_endpoint__ext_ies__field_descriptors NULL
4024 #define streaming_protobufs__gtptunnel_endpoint__ext_ies__field_indices_by_name NULL
4025 #define streaming_protobufs__gtptunnel_endpoint__ext_ies__number_ranges NULL
4026 const ProtobufCMessageDescriptor streaming_protobufs__gtptunnel_endpoint__ext_ies__descriptor =
4027 {
4028   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4029   "streaming_protobufs.GTPtunnelEndpoint_ExtIEs",
4030   "GTPtunnelEndpointExtIEs",
4031   "StreamingProtobufs__GTPtunnelEndpointExtIEs",
4032   "streaming_protobufs",
4033   sizeof(StreamingProtobufs__GTPtunnelEndpointExtIEs),
4034   0,
4035   streaming_protobufs__gtptunnel_endpoint__ext_ies__field_descriptors,
4036   streaming_protobufs__gtptunnel_endpoint__ext_ies__field_indices_by_name,
4037   0,  streaming_protobufs__gtptunnel_endpoint__ext_ies__number_ranges,
4038   (ProtobufCMessageInit) streaming_protobufs__gtptunnel_endpoint__ext_ies__init,
4039   NULL,NULL,NULL    /* reserved[123] */
4040 };
4041 static const ProtobufCEnumValue streaming_protobufs__rlcmode__value__enum_values_by_number[5] =
4042 {
4043   { "protobuf_unspecified", "STREAMING_PROTOBUFS__RLCMODE__VALUE__protobuf_unspecified", 0 },
4044   { "rlc_am", "STREAMING_PROTOBUFS__RLCMODE__VALUE__rlc_am", 1 },
4045   { "rlc_um_bidirectional", "STREAMING_PROTOBUFS__RLCMODE__VALUE__rlc_um_bidirectional", 2 },
4046   { "rlc_um_unidirectional_ul", "STREAMING_PROTOBUFS__RLCMODE__VALUE__rlc_um_unidirectional_ul", 3 },
4047   { "rlc_um_unidirectional_dl", "STREAMING_PROTOBUFS__RLCMODE__VALUE__rlc_um_unidirectional_dl", 4 },
4048 };
4049 static const ProtobufCIntRange streaming_protobufs__rlcmode__value__value_ranges[] = {
4050 {0, 0},{0, 5}
4051 };
4052 static const ProtobufCEnumValueIndex streaming_protobufs__rlcmode__value__enum_values_by_name[5] =
4053 {
4054   { "protobuf_unspecified", 0 },
4055   { "rlc_am", 1 },
4056   { "rlc_um_bidirectional", 2 },
4057   { "rlc_um_unidirectional_dl", 4 },
4058   { "rlc_um_unidirectional_ul", 3 },
4059 };
4060 const ProtobufCEnumDescriptor streaming_protobufs__rlcmode__value__descriptor =
4061 {
4062   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4063   "streaming_protobufs.RLCMode.Value",
4064   "Value",
4065   "StreamingProtobufs__RLCMode__Value",
4066   "streaming_protobufs",
4067   5,
4068   streaming_protobufs__rlcmode__value__enum_values_by_number,
4069   5,
4070   streaming_protobufs__rlcmode__value__enum_values_by_name,
4071   1,
4072   streaming_protobufs__rlcmode__value__value_ranges,
4073   NULL,NULL,NULL,NULL   /* reserved[1234] */
4074 };
4075 static const ProtobufCFieldDescriptor streaming_protobufs__rlcmode__field_descriptors[1] =
4076 {
4077   {
4078     "value",
4079     1,
4080     PROTOBUF_C_LABEL_NONE,
4081     PROTOBUF_C_TYPE_ENUM,
4082     0,   /* quantifier_offset */
4083     offsetof(StreamingProtobufs__RLCMode, value),
4084     &streaming_protobufs__rlcmode__value__descriptor,
4085     NULL,
4086     0,             /* flags */
4087     0,NULL,NULL    /* reserved1,reserved2, etc */
4088   },
4089 };
4090 static const unsigned streaming_protobufs__rlcmode__field_indices_by_name[] = {
4091   0,   /* field[0] = value */
4092 };
4093 static const ProtobufCIntRange streaming_protobufs__rlcmode__number_ranges[1 + 1] =
4094 {
4095   { 1, 0 },
4096   { 0, 1 }
4097 };
4098 const ProtobufCMessageDescriptor streaming_protobufs__rlcmode__descriptor =
4099 {
4100   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4101   "streaming_protobufs.RLCMode",
4102   "RLCMode",
4103   "StreamingProtobufs__RLCMode",
4104   "streaming_protobufs",
4105   sizeof(StreamingProtobufs__RLCMode),
4106   1,
4107   streaming_protobufs__rlcmode__field_descriptors,
4108   streaming_protobufs__rlcmode__field_indices_by_name,
4109   1,  streaming_protobufs__rlcmode__number_ranges,
4110   (ProtobufCMessageInit) streaming_protobufs__rlcmode__init,
4111   NULL,NULL,NULL    /* reserved[123] */
4112 };
4113 static const ProtobufCEnumValue streaming_protobufs__rlc__status__reestablishment__indication__enum_values_by_number[2] =
4114 {
4115   { "protobuf_unspecified", "STREAMING_PROTOBUFS__RLC__STATUS__REESTABLISHMENT__INDICATION__protobuf_unspecified", 0 },
4116   { "reestablished", "STREAMING_PROTOBUFS__RLC__STATUS__REESTABLISHMENT__INDICATION__reestablished", 1 },
4117 };
4118 static const ProtobufCIntRange streaming_protobufs__rlc__status__reestablishment__indication__value_ranges[] = {
4119 {0, 0},{0, 2}
4120 };
4121 static const ProtobufCEnumValueIndex streaming_protobufs__rlc__status__reestablishment__indication__enum_values_by_name[2] =
4122 {
4123   { "protobuf_unspecified", 0 },
4124   { "reestablished", 1 },
4125 };
4126 const ProtobufCEnumDescriptor streaming_protobufs__rlc__status__reestablishment__indication__descriptor =
4127 {
4128   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4129   "streaming_protobufs.RLC_Status.Reestablishment_Indication",
4130   "Reestablishment_Indication",
4131   "StreamingProtobufs__RLCStatus__ReestablishmentIndication",
4132   "streaming_protobufs",
4133   2,
4134   streaming_protobufs__rlc__status__reestablishment__indication__enum_values_by_number,
4135   2,
4136   streaming_protobufs__rlc__status__reestablishment__indication__enum_values_by_name,
4137   1,
4138   streaming_protobufs__rlc__status__reestablishment__indication__value_ranges,
4139   NULL,NULL,NULL,NULL   /* reserved[1234] */
4140 };
4141 static const ProtobufCFieldDescriptor streaming_protobufs__rlc__status__field_descriptors[1] =
4142 {
4143   {
4144     "reestablishment_Indication",
4145     1,
4146     PROTOBUF_C_LABEL_NONE,
4147     PROTOBUF_C_TYPE_ENUM,
4148     0,   /* quantifier_offset */
4149     offsetof(StreamingProtobufs__RLCStatus, reestablishment_indication),
4150     &streaming_protobufs__rlc__status__reestablishment__indication__descriptor,
4151     NULL,
4152     0,             /* flags */
4153     0,NULL,NULL    /* reserved1,reserved2, etc */
4154   },
4155 };
4156 static const unsigned streaming_protobufs__rlc__status__field_indices_by_name[] = {
4157   0,   /* field[0] = reestablishment_Indication */
4158 };
4159 static const ProtobufCIntRange streaming_protobufs__rlc__status__number_ranges[1 + 1] =
4160 {
4161   { 1, 0 },
4162   { 0, 1 }
4163 };
4164 const ProtobufCMessageDescriptor streaming_protobufs__rlc__status__descriptor =
4165 {
4166   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4167   "streaming_protobufs.RLC_Status",
4168   "RLCStatus",
4169   "StreamingProtobufs__RLCStatus",
4170   "streaming_protobufs",
4171   sizeof(StreamingProtobufs__RLCStatus),
4172   1,
4173   streaming_protobufs__rlc__status__field_descriptors,
4174   streaming_protobufs__rlc__status__field_indices_by_name,
4175   1,  streaming_protobufs__rlc__status__number_ranges,
4176   (ProtobufCMessageInit) streaming_protobufs__rlc__status__init,
4177   NULL,NULL,NULL    /* reserved[123] */
4178 };
4179 static const ProtobufCEnumValue streaming_protobufs__ulconfiguration__ul__ue__configuration__enum_values_by_number[4] =
4180 {
4181   { "protobuf_unspecified", "STREAMING_PROTOBUFS__ULCONFIGURATION__UL__UE__CONFIGURATION__protobuf_unspecified", 0 },
4182   { "no_data", "STREAMING_PROTOBUFS__ULCONFIGURATION__UL__UE__CONFIGURATION__no_data", 1 },
4183   { "shared", "STREAMING_PROTOBUFS__ULCONFIGURATION__UL__UE__CONFIGURATION__shared", 2 },
4184   { "only", "STREAMING_PROTOBUFS__ULCONFIGURATION__UL__UE__CONFIGURATION__only", 3 },
4185 };
4186 static const ProtobufCIntRange streaming_protobufs__ulconfiguration__ul__ue__configuration__value_ranges[] = {
4187 {0, 0},{0, 4}
4188 };
4189 static const ProtobufCEnumValueIndex streaming_protobufs__ulconfiguration__ul__ue__configuration__enum_values_by_name[4] =
4190 {
4191   { "no_data", 1 },
4192   { "only", 3 },
4193   { "protobuf_unspecified", 0 },
4194   { "shared", 2 },
4195 };
4196 const ProtobufCEnumDescriptor streaming_protobufs__ulconfiguration__ul__ue__configuration__descriptor =
4197 {
4198   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4199   "streaming_protobufs.ULConfiguration.UL_UE_Configuration",
4200   "UL_UE_Configuration",
4201   "StreamingProtobufs__ULConfiguration__ULUEConfiguration",
4202   "streaming_protobufs",
4203   4,
4204   streaming_protobufs__ulconfiguration__ul__ue__configuration__enum_values_by_number,
4205   4,
4206   streaming_protobufs__ulconfiguration__ul__ue__configuration__enum_values_by_name,
4207   1,
4208   streaming_protobufs__ulconfiguration__ul__ue__configuration__value_ranges,
4209   NULL,NULL,NULL,NULL   /* reserved[1234] */
4210 };
4211 static const ProtobufCFieldDescriptor streaming_protobufs__ulconfiguration__field_descriptors[1] =
4212 {
4213   {
4214     "uL_PDCP",
4215     1,
4216     PROTOBUF_C_LABEL_NONE,
4217     PROTOBUF_C_TYPE_ENUM,
4218     0,   /* quantifier_offset */
4219     offsetof(StreamingProtobufs__ULConfiguration, ul_pdcp),
4220     &streaming_protobufs__ulconfiguration__ul__ue__configuration__descriptor,
4221     NULL,
4222     0,             /* flags */
4223     0,NULL,NULL    /* reserved1,reserved2, etc */
4224   },
4225 };
4226 static const unsigned streaming_protobufs__ulconfiguration__field_indices_by_name[] = {
4227   0,   /* field[0] = uL_PDCP */
4228 };
4229 static const ProtobufCIntRange streaming_protobufs__ulconfiguration__number_ranges[1 + 1] =
4230 {
4231   { 1, 0 },
4232   { 0, 1 }
4233 };
4234 const ProtobufCMessageDescriptor streaming_protobufs__ulconfiguration__descriptor =
4235 {
4236   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4237   "streaming_protobufs.ULConfiguration",
4238   "ULConfiguration",
4239   "StreamingProtobufs__ULConfiguration",
4240   "streaming_protobufs",
4241   sizeof(StreamingProtobufs__ULConfiguration),
4242   1,
4243   streaming_protobufs__ulconfiguration__field_descriptors,
4244   streaming_protobufs__ulconfiguration__field_indices_by_name,
4245   1,  streaming_protobufs__ulconfiguration__number_ranges,
4246   (ProtobufCMessageInit) streaming_protobufs__ulconfiguration__init,
4247   NULL,NULL,NULL    /* reserved[123] */
4248 };
4249 static const ProtobufCEnumValue streaming_protobufs__pdcpsn_length__value__enum_values_by_number[3] =
4250 {
4251   { "protobuf_unspecified", "STREAMING_PROTOBUFS__PDCPSN_LENGTH__VALUE__protobuf_unspecified", 0 },
4252   { "twelve_bits", "STREAMING_PROTOBUFS__PDCPSN_LENGTH__VALUE__twelve_bits", 1 },
4253   { "eighteen_bits", "STREAMING_PROTOBUFS__PDCPSN_LENGTH__VALUE__eighteen_bits", 2 },
4254 };
4255 static const ProtobufCIntRange streaming_protobufs__pdcpsn_length__value__value_ranges[] = {
4256 {0, 0},{0, 3}
4257 };
4258 static const ProtobufCEnumValueIndex streaming_protobufs__pdcpsn_length__value__enum_values_by_name[3] =
4259 {
4260   { "eighteen_bits", 2 },
4261   { "protobuf_unspecified", 0 },
4262   { "twelve_bits", 1 },
4263 };
4264 const ProtobufCEnumDescriptor streaming_protobufs__pdcpsn_length__value__descriptor =
4265 {
4266   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4267   "streaming_protobufs.PDCPSnLength.Value",
4268   "Value",
4269   "StreamingProtobufs__PDCPSnLength__Value",
4270   "streaming_protobufs",
4271   3,
4272   streaming_protobufs__pdcpsn_length__value__enum_values_by_number,
4273   3,
4274   streaming_protobufs__pdcpsn_length__value__enum_values_by_name,
4275   1,
4276   streaming_protobufs__pdcpsn_length__value__value_ranges,
4277   NULL,NULL,NULL,NULL   /* reserved[1234] */
4278 };
4279 static const ProtobufCFieldDescriptor streaming_protobufs__pdcpsn_length__field_descriptors[1] =
4280 {
4281   {
4282     "value",
4283     1,
4284     PROTOBUF_C_LABEL_NONE,
4285     PROTOBUF_C_TYPE_ENUM,
4286     0,   /* quantifier_offset */
4287     offsetof(StreamingProtobufs__PDCPSnLength, value),
4288     &streaming_protobufs__pdcpsn_length__value__descriptor,
4289     NULL,
4290     0,             /* flags */
4291     0,NULL,NULL    /* reserved1,reserved2, etc */
4292   },
4293 };
4294 static const unsigned streaming_protobufs__pdcpsn_length__field_indices_by_name[] = {
4295   0,   /* field[0] = value */
4296 };
4297 static const ProtobufCIntRange streaming_protobufs__pdcpsn_length__number_ranges[1 + 1] =
4298 {
4299   { 1, 0 },
4300   { 0, 1 }
4301 };
4302 const ProtobufCMessageDescriptor streaming_protobufs__pdcpsn_length__descriptor =
4303 {
4304   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4305   "streaming_protobufs.PDCPSnLength",
4306   "PDCPSnLength",
4307   "StreamingProtobufs__PDCPSnLength",
4308   "streaming_protobufs",
4309   sizeof(StreamingProtobufs__PDCPSnLength),
4310   1,
4311   streaming_protobufs__pdcpsn_length__field_descriptors,
4312   streaming_protobufs__pdcpsn_length__field_indices_by_name,
4313   1,  streaming_protobufs__pdcpsn_length__number_ranges,
4314   (ProtobufCMessageInit) streaming_protobufs__pdcpsn_length__init,
4315   NULL,NULL,NULL    /* reserved[123] */
4316 };
4317 static const ProtobufCEnumValue streaming_protobufs__pdcpchange_indication__value__enum_values_by_number[3] =
4318 {
4319   { "protobuf_unspecified", "STREAMING_PROTOBUFS__PDCPCHANGE_INDICATION__VALUE__protobuf_unspecified", 0 },
4320   { "s_KgNB_update_required", "STREAMING_PROTOBUFS__PDCPCHANGE_INDICATION__VALUE__s_KgNB_update_required", 1 },
4321   { "pDCP_data_recovery_required", "STREAMING_PROTOBUFS__PDCPCHANGE_INDICATION__VALUE__pDCP_data_recovery_required", 2 },
4322 };
4323 static const ProtobufCIntRange streaming_protobufs__pdcpchange_indication__value__value_ranges[] = {
4324 {0, 0},{0, 3}
4325 };
4326 static const ProtobufCEnumValueIndex streaming_protobufs__pdcpchange_indication__value__enum_values_by_name[3] =
4327 {
4328   { "pDCP_data_recovery_required", 2 },
4329   { "protobuf_unspecified", 0 },
4330   { "s_KgNB_update_required", 1 },
4331 };
4332 const ProtobufCEnumDescriptor streaming_protobufs__pdcpchange_indication__value__descriptor =
4333 {
4334   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4335   "streaming_protobufs.PDCPChangeIndication.Value",
4336   "Value",
4337   "StreamingProtobufs__PDCPChangeIndication__Value",
4338   "streaming_protobufs",
4339   3,
4340   streaming_protobufs__pdcpchange_indication__value__enum_values_by_number,
4341   3,
4342   streaming_protobufs__pdcpchange_indication__value__enum_values_by_name,
4343   1,
4344   streaming_protobufs__pdcpchange_indication__value__value_ranges,
4345   NULL,NULL,NULL,NULL   /* reserved[1234] */
4346 };
4347 static const ProtobufCFieldDescriptor streaming_protobufs__pdcpchange_indication__field_descriptors[1] =
4348 {
4349   {
4350     "value",
4351     1,
4352     PROTOBUF_C_LABEL_NONE,
4353     PROTOBUF_C_TYPE_ENUM,
4354     0,   /* quantifier_offset */
4355     offsetof(StreamingProtobufs__PDCPChangeIndication, value),
4356     &streaming_protobufs__pdcpchange_indication__value__descriptor,
4357     NULL,
4358     0,             /* flags */
4359     0,NULL,NULL    /* reserved1,reserved2, etc */
4360   },
4361 };
4362 static const unsigned streaming_protobufs__pdcpchange_indication__field_indices_by_name[] = {
4363   0,   /* field[0] = value */
4364 };
4365 static const ProtobufCIntRange streaming_protobufs__pdcpchange_indication__number_ranges[1 + 1] =
4366 {
4367   { 1, 0 },
4368   { 0, 1 }
4369 };
4370 const ProtobufCMessageDescriptor streaming_protobufs__pdcpchange_indication__descriptor =
4371 {
4372   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4373   "streaming_protobufs.PDCPChangeIndication",
4374   "PDCPChangeIndication",
4375   "StreamingProtobufs__PDCPChangeIndication",
4376   "streaming_protobufs",
4377   sizeof(StreamingProtobufs__PDCPChangeIndication),
4378   1,
4379   streaming_protobufs__pdcpchange_indication__field_descriptors,
4380   streaming_protobufs__pdcpchange_indication__field_indices_by_name,
4381   1,  streaming_protobufs__pdcpchange_indication__number_ranges,
4382   (ProtobufCMessageInit) streaming_protobufs__pdcpchange_indication__init,
4383   NULL,NULL,NULL    /* reserved[123] */
4384 };
4385 static const ProtobufCEnumValue streaming_protobufs__split_srbs__value__enum_values_by_number[4] =
4386 {
4387   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SPLIT_SRBS__VALUE__protobuf_unspecified", 0 },
4388   { "srb1", "STREAMING_PROTOBUFS__SPLIT_SRBS__VALUE__srb1", 1 },
4389   { "srb2", "STREAMING_PROTOBUFS__SPLIT_SRBS__VALUE__srb2", 2 },
4390   { "srb1and2", "STREAMING_PROTOBUFS__SPLIT_SRBS__VALUE__srb1and2", 3 },
4391 };
4392 static const ProtobufCIntRange streaming_protobufs__split_srbs__value__value_ranges[] = {
4393 {0, 0},{0, 4}
4394 };
4395 static const ProtobufCEnumValueIndex streaming_protobufs__split_srbs__value__enum_values_by_name[4] =
4396 {
4397   { "protobuf_unspecified", 0 },
4398   { "srb1", 1 },
4399   { "srb1and2", 3 },
4400   { "srb2", 2 },
4401 };
4402 const ProtobufCEnumDescriptor streaming_protobufs__split_srbs__value__descriptor =
4403 {
4404   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4405   "streaming_protobufs.SplitSRBs.Value",
4406   "Value",
4407   "StreamingProtobufs__SplitSRBs__Value",
4408   "streaming_protobufs",
4409   4,
4410   streaming_protobufs__split_srbs__value__enum_values_by_number,
4411   4,
4412   streaming_protobufs__split_srbs__value__enum_values_by_name,
4413   1,
4414   streaming_protobufs__split_srbs__value__value_ranges,
4415   NULL,NULL,NULL,NULL   /* reserved[1234] */
4416 };
4417 static const ProtobufCFieldDescriptor streaming_protobufs__split_srbs__field_descriptors[1] =
4418 {
4419   {
4420     "value",
4421     1,
4422     PROTOBUF_C_LABEL_NONE,
4423     PROTOBUF_C_TYPE_ENUM,
4424     0,   /* quantifier_offset */
4425     offsetof(StreamingProtobufs__SplitSRBs, value),
4426     &streaming_protobufs__split_srbs__value__descriptor,
4427     NULL,
4428     0,             /* flags */
4429     0,NULL,NULL    /* reserved1,reserved2, etc */
4430   },
4431 };
4432 static const unsigned streaming_protobufs__split_srbs__field_indices_by_name[] = {
4433   0,   /* field[0] = value */
4434 };
4435 static const ProtobufCIntRange streaming_protobufs__split_srbs__number_ranges[1 + 1] =
4436 {
4437   { 1, 0 },
4438   { 0, 1 }
4439 };
4440 const ProtobufCMessageDescriptor streaming_protobufs__split_srbs__descriptor =
4441 {
4442   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4443   "streaming_protobufs.SplitSRBs",
4444   "SplitSRBs",
4445   "StreamingProtobufs__SplitSRBs",
4446   "streaming_protobufs",
4447   sizeof(StreamingProtobufs__SplitSRBs),
4448   1,
4449   streaming_protobufs__split_srbs__field_descriptors,
4450   streaming_protobufs__split_srbs__field_indices_by_name,
4451   1,  streaming_protobufs__split_srbs__number_ranges,
4452   (ProtobufCMessageInit) streaming_protobufs__split_srbs__init,
4453   NULL,NULL,NULL    /* reserved[123] */
4454 };
4455 static const ProtobufCFieldDescriptor streaming_protobufs__nrcgi__field_descriptors[3] =
4456 {
4457   {
4458     "pLMN_Identity",
4459     1,
4460     PROTOBUF_C_LABEL_NONE,
4461     PROTOBUF_C_TYPE_BYTES,
4462     0,   /* quantifier_offset */
4463     offsetof(StreamingProtobufs__NRCGI, plmn_identity),
4464     NULL,
4465     NULL,
4466     0,             /* flags */
4467     0,NULL,NULL    /* reserved1,reserved2, etc */
4468   },
4469   {
4470     "nRcellIdentifier",
4471     2,
4472     PROTOBUF_C_LABEL_NONE,
4473     PROTOBUF_C_TYPE_BYTES,
4474     0,   /* quantifier_offset */
4475     offsetof(StreamingProtobufs__NRCGI, nrcellidentifier),
4476     NULL,
4477     NULL,
4478     0,             /* flags */
4479     0,NULL,NULL    /* reserved1,reserved2, etc */
4480   },
4481   {
4482     "iE_Extensions",
4483     3,
4484     PROTOBUF_C_LABEL_REPEATED,
4485     PROTOBUF_C_TYPE_MESSAGE,
4486     offsetof(StreamingProtobufs__NRCGI, n_ie_extensions),
4487     offsetof(StreamingProtobufs__NRCGI, ie_extensions),
4488     &streaming_protobufs__nrcgi__ext_ies__descriptor,
4489     NULL,
4490     0,             /* flags */
4491     0,NULL,NULL    /* reserved1,reserved2, etc */
4492   },
4493 };
4494 static const unsigned streaming_protobufs__nrcgi__field_indices_by_name[] = {
4495   2,   /* field[2] = iE_Extensions */
4496   1,   /* field[1] = nRcellIdentifier */
4497   0,   /* field[0] = pLMN_Identity */
4498 };
4499 static const ProtobufCIntRange streaming_protobufs__nrcgi__number_ranges[1 + 1] =
4500 {
4501   { 1, 0 },
4502   { 0, 3 }
4503 };
4504 const ProtobufCMessageDescriptor streaming_protobufs__nrcgi__descriptor =
4505 {
4506   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4507   "streaming_protobufs.NRCGI",
4508   "NRCGI",
4509   "StreamingProtobufs__NRCGI",
4510   "streaming_protobufs",
4511   sizeof(StreamingProtobufs__NRCGI),
4512   3,
4513   streaming_protobufs__nrcgi__field_descriptors,
4514   streaming_protobufs__nrcgi__field_indices_by_name,
4515   1,  streaming_protobufs__nrcgi__number_ranges,
4516   (ProtobufCMessageInit) streaming_protobufs__nrcgi__init,
4517   NULL,NULL,NULL    /* reserved[123] */
4518 };
4519 #define streaming_protobufs__nrcgi__ext_ies__field_descriptors NULL
4520 #define streaming_protobufs__nrcgi__ext_ies__field_indices_by_name NULL
4521 #define streaming_protobufs__nrcgi__ext_ies__number_ranges NULL
4522 const ProtobufCMessageDescriptor streaming_protobufs__nrcgi__ext_ies__descriptor =
4523 {
4524   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4525   "streaming_protobufs.NRCGI_ExtIEs",
4526   "NRCGIExtIEs",
4527   "StreamingProtobufs__NRCGIExtIEs",
4528   "streaming_protobufs",
4529   sizeof(StreamingProtobufs__NRCGIExtIEs),
4530   0,
4531   streaming_protobufs__nrcgi__ext_ies__field_descriptors,
4532   streaming_protobufs__nrcgi__ext_ies__field_indices_by_name,
4533   0,  streaming_protobufs__nrcgi__ext_ies__number_ranges,
4534   (ProtobufCMessageInit) streaming_protobufs__nrcgi__ext_ies__init,
4535   NULL,NULL,NULL    /* reserved[123] */
4536 };
4537 static const ProtobufCFieldDescriptor streaming_protobufs__ecgi__field_descriptors[2] =
4538 {
4539   {
4540     "pLMN_Identity",
4541     1,
4542     PROTOBUF_C_LABEL_NONE,
4543     PROTOBUF_C_TYPE_BYTES,
4544     0,   /* quantifier_offset */
4545     offsetof(StreamingProtobufs__ECGI, plmn_identity),
4546     NULL,
4547     NULL,
4548     0,             /* flags */
4549     0,NULL,NULL    /* reserved1,reserved2, etc */
4550   },
4551   {
4552     "eUTRANcellIdentifier",
4553     2,
4554     PROTOBUF_C_LABEL_NONE,
4555     PROTOBUF_C_TYPE_BYTES,
4556     0,   /* quantifier_offset */
4557     offsetof(StreamingProtobufs__ECGI, eutrancellidentifier),
4558     NULL,
4559     NULL,
4560     0,             /* flags */
4561     0,NULL,NULL    /* reserved1,reserved2, etc */
4562   },
4563 };
4564 static const unsigned streaming_protobufs__ecgi__field_indices_by_name[] = {
4565   1,   /* field[1] = eUTRANcellIdentifier */
4566   0,   /* field[0] = pLMN_Identity */
4567 };
4568 static const ProtobufCIntRange streaming_protobufs__ecgi__number_ranges[1 + 1] =
4569 {
4570   { 1, 0 },
4571   { 0, 2 }
4572 };
4573 const ProtobufCMessageDescriptor streaming_protobufs__ecgi__descriptor =
4574 {
4575   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4576   "streaming_protobufs.ECGI",
4577   "ECGI",
4578   "StreamingProtobufs__ECGI",
4579   "streaming_protobufs",
4580   sizeof(StreamingProtobufs__ECGI),
4581   2,
4582   streaming_protobufs__ecgi__field_descriptors,
4583   streaming_protobufs__ecgi__field_indices_by_name,
4584   1,  streaming_protobufs__ecgi__number_ranges,
4585   (ProtobufCMessageInit) streaming_protobufs__ecgi__init,
4586   NULL,NULL,NULL    /* reserved[123] */
4587 };
4588 static const ProtobufCFieldDescriptor streaming_protobufs__e__rab__list__field_descriptors[1] =
4589 {
4590   {
4591     "items",
4592     1,
4593     PROTOBUF_C_LABEL_REPEATED,
4594     PROTOBUF_C_TYPE_MESSAGE,
4595     offsetof(StreamingProtobufs__ERABList, n_items),
4596     offsetof(StreamingProtobufs__ERABList, items),
4597     &streaming_protobufs__e__rab__item_ies__descriptor,
4598     NULL,
4599     0,             /* flags */
4600     0,NULL,NULL    /* reserved1,reserved2, etc */
4601   },
4602 };
4603 static const unsigned streaming_protobufs__e__rab__list__field_indices_by_name[] = {
4604   0,   /* field[0] = items */
4605 };
4606 static const ProtobufCIntRange streaming_protobufs__e__rab__list__number_ranges[1 + 1] =
4607 {
4608   { 1, 0 },
4609   { 0, 1 }
4610 };
4611 const ProtobufCMessageDescriptor streaming_protobufs__e__rab__list__descriptor =
4612 {
4613   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4614   "streaming_protobufs.E_RAB_List",
4615   "ERABList",
4616   "StreamingProtobufs__ERABList",
4617   "streaming_protobufs",
4618   sizeof(StreamingProtobufs__ERABList),
4619   1,
4620   streaming_protobufs__e__rab__list__field_descriptors,
4621   streaming_protobufs__e__rab__list__field_indices_by_name,
4622   1,  streaming_protobufs__e__rab__list__number_ranges,
4623   (ProtobufCMessageInit) streaming_protobufs__e__rab__list__init,
4624   NULL,NULL,NULL    /* reserved[123] */
4625 };
4626 static const ProtobufCFieldDescriptor streaming_protobufs__e__rab__item_ies__field_descriptors[1] =
4627 {
4628   {
4629     "id_E_RAB_Item",
4630     1,
4631     PROTOBUF_C_LABEL_NONE,
4632     PROTOBUF_C_TYPE_MESSAGE,
4633     0,   /* quantifier_offset */
4634     offsetof(StreamingProtobufs__ERABItemIEs, id_e_rab_item),
4635     &streaming_protobufs__e__rab__item__descriptor,
4636     NULL,
4637     0,             /* flags */
4638     0,NULL,NULL    /* reserved1,reserved2, etc */
4639   },
4640 };
4641 static const unsigned streaming_protobufs__e__rab__item_ies__field_indices_by_name[] = {
4642   0,   /* field[0] = id_E_RAB_Item */
4643 };
4644 static const ProtobufCIntRange streaming_protobufs__e__rab__item_ies__number_ranges[1 + 1] =
4645 {
4646   { 1, 0 },
4647   { 0, 1 }
4648 };
4649 const ProtobufCMessageDescriptor streaming_protobufs__e__rab__item_ies__descriptor =
4650 {
4651   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4652   "streaming_protobufs.E_RAB_ItemIEs",
4653   "ERABItemIEs",
4654   "StreamingProtobufs__ERABItemIEs",
4655   "streaming_protobufs",
4656   sizeof(StreamingProtobufs__ERABItemIEs),
4657   1,
4658   streaming_protobufs__e__rab__item_ies__field_descriptors,
4659   streaming_protobufs__e__rab__item_ies__field_indices_by_name,
4660   1,  streaming_protobufs__e__rab__item_ies__number_ranges,
4661   (ProtobufCMessageInit) streaming_protobufs__e__rab__item_ies__init,
4662   NULL,NULL,NULL    /* reserved[123] */
4663 };
4664 static const ProtobufCFieldDescriptor streaming_protobufs__e__rab__item__field_descriptors[2] =
4665 {
4666   {
4667     "e_RAB_ID",
4668     1,
4669     PROTOBUF_C_LABEL_NONE,
4670     PROTOBUF_C_TYPE_UINT32,
4671     0,   /* quantifier_offset */
4672     offsetof(StreamingProtobufs__ERABItem, e_rab_id),
4673     NULL,
4674     NULL,
4675     0,             /* flags */
4676     0,NULL,NULL    /* reserved1,reserved2, etc */
4677   },
4678   {
4679     "cause",
4680     2,
4681     PROTOBUF_C_LABEL_NONE,
4682     PROTOBUF_C_TYPE_MESSAGE,
4683     0,   /* quantifier_offset */
4684     offsetof(StreamingProtobufs__ERABItem, cause),
4685     &streaming_protobufs__cause__descriptor,
4686     NULL,
4687     0,             /* flags */
4688     0,NULL,NULL    /* reserved1,reserved2, etc */
4689   },
4690 };
4691 static const unsigned streaming_protobufs__e__rab__item__field_indices_by_name[] = {
4692   1,   /* field[1] = cause */
4693   0,   /* field[0] = e_RAB_ID */
4694 };
4695 static const ProtobufCIntRange streaming_protobufs__e__rab__item__number_ranges[1 + 1] =
4696 {
4697   { 1, 0 },
4698   { 0, 2 }
4699 };
4700 const ProtobufCMessageDescriptor streaming_protobufs__e__rab__item__descriptor =
4701 {
4702   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4703   "streaming_protobufs.E_RAB_Item",
4704   "ERABItem",
4705   "StreamingProtobufs__ERABItem",
4706   "streaming_protobufs",
4707   sizeof(StreamingProtobufs__ERABItem),
4708   2,
4709   streaming_protobufs__e__rab__item__field_descriptors,
4710   streaming_protobufs__e__rab__item__field_indices_by_name,
4711   1,  streaming_protobufs__e__rab__item__number_ranges,
4712   (ProtobufCMessageInit) streaming_protobufs__e__rab__item__init,
4713   NULL,NULL,NULL    /* reserved[123] */
4714 };
4715 static const ProtobufCFieldDescriptor streaming_protobufs__erabactivity_notify_item_list__field_descriptors[1] =
4716 {
4717   {
4718     "items",
4719     1,
4720     PROTOBUF_C_LABEL_REPEATED,
4721     PROTOBUF_C_TYPE_MESSAGE,
4722     offsetof(StreamingProtobufs__ERABActivityNotifyItemList, n_items),
4723     offsetof(StreamingProtobufs__ERABActivityNotifyItemList, items),
4724     &streaming_protobufs__erabactivity_notify_item__descriptor,
4725     NULL,
4726     0,             /* flags */
4727     0,NULL,NULL    /* reserved1,reserved2, etc */
4728   },
4729 };
4730 static const unsigned streaming_protobufs__erabactivity_notify_item_list__field_indices_by_name[] = {
4731   0,   /* field[0] = items */
4732 };
4733 static const ProtobufCIntRange streaming_protobufs__erabactivity_notify_item_list__number_ranges[1 + 1] =
4734 {
4735   { 1, 0 },
4736   { 0, 1 }
4737 };
4738 const ProtobufCMessageDescriptor streaming_protobufs__erabactivity_notify_item_list__descriptor =
4739 {
4740   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4741   "streaming_protobufs.ERABActivityNotifyItemList",
4742   "ERABActivityNotifyItemList",
4743   "StreamingProtobufs__ERABActivityNotifyItemList",
4744   "streaming_protobufs",
4745   sizeof(StreamingProtobufs__ERABActivityNotifyItemList),
4746   1,
4747   streaming_protobufs__erabactivity_notify_item_list__field_descriptors,
4748   streaming_protobufs__erabactivity_notify_item_list__field_indices_by_name,
4749   1,  streaming_protobufs__erabactivity_notify_item_list__number_ranges,
4750   (ProtobufCMessageInit) streaming_protobufs__erabactivity_notify_item_list__init,
4751   NULL,NULL,NULL    /* reserved[123] */
4752 };
4753 static const ProtobufCFieldDescriptor streaming_protobufs__erabactivity_notify_item__field_descriptors[3] =
4754 {
4755   {
4756     "e_RAB_ID",
4757     1,
4758     PROTOBUF_C_LABEL_NONE,
4759     PROTOBUF_C_TYPE_UINT32,
4760     0,   /* quantifier_offset */
4761     offsetof(StreamingProtobufs__ERABActivityNotifyItem, e_rab_id),
4762     NULL,
4763     NULL,
4764     0,             /* flags */
4765     0,NULL,NULL    /* reserved1,reserved2, etc */
4766   },
4767   {
4768     "activityReport",
4769     2,
4770     PROTOBUF_C_LABEL_NONE,
4771     PROTOBUF_C_TYPE_MESSAGE,
4772     0,   /* quantifier_offset */
4773     offsetof(StreamingProtobufs__ERABActivityNotifyItem, activityreport),
4774     &streaming_protobufs__user_plane_traffic_activity_report__descriptor,
4775     NULL,
4776     0,             /* flags */
4777     0,NULL,NULL    /* reserved1,reserved2, etc */
4778   },
4779   {
4780     "iE_Extensions",
4781     3,
4782     PROTOBUF_C_LABEL_NONE,
4783     PROTOBUF_C_TYPE_MESSAGE,
4784     0,   /* quantifier_offset */
4785     offsetof(StreamingProtobufs__ERABActivityNotifyItem, ie_extensions),
4786     &streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor,
4787     NULL,
4788     0,             /* flags */
4789     0,NULL,NULL    /* reserved1,reserved2, etc */
4790   },
4791 };
4792 static const unsigned streaming_protobufs__erabactivity_notify_item__field_indices_by_name[] = {
4793   1,   /* field[1] = activityReport */
4794   0,   /* field[0] = e_RAB_ID */
4795   2,   /* field[2] = iE_Extensions */
4796 };
4797 static const ProtobufCIntRange streaming_protobufs__erabactivity_notify_item__number_ranges[1 + 1] =
4798 {
4799   { 1, 0 },
4800   { 0, 3 }
4801 };
4802 const ProtobufCMessageDescriptor streaming_protobufs__erabactivity_notify_item__descriptor =
4803 {
4804   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4805   "streaming_protobufs.ERABActivityNotifyItem",
4806   "ERABActivityNotifyItem",
4807   "StreamingProtobufs__ERABActivityNotifyItem",
4808   "streaming_protobufs",
4809   sizeof(StreamingProtobufs__ERABActivityNotifyItem),
4810   3,
4811   streaming_protobufs__erabactivity_notify_item__field_descriptors,
4812   streaming_protobufs__erabactivity_notify_item__field_indices_by_name,
4813   1,  streaming_protobufs__erabactivity_notify_item__number_ranges,
4814   (ProtobufCMessageInit) streaming_protobufs__erabactivity_notify_item__init,
4815   NULL,NULL,NULL    /* reserved[123] */
4816 };
4817 #define streaming_protobufs__erabactivity_notify_item__ext_ies__field_descriptors NULL
4818 #define streaming_protobufs__erabactivity_notify_item__ext_ies__field_indices_by_name NULL
4819 #define streaming_protobufs__erabactivity_notify_item__ext_ies__number_ranges NULL
4820 const ProtobufCMessageDescriptor streaming_protobufs__erabactivity_notify_item__ext_ies__descriptor =
4821 {
4822   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4823   "streaming_protobufs.ERABActivityNotifyItem_ExtIEs",
4824   "ERABActivityNotifyItemExtIEs",
4825   "StreamingProtobufs__ERABActivityNotifyItemExtIEs",
4826   "streaming_protobufs",
4827   sizeof(StreamingProtobufs__ERABActivityNotifyItemExtIEs),
4828   0,
4829   streaming_protobufs__erabactivity_notify_item__ext_ies__field_descriptors,
4830   streaming_protobufs__erabactivity_notify_item__ext_ies__field_indices_by_name,
4831   0,  streaming_protobufs__erabactivity_notify_item__ext_ies__number_ranges,
4832   (ProtobufCMessageInit) streaming_protobufs__erabactivity_notify_item__ext_ies__init,
4833   NULL,NULL,NULL    /* reserved[123] */
4834 };
4835 static const ProtobufCEnumValue streaming_protobufs__user_plane_traffic_activity_report__value__enum_values_by_number[3] =
4836 {
4837   { "protobuf_unspecified", "STREAMING_PROTOBUFS__USER_PLANE_TRAFFIC_ACTIVITY_REPORT__VALUE__protobuf_unspecified", 0 },
4838   { "inactive", "STREAMING_PROTOBUFS__USER_PLANE_TRAFFIC_ACTIVITY_REPORT__VALUE__inactive", 1 },
4839   { "re_activated", "STREAMING_PROTOBUFS__USER_PLANE_TRAFFIC_ACTIVITY_REPORT__VALUE__re_activated", 2 },
4840 };
4841 static const ProtobufCIntRange streaming_protobufs__user_plane_traffic_activity_report__value__value_ranges[] = {
4842 {0, 0},{0, 3}
4843 };
4844 static const ProtobufCEnumValueIndex streaming_protobufs__user_plane_traffic_activity_report__value__enum_values_by_name[3] =
4845 {
4846   { "inactive", 1 },
4847   { "protobuf_unspecified", 0 },
4848   { "re_activated", 2 },
4849 };
4850 const ProtobufCEnumDescriptor streaming_protobufs__user_plane_traffic_activity_report__value__descriptor =
4851 {
4852   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4853   "streaming_protobufs.UserPlaneTrafficActivityReport.Value",
4854   "Value",
4855   "StreamingProtobufs__UserPlaneTrafficActivityReport__Value",
4856   "streaming_protobufs",
4857   3,
4858   streaming_protobufs__user_plane_traffic_activity_report__value__enum_values_by_number,
4859   3,
4860   streaming_protobufs__user_plane_traffic_activity_report__value__enum_values_by_name,
4861   1,
4862   streaming_protobufs__user_plane_traffic_activity_report__value__value_ranges,
4863   NULL,NULL,NULL,NULL   /* reserved[1234] */
4864 };
4865 static const ProtobufCFieldDescriptor streaming_protobufs__user_plane_traffic_activity_report__field_descriptors[1] =
4866 {
4867   {
4868     "value",
4869     1,
4870     PROTOBUF_C_LABEL_NONE,
4871     PROTOBUF_C_TYPE_ENUM,
4872     0,   /* quantifier_offset */
4873     offsetof(StreamingProtobufs__UserPlaneTrafficActivityReport, value),
4874     &streaming_protobufs__user_plane_traffic_activity_report__value__descriptor,
4875     NULL,
4876     0,             /* flags */
4877     0,NULL,NULL    /* reserved1,reserved2, etc */
4878   },
4879 };
4880 static const unsigned streaming_protobufs__user_plane_traffic_activity_report__field_indices_by_name[] = {
4881   0,   /* field[0] = value */
4882 };
4883 static const ProtobufCIntRange streaming_protobufs__user_plane_traffic_activity_report__number_ranges[1 + 1] =
4884 {
4885   { 1, 0 },
4886   { 0, 1 }
4887 };
4888 const ProtobufCMessageDescriptor streaming_protobufs__user_plane_traffic_activity_report__descriptor =
4889 {
4890   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4891   "streaming_protobufs.UserPlaneTrafficActivityReport",
4892   "UserPlaneTrafficActivityReport",
4893   "StreamingProtobufs__UserPlaneTrafficActivityReport",
4894   "streaming_protobufs",
4895   sizeof(StreamingProtobufs__UserPlaneTrafficActivityReport),
4896   1,
4897   streaming_protobufs__user_plane_traffic_activity_report__field_descriptors,
4898   streaming_protobufs__user_plane_traffic_activity_report__field_indices_by_name,
4899   1,  streaming_protobufs__user_plane_traffic_activity_report__number_ranges,
4900   (ProtobufCMessageInit) streaming_protobufs__user_plane_traffic_activity_report__init,
4901   NULL,NULL,NULL    /* reserved[123] */
4902 };
4903 static const ProtobufCEnumValue streaming_protobufs__gnboverload_information__value__enum_values_by_number[3] =
4904 {
4905   { "protobuf_unspecified", "STREAMING_PROTOBUFS__GNBOVERLOAD_INFORMATION__VALUE__protobuf_unspecified", 0 },
4906   { "overloaded", "STREAMING_PROTOBUFS__GNBOVERLOAD_INFORMATION__VALUE__overloaded", 1 },
4907   { "not_overloaded", "STREAMING_PROTOBUFS__GNBOVERLOAD_INFORMATION__VALUE__not_overloaded", 2 },
4908 };
4909 static const ProtobufCIntRange streaming_protobufs__gnboverload_information__value__value_ranges[] = {
4910 {0, 0},{0, 3}
4911 };
4912 static const ProtobufCEnumValueIndex streaming_protobufs__gnboverload_information__value__enum_values_by_name[3] =
4913 {
4914   { "not_overloaded", 2 },
4915   { "overloaded", 1 },
4916   { "protobuf_unspecified", 0 },
4917 };
4918 const ProtobufCEnumDescriptor streaming_protobufs__gnboverload_information__value__descriptor =
4919 {
4920   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4921   "streaming_protobufs.GNBOverloadInformation.Value",
4922   "Value",
4923   "StreamingProtobufs__GNBOverloadInformation__Value",
4924   "streaming_protobufs",
4925   3,
4926   streaming_protobufs__gnboverload_information__value__enum_values_by_number,
4927   3,
4928   streaming_protobufs__gnboverload_information__value__enum_values_by_name,
4929   1,
4930   streaming_protobufs__gnboverload_information__value__value_ranges,
4931   NULL,NULL,NULL,NULL   /* reserved[1234] */
4932 };
4933 static const ProtobufCFieldDescriptor streaming_protobufs__gnboverload_information__field_descriptors[1] =
4934 {
4935   {
4936     "value",
4937     1,
4938     PROTOBUF_C_LABEL_NONE,
4939     PROTOBUF_C_TYPE_ENUM,
4940     0,   /* quantifier_offset */
4941     offsetof(StreamingProtobufs__GNBOverloadInformation, value),
4942     &streaming_protobufs__gnboverload_information__value__descriptor,
4943     NULL,
4944     0,             /* flags */
4945     0,NULL,NULL    /* reserved1,reserved2, etc */
4946   },
4947 };
4948 static const unsigned streaming_protobufs__gnboverload_information__field_indices_by_name[] = {
4949   0,   /* field[0] = value */
4950 };
4951 static const ProtobufCIntRange streaming_protobufs__gnboverload_information__number_ranges[1 + 1] =
4952 {
4953   { 1, 0 },
4954   { 0, 1 }
4955 };
4956 const ProtobufCMessageDescriptor streaming_protobufs__gnboverload_information__descriptor =
4957 {
4958   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4959   "streaming_protobufs.GNBOverloadInformation",
4960   "GNBOverloadInformation",
4961   "StreamingProtobufs__GNBOverloadInformation",
4962   "streaming_protobufs",
4963   sizeof(StreamingProtobufs__GNBOverloadInformation),
4964   1,
4965   streaming_protobufs__gnboverload_information__field_descriptors,
4966   streaming_protobufs__gnboverload_information__field_indices_by_name,
4967   1,  streaming_protobufs__gnboverload_information__number_ranges,
4968   (ProtobufCMessageInit) streaming_protobufs__gnboverload_information__init,
4969   NULL,NULL,NULL    /* reserved[123] */
4970 };
4971 static const ProtobufCFieldDescriptor streaming_protobufs__criticality_diagnostics__field_descriptors[5] =
4972 {
4973   {
4974     "procedureCode",
4975     1,
4976     PROTOBUF_C_LABEL_NONE,
4977     PROTOBUF_C_TYPE_MESSAGE,
4978     0,   /* quantifier_offset */
4979     offsetof(StreamingProtobufs__CriticalityDiagnostics, procedurecode),
4980     &google__protobuf__uint32_value__descriptor,
4981     NULL,
4982     0,             /* flags */
4983     0,NULL,NULL    /* reserved1,reserved2, etc */
4984   },
4985   {
4986     "triggeringMessage",
4987     2,
4988     PROTOBUF_C_LABEL_NONE,
4989     PROTOBUF_C_TYPE_MESSAGE,
4990     0,   /* quantifier_offset */
4991     offsetof(StreamingProtobufs__CriticalityDiagnostics, triggeringmessage),
4992     &streaming_protobufs__triggering_message__descriptor,
4993     NULL,
4994     0,             /* flags */
4995     0,NULL,NULL    /* reserved1,reserved2, etc */
4996   },
4997   {
4998     "procedureCriticality",
4999     3,
5000     PROTOBUF_C_LABEL_NONE,
5001     PROTOBUF_C_TYPE_MESSAGE,
5002     0,   /* quantifier_offset */
5003     offsetof(StreamingProtobufs__CriticalityDiagnostics, procedurecriticality),
5004     &streaming_protobufs__criticality__descriptor,
5005     NULL,
5006     0,             /* flags */
5007     0,NULL,NULL    /* reserved1,reserved2, etc */
5008   },
5009   {
5010     "iEsCriticalityDiagnostics",
5011     4,
5012     PROTOBUF_C_LABEL_NONE,
5013     PROTOBUF_C_TYPE_MESSAGE,
5014     0,   /* quantifier_offset */
5015     offsetof(StreamingProtobufs__CriticalityDiagnostics, iescriticalitydiagnostics),
5016     &streaming_protobufs__criticality_diagnostics__ie__list__descriptor,
5017     NULL,
5018     0,             /* flags */
5019     0,NULL,NULL    /* reserved1,reserved2, etc */
5020   },
5021   {
5022     "iE_Extensions",
5023     5,
5024     PROTOBUF_C_LABEL_REPEATED,
5025     PROTOBUF_C_TYPE_MESSAGE,
5026     offsetof(StreamingProtobufs__CriticalityDiagnostics, n_ie_extensions),
5027     offsetof(StreamingProtobufs__CriticalityDiagnostics, ie_extensions),
5028     &streaming_protobufs__criticality_diagnostics__ext_ies__descriptor,
5029     NULL,
5030     0,             /* flags */
5031     0,NULL,NULL    /* reserved1,reserved2, etc */
5032   },
5033 };
5034 static const unsigned streaming_protobufs__criticality_diagnostics__field_indices_by_name[] = {
5035   4,   /* field[4] = iE_Extensions */
5036   3,   /* field[3] = iEsCriticalityDiagnostics */
5037   0,   /* field[0] = procedureCode */
5038   2,   /* field[2] = procedureCriticality */
5039   1,   /* field[1] = triggeringMessage */
5040 };
5041 static const ProtobufCIntRange streaming_protobufs__criticality_diagnostics__number_ranges[1 + 1] =
5042 {
5043   { 1, 0 },
5044   { 0, 5 }
5045 };
5046 const ProtobufCMessageDescriptor streaming_protobufs__criticality_diagnostics__descriptor =
5047 {
5048   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5049   "streaming_protobufs.CriticalityDiagnostics",
5050   "CriticalityDiagnostics",
5051   "StreamingProtobufs__CriticalityDiagnostics",
5052   "streaming_protobufs",
5053   sizeof(StreamingProtobufs__CriticalityDiagnostics),
5054   5,
5055   streaming_protobufs__criticality_diagnostics__field_descriptors,
5056   streaming_protobufs__criticality_diagnostics__field_indices_by_name,
5057   1,  streaming_protobufs__criticality_diagnostics__number_ranges,
5058   (ProtobufCMessageInit) streaming_protobufs__criticality_diagnostics__init,
5059   NULL,NULL,NULL    /* reserved[123] */
5060 };
5061 static const ProtobufCEnumValue streaming_protobufs__triggering_message__value__enum_values_by_number[4] =
5062 {
5063   { "protobuf_unspecified", "STREAMING_PROTOBUFS__TRIGGERING_MESSAGE__VALUE__protobuf_unspecified", 0 },
5064   { "initiating_message", "STREAMING_PROTOBUFS__TRIGGERING_MESSAGE__VALUE__initiating_message", 1 },
5065   { "successful_outcome", "STREAMING_PROTOBUFS__TRIGGERING_MESSAGE__VALUE__successful_outcome", 2 },
5066   { "unsuccessful_outcome", "STREAMING_PROTOBUFS__TRIGGERING_MESSAGE__VALUE__unsuccessful_outcome", 3 },
5067 };
5068 static const ProtobufCIntRange streaming_protobufs__triggering_message__value__value_ranges[] = {
5069 {0, 0},{0, 4}
5070 };
5071 static const ProtobufCEnumValueIndex streaming_protobufs__triggering_message__value__enum_values_by_name[4] =
5072 {
5073   { "initiating_message", 1 },
5074   { "protobuf_unspecified", 0 },
5075   { "successful_outcome", 2 },
5076   { "unsuccessful_outcome", 3 },
5077 };
5078 const ProtobufCEnumDescriptor streaming_protobufs__triggering_message__value__descriptor =
5079 {
5080   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
5081   "streaming_protobufs.TriggeringMessage.Value",
5082   "Value",
5083   "StreamingProtobufs__TriggeringMessage__Value",
5084   "streaming_protobufs",
5085   4,
5086   streaming_protobufs__triggering_message__value__enum_values_by_number,
5087   4,
5088   streaming_protobufs__triggering_message__value__enum_values_by_name,
5089   1,
5090   streaming_protobufs__triggering_message__value__value_ranges,
5091   NULL,NULL,NULL,NULL   /* reserved[1234] */
5092 };
5093 static const ProtobufCFieldDescriptor streaming_protobufs__triggering_message__field_descriptors[1] =
5094 {
5095   {
5096     "value",
5097     1,
5098     PROTOBUF_C_LABEL_NONE,
5099     PROTOBUF_C_TYPE_ENUM,
5100     0,   /* quantifier_offset */
5101     offsetof(StreamingProtobufs__TriggeringMessage, value),
5102     &streaming_protobufs__triggering_message__value__descriptor,
5103     NULL,
5104     0,             /* flags */
5105     0,NULL,NULL    /* reserved1,reserved2, etc */
5106   },
5107 };
5108 static const unsigned streaming_protobufs__triggering_message__field_indices_by_name[] = {
5109   0,   /* field[0] = value */
5110 };
5111 static const ProtobufCIntRange streaming_protobufs__triggering_message__number_ranges[1 + 1] =
5112 {
5113   { 1, 0 },
5114   { 0, 1 }
5115 };
5116 const ProtobufCMessageDescriptor streaming_protobufs__triggering_message__descriptor =
5117 {
5118   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5119   "streaming_protobufs.TriggeringMessage",
5120   "TriggeringMessage",
5121   "StreamingProtobufs__TriggeringMessage",
5122   "streaming_protobufs",
5123   sizeof(StreamingProtobufs__TriggeringMessage),
5124   1,
5125   streaming_protobufs__triggering_message__field_descriptors,
5126   streaming_protobufs__triggering_message__field_indices_by_name,
5127   1,  streaming_protobufs__triggering_message__number_ranges,
5128   (ProtobufCMessageInit) streaming_protobufs__triggering_message__init,
5129   NULL,NULL,NULL    /* reserved[123] */
5130 };
5131 static const ProtobufCEnumValue streaming_protobufs__criticality__value__enum_values_by_number[4] =
5132 {
5133   { "protobuf_unspecified", "STREAMING_PROTOBUFS__CRITICALITY__VALUE__protobuf_unspecified", 0 },
5134   { "reject", "STREAMING_PROTOBUFS__CRITICALITY__VALUE__reject", 1 },
5135   { "ignore", "STREAMING_PROTOBUFS__CRITICALITY__VALUE__ignore", 2 },
5136   { "notify", "STREAMING_PROTOBUFS__CRITICALITY__VALUE__notify", 3 },
5137 };
5138 static const ProtobufCIntRange streaming_protobufs__criticality__value__value_ranges[] = {
5139 {0, 0},{0, 4}
5140 };
5141 static const ProtobufCEnumValueIndex streaming_protobufs__criticality__value__enum_values_by_name[4] =
5142 {
5143   { "ignore", 2 },
5144   { "notify", 3 },
5145   { "protobuf_unspecified", 0 },
5146   { "reject", 1 },
5147 };
5148 const ProtobufCEnumDescriptor streaming_protobufs__criticality__value__descriptor =
5149 {
5150   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
5151   "streaming_protobufs.Criticality.Value",
5152   "Value",
5153   "StreamingProtobufs__Criticality__Value",
5154   "streaming_protobufs",
5155   4,
5156   streaming_protobufs__criticality__value__enum_values_by_number,
5157   4,
5158   streaming_protobufs__criticality__value__enum_values_by_name,
5159   1,
5160   streaming_protobufs__criticality__value__value_ranges,
5161   NULL,NULL,NULL,NULL   /* reserved[1234] */
5162 };
5163 static const ProtobufCFieldDescriptor streaming_protobufs__criticality__field_descriptors[1] =
5164 {
5165   {
5166     "value",
5167     1,
5168     PROTOBUF_C_LABEL_NONE,
5169     PROTOBUF_C_TYPE_ENUM,
5170     0,   /* quantifier_offset */
5171     offsetof(StreamingProtobufs__Criticality, value),
5172     &streaming_protobufs__criticality__value__descriptor,
5173     NULL,
5174     0,             /* flags */
5175     0,NULL,NULL    /* reserved1,reserved2, etc */
5176   },
5177 };
5178 static const unsigned streaming_protobufs__criticality__field_indices_by_name[] = {
5179   0,   /* field[0] = value */
5180 };
5181 static const ProtobufCIntRange streaming_protobufs__criticality__number_ranges[1 + 1] =
5182 {
5183   { 1, 0 },
5184   { 0, 1 }
5185 };
5186 const ProtobufCMessageDescriptor streaming_protobufs__criticality__descriptor =
5187 {
5188   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5189   "streaming_protobufs.Criticality",
5190   "Criticality",
5191   "StreamingProtobufs__Criticality",
5192   "streaming_protobufs",
5193   sizeof(StreamingProtobufs__Criticality),
5194   1,
5195   streaming_protobufs__criticality__field_descriptors,
5196   streaming_protobufs__criticality__field_indices_by_name,
5197   1,  streaming_protobufs__criticality__number_ranges,
5198   (ProtobufCMessageInit) streaming_protobufs__criticality__init,
5199   NULL,NULL,NULL    /* reserved[123] */
5200 };
5201 static const ProtobufCFieldDescriptor streaming_protobufs__criticality_diagnostics__ie__list__field_descriptors[1] =
5202 {
5203   {
5204     "items",
5205     1,
5206     PROTOBUF_C_LABEL_REPEATED,
5207     PROTOBUF_C_TYPE_MESSAGE,
5208     offsetof(StreamingProtobufs__CriticalityDiagnosticsIEList, n_items),
5209     offsetof(StreamingProtobufs__CriticalityDiagnosticsIEList, items),
5210     &streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor,
5211     NULL,
5212     0,             /* flags */
5213     0,NULL,NULL    /* reserved1,reserved2, etc */
5214   },
5215 };
5216 static const unsigned streaming_protobufs__criticality_diagnostics__ie__list__field_indices_by_name[] = {
5217   0,   /* field[0] = items */
5218 };
5219 static const ProtobufCIntRange streaming_protobufs__criticality_diagnostics__ie__list__number_ranges[1 + 1] =
5220 {
5221   { 1, 0 },
5222   { 0, 1 }
5223 };
5224 const ProtobufCMessageDescriptor streaming_protobufs__criticality_diagnostics__ie__list__descriptor =
5225 {
5226   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5227   "streaming_protobufs.CriticalityDiagnostics_IE_List",
5228   "CriticalityDiagnosticsIEList",
5229   "StreamingProtobufs__CriticalityDiagnosticsIEList",
5230   "streaming_protobufs",
5231   sizeof(StreamingProtobufs__CriticalityDiagnosticsIEList),
5232   1,
5233   streaming_protobufs__criticality_diagnostics__ie__list__field_descriptors,
5234   streaming_protobufs__criticality_diagnostics__ie__list__field_indices_by_name,
5235   1,  streaming_protobufs__criticality_diagnostics__ie__list__number_ranges,
5236   (ProtobufCMessageInit) streaming_protobufs__criticality_diagnostics__ie__list__init,
5237   NULL,NULL,NULL    /* reserved[123] */
5238 };
5239 static const ProtobufCFieldDescriptor streaming_protobufs__criticality_diagnostics__ie__list__item__field_descriptors[3] =
5240 {
5241   {
5242     "iECriticality",
5243     1,
5244     PROTOBUF_C_LABEL_NONE,
5245     PROTOBUF_C_TYPE_MESSAGE,
5246     0,   /* quantifier_offset */
5247     offsetof(StreamingProtobufs__CriticalityDiagnosticsIEListItem, iecriticality),
5248     &streaming_protobufs__criticality__descriptor,
5249     NULL,
5250     0,             /* flags */
5251     0,NULL,NULL    /* reserved1,reserved2, etc */
5252   },
5253   {
5254     "iE_ID",
5255     2,
5256     PROTOBUF_C_LABEL_NONE,
5257     PROTOBUF_C_TYPE_UINT32,
5258     0,   /* quantifier_offset */
5259     offsetof(StreamingProtobufs__CriticalityDiagnosticsIEListItem, ie_id),
5260     NULL,
5261     NULL,
5262     0,             /* flags */
5263     0,NULL,NULL    /* reserved1,reserved2, etc */
5264   },
5265   {
5266     "typeOfError",
5267     3,
5268     PROTOBUF_C_LABEL_NONE,
5269     PROTOBUF_C_TYPE_MESSAGE,
5270     0,   /* quantifier_offset */
5271     offsetof(StreamingProtobufs__CriticalityDiagnosticsIEListItem, typeoferror),
5272     &streaming_protobufs__type_of_error__descriptor,
5273     NULL,
5274     0,             /* flags */
5275     0,NULL,NULL    /* reserved1,reserved2, etc */
5276   },
5277 };
5278 static const unsigned streaming_protobufs__criticality_diagnostics__ie__list__item__field_indices_by_name[] = {
5279   0,   /* field[0] = iECriticality */
5280   1,   /* field[1] = iE_ID */
5281   2,   /* field[2] = typeOfError */
5282 };
5283 static const ProtobufCIntRange streaming_protobufs__criticality_diagnostics__ie__list__item__number_ranges[1 + 1] =
5284 {
5285   { 1, 0 },
5286   { 0, 3 }
5287 };
5288 const ProtobufCMessageDescriptor streaming_protobufs__criticality_diagnostics__ie__list__item__descriptor =
5289 {
5290   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5291   "streaming_protobufs.CriticalityDiagnostics_IE_List_Item",
5292   "CriticalityDiagnosticsIEListItem",
5293   "StreamingProtobufs__CriticalityDiagnosticsIEListItem",
5294   "streaming_protobufs",
5295   sizeof(StreamingProtobufs__CriticalityDiagnosticsIEListItem),
5296   3,
5297   streaming_protobufs__criticality_diagnostics__ie__list__item__field_descriptors,
5298   streaming_protobufs__criticality_diagnostics__ie__list__item__field_indices_by_name,
5299   1,  streaming_protobufs__criticality_diagnostics__ie__list__item__number_ranges,
5300   (ProtobufCMessageInit) streaming_protobufs__criticality_diagnostics__ie__list__item__init,
5301   NULL,NULL,NULL    /* reserved[123] */
5302 };
5303 static const ProtobufCEnumValue streaming_protobufs__type_of_error__value__enum_values_by_number[3] =
5304 {
5305   { "protobuf_unspecified", "STREAMING_PROTOBUFS__TYPE_OF_ERROR__VALUE__protobuf_unspecified", 0 },
5306   { "not_understood", "STREAMING_PROTOBUFS__TYPE_OF_ERROR__VALUE__not_understood", 1 },
5307   { "missing", "STREAMING_PROTOBUFS__TYPE_OF_ERROR__VALUE__missing", 2 },
5308 };
5309 static const ProtobufCIntRange streaming_protobufs__type_of_error__value__value_ranges[] = {
5310 {0, 0},{0, 3}
5311 };
5312 static const ProtobufCEnumValueIndex streaming_protobufs__type_of_error__value__enum_values_by_name[3] =
5313 {
5314   { "missing", 2 },
5315   { "not_understood", 1 },
5316   { "protobuf_unspecified", 0 },
5317 };
5318 const ProtobufCEnumDescriptor streaming_protobufs__type_of_error__value__descriptor =
5319 {
5320   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
5321   "streaming_protobufs.TypeOfError.Value",
5322   "Value",
5323   "StreamingProtobufs__TypeOfError__Value",
5324   "streaming_protobufs",
5325   3,
5326   streaming_protobufs__type_of_error__value__enum_values_by_number,
5327   3,
5328   streaming_protobufs__type_of_error__value__enum_values_by_name,
5329   1,
5330   streaming_protobufs__type_of_error__value__value_ranges,
5331   NULL,NULL,NULL,NULL   /* reserved[1234] */
5332 };
5333 static const ProtobufCFieldDescriptor streaming_protobufs__type_of_error__field_descriptors[1] =
5334 {
5335   {
5336     "value",
5337     1,
5338     PROTOBUF_C_LABEL_NONE,
5339     PROTOBUF_C_TYPE_ENUM,
5340     0,   /* quantifier_offset */
5341     offsetof(StreamingProtobufs__TypeOfError, value),
5342     &streaming_protobufs__type_of_error__value__descriptor,
5343     NULL,
5344     0,             /* flags */
5345     0,NULL,NULL    /* reserved1,reserved2, etc */
5346   },
5347 };
5348 static const unsigned streaming_protobufs__type_of_error__field_indices_by_name[] = {
5349   0,   /* field[0] = value */
5350 };
5351 static const ProtobufCIntRange streaming_protobufs__type_of_error__number_ranges[1 + 1] =
5352 {
5353   { 1, 0 },
5354   { 0, 1 }
5355 };
5356 const ProtobufCMessageDescriptor streaming_protobufs__type_of_error__descriptor =
5357 {
5358   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5359   "streaming_protobufs.TypeOfError",
5360   "TypeOfError",
5361   "StreamingProtobufs__TypeOfError",
5362   "streaming_protobufs",
5363   sizeof(StreamingProtobufs__TypeOfError),
5364   1,
5365   streaming_protobufs__type_of_error__field_descriptors,
5366   streaming_protobufs__type_of_error__field_indices_by_name,
5367   1,  streaming_protobufs__type_of_error__number_ranges,
5368   (ProtobufCMessageInit) streaming_protobufs__type_of_error__init,
5369   NULL,NULL,NULL    /* reserved[123] */
5370 };
5371 #define streaming_protobufs__criticality_diagnostics__ext_ies__field_descriptors NULL
5372 #define streaming_protobufs__criticality_diagnostics__ext_ies__field_indices_by_name NULL
5373 #define streaming_protobufs__criticality_diagnostics__ext_ies__number_ranges NULL
5374 const ProtobufCMessageDescriptor streaming_protobufs__criticality_diagnostics__ext_ies__descriptor =
5375 {
5376   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5377   "streaming_protobufs.CriticalityDiagnostics_ExtIEs",
5378   "CriticalityDiagnosticsExtIEs",
5379   "StreamingProtobufs__CriticalityDiagnosticsExtIEs",
5380   "streaming_protobufs",
5381   sizeof(StreamingProtobufs__CriticalityDiagnosticsExtIEs),
5382   0,
5383   streaming_protobufs__criticality_diagnostics__ext_ies__field_descriptors,
5384   streaming_protobufs__criticality_diagnostics__ext_ies__field_indices_by_name,
5385   0,  streaming_protobufs__criticality_diagnostics__ext_ies__number_ranges,
5386   (ProtobufCMessageInit) streaming_protobufs__criticality_diagnostics__ext_ies__init,
5387   NULL,NULL,NULL    /* reserved[123] */
5388 };
5389 static const ProtobufCFieldDescriptor streaming_protobufs__sg_nbresource_coordination_information__field_descriptors[4] =
5390 {
5391   {
5392     "nR_CGI",
5393     1,
5394     PROTOBUF_C_LABEL_NONE,
5395     PROTOBUF_C_TYPE_MESSAGE,
5396     0,   /* quantifier_offset */
5397     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformation, nr_cgi),
5398     &streaming_protobufs__nrcgi__descriptor,
5399     NULL,
5400     0,             /* flags */
5401     0,NULL,NULL    /* reserved1,reserved2, etc */
5402   },
5403   {
5404     "uLCoordinationInformation",
5405     2,
5406     PROTOBUF_C_LABEL_NONE,
5407     PROTOBUF_C_TYPE_BYTES,
5408     0,   /* quantifier_offset */
5409     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformation, ulcoordinationinformation),
5410     NULL,
5411     NULL,
5412     0,             /* flags */
5413     0,NULL,NULL    /* reserved1,reserved2, etc */
5414   },
5415   {
5416     "dLCoordinationInformation",
5417     3,
5418     PROTOBUF_C_LABEL_NONE,
5419     PROTOBUF_C_TYPE_MESSAGE,
5420     0,   /* quantifier_offset */
5421     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformation, dlcoordinationinformation),
5422     &google__protobuf__bytes_value__descriptor,
5423     NULL,
5424     0,             /* flags */
5425     0,NULL,NULL    /* reserved1,reserved2, etc */
5426   },
5427   {
5428     "iE_Extensions",
5429     4,
5430     PROTOBUF_C_LABEL_REPEATED,
5431     PROTOBUF_C_TYPE_MESSAGE,
5432     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformation, n_ie_extensions),
5433     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformation, ie_extensions),
5434     &streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor,
5435     NULL,
5436     0,             /* flags */
5437     0,NULL,NULL    /* reserved1,reserved2, etc */
5438   },
5439 };
5440 static const unsigned streaming_protobufs__sg_nbresource_coordination_information__field_indices_by_name[] = {
5441   2,   /* field[2] = dLCoordinationInformation */
5442   3,   /* field[3] = iE_Extensions */
5443   0,   /* field[0] = nR_CGI */
5444   1,   /* field[1] = uLCoordinationInformation */
5445 };
5446 static const ProtobufCIntRange streaming_protobufs__sg_nbresource_coordination_information__number_ranges[1 + 1] =
5447 {
5448   { 1, 0 },
5449   { 0, 4 }
5450 };
5451 const ProtobufCMessageDescriptor streaming_protobufs__sg_nbresource_coordination_information__descriptor =
5452 {
5453   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5454   "streaming_protobufs.SgNBResourceCoordinationInformation",
5455   "SgNBResourceCoordinationInformation",
5456   "StreamingProtobufs__SgNBResourceCoordinationInformation",
5457   "streaming_protobufs",
5458   sizeof(StreamingProtobufs__SgNBResourceCoordinationInformation),
5459   4,
5460   streaming_protobufs__sg_nbresource_coordination_information__field_descriptors,
5461   streaming_protobufs__sg_nbresource_coordination_information__field_indices_by_name,
5462   1,  streaming_protobufs__sg_nbresource_coordination_information__number_ranges,
5463   (ProtobufCMessageInit) streaming_protobufs__sg_nbresource_coordination_information__init,
5464   NULL,NULL,NULL    /* reserved[123] */
5465 };
5466 static const ProtobufCFieldDescriptor streaming_protobufs__sg_nbresource_coordination_information_ext_ies__field_descriptors[2] =
5467 {
5468   {
5469     "id_ECGI",
5470     1,
5471     PROTOBUF_C_LABEL_NONE,
5472     PROTOBUF_C_TYPE_MESSAGE,
5473     0,   /* quantifier_offset */
5474     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs, id_ecgi),
5475     &streaming_protobufs__ecgi__descriptor,
5476     NULL,
5477     0,             /* flags */
5478     0,NULL,NULL    /* reserved1,reserved2, etc */
5479   },
5480   {
5481     "id_SgNBCoordinationAssistanceInformation",
5482     2,
5483     PROTOBUF_C_LABEL_NONE,
5484     PROTOBUF_C_TYPE_MESSAGE,
5485     0,   /* quantifier_offset */
5486     offsetof(StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs, id_sgnbcoordinationassistanceinformation),
5487     &streaming_protobufs__sg_nbcoordination_assistance_information__descriptor,
5488     NULL,
5489     0,             /* flags */
5490     0,NULL,NULL    /* reserved1,reserved2, etc */
5491   },
5492 };
5493 static const unsigned streaming_protobufs__sg_nbresource_coordination_information_ext_ies__field_indices_by_name[] = {
5494   0,   /* field[0] = id_ECGI */
5495   1,   /* field[1] = id_SgNBCoordinationAssistanceInformation */
5496 };
5497 static const ProtobufCIntRange streaming_protobufs__sg_nbresource_coordination_information_ext_ies__number_ranges[1 + 1] =
5498 {
5499   { 1, 0 },
5500   { 0, 2 }
5501 };
5502 const ProtobufCMessageDescriptor streaming_protobufs__sg_nbresource_coordination_information_ext_ies__descriptor =
5503 {
5504   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5505   "streaming_protobufs.SgNBResourceCoordinationInformationExtIEs",
5506   "SgNBResourceCoordinationInformationExtIEs",
5507   "StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs",
5508   "streaming_protobufs",
5509   sizeof(StreamingProtobufs__SgNBResourceCoordinationInformationExtIEs),
5510   2,
5511   streaming_protobufs__sg_nbresource_coordination_information_ext_ies__field_descriptors,
5512   streaming_protobufs__sg_nbresource_coordination_information_ext_ies__field_indices_by_name,
5513   1,  streaming_protobufs__sg_nbresource_coordination_information_ext_ies__number_ranges,
5514   (ProtobufCMessageInit) streaming_protobufs__sg_nbresource_coordination_information_ext_ies__init,
5515   NULL,NULL,NULL    /* reserved[123] */
5516 };
5517 static const ProtobufCEnumValue streaming_protobufs__sg_nbcoordination_assistance_information__value__enum_values_by_number[2] =
5518 {
5519   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SG_NBCOORDINATION_ASSISTANCE_INFORMATION__VALUE__protobuf_unspecified", 0 },
5520   { "coordination_not_required", "STREAMING_PROTOBUFS__SG_NBCOORDINATION_ASSISTANCE_INFORMATION__VALUE__coordination_not_required", 1 },
5521 };
5522 static const ProtobufCIntRange streaming_protobufs__sg_nbcoordination_assistance_information__value__value_ranges[] = {
5523 {0, 0},{0, 2}
5524 };
5525 static const ProtobufCEnumValueIndex streaming_protobufs__sg_nbcoordination_assistance_information__value__enum_values_by_name[2] =
5526 {
5527   { "coordination_not_required", 1 },
5528   { "protobuf_unspecified", 0 },
5529 };
5530 const ProtobufCEnumDescriptor streaming_protobufs__sg_nbcoordination_assistance_information__value__descriptor =
5531 {
5532   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
5533   "streaming_protobufs.SgNBCoordinationAssistanceInformation.Value",
5534   "Value",
5535   "StreamingProtobufs__SgNBCoordinationAssistanceInformation__Value",
5536   "streaming_protobufs",
5537   2,
5538   streaming_protobufs__sg_nbcoordination_assistance_information__value__enum_values_by_number,
5539   2,
5540   streaming_protobufs__sg_nbcoordination_assistance_information__value__enum_values_by_name,
5541   1,
5542   streaming_protobufs__sg_nbcoordination_assistance_information__value__value_ranges,
5543   NULL,NULL,NULL,NULL   /* reserved[1234] */
5544 };
5545 static const ProtobufCFieldDescriptor streaming_protobufs__sg_nbcoordination_assistance_information__field_descriptors[1] =
5546 {
5547   {
5548     "value",
5549     1,
5550     PROTOBUF_C_LABEL_NONE,
5551     PROTOBUF_C_TYPE_ENUM,
5552     0,   /* quantifier_offset */
5553     offsetof(StreamingProtobufs__SgNBCoordinationAssistanceInformation, value),
5554     &streaming_protobufs__sg_nbcoordination_assistance_information__value__descriptor,
5555     NULL,
5556     0,             /* flags */
5557     0,NULL,NULL    /* reserved1,reserved2, etc */
5558   },
5559 };
5560 static const unsigned streaming_protobufs__sg_nbcoordination_assistance_information__field_indices_by_name[] = {
5561   0,   /* field[0] = value */
5562 };
5563 static const ProtobufCIntRange streaming_protobufs__sg_nbcoordination_assistance_information__number_ranges[1 + 1] =
5564 {
5565   { 1, 0 },
5566   { 0, 1 }
5567 };
5568 const ProtobufCMessageDescriptor streaming_protobufs__sg_nbcoordination_assistance_information__descriptor =
5569 {
5570   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5571   "streaming_protobufs.SgNBCoordinationAssistanceInformation",
5572   "SgNBCoordinationAssistanceInformation",
5573   "StreamingProtobufs__SgNBCoordinationAssistanceInformation",
5574   "streaming_protobufs",
5575   sizeof(StreamingProtobufs__SgNBCoordinationAssistanceInformation),
5576   1,
5577   streaming_protobufs__sg_nbcoordination_assistance_information__field_descriptors,
5578   streaming_protobufs__sg_nbcoordination_assistance_information__field_indices_by_name,
5579   1,  streaming_protobufs__sg_nbcoordination_assistance_information__number_ranges,
5580   (ProtobufCMessageInit) streaming_protobufs__sg_nbcoordination_assistance_information__init,
5581   NULL,NULL,NULL    /* reserved[123] */
5582 };
5583 static const ProtobufCEnumValue streaming_protobufs__rrc__config__ind__value__enum_values_by_number[3] =
5584 {
5585   { "protobuf_unspecified", "STREAMING_PROTOBUFS__RRC__CONFIG__IND__VALUE__protobuf_unspecified", 0 },
5586   { "full_config", "STREAMING_PROTOBUFS__RRC__CONFIG__IND__VALUE__full_config", 1 },
5587   { "delta_config", "STREAMING_PROTOBUFS__RRC__CONFIG__IND__VALUE__delta_config", 2 },
5588 };
5589 static const ProtobufCIntRange streaming_protobufs__rrc__config__ind__value__value_ranges[] = {
5590 {0, 0},{0, 3}
5591 };
5592 static const ProtobufCEnumValueIndex streaming_protobufs__rrc__config__ind__value__enum_values_by_name[3] =
5593 {
5594   { "delta_config", 2 },
5595   { "full_config", 1 },
5596   { "protobuf_unspecified", 0 },
5597 };
5598 const ProtobufCEnumDescriptor streaming_protobufs__rrc__config__ind__value__descriptor =
5599 {
5600   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
5601   "streaming_protobufs.RRC_Config_Ind.Value",
5602   "Value",
5603   "StreamingProtobufs__RRCConfigInd__Value",
5604   "streaming_protobufs",
5605   3,
5606   streaming_protobufs__rrc__config__ind__value__enum_values_by_number,
5607   3,
5608   streaming_protobufs__rrc__config__ind__value__enum_values_by_name,
5609   1,
5610   streaming_protobufs__rrc__config__ind__value__value_ranges,
5611   NULL,NULL,NULL,NULL   /* reserved[1234] */
5612 };
5613 static const ProtobufCFieldDescriptor streaming_protobufs__rrc__config__ind__field_descriptors[1] =
5614 {
5615   {
5616     "value",
5617     1,
5618     PROTOBUF_C_LABEL_NONE,
5619     PROTOBUF_C_TYPE_ENUM,
5620     0,   /* quantifier_offset */
5621     offsetof(StreamingProtobufs__RRCConfigInd, value),
5622     &streaming_protobufs__rrc__config__ind__value__descriptor,
5623     NULL,
5624     0,             /* flags */
5625     0,NULL,NULL    /* reserved1,reserved2, etc */
5626   },
5627 };
5628 static const unsigned streaming_protobufs__rrc__config__ind__field_indices_by_name[] = {
5629   0,   /* field[0] = value */
5630 };
5631 static const ProtobufCIntRange streaming_protobufs__rrc__config__ind__number_ranges[1 + 1] =
5632 {
5633   { 1, 0 },
5634   { 0, 1 }
5635 };
5636 const ProtobufCMessageDescriptor streaming_protobufs__rrc__config__ind__descriptor =
5637 {
5638   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5639   "streaming_protobufs.RRC_Config_Ind",
5640   "RRCConfigInd",
5641   "StreamingProtobufs__RRCConfigInd",
5642   "streaming_protobufs",
5643   sizeof(StreamingProtobufs__RRCConfigInd),
5644   1,
5645   streaming_protobufs__rrc__config__ind__field_descriptors,
5646   streaming_protobufs__rrc__config__ind__field_indices_by_name,
5647   1,  streaming_protobufs__rrc__config__ind__number_ranges,
5648   (ProtobufCMessageInit) streaming_protobufs__rrc__config__ind__init,
5649   NULL,NULL,NULL    /* reserved[123] */
5650 };
5651 static const ProtobufCFieldDescriptor streaming_protobufs__handover_restriction_list__field_descriptors[6] =
5652 {
5653   {
5654     "servingPLMN",
5655     1,
5656     PROTOBUF_C_LABEL_NONE,
5657     PROTOBUF_C_TYPE_BYTES,
5658     0,   /* quantifier_offset */
5659     offsetof(StreamingProtobufs__HandoverRestrictionList, servingplmn),
5660     NULL,
5661     NULL,
5662     0,             /* flags */
5663     0,NULL,NULL    /* reserved1,reserved2, etc */
5664   },
5665   {
5666     "equivalentPLMNs",
5667     2,
5668     PROTOBUF_C_LABEL_NONE,
5669     PROTOBUF_C_TYPE_MESSAGE,
5670     0,   /* quantifier_offset */
5671     offsetof(StreamingProtobufs__HandoverRestrictionList, equivalentplmns),
5672     &streaming_protobufs__eplmns__descriptor,
5673     NULL,
5674     0,             /* flags */
5675     0,NULL,NULL    /* reserved1,reserved2, etc */
5676   },
5677   {
5678     "forbiddenTAs",
5679     3,
5680     PROTOBUF_C_LABEL_NONE,
5681     PROTOBUF_C_TYPE_MESSAGE,
5682     0,   /* quantifier_offset */
5683     offsetof(StreamingProtobufs__HandoverRestrictionList, forbiddentas),
5684     &streaming_protobufs__forbidden_tas__descriptor,
5685     NULL,
5686     0,             /* flags */
5687     0,NULL,NULL    /* reserved1,reserved2, etc */
5688   },
5689   {
5690     "forbiddenLAs",
5691     4,
5692     PROTOBUF_C_LABEL_NONE,
5693     PROTOBUF_C_TYPE_MESSAGE,
5694     0,   /* quantifier_offset */
5695     offsetof(StreamingProtobufs__HandoverRestrictionList, forbiddenlas),
5696     &streaming_protobufs__forbidden_las__descriptor,
5697     NULL,
5698     0,             /* flags */
5699     0,NULL,NULL    /* reserved1,reserved2, etc */
5700   },
5701   {
5702     "forbiddenInterRATs",
5703     5,
5704     PROTOBUF_C_LABEL_NONE,
5705     PROTOBUF_C_TYPE_MESSAGE,
5706     0,   /* quantifier_offset */
5707     offsetof(StreamingProtobufs__HandoverRestrictionList, forbiddeninterrats),
5708     &streaming_protobufs__forbidden_inter_rats__descriptor,
5709     NULL,
5710     0,             /* flags */
5711     0,NULL,NULL    /* reserved1,reserved2, etc */
5712   },
5713   {
5714     "iE_Extensions",
5715     6,
5716     PROTOBUF_C_LABEL_REPEATED,
5717     PROTOBUF_C_TYPE_MESSAGE,
5718     offsetof(StreamingProtobufs__HandoverRestrictionList, n_ie_extensions),
5719     offsetof(StreamingProtobufs__HandoverRestrictionList, ie_extensions),
5720     &streaming_protobufs__handover_restriction_list__ext_ies__descriptor,
5721     NULL,
5722     0,             /* flags */
5723     0,NULL,NULL    /* reserved1,reserved2, etc */
5724   },
5725 };
5726 static const unsigned streaming_protobufs__handover_restriction_list__field_indices_by_name[] = {
5727   1,   /* field[1] = equivalentPLMNs */
5728   4,   /* field[4] = forbiddenInterRATs */
5729   3,   /* field[3] = forbiddenLAs */
5730   2,   /* field[2] = forbiddenTAs */
5731   5,   /* field[5] = iE_Extensions */
5732   0,   /* field[0] = servingPLMN */
5733 };
5734 static const ProtobufCIntRange streaming_protobufs__handover_restriction_list__number_ranges[1 + 1] =
5735 {
5736   { 1, 0 },
5737   { 0, 6 }
5738 };
5739 const ProtobufCMessageDescriptor streaming_protobufs__handover_restriction_list__descriptor =
5740 {
5741   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5742   "streaming_protobufs.HandoverRestrictionList",
5743   "HandoverRestrictionList",
5744   "StreamingProtobufs__HandoverRestrictionList",
5745   "streaming_protobufs",
5746   sizeof(StreamingProtobufs__HandoverRestrictionList),
5747   6,
5748   streaming_protobufs__handover_restriction_list__field_descriptors,
5749   streaming_protobufs__handover_restriction_list__field_indices_by_name,
5750   1,  streaming_protobufs__handover_restriction_list__number_ranges,
5751   (ProtobufCMessageInit) streaming_protobufs__handover_restriction_list__init,
5752   NULL,NULL,NULL    /* reserved[123] */
5753 };
5754 static const ProtobufCFieldDescriptor streaming_protobufs__eplmns__field_descriptors[1] =
5755 {
5756   {
5757     "items",
5758     1,
5759     PROTOBUF_C_LABEL_REPEATED,
5760     PROTOBUF_C_TYPE_BYTES,
5761     offsetof(StreamingProtobufs__EPLMNs, n_items),
5762     offsetof(StreamingProtobufs__EPLMNs, items),
5763     NULL,
5764     NULL,
5765     0,             /* flags */
5766     0,NULL,NULL    /* reserved1,reserved2, etc */
5767   },
5768 };
5769 static const unsigned streaming_protobufs__eplmns__field_indices_by_name[] = {
5770   0,   /* field[0] = items */
5771 };
5772 static const ProtobufCIntRange streaming_protobufs__eplmns__number_ranges[1 + 1] =
5773 {
5774   { 1, 0 },
5775   { 0, 1 }
5776 };
5777 const ProtobufCMessageDescriptor streaming_protobufs__eplmns__descriptor =
5778 {
5779   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5780   "streaming_protobufs.EPLMNs",
5781   "EPLMNs",
5782   "StreamingProtobufs__EPLMNs",
5783   "streaming_protobufs",
5784   sizeof(StreamingProtobufs__EPLMNs),
5785   1,
5786   streaming_protobufs__eplmns__field_descriptors,
5787   streaming_protobufs__eplmns__field_indices_by_name,
5788   1,  streaming_protobufs__eplmns__number_ranges,
5789   (ProtobufCMessageInit) streaming_protobufs__eplmns__init,
5790   NULL,NULL,NULL    /* reserved[123] */
5791 };
5792 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_tas__field_descriptors[1] =
5793 {
5794   {
5795     "items",
5796     1,
5797     PROTOBUF_C_LABEL_REPEATED,
5798     PROTOBUF_C_TYPE_MESSAGE,
5799     offsetof(StreamingProtobufs__ForbiddenTAs, n_items),
5800     offsetof(StreamingProtobufs__ForbiddenTAs, items),
5801     &streaming_protobufs__forbidden_tas__item__descriptor,
5802     NULL,
5803     0,             /* flags */
5804     0,NULL,NULL    /* reserved1,reserved2, etc */
5805   },
5806 };
5807 static const unsigned streaming_protobufs__forbidden_tas__field_indices_by_name[] = {
5808   0,   /* field[0] = items */
5809 };
5810 static const ProtobufCIntRange streaming_protobufs__forbidden_tas__number_ranges[1 + 1] =
5811 {
5812   { 1, 0 },
5813   { 0, 1 }
5814 };
5815 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_tas__descriptor =
5816 {
5817   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5818   "streaming_protobufs.ForbiddenTAs",
5819   "ForbiddenTAs",
5820   "StreamingProtobufs__ForbiddenTAs",
5821   "streaming_protobufs",
5822   sizeof(StreamingProtobufs__ForbiddenTAs),
5823   1,
5824   streaming_protobufs__forbidden_tas__field_descriptors,
5825   streaming_protobufs__forbidden_tas__field_indices_by_name,
5826   1,  streaming_protobufs__forbidden_tas__number_ranges,
5827   (ProtobufCMessageInit) streaming_protobufs__forbidden_tas__init,
5828   NULL,NULL,NULL    /* reserved[123] */
5829 };
5830 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_tas__item__field_descriptors[2] =
5831 {
5832   {
5833     "pLMN_Identity",
5834     1,
5835     PROTOBUF_C_LABEL_NONE,
5836     PROTOBUF_C_TYPE_BYTES,
5837     0,   /* quantifier_offset */
5838     offsetof(StreamingProtobufs__ForbiddenTAsItem, plmn_identity),
5839     NULL,
5840     NULL,
5841     0,             /* flags */
5842     0,NULL,NULL    /* reserved1,reserved2, etc */
5843   },
5844   {
5845     "forbiddenTACs",
5846     2,
5847     PROTOBUF_C_LABEL_NONE,
5848     PROTOBUF_C_TYPE_MESSAGE,
5849     0,   /* quantifier_offset */
5850     offsetof(StreamingProtobufs__ForbiddenTAsItem, forbiddentacs),
5851     &streaming_protobufs__forbidden_tacs__descriptor,
5852     NULL,
5853     0,             /* flags */
5854     0,NULL,NULL    /* reserved1,reserved2, etc */
5855   },
5856 };
5857 static const unsigned streaming_protobufs__forbidden_tas__item__field_indices_by_name[] = {
5858   1,   /* field[1] = forbiddenTACs */
5859   0,   /* field[0] = pLMN_Identity */
5860 };
5861 static const ProtobufCIntRange streaming_protobufs__forbidden_tas__item__number_ranges[1 + 1] =
5862 {
5863   { 1, 0 },
5864   { 0, 2 }
5865 };
5866 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_tas__item__descriptor =
5867 {
5868   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5869   "streaming_protobufs.ForbiddenTAs_Item",
5870   "ForbiddenTAsItem",
5871   "StreamingProtobufs__ForbiddenTAsItem",
5872   "streaming_protobufs",
5873   sizeof(StreamingProtobufs__ForbiddenTAsItem),
5874   2,
5875   streaming_protobufs__forbidden_tas__item__field_descriptors,
5876   streaming_protobufs__forbidden_tas__item__field_indices_by_name,
5877   1,  streaming_protobufs__forbidden_tas__item__number_ranges,
5878   (ProtobufCMessageInit) streaming_protobufs__forbidden_tas__item__init,
5879   NULL,NULL,NULL    /* reserved[123] */
5880 };
5881 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_tacs__field_descriptors[1] =
5882 {
5883   {
5884     "items",
5885     1,
5886     PROTOBUF_C_LABEL_REPEATED,
5887     PROTOBUF_C_TYPE_BYTES,
5888     offsetof(StreamingProtobufs__ForbiddenTACs, n_items),
5889     offsetof(StreamingProtobufs__ForbiddenTACs, items),
5890     NULL,
5891     NULL,
5892     0,             /* flags */
5893     0,NULL,NULL    /* reserved1,reserved2, etc */
5894   },
5895 };
5896 static const unsigned streaming_protobufs__forbidden_tacs__field_indices_by_name[] = {
5897   0,   /* field[0] = items */
5898 };
5899 static const ProtobufCIntRange streaming_protobufs__forbidden_tacs__number_ranges[1 + 1] =
5900 {
5901   { 1, 0 },
5902   { 0, 1 }
5903 };
5904 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_tacs__descriptor =
5905 {
5906   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5907   "streaming_protobufs.ForbiddenTACs",
5908   "ForbiddenTACs",
5909   "StreamingProtobufs__ForbiddenTACs",
5910   "streaming_protobufs",
5911   sizeof(StreamingProtobufs__ForbiddenTACs),
5912   1,
5913   streaming_protobufs__forbidden_tacs__field_descriptors,
5914   streaming_protobufs__forbidden_tacs__field_indices_by_name,
5915   1,  streaming_protobufs__forbidden_tacs__number_ranges,
5916   (ProtobufCMessageInit) streaming_protobufs__forbidden_tacs__init,
5917   NULL,NULL,NULL    /* reserved[123] */
5918 };
5919 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_las__field_descriptors[1] =
5920 {
5921   {
5922     "items",
5923     1,
5924     PROTOBUF_C_LABEL_REPEATED,
5925     PROTOBUF_C_TYPE_MESSAGE,
5926     offsetof(StreamingProtobufs__ForbiddenLAs, n_items),
5927     offsetof(StreamingProtobufs__ForbiddenLAs, items),
5928     &streaming_protobufs__forbidden_las__item__descriptor,
5929     NULL,
5930     0,             /* flags */
5931     0,NULL,NULL    /* reserved1,reserved2, etc */
5932   },
5933 };
5934 static const unsigned streaming_protobufs__forbidden_las__field_indices_by_name[] = {
5935   0,   /* field[0] = items */
5936 };
5937 static const ProtobufCIntRange streaming_protobufs__forbidden_las__number_ranges[1 + 1] =
5938 {
5939   { 1, 0 },
5940   { 0, 1 }
5941 };
5942 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_las__descriptor =
5943 {
5944   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5945   "streaming_protobufs.ForbiddenLAs",
5946   "ForbiddenLAs",
5947   "StreamingProtobufs__ForbiddenLAs",
5948   "streaming_protobufs",
5949   sizeof(StreamingProtobufs__ForbiddenLAs),
5950   1,
5951   streaming_protobufs__forbidden_las__field_descriptors,
5952   streaming_protobufs__forbidden_las__field_indices_by_name,
5953   1,  streaming_protobufs__forbidden_las__number_ranges,
5954   (ProtobufCMessageInit) streaming_protobufs__forbidden_las__init,
5955   NULL,NULL,NULL    /* reserved[123] */
5956 };
5957 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_las__item__field_descriptors[2] =
5958 {
5959   {
5960     "pLMN_Identity",
5961     1,
5962     PROTOBUF_C_LABEL_NONE,
5963     PROTOBUF_C_TYPE_BYTES,
5964     0,   /* quantifier_offset */
5965     offsetof(StreamingProtobufs__ForbiddenLAsItem, plmn_identity),
5966     NULL,
5967     NULL,
5968     0,             /* flags */
5969     0,NULL,NULL    /* reserved1,reserved2, etc */
5970   },
5971   {
5972     "forbiddenLACs",
5973     2,
5974     PROTOBUF_C_LABEL_NONE,
5975     PROTOBUF_C_TYPE_MESSAGE,
5976     0,   /* quantifier_offset */
5977     offsetof(StreamingProtobufs__ForbiddenLAsItem, forbiddenlacs),
5978     &streaming_protobufs__forbidden_lacs__descriptor,
5979     NULL,
5980     0,             /* flags */
5981     0,NULL,NULL    /* reserved1,reserved2, etc */
5982   },
5983 };
5984 static const unsigned streaming_protobufs__forbidden_las__item__field_indices_by_name[] = {
5985   1,   /* field[1] = forbiddenLACs */
5986   0,   /* field[0] = pLMN_Identity */
5987 };
5988 static const ProtobufCIntRange streaming_protobufs__forbidden_las__item__number_ranges[1 + 1] =
5989 {
5990   { 1, 0 },
5991   { 0, 2 }
5992 };
5993 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_las__item__descriptor =
5994 {
5995   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5996   "streaming_protobufs.ForbiddenLAs_Item",
5997   "ForbiddenLAsItem",
5998   "StreamingProtobufs__ForbiddenLAsItem",
5999   "streaming_protobufs",
6000   sizeof(StreamingProtobufs__ForbiddenLAsItem),
6001   2,
6002   streaming_protobufs__forbidden_las__item__field_descriptors,
6003   streaming_protobufs__forbidden_las__item__field_indices_by_name,
6004   1,  streaming_protobufs__forbidden_las__item__number_ranges,
6005   (ProtobufCMessageInit) streaming_protobufs__forbidden_las__item__init,
6006   NULL,NULL,NULL    /* reserved[123] */
6007 };
6008 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_lacs__field_descriptors[1] =
6009 {
6010   {
6011     "items",
6012     1,
6013     PROTOBUF_C_LABEL_REPEATED,
6014     PROTOBUF_C_TYPE_BYTES,
6015     offsetof(StreamingProtobufs__ForbiddenLACs, n_items),
6016     offsetof(StreamingProtobufs__ForbiddenLACs, items),
6017     NULL,
6018     NULL,
6019     0,             /* flags */
6020     0,NULL,NULL    /* reserved1,reserved2, etc */
6021   },
6022 };
6023 static const unsigned streaming_protobufs__forbidden_lacs__field_indices_by_name[] = {
6024   0,   /* field[0] = items */
6025 };
6026 static const ProtobufCIntRange streaming_protobufs__forbidden_lacs__number_ranges[1 + 1] =
6027 {
6028   { 1, 0 },
6029   { 0, 1 }
6030 };
6031 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_lacs__descriptor =
6032 {
6033   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6034   "streaming_protobufs.ForbiddenLACs",
6035   "ForbiddenLACs",
6036   "StreamingProtobufs__ForbiddenLACs",
6037   "streaming_protobufs",
6038   sizeof(StreamingProtobufs__ForbiddenLACs),
6039   1,
6040   streaming_protobufs__forbidden_lacs__field_descriptors,
6041   streaming_protobufs__forbidden_lacs__field_indices_by_name,
6042   1,  streaming_protobufs__forbidden_lacs__number_ranges,
6043   (ProtobufCMessageInit) streaming_protobufs__forbidden_lacs__init,
6044   NULL,NULL,NULL    /* reserved[123] */
6045 };
6046 static const ProtobufCEnumValue streaming_protobufs__forbidden_inter_rats__value__enum_values_by_number[7] =
6047 {
6048   { "protobuf_unspecified", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__protobuf_unspecified", 0 },
6049   { "all", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__all", 1 },
6050   { "geran", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__geran", 2 },
6051   { "utran", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__utran", 3 },
6052   { "cdma2000", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__cdma2000", 4 },
6053   { "geranandutran", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__geranandutran", 5 },
6054   { "cdma2000andutran", "STREAMING_PROTOBUFS__FORBIDDEN_INTER_RATS__VALUE__cdma2000andutran", 6 },
6055 };
6056 static const ProtobufCIntRange streaming_protobufs__forbidden_inter_rats__value__value_ranges[] = {
6057 {0, 0},{0, 7}
6058 };
6059 static const ProtobufCEnumValueIndex streaming_protobufs__forbidden_inter_rats__value__enum_values_by_name[7] =
6060 {
6061   { "all", 1 },
6062   { "cdma2000", 4 },
6063   { "cdma2000andutran", 6 },
6064   { "geran", 2 },
6065   { "geranandutran", 5 },
6066   { "protobuf_unspecified", 0 },
6067   { "utran", 3 },
6068 };
6069 const ProtobufCEnumDescriptor streaming_protobufs__forbidden_inter_rats__value__descriptor =
6070 {
6071   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6072   "streaming_protobufs.ForbiddenInterRATs.Value",
6073   "Value",
6074   "StreamingProtobufs__ForbiddenInterRATs__Value",
6075   "streaming_protobufs",
6076   7,
6077   streaming_protobufs__forbidden_inter_rats__value__enum_values_by_number,
6078   7,
6079   streaming_protobufs__forbidden_inter_rats__value__enum_values_by_name,
6080   1,
6081   streaming_protobufs__forbidden_inter_rats__value__value_ranges,
6082   NULL,NULL,NULL,NULL   /* reserved[1234] */
6083 };
6084 static const ProtobufCFieldDescriptor streaming_protobufs__forbidden_inter_rats__field_descriptors[1] =
6085 {
6086   {
6087     "value",
6088     1,
6089     PROTOBUF_C_LABEL_NONE,
6090     PROTOBUF_C_TYPE_ENUM,
6091     0,   /* quantifier_offset */
6092     offsetof(StreamingProtobufs__ForbiddenInterRATs, value),
6093     &streaming_protobufs__forbidden_inter_rats__value__descriptor,
6094     NULL,
6095     0,             /* flags */
6096     0,NULL,NULL    /* reserved1,reserved2, etc */
6097   },
6098 };
6099 static const unsigned streaming_protobufs__forbidden_inter_rats__field_indices_by_name[] = {
6100   0,   /* field[0] = value */
6101 };
6102 static const ProtobufCIntRange streaming_protobufs__forbidden_inter_rats__number_ranges[1 + 1] =
6103 {
6104   { 1, 0 },
6105   { 0, 1 }
6106 };
6107 const ProtobufCMessageDescriptor streaming_protobufs__forbidden_inter_rats__descriptor =
6108 {
6109   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6110   "streaming_protobufs.ForbiddenInterRATs",
6111   "ForbiddenInterRATs",
6112   "StreamingProtobufs__ForbiddenInterRATs",
6113   "streaming_protobufs",
6114   sizeof(StreamingProtobufs__ForbiddenInterRATs),
6115   1,
6116   streaming_protobufs__forbidden_inter_rats__field_descriptors,
6117   streaming_protobufs__forbidden_inter_rats__field_indices_by_name,
6118   1,  streaming_protobufs__forbidden_inter_rats__number_ranges,
6119   (ProtobufCMessageInit) streaming_protobufs__forbidden_inter_rats__init,
6120   NULL,NULL,NULL    /* reserved[123] */
6121 };
6122 static const ProtobufCFieldDescriptor streaming_protobufs__handover_restriction_list__ext_ies__field_descriptors[3] =
6123 {
6124   {
6125     "id_NRrestrictioninEPSasSecondaryRAT",
6126     1,
6127     PROTOBUF_C_LABEL_NONE,
6128     PROTOBUF_C_TYPE_MESSAGE,
6129     0,   /* quantifier_offset */
6130     offsetof(StreamingProtobufs__HandoverRestrictionListExtIEs, id_nrrestrictioninepsassecondaryrat),
6131     &streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor,
6132     NULL,
6133     0,             /* flags */
6134     0,NULL,NULL    /* reserved1,reserved2, etc */
6135   },
6136   {
6137     "id_CNTypeRestrictions",
6138     2,
6139     PROTOBUF_C_LABEL_NONE,
6140     PROTOBUF_C_TYPE_MESSAGE,
6141     0,   /* quantifier_offset */
6142     offsetof(StreamingProtobufs__HandoverRestrictionListExtIEs, id_cntyperestrictions),
6143     &streaming_protobufs__cntype_restrictions__descriptor,
6144     NULL,
6145     0,             /* flags */
6146     0,NULL,NULL    /* reserved1,reserved2, etc */
6147   },
6148   {
6149     "id_NRrestrictionin5GS",
6150     3,
6151     PROTOBUF_C_LABEL_NONE,
6152     PROTOBUF_C_TYPE_MESSAGE,
6153     0,   /* quantifier_offset */
6154     offsetof(StreamingProtobufs__HandoverRestrictionListExtIEs, id_nrrestrictionin5gs),
6155     &streaming_protobufs__nrrestrictionin5_gs__descriptor,
6156     NULL,
6157     0,             /* flags */
6158     0,NULL,NULL    /* reserved1,reserved2, etc */
6159   },
6160 };
6161 static const unsigned streaming_protobufs__handover_restriction_list__ext_ies__field_indices_by_name[] = {
6162   1,   /* field[1] = id_CNTypeRestrictions */
6163   2,   /* field[2] = id_NRrestrictionin5GS */
6164   0,   /* field[0] = id_NRrestrictioninEPSasSecondaryRAT */
6165 };
6166 static const ProtobufCIntRange streaming_protobufs__handover_restriction_list__ext_ies__number_ranges[1 + 1] =
6167 {
6168   { 1, 0 },
6169   { 0, 3 }
6170 };
6171 const ProtobufCMessageDescriptor streaming_protobufs__handover_restriction_list__ext_ies__descriptor =
6172 {
6173   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6174   "streaming_protobufs.HandoverRestrictionList_ExtIEs",
6175   "HandoverRestrictionListExtIEs",
6176   "StreamingProtobufs__HandoverRestrictionListExtIEs",
6177   "streaming_protobufs",
6178   sizeof(StreamingProtobufs__HandoverRestrictionListExtIEs),
6179   3,
6180   streaming_protobufs__handover_restriction_list__ext_ies__field_descriptors,
6181   streaming_protobufs__handover_restriction_list__ext_ies__field_indices_by_name,
6182   1,  streaming_protobufs__handover_restriction_list__ext_ies__number_ranges,
6183   (ProtobufCMessageInit) streaming_protobufs__handover_restriction_list__ext_ies__init,
6184   NULL,NULL,NULL    /* reserved[123] */
6185 };
6186 static const ProtobufCEnumValue streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__enum_values_by_number[2] =
6187 {
6188   { "protobuf_unspecified", "STREAMING_PROTOBUFS__NRRESTRICTIONIN_EPSAS_SECONDARY_RAT__VALUE__protobuf_unspecified", 0 },
6189   { "nRrestrictedinEPSasSecondaryRAT", "STREAMING_PROTOBUFS__NRRESTRICTIONIN_EPSAS_SECONDARY_RAT__VALUE__nRrestrictedinEPSasSecondaryRAT", 1 },
6190 };
6191 static const ProtobufCIntRange streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__value_ranges[] = {
6192 {0, 0},{0, 2}
6193 };
6194 static const ProtobufCEnumValueIndex streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__enum_values_by_name[2] =
6195 {
6196   { "nRrestrictedinEPSasSecondaryRAT", 1 },
6197   { "protobuf_unspecified", 0 },
6198 };
6199 const ProtobufCEnumDescriptor streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__descriptor =
6200 {
6201   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6202   "streaming_protobufs.NRrestrictioninEPSasSecondaryRAT.Value",
6203   "Value",
6204   "StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT__Value",
6205   "streaming_protobufs",
6206   2,
6207   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__enum_values_by_number,
6208   2,
6209   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__enum_values_by_name,
6210   1,
6211   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__value_ranges,
6212   NULL,NULL,NULL,NULL   /* reserved[1234] */
6213 };
6214 static const ProtobufCFieldDescriptor streaming_protobufs__nrrestrictionin_epsas_secondary_rat__field_descriptors[1] =
6215 {
6216   {
6217     "value",
6218     1,
6219     PROTOBUF_C_LABEL_NONE,
6220     PROTOBUF_C_TYPE_ENUM,
6221     0,   /* quantifier_offset */
6222     offsetof(StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT, value),
6223     &streaming_protobufs__nrrestrictionin_epsas_secondary_rat__value__descriptor,
6224     NULL,
6225     0,             /* flags */
6226     0,NULL,NULL    /* reserved1,reserved2, etc */
6227   },
6228 };
6229 static const unsigned streaming_protobufs__nrrestrictionin_epsas_secondary_rat__field_indices_by_name[] = {
6230   0,   /* field[0] = value */
6231 };
6232 static const ProtobufCIntRange streaming_protobufs__nrrestrictionin_epsas_secondary_rat__number_ranges[1 + 1] =
6233 {
6234   { 1, 0 },
6235   { 0, 1 }
6236 };
6237 const ProtobufCMessageDescriptor streaming_protobufs__nrrestrictionin_epsas_secondary_rat__descriptor =
6238 {
6239   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6240   "streaming_protobufs.NRrestrictioninEPSasSecondaryRAT",
6241   "NRrestrictioninEPSasSecondaryRAT",
6242   "StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT",
6243   "streaming_protobufs",
6244   sizeof(StreamingProtobufs__NRrestrictioninEPSasSecondaryRAT),
6245   1,
6246   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__field_descriptors,
6247   streaming_protobufs__nrrestrictionin_epsas_secondary_rat__field_indices_by_name,
6248   1,  streaming_protobufs__nrrestrictionin_epsas_secondary_rat__number_ranges,
6249   (ProtobufCMessageInit) streaming_protobufs__nrrestrictionin_epsas_secondary_rat__init,
6250   NULL,NULL,NULL    /* reserved[123] */
6251 };
6252 static const ProtobufCFieldDescriptor streaming_protobufs__cntype_restrictions__field_descriptors[1] =
6253 {
6254   {
6255     "items",
6256     1,
6257     PROTOBUF_C_LABEL_REPEATED,
6258     PROTOBUF_C_TYPE_MESSAGE,
6259     offsetof(StreamingProtobufs__CNTypeRestrictions, n_items),
6260     offsetof(StreamingProtobufs__CNTypeRestrictions, items),
6261     &streaming_protobufs__cntype_restrictions_item__descriptor,
6262     NULL,
6263     0,             /* flags */
6264     0,NULL,NULL    /* reserved1,reserved2, etc */
6265   },
6266 };
6267 static const unsigned streaming_protobufs__cntype_restrictions__field_indices_by_name[] = {
6268   0,   /* field[0] = items */
6269 };
6270 static const ProtobufCIntRange streaming_protobufs__cntype_restrictions__number_ranges[1 + 1] =
6271 {
6272   { 1, 0 },
6273   { 0, 1 }
6274 };
6275 const ProtobufCMessageDescriptor streaming_protobufs__cntype_restrictions__descriptor =
6276 {
6277   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6278   "streaming_protobufs.CNTypeRestrictions",
6279   "CNTypeRestrictions",
6280   "StreamingProtobufs__CNTypeRestrictions",
6281   "streaming_protobufs",
6282   sizeof(StreamingProtobufs__CNTypeRestrictions),
6283   1,
6284   streaming_protobufs__cntype_restrictions__field_descriptors,
6285   streaming_protobufs__cntype_restrictions__field_indices_by_name,
6286   1,  streaming_protobufs__cntype_restrictions__number_ranges,
6287   (ProtobufCMessageInit) streaming_protobufs__cntype_restrictions__init,
6288   NULL,NULL,NULL    /* reserved[123] */
6289 };
6290 static const ProtobufCEnumValue streaming_protobufs__cntype_restrictions_item__cn_type__enum_values_by_number[2] =
6291 {
6292   { "protobuf_unspecified", "STREAMING_PROTOBUFS__CNTYPE_RESTRICTIONS_ITEM__CN_TYPE__protobuf_unspecified", 0 },
6293   { "fiveGC_forbidden", "STREAMING_PROTOBUFS__CNTYPE_RESTRICTIONS_ITEM__CN_TYPE__fiveGC_forbidden", 1 },
6294 };
6295 static const ProtobufCIntRange streaming_protobufs__cntype_restrictions_item__cn_type__value_ranges[] = {
6296 {0, 0},{0, 2}
6297 };
6298 static const ProtobufCEnumValueIndex streaming_protobufs__cntype_restrictions_item__cn_type__enum_values_by_name[2] =
6299 {
6300   { "fiveGC_forbidden", 1 },
6301   { "protobuf_unspecified", 0 },
6302 };
6303 const ProtobufCEnumDescriptor streaming_protobufs__cntype_restrictions_item__cn_type__descriptor =
6304 {
6305   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6306   "streaming_protobufs.CNTypeRestrictionsItem.CN_type",
6307   "CN_type",
6308   "StreamingProtobufs__CNTypeRestrictionsItem__CNType",
6309   "streaming_protobufs",
6310   2,
6311   streaming_protobufs__cntype_restrictions_item__cn_type__enum_values_by_number,
6312   2,
6313   streaming_protobufs__cntype_restrictions_item__cn_type__enum_values_by_name,
6314   1,
6315   streaming_protobufs__cntype_restrictions_item__cn_type__value_ranges,
6316   NULL,NULL,NULL,NULL   /* reserved[1234] */
6317 };
6318 static const ProtobufCFieldDescriptor streaming_protobufs__cntype_restrictions_item__field_descriptors[2] =
6319 {
6320   {
6321     "plmn_Id",
6322     1,
6323     PROTOBUF_C_LABEL_NONE,
6324     PROTOBUF_C_TYPE_BYTES,
6325     0,   /* quantifier_offset */
6326     offsetof(StreamingProtobufs__CNTypeRestrictionsItem, plmn_id),
6327     NULL,
6328     NULL,
6329     0,             /* flags */
6330     0,NULL,NULL    /* reserved1,reserved2, etc */
6331   },
6332   {
6333     "cn_type",
6334     2,
6335     PROTOBUF_C_LABEL_NONE,
6336     PROTOBUF_C_TYPE_ENUM,
6337     0,   /* quantifier_offset */
6338     offsetof(StreamingProtobufs__CNTypeRestrictionsItem, cn_type),
6339     &streaming_protobufs__cntype_restrictions_item__cn_type__descriptor,
6340     NULL,
6341     0,             /* flags */
6342     0,NULL,NULL    /* reserved1,reserved2, etc */
6343   },
6344 };
6345 static const unsigned streaming_protobufs__cntype_restrictions_item__field_indices_by_name[] = {
6346   1,   /* field[1] = cn_type */
6347   0,   /* field[0] = plmn_Id */
6348 };
6349 static const ProtobufCIntRange streaming_protobufs__cntype_restrictions_item__number_ranges[1 + 1] =
6350 {
6351   { 1, 0 },
6352   { 0, 2 }
6353 };
6354 const ProtobufCMessageDescriptor streaming_protobufs__cntype_restrictions_item__descriptor =
6355 {
6356   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6357   "streaming_protobufs.CNTypeRestrictionsItem",
6358   "CNTypeRestrictionsItem",
6359   "StreamingProtobufs__CNTypeRestrictionsItem",
6360   "streaming_protobufs",
6361   sizeof(StreamingProtobufs__CNTypeRestrictionsItem),
6362   2,
6363   streaming_protobufs__cntype_restrictions_item__field_descriptors,
6364   streaming_protobufs__cntype_restrictions_item__field_indices_by_name,
6365   1,  streaming_protobufs__cntype_restrictions_item__number_ranges,
6366   (ProtobufCMessageInit) streaming_protobufs__cntype_restrictions_item__init,
6367   NULL,NULL,NULL    /* reserved[123] */
6368 };
6369 static const ProtobufCEnumValue streaming_protobufs__nrrestrictionin5_gs__value__enum_values_by_number[2] =
6370 {
6371   { "protobuf_unspecified", "STREAMING_PROTOBUFS__NRRESTRICTIONIN5_GS__VALUE__protobuf_unspecified", 0 },
6372   { "nRrestrictedin5GS", "STREAMING_PROTOBUFS__NRRESTRICTIONIN5_GS__VALUE__nRrestrictedin5GS", 1 },
6373 };
6374 static const ProtobufCIntRange streaming_protobufs__nrrestrictionin5_gs__value__value_ranges[] = {
6375 {0, 0},{0, 2}
6376 };
6377 static const ProtobufCEnumValueIndex streaming_protobufs__nrrestrictionin5_gs__value__enum_values_by_name[2] =
6378 {
6379   { "nRrestrictedin5GS", 1 },
6380   { "protobuf_unspecified", 0 },
6381 };
6382 const ProtobufCEnumDescriptor streaming_protobufs__nrrestrictionin5_gs__value__descriptor =
6383 {
6384   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6385   "streaming_protobufs.NRrestrictionin5GS.Value",
6386   "Value",
6387   "StreamingProtobufs__NRrestrictionin5GS__Value",
6388   "streaming_protobufs",
6389   2,
6390   streaming_protobufs__nrrestrictionin5_gs__value__enum_values_by_number,
6391   2,
6392   streaming_protobufs__nrrestrictionin5_gs__value__enum_values_by_name,
6393   1,
6394   streaming_protobufs__nrrestrictionin5_gs__value__value_ranges,
6395   NULL,NULL,NULL,NULL   /* reserved[1234] */
6396 };
6397 static const ProtobufCFieldDescriptor streaming_protobufs__nrrestrictionin5_gs__field_descriptors[1] =
6398 {
6399   {
6400     "value",
6401     1,
6402     PROTOBUF_C_LABEL_NONE,
6403     PROTOBUF_C_TYPE_ENUM,
6404     0,   /* quantifier_offset */
6405     offsetof(StreamingProtobufs__NRrestrictionin5GS, value),
6406     &streaming_protobufs__nrrestrictionin5_gs__value__descriptor,
6407     NULL,
6408     0,             /* flags */
6409     0,NULL,NULL    /* reserved1,reserved2, etc */
6410   },
6411 };
6412 static const unsigned streaming_protobufs__nrrestrictionin5_gs__field_indices_by_name[] = {
6413   0,   /* field[0] = value */
6414 };
6415 static const ProtobufCIntRange streaming_protobufs__nrrestrictionin5_gs__number_ranges[1 + 1] =
6416 {
6417   { 1, 0 },
6418   { 0, 1 }
6419 };
6420 const ProtobufCMessageDescriptor streaming_protobufs__nrrestrictionin5_gs__descriptor =
6421 {
6422   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6423   "streaming_protobufs.NRrestrictionin5GS",
6424   "NRrestrictionin5GS",
6425   "StreamingProtobufs__NRrestrictionin5GS",
6426   "streaming_protobufs",
6427   sizeof(StreamingProtobufs__NRrestrictionin5GS),
6428   1,
6429   streaming_protobufs__nrrestrictionin5_gs__field_descriptors,
6430   streaming_protobufs__nrrestrictionin5_gs__field_indices_by_name,
6431   1,  streaming_protobufs__nrrestrictionin5_gs__number_ranges,
6432   (ProtobufCMessageInit) streaming_protobufs__nrrestrictionin5_gs__init,
6433   NULL,NULL,NULL    /* reserved[123] */
6434 };
6435 static const ProtobufCFieldDescriptor streaming_protobufs__nruesecurity_capabilities__field_descriptors[2] =
6436 {
6437   {
6438     "nRencryptionAlgorithms",
6439     1,
6440     PROTOBUF_C_LABEL_NONE,
6441     PROTOBUF_C_TYPE_BYTES,
6442     0,   /* quantifier_offset */
6443     offsetof(StreamingProtobufs__NRUESecurityCapabilities, nrencryptionalgorithms),
6444     NULL,
6445     NULL,
6446     0,             /* flags */
6447     0,NULL,NULL    /* reserved1,reserved2, etc */
6448   },
6449   {
6450     "nRintegrityProtectionAlgorithms",
6451     2,
6452     PROTOBUF_C_LABEL_NONE,
6453     PROTOBUF_C_TYPE_BYTES,
6454     0,   /* quantifier_offset */
6455     offsetof(StreamingProtobufs__NRUESecurityCapabilities, nrintegrityprotectionalgorithms),
6456     NULL,
6457     NULL,
6458     0,             /* flags */
6459     0,NULL,NULL    /* reserved1,reserved2, etc */
6460   },
6461 };
6462 static const unsigned streaming_protobufs__nruesecurity_capabilities__field_indices_by_name[] = {
6463   0,   /* field[0] = nRencryptionAlgorithms */
6464   1,   /* field[1] = nRintegrityProtectionAlgorithms */
6465 };
6466 static const ProtobufCIntRange streaming_protobufs__nruesecurity_capabilities__number_ranges[1 + 1] =
6467 {
6468   { 1, 0 },
6469   { 0, 2 }
6470 };
6471 const ProtobufCMessageDescriptor streaming_protobufs__nruesecurity_capabilities__descriptor =
6472 {
6473   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6474   "streaming_protobufs.NRUESecurityCapabilities",
6475   "NRUESecurityCapabilities",
6476   "StreamingProtobufs__NRUESecurityCapabilities",
6477   "streaming_protobufs",
6478   sizeof(StreamingProtobufs__NRUESecurityCapabilities),
6479   2,
6480   streaming_protobufs__nruesecurity_capabilities__field_descriptors,
6481   streaming_protobufs__nruesecurity_capabilities__field_indices_by_name,
6482   1,  streaming_protobufs__nruesecurity_capabilities__number_ranges,
6483   (ProtobufCMessageInit) streaming_protobufs__nruesecurity_capabilities__init,
6484   NULL,NULL,NULL    /* reserved[123] */
6485 };
6486 static const ProtobufCFieldDescriptor streaming_protobufs__ueaggregate_maximum_bit_rate__field_descriptors[3] =
6487 {
6488   {
6489     "uEaggregateMaximumBitRateDownlink",
6490     1,
6491     PROTOBUF_C_LABEL_NONE,
6492     PROTOBUF_C_TYPE_UINT64,
6493     0,   /* quantifier_offset */
6494     offsetof(StreamingProtobufs__UEAggregateMaximumBitRate, ueaggregatemaximumbitratedownlink),
6495     NULL,
6496     NULL,
6497     0,             /* flags */
6498     0,NULL,NULL    /* reserved1,reserved2, etc */
6499   },
6500   {
6501     "uEaggregateMaximumBitRateUplink",
6502     2,
6503     PROTOBUF_C_LABEL_NONE,
6504     PROTOBUF_C_TYPE_UINT64,
6505     0,   /* quantifier_offset */
6506     offsetof(StreamingProtobufs__UEAggregateMaximumBitRate, ueaggregatemaximumbitrateuplink),
6507     NULL,
6508     NULL,
6509     0,             /* flags */
6510     0,NULL,NULL    /* reserved1,reserved2, etc */
6511   },
6512   {
6513     "iE_Extensions",
6514     3,
6515     PROTOBUF_C_LABEL_REPEATED,
6516     PROTOBUF_C_TYPE_MESSAGE,
6517     offsetof(StreamingProtobufs__UEAggregateMaximumBitRate, n_ie_extensions),
6518     offsetof(StreamingProtobufs__UEAggregateMaximumBitRate, ie_extensions),
6519     &streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor,
6520     NULL,
6521     0,             /* flags */
6522     0,NULL,NULL    /* reserved1,reserved2, etc */
6523   },
6524 };
6525 static const unsigned streaming_protobufs__ueaggregate_maximum_bit_rate__field_indices_by_name[] = {
6526   2,   /* field[2] = iE_Extensions */
6527   0,   /* field[0] = uEaggregateMaximumBitRateDownlink */
6528   1,   /* field[1] = uEaggregateMaximumBitRateUplink */
6529 };
6530 static const ProtobufCIntRange streaming_protobufs__ueaggregate_maximum_bit_rate__number_ranges[1 + 1] =
6531 {
6532   { 1, 0 },
6533   { 0, 3 }
6534 };
6535 const ProtobufCMessageDescriptor streaming_protobufs__ueaggregate_maximum_bit_rate__descriptor =
6536 {
6537   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6538   "streaming_protobufs.UEAggregateMaximumBitRate",
6539   "UEAggregateMaximumBitRate",
6540   "StreamingProtobufs__UEAggregateMaximumBitRate",
6541   "streaming_protobufs",
6542   sizeof(StreamingProtobufs__UEAggregateMaximumBitRate),
6543   3,
6544   streaming_protobufs__ueaggregate_maximum_bit_rate__field_descriptors,
6545   streaming_protobufs__ueaggregate_maximum_bit_rate__field_indices_by_name,
6546   1,  streaming_protobufs__ueaggregate_maximum_bit_rate__number_ranges,
6547   (ProtobufCMessageInit) streaming_protobufs__ueaggregate_maximum_bit_rate__init,
6548   NULL,NULL,NULL    /* reserved[123] */
6549 };
6550 static const ProtobufCFieldDescriptor streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__field_descriptors[2] =
6551 {
6552   {
6553     "id_extended_uEaggregateMaximumBitRateDownlink",
6554     1,
6555     PROTOBUF_C_LABEL_NONE,
6556     PROTOBUF_C_TYPE_MESSAGE,
6557     0,   /* quantifier_offset */
6558     offsetof(StreamingProtobufs__UEAggregateMaximumBitrateExtIEs, id_extended_ueaggregatemaximumbitratedownlink),
6559     &google__protobuf__uint64_value__descriptor,
6560     NULL,
6561     0,             /* flags */
6562     0,NULL,NULL    /* reserved1,reserved2, etc */
6563   },
6564   {
6565     "id_extended_uEaggregateMaximumBitRateUplink",
6566     2,
6567     PROTOBUF_C_LABEL_NONE,
6568     PROTOBUF_C_TYPE_MESSAGE,
6569     0,   /* quantifier_offset */
6570     offsetof(StreamingProtobufs__UEAggregateMaximumBitrateExtIEs, id_extended_ueaggregatemaximumbitrateuplink),
6571     &google__protobuf__uint64_value__descriptor,
6572     NULL,
6573     0,             /* flags */
6574     0,NULL,NULL    /* reserved1,reserved2, etc */
6575   },
6576 };
6577 static const unsigned streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__field_indices_by_name[] = {
6578   0,   /* field[0] = id_extended_uEaggregateMaximumBitRateDownlink */
6579   1,   /* field[1] = id_extended_uEaggregateMaximumBitRateUplink */
6580 };
6581 static const ProtobufCIntRange streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__number_ranges[1 + 1] =
6582 {
6583   { 1, 0 },
6584   { 0, 2 }
6585 };
6586 const ProtobufCMessageDescriptor streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__descriptor =
6587 {
6588   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6589   "streaming_protobufs.UEAggregate_MaximumBitrate_ExtIEs",
6590   "UEAggregateMaximumBitrateExtIEs",
6591   "StreamingProtobufs__UEAggregateMaximumBitrateExtIEs",
6592   "streaming_protobufs",
6593   sizeof(StreamingProtobufs__UEAggregateMaximumBitrateExtIEs),
6594   2,
6595   streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__field_descriptors,
6596   streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__field_indices_by_name,
6597   1,  streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__number_ranges,
6598   (ProtobufCMessageInit) streaming_protobufs__ueaggregate__maximum_bitrate__ext_ies__init,
6599   NULL,NULL,NULL    /* reserved[123] */
6600 };
6601 static const ProtobufCEnumValue streaming_protobufs__dl__forwarding__value__enum_values_by_number[2] =
6602 {
6603   { "protobuf_unspecified", "STREAMING_PROTOBUFS__DL__FORWARDING__VALUE__protobuf_unspecified", 0 },
6604   { "dL_forwardingProposed", "STREAMING_PROTOBUFS__DL__FORWARDING__VALUE__dL_forwardingProposed", 1 },
6605 };
6606 static const ProtobufCIntRange streaming_protobufs__dl__forwarding__value__value_ranges[] = {
6607 {0, 0},{0, 2}
6608 };
6609 static const ProtobufCEnumValueIndex streaming_protobufs__dl__forwarding__value__enum_values_by_name[2] =
6610 {
6611   { "dL_forwardingProposed", 1 },
6612   { "protobuf_unspecified", 0 },
6613 };
6614 const ProtobufCEnumDescriptor streaming_protobufs__dl__forwarding__value__descriptor =
6615 {
6616   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6617   "streaming_protobufs.DL_Forwarding.Value",
6618   "Value",
6619   "StreamingProtobufs__DLForwarding__Value",
6620   "streaming_protobufs",
6621   2,
6622   streaming_protobufs__dl__forwarding__value__enum_values_by_number,
6623   2,
6624   streaming_protobufs__dl__forwarding__value__enum_values_by_name,
6625   1,
6626   streaming_protobufs__dl__forwarding__value__value_ranges,
6627   NULL,NULL,NULL,NULL   /* reserved[1234] */
6628 };
6629 static const ProtobufCFieldDescriptor streaming_protobufs__dl__forwarding__field_descriptors[1] =
6630 {
6631   {
6632     "value",
6633     1,
6634     PROTOBUF_C_LABEL_NONE,
6635     PROTOBUF_C_TYPE_ENUM,
6636     0,   /* quantifier_offset */
6637     offsetof(StreamingProtobufs__DLForwarding, value),
6638     &streaming_protobufs__dl__forwarding__value__descriptor,
6639     NULL,
6640     0,             /* flags */
6641     0,NULL,NULL    /* reserved1,reserved2, etc */
6642   },
6643 };
6644 static const unsigned streaming_protobufs__dl__forwarding__field_indices_by_name[] = {
6645   0,   /* field[0] = value */
6646 };
6647 static const ProtobufCIntRange streaming_protobufs__dl__forwarding__number_ranges[1 + 1] =
6648 {
6649   { 1, 0 },
6650   { 0, 1 }
6651 };
6652 const ProtobufCMessageDescriptor streaming_protobufs__dl__forwarding__descriptor =
6653 {
6654   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6655   "streaming_protobufs.DL_Forwarding",
6656   "DLForwarding",
6657   "StreamingProtobufs__DLForwarding",
6658   "streaming_protobufs",
6659   sizeof(StreamingProtobufs__DLForwarding),
6660   1,
6661   streaming_protobufs__dl__forwarding__field_descriptors,
6662   streaming_protobufs__dl__forwarding__field_indices_by_name,
6663   1,  streaming_protobufs__dl__forwarding__number_ranges,
6664   (ProtobufCMessageInit) streaming_protobufs__dl__forwarding__init,
6665   NULL,NULL,NULL    /* reserved[123] */
6666 };
6667 static const ProtobufCEnumValue streaming_protobufs__duplication_activation__value__enum_values_by_number[3] =
6668 {
6669   { "protobuf_unspecified", "STREAMING_PROTOBUFS__DUPLICATION_ACTIVATION__VALUE__protobuf_unspecified", 0 },
6670   { "active", "STREAMING_PROTOBUFS__DUPLICATION_ACTIVATION__VALUE__active", 1 },
6671   { "inactive", "STREAMING_PROTOBUFS__DUPLICATION_ACTIVATION__VALUE__inactive", 2 },
6672 };
6673 static const ProtobufCIntRange streaming_protobufs__duplication_activation__value__value_ranges[] = {
6674 {0, 0},{0, 3}
6675 };
6676 static const ProtobufCEnumValueIndex streaming_protobufs__duplication_activation__value__enum_values_by_name[3] =
6677 {
6678   { "active", 1 },
6679   { "inactive", 2 },
6680   { "protobuf_unspecified", 0 },
6681 };
6682 const ProtobufCEnumDescriptor streaming_protobufs__duplication_activation__value__descriptor =
6683 {
6684   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6685   "streaming_protobufs.DuplicationActivation.Value",
6686   "Value",
6687   "StreamingProtobufs__DuplicationActivation__Value",
6688   "streaming_protobufs",
6689   3,
6690   streaming_protobufs__duplication_activation__value__enum_values_by_number,
6691   3,
6692   streaming_protobufs__duplication_activation__value__enum_values_by_name,
6693   1,
6694   streaming_protobufs__duplication_activation__value__value_ranges,
6695   NULL,NULL,NULL,NULL   /* reserved[1234] */
6696 };
6697 static const ProtobufCFieldDescriptor streaming_protobufs__duplication_activation__field_descriptors[1] =
6698 {
6699   {
6700     "value",
6701     1,
6702     PROTOBUF_C_LABEL_NONE,
6703     PROTOBUF_C_TYPE_ENUM,
6704     0,   /* quantifier_offset */
6705     offsetof(StreamingProtobufs__DuplicationActivation, value),
6706     &streaming_protobufs__duplication_activation__value__descriptor,
6707     NULL,
6708     0,             /* flags */
6709     0,NULL,NULL    /* reserved1,reserved2, etc */
6710   },
6711 };
6712 static const unsigned streaming_protobufs__duplication_activation__field_indices_by_name[] = {
6713   0,   /* field[0] = value */
6714 };
6715 static const ProtobufCIntRange streaming_protobufs__duplication_activation__number_ranges[1 + 1] =
6716 {
6717   { 1, 0 },
6718   { 0, 1 }
6719 };
6720 const ProtobufCMessageDescriptor streaming_protobufs__duplication_activation__descriptor =
6721 {
6722   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6723   "streaming_protobufs.DuplicationActivation",
6724   "DuplicationActivation",
6725   "StreamingProtobufs__DuplicationActivation",
6726   "streaming_protobufs",
6727   sizeof(StreamingProtobufs__DuplicationActivation),
6728   1,
6729   streaming_protobufs__duplication_activation__field_descriptors,
6730   streaming_protobufs__duplication_activation__field_indices_by_name,
6731   1,  streaming_protobufs__duplication_activation__number_ranges,
6732   (ProtobufCMessageInit) streaming_protobufs__duplication_activation__init,
6733   NULL,NULL,NULL    /* reserved[123] */
6734 };
6735 static const ProtobufCFieldDescriptor streaming_protobufs__me_nbresource_coordination_information__field_descriptors[4] =
6736 {
6737   {
6738     "eUTRA_Cell_ID",
6739     1,
6740     PROTOBUF_C_LABEL_NONE,
6741     PROTOBUF_C_TYPE_MESSAGE,
6742     0,   /* quantifier_offset */
6743     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformation, eutra_cell_id),
6744     &streaming_protobufs__ecgi__descriptor,
6745     NULL,
6746     0,             /* flags */
6747     0,NULL,NULL    /* reserved1,reserved2, etc */
6748   },
6749   {
6750     "uLCoordinationInformation",
6751     2,
6752     PROTOBUF_C_LABEL_NONE,
6753     PROTOBUF_C_TYPE_BYTES,
6754     0,   /* quantifier_offset */
6755     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformation, ulcoordinationinformation),
6756     NULL,
6757     NULL,
6758     0,             /* flags */
6759     0,NULL,NULL    /* reserved1,reserved2, etc */
6760   },
6761   {
6762     "dLCoordinationInformation",
6763     3,
6764     PROTOBUF_C_LABEL_NONE,
6765     PROTOBUF_C_TYPE_MESSAGE,
6766     0,   /* quantifier_offset */
6767     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformation, dlcoordinationinformation),
6768     &google__protobuf__bytes_value__descriptor,
6769     NULL,
6770     0,             /* flags */
6771     0,NULL,NULL    /* reserved1,reserved2, etc */
6772   },
6773   {
6774     "iE_Extensions",
6775     4,
6776     PROTOBUF_C_LABEL_REPEATED,
6777     PROTOBUF_C_TYPE_MESSAGE,
6778     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformation, n_ie_extensions),
6779     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformation, ie_extensions),
6780     &streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor,
6781     NULL,
6782     0,             /* flags */
6783     0,NULL,NULL    /* reserved1,reserved2, etc */
6784   },
6785 };
6786 static const unsigned streaming_protobufs__me_nbresource_coordination_information__field_indices_by_name[] = {
6787   2,   /* field[2] = dLCoordinationInformation */
6788   0,   /* field[0] = eUTRA_Cell_ID */
6789   3,   /* field[3] = iE_Extensions */
6790   1,   /* field[1] = uLCoordinationInformation */
6791 };
6792 static const ProtobufCIntRange streaming_protobufs__me_nbresource_coordination_information__number_ranges[1 + 1] =
6793 {
6794   { 1, 0 },
6795   { 0, 4 }
6796 };
6797 const ProtobufCMessageDescriptor streaming_protobufs__me_nbresource_coordination_information__descriptor =
6798 {
6799   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6800   "streaming_protobufs.MeNBResourceCoordinationInformation",
6801   "MeNBResourceCoordinationInformation",
6802   "StreamingProtobufs__MeNBResourceCoordinationInformation",
6803   "streaming_protobufs",
6804   sizeof(StreamingProtobufs__MeNBResourceCoordinationInformation),
6805   4,
6806   streaming_protobufs__me_nbresource_coordination_information__field_descriptors,
6807   streaming_protobufs__me_nbresource_coordination_information__field_indices_by_name,
6808   1,  streaming_protobufs__me_nbresource_coordination_information__number_ranges,
6809   (ProtobufCMessageInit) streaming_protobufs__me_nbresource_coordination_information__init,
6810   NULL,NULL,NULL    /* reserved[123] */
6811 };
6812 static const ProtobufCFieldDescriptor streaming_protobufs__me_nbresource_coordination_information_ext_ies__field_descriptors[2] =
6813 {
6814   {
6815     "id_NRCGI",
6816     1,
6817     PROTOBUF_C_LABEL_NONE,
6818     PROTOBUF_C_TYPE_MESSAGE,
6819     0,   /* quantifier_offset */
6820     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs, id_nrcgi),
6821     &streaming_protobufs__nrcgi__descriptor,
6822     NULL,
6823     0,             /* flags */
6824     0,NULL,NULL    /* reserved1,reserved2, etc */
6825   },
6826   {
6827     "id_MeNBCoordinationAssistanceInformation",
6828     2,
6829     PROTOBUF_C_LABEL_NONE,
6830     PROTOBUF_C_TYPE_MESSAGE,
6831     0,   /* quantifier_offset */
6832     offsetof(StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs, id_menbcoordinationassistanceinformation),
6833     &streaming_protobufs__me_nbcoordination_assistance_information__descriptor,
6834     NULL,
6835     0,             /* flags */
6836     0,NULL,NULL    /* reserved1,reserved2, etc */
6837   },
6838 };
6839 static const unsigned streaming_protobufs__me_nbresource_coordination_information_ext_ies__field_indices_by_name[] = {
6840   1,   /* field[1] = id_MeNBCoordinationAssistanceInformation */
6841   0,   /* field[0] = id_NRCGI */
6842 };
6843 static const ProtobufCIntRange streaming_protobufs__me_nbresource_coordination_information_ext_ies__number_ranges[1 + 1] =
6844 {
6845   { 1, 0 },
6846   { 0, 2 }
6847 };
6848 const ProtobufCMessageDescriptor streaming_protobufs__me_nbresource_coordination_information_ext_ies__descriptor =
6849 {
6850   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6851   "streaming_protobufs.MeNBResourceCoordinationInformationExtIEs",
6852   "MeNBResourceCoordinationInformationExtIEs",
6853   "StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs",
6854   "streaming_protobufs",
6855   sizeof(StreamingProtobufs__MeNBResourceCoordinationInformationExtIEs),
6856   2,
6857   streaming_protobufs__me_nbresource_coordination_information_ext_ies__field_descriptors,
6858   streaming_protobufs__me_nbresource_coordination_information_ext_ies__field_indices_by_name,
6859   1,  streaming_protobufs__me_nbresource_coordination_information_ext_ies__number_ranges,
6860   (ProtobufCMessageInit) streaming_protobufs__me_nbresource_coordination_information_ext_ies__init,
6861   NULL,NULL,NULL    /* reserved[123] */
6862 };
6863 static const ProtobufCEnumValue streaming_protobufs__me_nbcoordination_assistance_information__value__enum_values_by_number[2] =
6864 {
6865   { "protobuf_unspecified", "STREAMING_PROTOBUFS__ME_NBCOORDINATION_ASSISTANCE_INFORMATION__VALUE__protobuf_unspecified", 0 },
6866   { "coordination_not_required", "STREAMING_PROTOBUFS__ME_NBCOORDINATION_ASSISTANCE_INFORMATION__VALUE__coordination_not_required", 1 },
6867 };
6868 static const ProtobufCIntRange streaming_protobufs__me_nbcoordination_assistance_information__value__value_ranges[] = {
6869 {0, 0},{0, 2}
6870 };
6871 static const ProtobufCEnumValueIndex streaming_protobufs__me_nbcoordination_assistance_information__value__enum_values_by_name[2] =
6872 {
6873   { "coordination_not_required", 1 },
6874   { "protobuf_unspecified", 0 },
6875 };
6876 const ProtobufCEnumDescriptor streaming_protobufs__me_nbcoordination_assistance_information__value__descriptor =
6877 {
6878   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6879   "streaming_protobufs.MeNBCoordinationAssistanceInformation.Value",
6880   "Value",
6881   "StreamingProtobufs__MeNBCoordinationAssistanceInformation__Value",
6882   "streaming_protobufs",
6883   2,
6884   streaming_protobufs__me_nbcoordination_assistance_information__value__enum_values_by_number,
6885   2,
6886   streaming_protobufs__me_nbcoordination_assistance_information__value__enum_values_by_name,
6887   1,
6888   streaming_protobufs__me_nbcoordination_assistance_information__value__value_ranges,
6889   NULL,NULL,NULL,NULL   /* reserved[1234] */
6890 };
6891 static const ProtobufCFieldDescriptor streaming_protobufs__me_nbcoordination_assistance_information__field_descriptors[1] =
6892 {
6893   {
6894     "value",
6895     1,
6896     PROTOBUF_C_LABEL_NONE,
6897     PROTOBUF_C_TYPE_ENUM,
6898     0,   /* quantifier_offset */
6899     offsetof(StreamingProtobufs__MeNBCoordinationAssistanceInformation, value),
6900     &streaming_protobufs__me_nbcoordination_assistance_information__value__descriptor,
6901     NULL,
6902     0,             /* flags */
6903     0,NULL,NULL    /* reserved1,reserved2, etc */
6904   },
6905 };
6906 static const unsigned streaming_protobufs__me_nbcoordination_assistance_information__field_indices_by_name[] = {
6907   0,   /* field[0] = value */
6908 };
6909 static const ProtobufCIntRange streaming_protobufs__me_nbcoordination_assistance_information__number_ranges[1 + 1] =
6910 {
6911   { 1, 0 },
6912   { 0, 1 }
6913 };
6914 const ProtobufCMessageDescriptor streaming_protobufs__me_nbcoordination_assistance_information__descriptor =
6915 {
6916   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6917   "streaming_protobufs.MeNBCoordinationAssistanceInformation",
6918   "MeNBCoordinationAssistanceInformation",
6919   "StreamingProtobufs__MeNBCoordinationAssistanceInformation",
6920   "streaming_protobufs",
6921   sizeof(StreamingProtobufs__MeNBCoordinationAssistanceInformation),
6922   1,
6923   streaming_protobufs__me_nbcoordination_assistance_information__field_descriptors,
6924   streaming_protobufs__me_nbcoordination_assistance_information__field_indices_by_name,
6925   1,  streaming_protobufs__me_nbcoordination_assistance_information__number_ranges,
6926   (ProtobufCMessageInit) streaming_protobufs__me_nbcoordination_assistance_information__init,
6927   NULL,NULL,NULL    /* reserved[123] */
6928 };
6929 static const ProtobufCFieldDescriptor streaming_protobufs__countvalue__field_descriptors[2] =
6930 {
6931   {
6932     "pDCP_SN",
6933     1,
6934     PROTOBUF_C_LABEL_NONE,
6935     PROTOBUF_C_TYPE_UINT32,
6936     0,   /* quantifier_offset */
6937     offsetof(StreamingProtobufs__COUNTvalue, pdcp_sn),
6938     NULL,
6939     NULL,
6940     0,             /* flags */
6941     0,NULL,NULL    /* reserved1,reserved2, etc */
6942   },
6943   {
6944     "hFN",
6945     2,
6946     PROTOBUF_C_LABEL_NONE,
6947     PROTOBUF_C_TYPE_UINT32,
6948     0,   /* quantifier_offset */
6949     offsetof(StreamingProtobufs__COUNTvalue, hfn),
6950     NULL,
6951     NULL,
6952     0,             /* flags */
6953     0,NULL,NULL    /* reserved1,reserved2, etc */
6954   },
6955 };
6956 static const unsigned streaming_protobufs__countvalue__field_indices_by_name[] = {
6957   1,   /* field[1] = hFN */
6958   0,   /* field[0] = pDCP_SN */
6959 };
6960 static const ProtobufCIntRange streaming_protobufs__countvalue__number_ranges[1 + 1] =
6961 {
6962   { 1, 0 },
6963   { 0, 2 }
6964 };
6965 const ProtobufCMessageDescriptor streaming_protobufs__countvalue__descriptor =
6966 {
6967   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6968   "streaming_protobufs.COUNTvalue",
6969   "COUNTvalue",
6970   "StreamingProtobufs__COUNTvalue",
6971   "streaming_protobufs",
6972   sizeof(StreamingProtobufs__COUNTvalue),
6973   2,
6974   streaming_protobufs__countvalue__field_descriptors,
6975   streaming_protobufs__countvalue__field_indices_by_name,
6976   1,  streaming_protobufs__countvalue__number_ranges,
6977   (ProtobufCMessageInit) streaming_protobufs__countvalue__init,
6978   NULL,NULL,NULL    /* reserved[123] */
6979 };
6980 static const ProtobufCFieldDescriptor streaming_protobufs__countvalue_extended__field_descriptors[2] =
6981 {
6982   {
6983     "pDCP_SNExtended",
6984     1,
6985     PROTOBUF_C_LABEL_NONE,
6986     PROTOBUF_C_TYPE_UINT32,
6987     0,   /* quantifier_offset */
6988     offsetof(StreamingProtobufs__COUNTValueExtended, pdcp_snextended),
6989     NULL,
6990     NULL,
6991     0,             /* flags */
6992     0,NULL,NULL    /* reserved1,reserved2, etc */
6993   },
6994   {
6995     "hFNModified",
6996     2,
6997     PROTOBUF_C_LABEL_NONE,
6998     PROTOBUF_C_TYPE_UINT32,
6999     0,   /* quantifier_offset */
7000     offsetof(StreamingProtobufs__COUNTValueExtended, hfnmodified),
7001     NULL,
7002     NULL,
7003     0,             /* flags */
7004     0,NULL,NULL    /* reserved1,reserved2, etc */
7005   },
7006 };
7007 static const unsigned streaming_protobufs__countvalue_extended__field_indices_by_name[] = {
7008   1,   /* field[1] = hFNModified */
7009   0,   /* field[0] = pDCP_SNExtended */
7010 };
7011 static const ProtobufCIntRange streaming_protobufs__countvalue_extended__number_ranges[1 + 1] =
7012 {
7013   { 1, 0 },
7014   { 0, 2 }
7015 };
7016 const ProtobufCMessageDescriptor streaming_protobufs__countvalue_extended__descriptor =
7017 {
7018   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7019   "streaming_protobufs.COUNTValueExtended",
7020   "COUNTValueExtended",
7021   "StreamingProtobufs__COUNTValueExtended",
7022   "streaming_protobufs",
7023   sizeof(StreamingProtobufs__COUNTValueExtended),
7024   2,
7025   streaming_protobufs__countvalue_extended__field_descriptors,
7026   streaming_protobufs__countvalue_extended__field_indices_by_name,
7027   1,  streaming_protobufs__countvalue_extended__number_ranges,
7028   (ProtobufCMessageInit) streaming_protobufs__countvalue_extended__init,
7029   NULL,NULL,NULL    /* reserved[123] */
7030 };
7031 static const ProtobufCFieldDescriptor streaming_protobufs__countvalue_pdcp__snlength18__field_descriptors[2] =
7032 {
7033   {
7034     "pDCP_SNlength18",
7035     1,
7036     PROTOBUF_C_LABEL_NONE,
7037     PROTOBUF_C_TYPE_UINT32,
7038     0,   /* quantifier_offset */
7039     offsetof(StreamingProtobufs__COUNTvaluePDCPSNlength18, pdcp_snlength18),
7040     NULL,
7041     NULL,
7042     0,             /* flags */
7043     0,NULL,NULL    /* reserved1,reserved2, etc */
7044   },
7045   {
7046     "hFNforPDCP_SNlength18",
7047     2,
7048     PROTOBUF_C_LABEL_NONE,
7049     PROTOBUF_C_TYPE_UINT32,
7050     0,   /* quantifier_offset */
7051     offsetof(StreamingProtobufs__COUNTvaluePDCPSNlength18, hfnforpdcp_snlength18),
7052     NULL,
7053     NULL,
7054     0,             /* flags */
7055     0,NULL,NULL    /* reserved1,reserved2, etc */
7056   },
7057 };
7058 static const unsigned streaming_protobufs__countvalue_pdcp__snlength18__field_indices_by_name[] = {
7059   1,   /* field[1] = hFNforPDCP_SNlength18 */
7060   0,   /* field[0] = pDCP_SNlength18 */
7061 };
7062 static const ProtobufCIntRange streaming_protobufs__countvalue_pdcp__snlength18__number_ranges[1 + 1] =
7063 {
7064   { 1, 0 },
7065   { 0, 2 }
7066 };
7067 const ProtobufCMessageDescriptor streaming_protobufs__countvalue_pdcp__snlength18__descriptor =
7068 {
7069   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7070   "streaming_protobufs.COUNTvaluePDCP_SNlength18",
7071   "COUNTvaluePDCPSNlength18",
7072   "StreamingProtobufs__COUNTvaluePDCPSNlength18",
7073   "streaming_protobufs",
7074   sizeof(StreamingProtobufs__COUNTvaluePDCPSNlength18),
7075   2,
7076   streaming_protobufs__countvalue_pdcp__snlength18__field_descriptors,
7077   streaming_protobufs__countvalue_pdcp__snlength18__field_indices_by_name,
7078   1,  streaming_protobufs__countvalue_pdcp__snlength18__number_ranges,
7079   (ProtobufCMessageInit) streaming_protobufs__countvalue_pdcp__snlength18__init,
7080   NULL,NULL,NULL    /* reserved[123] */
7081 };
7082 static const ProtobufCFieldDescriptor streaming_protobufs__expected_uebehaviour__field_descriptors[2] =
7083 {
7084   {
7085     "expectedActivity",
7086     1,
7087     PROTOBUF_C_LABEL_NONE,
7088     PROTOBUF_C_TYPE_MESSAGE,
7089     0,   /* quantifier_offset */
7090     offsetof(StreamingProtobufs__ExpectedUEBehaviour, expectedactivity),
7091     &streaming_protobufs__expected_ueactivity_behaviour__descriptor,
7092     NULL,
7093     0,             /* flags */
7094     0,NULL,NULL    /* reserved1,reserved2, etc */
7095   },
7096   {
7097     "expectedHOInterval",
7098     2,
7099     PROTOBUF_C_LABEL_NONE,
7100     PROTOBUF_C_TYPE_MESSAGE,
7101     0,   /* quantifier_offset */
7102     offsetof(StreamingProtobufs__ExpectedUEBehaviour, expectedhointerval),
7103     &streaming_protobufs__expected_hointerval__descriptor,
7104     NULL,
7105     0,             /* flags */
7106     0,NULL,NULL    /* reserved1,reserved2, etc */
7107   },
7108 };
7109 static const unsigned streaming_protobufs__expected_uebehaviour__field_indices_by_name[] = {
7110   0,   /* field[0] = expectedActivity */
7111   1,   /* field[1] = expectedHOInterval */
7112 };
7113 static const ProtobufCIntRange streaming_protobufs__expected_uebehaviour__number_ranges[1 + 1] =
7114 {
7115   { 1, 0 },
7116   { 0, 2 }
7117 };
7118 const ProtobufCMessageDescriptor streaming_protobufs__expected_uebehaviour__descriptor =
7119 {
7120   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7121   "streaming_protobufs.ExpectedUEBehaviour",
7122   "ExpectedUEBehaviour",
7123   "StreamingProtobufs__ExpectedUEBehaviour",
7124   "streaming_protobufs",
7125   sizeof(StreamingProtobufs__ExpectedUEBehaviour),
7126   2,
7127   streaming_protobufs__expected_uebehaviour__field_descriptors,
7128   streaming_protobufs__expected_uebehaviour__field_indices_by_name,
7129   1,  streaming_protobufs__expected_uebehaviour__number_ranges,
7130   (ProtobufCMessageInit) streaming_protobufs__expected_uebehaviour__init,
7131   NULL,NULL,NULL    /* reserved[123] */
7132 };
7133 static const ProtobufCFieldDescriptor streaming_protobufs__expected_ueactivity_behaviour__field_descriptors[4] =
7134 {
7135   {
7136     "expectedActivityPeriod",
7137     1,
7138     PROTOBUF_C_LABEL_NONE,
7139     PROTOBUF_C_TYPE_MESSAGE,
7140     0,   /* quantifier_offset */
7141     offsetof(StreamingProtobufs__ExpectedUEActivityBehaviour, expectedactivityperiod),
7142     &google__protobuf__uint32_value__descriptor,
7143     NULL,
7144     0,             /* flags */
7145     0,NULL,NULL    /* reserved1,reserved2, etc */
7146   },
7147   {
7148     "expectedIdlePeriod",
7149     2,
7150     PROTOBUF_C_LABEL_NONE,
7151     PROTOBUF_C_TYPE_MESSAGE,
7152     0,   /* quantifier_offset */
7153     offsetof(StreamingProtobufs__ExpectedUEActivityBehaviour, expectedidleperiod),
7154     &google__protobuf__uint32_value__descriptor,
7155     NULL,
7156     0,             /* flags */
7157     0,NULL,NULL    /* reserved1,reserved2, etc */
7158   },
7159   {
7160     "sourceOfUEActivityBehaviourInformation",
7161     3,
7162     PROTOBUF_C_LABEL_NONE,
7163     PROTOBUF_C_TYPE_MESSAGE,
7164     0,   /* quantifier_offset */
7165     offsetof(StreamingProtobufs__ExpectedUEActivityBehaviour, sourceofueactivitybehaviourinformation),
7166     &streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor,
7167     NULL,
7168     0,             /* flags */
7169     0,NULL,NULL    /* reserved1,reserved2, etc */
7170   },
7171   {
7172     "iE_Extensions",
7173     4,
7174     PROTOBUF_C_LABEL_REPEATED,
7175     PROTOBUF_C_TYPE_MESSAGE,
7176     offsetof(StreamingProtobufs__ExpectedUEActivityBehaviour, n_ie_extensions),
7177     offsetof(StreamingProtobufs__ExpectedUEActivityBehaviour, ie_extensions),
7178     &streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor,
7179     NULL,
7180     0,             /* flags */
7181     0,NULL,NULL    /* reserved1,reserved2, etc */
7182   },
7183 };
7184 static const unsigned streaming_protobufs__expected_ueactivity_behaviour__field_indices_by_name[] = {
7185   0,   /* field[0] = expectedActivityPeriod */
7186   1,   /* field[1] = expectedIdlePeriod */
7187   3,   /* field[3] = iE_Extensions */
7188   2,   /* field[2] = sourceOfUEActivityBehaviourInformation */
7189 };
7190 static const ProtobufCIntRange streaming_protobufs__expected_ueactivity_behaviour__number_ranges[1 + 1] =
7191 {
7192   { 1, 0 },
7193   { 0, 4 }
7194 };
7195 const ProtobufCMessageDescriptor streaming_protobufs__expected_ueactivity_behaviour__descriptor =
7196 {
7197   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7198   "streaming_protobufs.ExpectedUEActivityBehaviour",
7199   "ExpectedUEActivityBehaviour",
7200   "StreamingProtobufs__ExpectedUEActivityBehaviour",
7201   "streaming_protobufs",
7202   sizeof(StreamingProtobufs__ExpectedUEActivityBehaviour),
7203   4,
7204   streaming_protobufs__expected_ueactivity_behaviour__field_descriptors,
7205   streaming_protobufs__expected_ueactivity_behaviour__field_indices_by_name,
7206   1,  streaming_protobufs__expected_ueactivity_behaviour__number_ranges,
7207   (ProtobufCMessageInit) streaming_protobufs__expected_ueactivity_behaviour__init,
7208   NULL,NULL,NULL    /* reserved[123] */
7209 };
7210 #define streaming_protobufs__expected_ueactivity_behaviour__ext_ies__field_descriptors NULL
7211 #define streaming_protobufs__expected_ueactivity_behaviour__ext_ies__field_indices_by_name NULL
7212 #define streaming_protobufs__expected_ueactivity_behaviour__ext_ies__number_ranges NULL
7213 const ProtobufCMessageDescriptor streaming_protobufs__expected_ueactivity_behaviour__ext_ies__descriptor =
7214 {
7215   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7216   "streaming_protobufs.ExpectedUEActivityBehaviour_ExtIEs",
7217   "ExpectedUEActivityBehaviourExtIEs",
7218   "StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs",
7219   "streaming_protobufs",
7220   sizeof(StreamingProtobufs__ExpectedUEActivityBehaviourExtIEs),
7221   0,
7222   streaming_protobufs__expected_ueactivity_behaviour__ext_ies__field_descriptors,
7223   streaming_protobufs__expected_ueactivity_behaviour__ext_ies__field_indices_by_name,
7224   0,  streaming_protobufs__expected_ueactivity_behaviour__ext_ies__number_ranges,
7225   (ProtobufCMessageInit) streaming_protobufs__expected_ueactivity_behaviour__ext_ies__init,
7226   NULL,NULL,NULL    /* reserved[123] */
7227 };
7228 static const ProtobufCEnumValue streaming_protobufs__expected_hointerval__value__enum_values_by_number[8] =
7229 {
7230   { "protobuf_unspecified", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__protobuf_unspecified", 0 },
7231   { "sec15", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__sec15", 1 },
7232   { "sec30", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__sec30", 2 },
7233   { "sec60", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__sec60", 3 },
7234   { "sec90", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__sec90", 4 },
7235   { "sec120", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__sec120", 5 },
7236   { "sec180", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__sec180", 6 },
7237   { "long_time", "STREAMING_PROTOBUFS__EXPECTED_HOINTERVAL__VALUE__long_time", 7 },
7238 };
7239 static const ProtobufCIntRange streaming_protobufs__expected_hointerval__value__value_ranges[] = {
7240 {0, 0},{0, 8}
7241 };
7242 static const ProtobufCEnumValueIndex streaming_protobufs__expected_hointerval__value__enum_values_by_name[8] =
7243 {
7244   { "long_time", 7 },
7245   { "protobuf_unspecified", 0 },
7246   { "sec120", 5 },
7247   { "sec15", 1 },
7248   { "sec180", 6 },
7249   { "sec30", 2 },
7250   { "sec60", 3 },
7251   { "sec90", 4 },
7252 };
7253 const ProtobufCEnumDescriptor streaming_protobufs__expected_hointerval__value__descriptor =
7254 {
7255   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7256   "streaming_protobufs.ExpectedHOInterval.Value",
7257   "Value",
7258   "StreamingProtobufs__ExpectedHOInterval__Value",
7259   "streaming_protobufs",
7260   8,
7261   streaming_protobufs__expected_hointerval__value__enum_values_by_number,
7262   8,
7263   streaming_protobufs__expected_hointerval__value__enum_values_by_name,
7264   1,
7265   streaming_protobufs__expected_hointerval__value__value_ranges,
7266   NULL,NULL,NULL,NULL   /* reserved[1234] */
7267 };
7268 static const ProtobufCFieldDescriptor streaming_protobufs__expected_hointerval__field_descriptors[1] =
7269 {
7270   {
7271     "value",
7272     1,
7273     PROTOBUF_C_LABEL_NONE,
7274     PROTOBUF_C_TYPE_ENUM,
7275     0,   /* quantifier_offset */
7276     offsetof(StreamingProtobufs__ExpectedHOInterval, value),
7277     &streaming_protobufs__expected_hointerval__value__descriptor,
7278     NULL,
7279     0,             /* flags */
7280     0,NULL,NULL    /* reserved1,reserved2, etc */
7281   },
7282 };
7283 static const unsigned streaming_protobufs__expected_hointerval__field_indices_by_name[] = {
7284   0,   /* field[0] = value */
7285 };
7286 static const ProtobufCIntRange streaming_protobufs__expected_hointerval__number_ranges[1 + 1] =
7287 {
7288   { 1, 0 },
7289   { 0, 1 }
7290 };
7291 const ProtobufCMessageDescriptor streaming_protobufs__expected_hointerval__descriptor =
7292 {
7293   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7294   "streaming_protobufs.ExpectedHOInterval",
7295   "ExpectedHOInterval",
7296   "StreamingProtobufs__ExpectedHOInterval",
7297   "streaming_protobufs",
7298   sizeof(StreamingProtobufs__ExpectedHOInterval),
7299   1,
7300   streaming_protobufs__expected_hointerval__field_descriptors,
7301   streaming_protobufs__expected_hointerval__field_indices_by_name,
7302   1,  streaming_protobufs__expected_hointerval__number_ranges,
7303   (ProtobufCMessageInit) streaming_protobufs__expected_hointerval__init,
7304   NULL,NULL,NULL    /* reserved[123] */
7305 };
7306 static const ProtobufCEnumValue streaming_protobufs__source_of_ueactivity_behaviour_information__value__enum_values_by_number[3] =
7307 {
7308   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SOURCE_OF_UEACTIVITY_BEHAVIOUR_INFORMATION__VALUE__protobuf_unspecified", 0 },
7309   { "subscription_information", "STREAMING_PROTOBUFS__SOURCE_OF_UEACTIVITY_BEHAVIOUR_INFORMATION__VALUE__subscription_information", 1 },
7310   { "statistics", "STREAMING_PROTOBUFS__SOURCE_OF_UEACTIVITY_BEHAVIOUR_INFORMATION__VALUE__statistics", 2 },
7311 };
7312 static const ProtobufCIntRange streaming_protobufs__source_of_ueactivity_behaviour_information__value__value_ranges[] = {
7313 {0, 0},{0, 3}
7314 };
7315 static const ProtobufCEnumValueIndex streaming_protobufs__source_of_ueactivity_behaviour_information__value__enum_values_by_name[3] =
7316 {
7317   { "protobuf_unspecified", 0 },
7318   { "statistics", 2 },
7319   { "subscription_information", 1 },
7320 };
7321 const ProtobufCEnumDescriptor streaming_protobufs__source_of_ueactivity_behaviour_information__value__descriptor =
7322 {
7323   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7324   "streaming_protobufs.SourceOfUEActivityBehaviourInformation.Value",
7325   "Value",
7326   "StreamingProtobufs__SourceOfUEActivityBehaviourInformation__Value",
7327   "streaming_protobufs",
7328   3,
7329   streaming_protobufs__source_of_ueactivity_behaviour_information__value__enum_values_by_number,
7330   3,
7331   streaming_protobufs__source_of_ueactivity_behaviour_information__value__enum_values_by_name,
7332   1,
7333   streaming_protobufs__source_of_ueactivity_behaviour_information__value__value_ranges,
7334   NULL,NULL,NULL,NULL   /* reserved[1234] */
7335 };
7336 static const ProtobufCFieldDescriptor streaming_protobufs__source_of_ueactivity_behaviour_information__field_descriptors[1] =
7337 {
7338   {
7339     "value",
7340     1,
7341     PROTOBUF_C_LABEL_NONE,
7342     PROTOBUF_C_TYPE_ENUM,
7343     0,   /* quantifier_offset */
7344     offsetof(StreamingProtobufs__SourceOfUEActivityBehaviourInformation, value),
7345     &streaming_protobufs__source_of_ueactivity_behaviour_information__value__descriptor,
7346     NULL,
7347     0,             /* flags */
7348     0,NULL,NULL    /* reserved1,reserved2, etc */
7349   },
7350 };
7351 static const unsigned streaming_protobufs__source_of_ueactivity_behaviour_information__field_indices_by_name[] = {
7352   0,   /* field[0] = value */
7353 };
7354 static const ProtobufCIntRange streaming_protobufs__source_of_ueactivity_behaviour_information__number_ranges[1 + 1] =
7355 {
7356   { 1, 0 },
7357   { 0, 1 }
7358 };
7359 const ProtobufCMessageDescriptor streaming_protobufs__source_of_ueactivity_behaviour_information__descriptor =
7360 {
7361   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7362   "streaming_protobufs.SourceOfUEActivityBehaviourInformation",
7363   "SourceOfUEActivityBehaviourInformation",
7364   "StreamingProtobufs__SourceOfUEActivityBehaviourInformation",
7365   "streaming_protobufs",
7366   sizeof(StreamingProtobufs__SourceOfUEActivityBehaviourInformation),
7367   1,
7368   streaming_protobufs__source_of_ueactivity_behaviour_information__field_descriptors,
7369   streaming_protobufs__source_of_ueactivity_behaviour_information__field_indices_by_name,
7370   1,  streaming_protobufs__source_of_ueactivity_behaviour_information__number_ranges,
7371   (ProtobufCMessageInit) streaming_protobufs__source_of_ueactivity_behaviour_information__init,
7372   NULL,NULL,NULL    /* reserved[123] */
7373 };
7374 static const ProtobufCEnumValue streaming_protobufs__sgnb__addition__trigger__ind__value__enum_values_by_number[4] =
7375 {
7376   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SGNB__ADDITION__TRIGGER__IND__VALUE__protobuf_unspecified", 0 },
7377   { "sn_change", "STREAMING_PROTOBUFS__SGNB__ADDITION__TRIGGER__IND__VALUE__sn_change", 1 },
7378   { "inter_eNB_HO", "STREAMING_PROTOBUFS__SGNB__ADDITION__TRIGGER__IND__VALUE__inter_eNB_HO", 2 },
7379   { "intra_eNB_HO", "STREAMING_PROTOBUFS__SGNB__ADDITION__TRIGGER__IND__VALUE__intra_eNB_HO", 3 },
7380 };
7381 static const ProtobufCIntRange streaming_protobufs__sgnb__addition__trigger__ind__value__value_ranges[] = {
7382 {0, 0},{0, 4}
7383 };
7384 static const ProtobufCEnumValueIndex streaming_protobufs__sgnb__addition__trigger__ind__value__enum_values_by_name[4] =
7385 {
7386   { "inter_eNB_HO", 2 },
7387   { "intra_eNB_HO", 3 },
7388   { "protobuf_unspecified", 0 },
7389   { "sn_change", 1 },
7390 };
7391 const ProtobufCEnumDescriptor streaming_protobufs__sgnb__addition__trigger__ind__value__descriptor =
7392 {
7393   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7394   "streaming_protobufs.SGNB_Addition_Trigger_Ind.Value",
7395   "Value",
7396   "StreamingProtobufs__SGNBAdditionTriggerInd__Value",
7397   "streaming_protobufs",
7398   4,
7399   streaming_protobufs__sgnb__addition__trigger__ind__value__enum_values_by_number,
7400   4,
7401   streaming_protobufs__sgnb__addition__trigger__ind__value__enum_values_by_name,
7402   1,
7403   streaming_protobufs__sgnb__addition__trigger__ind__value__value_ranges,
7404   NULL,NULL,NULL,NULL   /* reserved[1234] */
7405 };
7406 static const ProtobufCFieldDescriptor streaming_protobufs__sgnb__addition__trigger__ind__field_descriptors[1] =
7407 {
7408   {
7409     "value",
7410     1,
7411     PROTOBUF_C_LABEL_NONE,
7412     PROTOBUF_C_TYPE_ENUM,
7413     0,   /* quantifier_offset */
7414     offsetof(StreamingProtobufs__SGNBAdditionTriggerInd, value),
7415     &streaming_protobufs__sgnb__addition__trigger__ind__value__descriptor,
7416     NULL,
7417     0,             /* flags */
7418     0,NULL,NULL    /* reserved1,reserved2, etc */
7419   },
7420 };
7421 static const unsigned streaming_protobufs__sgnb__addition__trigger__ind__field_indices_by_name[] = {
7422   0,   /* field[0] = value */
7423 };
7424 static const ProtobufCIntRange streaming_protobufs__sgnb__addition__trigger__ind__number_ranges[1 + 1] =
7425 {
7426   { 1, 0 },
7427   { 0, 1 }
7428 };
7429 const ProtobufCMessageDescriptor streaming_protobufs__sgnb__addition__trigger__ind__descriptor =
7430 {
7431   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7432   "streaming_protobufs.SGNB_Addition_Trigger_Ind",
7433   "SGNBAdditionTriggerInd",
7434   "StreamingProtobufs__SGNBAdditionTriggerInd",
7435   "streaming_protobufs",
7436   sizeof(StreamingProtobufs__SGNBAdditionTriggerInd),
7437   1,
7438   streaming_protobufs__sgnb__addition__trigger__ind__field_descriptors,
7439   streaming_protobufs__sgnb__addition__trigger__ind__field_indices_by_name,
7440   1,  streaming_protobufs__sgnb__addition__trigger__ind__number_ranges,
7441   (ProtobufCMessageInit) streaming_protobufs__sgnb__addition__trigger__ind__init,
7442   NULL,NULL,NULL    /* reserved[123] */
7443 };