/src/protobuf-c-fuzzers/test-full.pb-c.c

Source (jump to first uncovered line)
/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: test-full.proto */

/* Do not generate deprecated warnings for self */
#ifndef PROTOBUF_C__NO_DEPRECATED
#define PROTOBUF_C__NO_DEPRECATED
#endif

#include "test-full.pb-c.h"
void   foo__sub_mess__sub_sub_mess__init
                     (Foo__SubMess__SubSubMess         *message)
{
  static const Foo__SubMess__SubSubMess init_value = FOO__SUB_MESS__SUB_SUB_MESS__INIT;
  *message = init_value;
}
void   foo__sub_mess__init
                     (Foo__SubMess         *message)
{
  static const Foo__SubMess init_value = FOO__SUB_MESS__INIT;
  *message = init_value;
}
size_t foo__sub_mess__get_packed_size
                     (const Foo__SubMess *message)
{
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__sub_mess__pack
                     (const Foo__SubMess *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__sub_mess__pack_to_buffer
                     (const Foo__SubMess *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__SubMess *
       foo__sub_mess__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__SubMess *)
     protobuf_c_message_unpack (&foo__sub_mess__descriptor,
                                allocator, len, data);
}
void   foo__sub_mess__free_unpacked
                     (Foo__SubMess *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no15__init
                     (Foo__TestFieldNo15         *message)
{
  static const Foo__TestFieldNo15 init_value = FOO__TEST_FIELD_NO15__INIT;
  *message = init_value;
}
size_t foo__test_field_no15__get_packed_size
                     (const Foo__TestFieldNo15 *message)
{
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no15__pack
                     (const Foo__TestFieldNo15 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no15__pack_to_buffer
                     (const Foo__TestFieldNo15 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo15 *
       foo__test_field_no15__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo15 *)
     protobuf_c_message_unpack (&foo__test_field_no15__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no15__free_unpacked
                     (Foo__TestFieldNo15 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no16__init
                     (Foo__TestFieldNo16         *message)
{
  static const Foo__TestFieldNo16 init_value = FOO__TEST_FIELD_NO16__INIT;
  *message = init_value;
}
size_t foo__test_field_no16__get_packed_size
                     (const Foo__TestFieldNo16 *message)
{
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no16__pack
                     (const Foo__TestFieldNo16 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no16__pack_to_buffer
                     (const Foo__TestFieldNo16 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo16 *
       foo__test_field_no16__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo16 *)
     protobuf_c_message_unpack (&foo__test_field_no16__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no16__free_unpacked
                     (Foo__TestFieldNo16 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no2047__init
                     (Foo__TestFieldNo2047         *message)
{
  static const Foo__TestFieldNo2047 init_value = FOO__TEST_FIELD_NO2047__INIT;
  *message = init_value;
}
size_t foo__test_field_no2047__get_packed_size
                     (const Foo__TestFieldNo2047 *message)
{
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no2047__pack
                     (const Foo__TestFieldNo2047 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no2047__pack_to_buffer
                     (const Foo__TestFieldNo2047 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo2047 *
       foo__test_field_no2047__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo2047 *)
     protobuf_c_message_unpack (&foo__test_field_no2047__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no2047__free_unpacked
                     (Foo__TestFieldNo2047 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no2048__init
                     (Foo__TestFieldNo2048         *message)
{
  static const Foo__TestFieldNo2048 init_value = FOO__TEST_FIELD_NO2048__INIT;
  *message = init_value;
}
size_t foo__test_field_no2048__get_packed_size
                     (const Foo__TestFieldNo2048 *message)
{
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no2048__pack
                     (const Foo__TestFieldNo2048 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no2048__pack_to_buffer
                     (const Foo__TestFieldNo2048 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo2048 *
       foo__test_field_no2048__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo2048 *)
     protobuf_c_message_unpack (&foo__test_field_no2048__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no2048__free_unpacked
                     (Foo__TestFieldNo2048 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no262143__init
                     (Foo__TestFieldNo262143         *message)
{
  static const Foo__TestFieldNo262143 init_value = FOO__TEST_FIELD_NO262143__INIT;
  *message = init_value;
}
size_t foo__test_field_no262143__get_packed_size
                     (const Foo__TestFieldNo262143 *message)
{
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no262143__pack
                     (const Foo__TestFieldNo262143 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no262143__pack_to_buffer
                     (const Foo__TestFieldNo262143 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo262143 *
       foo__test_field_no262143__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo262143 *)
     protobuf_c_message_unpack (&foo__test_field_no262143__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no262143__free_unpacked
                     (Foo__TestFieldNo262143 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no262144__init
                     (Foo__TestFieldNo262144         *message)
{
  static const Foo__TestFieldNo262144 init_value = FOO__TEST_FIELD_NO262144__INIT;
  *message = init_value;
}
size_t foo__test_field_no262144__get_packed_size
                     (const Foo__TestFieldNo262144 *message)
{
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no262144__pack
                     (const Foo__TestFieldNo262144 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no262144__pack_to_buffer
                     (const Foo__TestFieldNo262144 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo262144 *
       foo__test_field_no262144__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo262144 *)
     protobuf_c_message_unpack (&foo__test_field_no262144__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no262144__free_unpacked
                     (Foo__TestFieldNo262144 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no33554431__init
                     (Foo__TestFieldNo33554431         *message)
{
  static const Foo__TestFieldNo33554431 init_value = FOO__TEST_FIELD_NO33554431__INIT;
  *message = init_value;
}
size_t foo__test_field_no33554431__get_packed_size
                     (const Foo__TestFieldNo33554431 *message)
{
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no33554431__pack
                     (const Foo__TestFieldNo33554431 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no33554431__pack_to_buffer
                     (const Foo__TestFieldNo33554431 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo33554431 *
       foo__test_field_no33554431__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo33554431 *)
     protobuf_c_message_unpack (&foo__test_field_no33554431__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no33554431__free_unpacked
                     (Foo__TestFieldNo33554431 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_no33554432__init
                     (Foo__TestFieldNo33554432         *message)
{
  static const Foo__TestFieldNo33554432 init_value = FOO__TEST_FIELD_NO33554432__INIT;
  *message = init_value;
}
size_t foo__test_field_no33554432__get_packed_size
                     (const Foo__TestFieldNo33554432 *message)
{
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_no33554432__pack
                     (const Foo__TestFieldNo33554432 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_no33554432__pack_to_buffer
                     (const Foo__TestFieldNo33554432 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldNo33554432 *
       foo__test_field_no33554432__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldNo33554432 *)
     protobuf_c_message_unpack (&foo__test_field_no33554432__descriptor,
                                allocator, len, data);
}
void   foo__test_field_no33554432__free_unpacked
                     (Foo__TestFieldNo33554432 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess__init
                     (Foo__TestMess         *message)
{
  static const Foo__TestMess init_value = FOO__TEST_MESS__INIT;
  *message = init_value;
}
size_t foo__test_mess__get_packed_size
                     (const Foo__TestMess *message)
{
  assert(message->base.descriptor == &foo__test_mess__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess__pack
                     (const Foo__TestMess *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess__pack_to_buffer
                     (const Foo__TestMess *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMess *
       foo__test_mess__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMess *)
     protobuf_c_message_unpack (&foo__test_mess__descriptor,
                                allocator, len, data);
}
void   foo__test_mess__free_unpacked
                     (Foo__TestMess *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_packed__init
                     (Foo__TestMessPacked         *message)
{
  static const Foo__TestMessPacked init_value = FOO__TEST_MESS_PACKED__INIT;
  *message = init_value;
}
size_t foo__test_mess_packed__get_packed_size
                     (const Foo__TestMessPacked *message)
{
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_packed__pack
                     (const Foo__TestMessPacked *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_packed__pack_to_buffer
                     (const Foo__TestMessPacked *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessPacked *
       foo__test_mess_packed__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessPacked *)
     protobuf_c_message_unpack (&foo__test_mess_packed__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_packed__free_unpacked
                     (Foo__TestMessPacked *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_oneof__init
                     (Foo__TestMessOneof         *message)
{
  static const Foo__TestMessOneof init_value = FOO__TEST_MESS_ONEOF__INIT;
  *message = init_value;
}
size_t foo__test_mess_oneof__get_packed_size
                     (const Foo__TestMessOneof *message)
{
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_oneof__pack
                     (const Foo__TestMessOneof *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_oneof__pack_to_buffer
                     (const Foo__TestMessOneof *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessOneof *
       foo__test_mess_oneof__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessOneof *)
     protobuf_c_message_unpack (&foo__test_mess_oneof__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_oneof__free_unpacked
                     (Foo__TestMessOneof *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_int32__init
                     (Foo__TestMessRequiredInt32         *message)
{
  static const Foo__TestMessRequiredInt32 init_value = FOO__TEST_MESS_REQUIRED_INT32__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_int32__get_packed_size
                     (const Foo__TestMessRequiredInt32 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_int32__pack
                     (const Foo__TestMessRequiredInt32 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_int32__pack_to_buffer
                     (const Foo__TestMessRequiredInt32 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredInt32 *
       foo__test_mess_required_int32__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredInt32 *)
     protobuf_c_message_unpack (&foo__test_mess_required_int32__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_int32__free_unpacked
                     (Foo__TestMessRequiredInt32 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_sint32__init
                     (Foo__TestMessRequiredSInt32         *message)
{
  static const Foo__TestMessRequiredSInt32 init_value = FOO__TEST_MESS_REQUIRED_SINT32__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_sint32__get_packed_size
                     (const Foo__TestMessRequiredSInt32 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_sint32__pack
                     (const Foo__TestMessRequiredSInt32 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_sint32__pack_to_buffer
                     (const Foo__TestMessRequiredSInt32 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredSInt32 *
       foo__test_mess_required_sint32__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredSInt32 *)
     protobuf_c_message_unpack (&foo__test_mess_required_sint32__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_sint32__free_unpacked
                     (Foo__TestMessRequiredSInt32 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_sfixed32__init
                     (Foo__TestMessRequiredSFixed32         *message)
{
  static const Foo__TestMessRequiredSFixed32 init_value = FOO__TEST_MESS_REQUIRED_SFIXED32__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_sfixed32__get_packed_size
                     (const Foo__TestMessRequiredSFixed32 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_sfixed32__pack
                     (const Foo__TestMessRequiredSFixed32 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_sfixed32__pack_to_buffer
                     (const Foo__TestMessRequiredSFixed32 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredSFixed32 *
       foo__test_mess_required_sfixed32__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredSFixed32 *)
     protobuf_c_message_unpack (&foo__test_mess_required_sfixed32__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_sfixed32__free_unpacked
                     (Foo__TestMessRequiredSFixed32 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_int64__init
                     (Foo__TestMessRequiredInt64         *message)
{
  static const Foo__TestMessRequiredInt64 init_value = FOO__TEST_MESS_REQUIRED_INT64__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_int64__get_packed_size
                     (const Foo__TestMessRequiredInt64 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_int64__pack
                     (const Foo__TestMessRequiredInt64 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_int64__pack_to_buffer
                     (const Foo__TestMessRequiredInt64 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredInt64 *
       foo__test_mess_required_int64__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredInt64 *)
     protobuf_c_message_unpack (&foo__test_mess_required_int64__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_int64__free_unpacked
                     (Foo__TestMessRequiredInt64 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_sint64__init
                     (Foo__TestMessRequiredSInt64         *message)
{
  static const Foo__TestMessRequiredSInt64 init_value = FOO__TEST_MESS_REQUIRED_SINT64__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_sint64__get_packed_size
                     (const Foo__TestMessRequiredSInt64 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_sint64__pack
                     (const Foo__TestMessRequiredSInt64 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_sint64__pack_to_buffer
                     (const Foo__TestMessRequiredSInt64 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredSInt64 *
       foo__test_mess_required_sint64__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredSInt64 *)
     protobuf_c_message_unpack (&foo__test_mess_required_sint64__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_sint64__free_unpacked
                     (Foo__TestMessRequiredSInt64 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_sfixed64__init
                     (Foo__TestMessRequiredSFixed64         *message)
{
  static const Foo__TestMessRequiredSFixed64 init_value = FOO__TEST_MESS_REQUIRED_SFIXED64__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_sfixed64__get_packed_size
                     (const Foo__TestMessRequiredSFixed64 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_sfixed64__pack
                     (const Foo__TestMessRequiredSFixed64 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_sfixed64__pack_to_buffer
                     (const Foo__TestMessRequiredSFixed64 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredSFixed64 *
       foo__test_mess_required_sfixed64__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredSFixed64 *)
     protobuf_c_message_unpack (&foo__test_mess_required_sfixed64__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_sfixed64__free_unpacked
                     (Foo__TestMessRequiredSFixed64 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_uint32__init
                     (Foo__TestMessRequiredUInt32         *message)
{
  static const Foo__TestMessRequiredUInt32 init_value = FOO__TEST_MESS_REQUIRED_UINT32__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_uint32__get_packed_size
                     (const Foo__TestMessRequiredUInt32 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_uint32__pack
                     (const Foo__TestMessRequiredUInt32 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_uint32__pack_to_buffer
                     (const Foo__TestMessRequiredUInt32 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredUInt32 *
       foo__test_mess_required_uint32__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredUInt32 *)
     protobuf_c_message_unpack (&foo__test_mess_required_uint32__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_uint32__free_unpacked
                     (Foo__TestMessRequiredUInt32 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_fixed32__init
                     (Foo__TestMessRequiredFixed32         *message)
{
  static const Foo__TestMessRequiredFixed32 init_value = FOO__TEST_MESS_REQUIRED_FIXED32__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_fixed32__get_packed_size
                     (const Foo__TestMessRequiredFixed32 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_fixed32__pack
                     (const Foo__TestMessRequiredFixed32 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_fixed32__pack_to_buffer
                     (const Foo__TestMessRequiredFixed32 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredFixed32 *
       foo__test_mess_required_fixed32__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredFixed32 *)
     protobuf_c_message_unpack (&foo__test_mess_required_fixed32__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_fixed32__free_unpacked
                     (Foo__TestMessRequiredFixed32 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_uint64__init
                     (Foo__TestMessRequiredUInt64         *message)
{
  static const Foo__TestMessRequiredUInt64 init_value = FOO__TEST_MESS_REQUIRED_UINT64__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_uint64__get_packed_size
                     (const Foo__TestMessRequiredUInt64 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_uint64__pack
                     (const Foo__TestMessRequiredUInt64 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_uint64__pack_to_buffer
                     (const Foo__TestMessRequiredUInt64 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredUInt64 *
       foo__test_mess_required_uint64__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredUInt64 *)
     protobuf_c_message_unpack (&foo__test_mess_required_uint64__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_uint64__free_unpacked
                     (Foo__TestMessRequiredUInt64 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_fixed64__init
                     (Foo__TestMessRequiredFixed64         *message)
{
  static const Foo__TestMessRequiredFixed64 init_value = FOO__TEST_MESS_REQUIRED_FIXED64__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_fixed64__get_packed_size
                     (const Foo__TestMessRequiredFixed64 *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_fixed64__pack
                     (const Foo__TestMessRequiredFixed64 *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_fixed64__pack_to_buffer
                     (const Foo__TestMessRequiredFixed64 *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredFixed64 *
       foo__test_mess_required_fixed64__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredFixed64 *)
     protobuf_c_message_unpack (&foo__test_mess_required_fixed64__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_fixed64__free_unpacked
                     (Foo__TestMessRequiredFixed64 *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_float__init
                     (Foo__TestMessRequiredFloat         *message)
{
  static const Foo__TestMessRequiredFloat init_value = FOO__TEST_MESS_REQUIRED_FLOAT__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_float__get_packed_size
                     (const Foo__TestMessRequiredFloat *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_float__pack
                     (const Foo__TestMessRequiredFloat *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_float__pack_to_buffer
                     (const Foo__TestMessRequiredFloat *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredFloat *
       foo__test_mess_required_float__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredFloat *)
     protobuf_c_message_unpack (&foo__test_mess_required_float__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_float__free_unpacked
                     (Foo__TestMessRequiredFloat *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_double__init
                     (Foo__TestMessRequiredDouble         *message)
{
  static const Foo__TestMessRequiredDouble init_value = FOO__TEST_MESS_REQUIRED_DOUBLE__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_double__get_packed_size
                     (const Foo__TestMessRequiredDouble *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_double__pack
                     (const Foo__TestMessRequiredDouble *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_double__pack_to_buffer
                     (const Foo__TestMessRequiredDouble *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredDouble *
       foo__test_mess_required_double__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredDouble *)
     protobuf_c_message_unpack (&foo__test_mess_required_double__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_double__free_unpacked
                     (Foo__TestMessRequiredDouble *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_bool__init
                     (Foo__TestMessRequiredBool         *message)
{
  static const Foo__TestMessRequiredBool init_value = FOO__TEST_MESS_REQUIRED_BOOL__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_bool__get_packed_size
                     (const Foo__TestMessRequiredBool *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_bool__pack
                     (const Foo__TestMessRequiredBool *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_bool__pack_to_buffer
                     (const Foo__TestMessRequiredBool *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredBool *
       foo__test_mess_required_bool__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredBool *)
     protobuf_c_message_unpack (&foo__test_mess_required_bool__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_bool__free_unpacked
                     (Foo__TestMessRequiredBool *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_enum__init
                     (Foo__TestMessRequiredEnum         *message)
{
  static const Foo__TestMessRequiredEnum init_value = FOO__TEST_MESS_REQUIRED_ENUM__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_enum__get_packed_size
                     (const Foo__TestMessRequiredEnum *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_enum__pack
                     (const Foo__TestMessRequiredEnum *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_enum__pack_to_buffer
                     (const Foo__TestMessRequiredEnum *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredEnum *
       foo__test_mess_required_enum__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredEnum *)
     protobuf_c_message_unpack (&foo__test_mess_required_enum__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_enum__free_unpacked
                     (Foo__TestMessRequiredEnum *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_enum_small__init
                     (Foo__TestMessRequiredEnumSmall         *message)
{
  static const Foo__TestMessRequiredEnumSmall init_value = FOO__TEST_MESS_REQUIRED_ENUM_SMALL__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_enum_small__get_packed_size
                     (const Foo__TestMessRequiredEnumSmall *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_enum_small__pack
                     (const Foo__TestMessRequiredEnumSmall *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_enum_small__pack_to_buffer
                     (const Foo__TestMessRequiredEnumSmall *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredEnumSmall *
       foo__test_mess_required_enum_small__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredEnumSmall *)
     protobuf_c_message_unpack (&foo__test_mess_required_enum_small__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_enum_small__free_unpacked
                     (Foo__TestMessRequiredEnumSmall *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_string__init
                     (Foo__TestMessRequiredString         *message)
{
  static const Foo__TestMessRequiredString init_value = FOO__TEST_MESS_REQUIRED_STRING__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_string__get_packed_size
                     (const Foo__TestMessRequiredString *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_string__pack
                     (const Foo__TestMessRequiredString *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_string__pack_to_buffer
                     (const Foo__TestMessRequiredString *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredString *
       foo__test_mess_required_string__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredString *)
     protobuf_c_message_unpack (&foo__test_mess_required_string__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_string__free_unpacked
                     (Foo__TestMessRequiredString *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_bytes__init
                     (Foo__TestMessRequiredBytes         *message)
{
  static const Foo__TestMessRequiredBytes init_value = FOO__TEST_MESS_REQUIRED_BYTES__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_bytes__get_packed_size
                     (const Foo__TestMessRequiredBytes *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_bytes__pack
                     (const Foo__TestMessRequiredBytes *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_bytes__pack_to_buffer
                     (const Foo__TestMessRequiredBytes *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredBytes *
       foo__test_mess_required_bytes__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredBytes *)
     protobuf_c_message_unpack (&foo__test_mess_required_bytes__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_bytes__free_unpacked
                     (Foo__TestMessRequiredBytes *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_required_message__init
                     (Foo__TestMessRequiredMessage         *message)
{
  static const Foo__TestMessRequiredMessage init_value = FOO__TEST_MESS_REQUIRED_MESSAGE__INIT;
  *message = init_value;
}
size_t foo__test_mess_required_message__get_packed_size
                     (const Foo__TestMessRequiredMessage *message)
{
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_required_message__pack
                     (const Foo__TestMessRequiredMessage *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_required_message__pack_to_buffer
                     (const Foo__TestMessRequiredMessage *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessRequiredMessage *
       foo__test_mess_required_message__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessRequiredMessage *)
     protobuf_c_message_unpack (&foo__test_mess_required_message__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_required_message__free_unpacked
                     (Foo__TestMessRequiredMessage *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__empty_mess__init
                     (Foo__EmptyMess         *message)
{
  static const Foo__EmptyMess init_value = FOO__EMPTY_MESS__INIT;
  *message = init_value;
}
size_t foo__empty_mess__get_packed_size
                     (const Foo__EmptyMess *message)
{
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__empty_mess__pack
                     (const Foo__EmptyMess *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__empty_mess__pack_to_buffer
                     (const Foo__EmptyMess *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__EmptyMess *
       foo__empty_mess__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__EmptyMess *)
     protobuf_c_message_unpack (&foo__empty_mess__descriptor,
                                allocator, len, data);
}
void   foo__empty_mess__free_unpacked
                     (Foo__EmptyMess *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__default_required_values__init
                     (Foo__DefaultRequiredValues         *message)
{
  static const Foo__DefaultRequiredValues init_value = FOO__DEFAULT_REQUIRED_VALUES__INIT;
  *message = init_value;
}
size_t foo__default_required_values__get_packed_size
                     (const Foo__DefaultRequiredValues *message)
{
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__default_required_values__pack
                     (const Foo__DefaultRequiredValues *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__default_required_values__pack_to_buffer
                     (const Foo__DefaultRequiredValues *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__DefaultRequiredValues *
       foo__default_required_values__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__DefaultRequiredValues *)
     protobuf_c_message_unpack (&foo__default_required_values__descriptor,
                                allocator, len, data);
}
void   foo__default_required_values__free_unpacked
                     (Foo__DefaultRequiredValues *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__default_optional_values__init
                     (Foo__DefaultOptionalValues         *message)
{
  static const Foo__DefaultOptionalValues init_value = FOO__DEFAULT_OPTIONAL_VALUES__INIT;
  *message = init_value;
}
size_t foo__default_optional_values__get_packed_size
                     (const Foo__DefaultOptionalValues *message)
{
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__default_optional_values__pack
                     (const Foo__DefaultOptionalValues *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__default_optional_values__pack_to_buffer
                     (const Foo__DefaultOptionalValues *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__DefaultOptionalValues *
       foo__default_optional_values__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__DefaultOptionalValues *)
     protobuf_c_message_unpack (&foo__default_optional_values__descriptor,
                                allocator, len, data);
}
void   foo__default_optional_values__free_unpacked
                     (Foo__DefaultOptionalValues *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__lower_case__init
                     (Foo__LowerCase         *message)
{
  static const Foo__LowerCase init_value = FOO__LOWER_CASE__INIT;
  *message = init_value;
}
size_t foo__lower_case__get_packed_size
                     (const Foo__LowerCase *message)
{
  assert(message->base.descriptor == &foo__lower_case__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__lower_case__pack
                     (const Foo__LowerCase *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__lower_case__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__lower_case__pack_to_buffer
                     (const Foo__LowerCase *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__lower_case__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__LowerCase *
       foo__lower_case__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__LowerCase *)
     protobuf_c_message_unpack (&foo__lower_case__descriptor,
                                allocator, len, data);
}
void   foo__lower_case__free_unpacked
                     (Foo__LowerCase *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__lower_case__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__alloc_values__init
                     (Foo__AllocValues         *message)
{
  static const Foo__AllocValues init_value = FOO__ALLOC_VALUES__INIT;
  *message = init_value;
}
size_t foo__alloc_values__get_packed_size
                     (const Foo__AllocValues *message)
{
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__alloc_values__pack
                     (const Foo__AllocValues *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__alloc_values__pack_to_buffer
                     (const Foo__AllocValues *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__AllocValues *
       foo__alloc_values__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__AllocValues *)
     protobuf_c_message_unpack (&foo__alloc_values__descriptor,
                                allocator, len, data);
}
void   foo__alloc_values__free_unpacked
                     (Foo__AllocValues *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_required_fields_bitmap__init
                     (Foo__TestRequiredFieldsBitmap         *message)
{
  static const Foo__TestRequiredFieldsBitmap init_value = FOO__TEST_REQUIRED_FIELDS_BITMAP__INIT;
  *message = init_value;
}
size_t foo__test_required_fields_bitmap__get_packed_size
                     (const Foo__TestRequiredFieldsBitmap *message)
{
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_required_fields_bitmap__pack
                     (const Foo__TestRequiredFieldsBitmap *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_required_fields_bitmap__pack_to_buffer
                     (const Foo__TestRequiredFieldsBitmap *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestRequiredFieldsBitmap *
       foo__test_required_fields_bitmap__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestRequiredFieldsBitmap *)
     protobuf_c_message_unpack (&foo__test_required_fields_bitmap__descriptor,
                                allocator, len, data);
}
void   foo__test_required_fields_bitmap__free_unpacked
                     (Foo__TestRequiredFieldsBitmap *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_field_flags__init
                     (Foo__TestFieldFlags         *message)
{
  static const Foo__TestFieldFlags init_value = FOO__TEST_FIELD_FLAGS__INIT;
  *message = init_value;
}
size_t foo__test_field_flags__get_packed_size
                     (const Foo__TestFieldFlags *message)
{
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_field_flags__pack
                     (const Foo__TestFieldFlags *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_field_flags__pack_to_buffer
                     (const Foo__TestFieldFlags *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestFieldFlags *
       foo__test_field_flags__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestFieldFlags *)
     protobuf_c_message_unpack (&foo__test_field_flags__descriptor,
                                allocator, len, data);
}
void   foo__test_field_flags__free_unpacked
                     (Foo__TestFieldFlags *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_message_check__sub_message__init
                     (Foo__TestMessageCheck__SubMessage         *message)
{
  static const Foo__TestMessageCheck__SubMessage init_value = FOO__TEST_MESSAGE_CHECK__SUB_MESSAGE__INIT;
  *message = init_value;
}
void   foo__test_message_check__init
                     (Foo__TestMessageCheck         *message)
{
  static const Foo__TestMessageCheck init_value = FOO__TEST_MESSAGE_CHECK__INIT;
  *message = init_value;
}
size_t foo__test_message_check__get_packed_size
                     (const Foo__TestMessageCheck *message)
{
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_message_check__pack
                     (const Foo__TestMessageCheck *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_message_check__pack_to_buffer
                     (const Foo__TestMessageCheck *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessageCheck *
       foo__test_message_check__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessageCheck *)
     protobuf_c_message_unpack (&foo__test_message_check__descriptor,
                                allocator, len, data);
}
void   foo__test_message_check__free_unpacked
                     (Foo__TestMessageCheck *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   foo__test_mess_sub_mess__init
                     (Foo__TestMessSubMess         *message)
{
  static const Foo__TestMessSubMess init_value = FOO__TEST_MESS_SUB_MESS__INIT;
  *message = init_value;
}
size_t foo__test_mess_sub_mess__get_packed_size
                     (const Foo__TestMessSubMess *message)
{
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t foo__test_mess_sub_mess__pack
                     (const Foo__TestMessSubMess *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t foo__test_mess_sub_mess__pack_to_buffer
                     (const Foo__TestMessSubMess *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
Foo__TestMessSubMess *
       foo__test_mess_sub_mess__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (Foo__TestMessSubMess *)
     protobuf_c_message_unpack (&foo__test_mess_sub_mess__descriptor,
                                allocator, len, data);
}
void   foo__test_mess_sub_mess__free_unpacked
                     (Foo__TestMessSubMess *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
uint8_t foo__sub_mess__sub_sub_mess__bytes1__default_value_data[] = "a \000 char";
char foo__sub_mess__sub_sub_mess__str1__default_value[] = "hello world\n";
uint8_t foo__sub_mess__sub_sub_mess__str2__default_value_data[] = "hello\000world\n";
static const int32_t foo__sub_mess__sub_sub_mess__val1__default_value = 100;
static const ProtobufCBinaryData foo__sub_mess__sub_sub_mess__bytes1__default_value = { 8, foo__sub_mess__sub_sub_mess__bytes1__default_value_data };
static const ProtobufCBinaryData foo__sub_mess__sub_sub_mess__str2__default_value = { 12, foo__sub_mess__sub_sub_mess__str2__default_value_data };
static const ProtobufCFieldDescriptor foo__sub_mess__sub_sub_mess__field_descriptors[5] =
{
  {
    "val1",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__SubMess__SubSubMess, has_val1),
    offsetof(Foo__SubMess__SubSubMess, val1),
    NULL,
    &foo__sub_mess__sub_sub_mess__val1__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "bytes1",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__SubMess__SubSubMess, has_bytes1),
    offsetof(Foo__SubMess__SubSubMess, bytes1),
    NULL,
    &foo__sub_mess__sub_sub_mess__bytes1__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "str1",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__SubMess__SubSubMess, str1),
    NULL,
    &foo__sub_mess__sub_sub_mess__str1__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rep",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__SubMess__SubSubMess, n_rep),
    offsetof(Foo__SubMess__SubSubMess, rep),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "str2",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__SubMess__SubSubMess, has_str2),
    offsetof(Foo__SubMess__SubSubMess, str2),
    NULL,
    &foo__sub_mess__sub_sub_mess__str2__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__sub_mess__sub_sub_mess__field_indices_by_name[] = {
  1,   /* field[1] = bytes1 */
  3,   /* field[3] = rep */
  2,   /* field[2] = str1 */
  4,   /* field[4] = str2 */
  0,   /* field[0] = val1 */
};
static const ProtobufCIntRange foo__sub_mess__sub_sub_mess__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor foo__sub_mess__sub_sub_mess__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.SubMess.SubSubMess",
  "SubSubMess",
  "Foo__SubMess__SubSubMess",
  "foo",
  sizeof(Foo__SubMess__SubSubMess),
  5,
  foo__sub_mess__sub_sub_mess__field_descriptors,
  foo__sub_mess__sub_sub_mess__field_indices_by_name,
  1,  foo__sub_mess__sub_sub_mess__number_ranges,
  (ProtobufCMessageInit) foo__sub_mess__sub_sub_mess__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__sub_mess__field_descriptors[6] =
{
  {
    "test",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(Foo__SubMess, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "val1",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__SubMess, has_val1),
    offsetof(Foo__SubMess, val1),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "val2",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__SubMess, has_val2),
    offsetof(Foo__SubMess, val2),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rep",
    8,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__SubMess, n_rep),
    offsetof(Foo__SubMess, rep),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sub1",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__SubMess, sub1),
    &foo__sub_mess__sub_sub_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sub2",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__SubMess, sub2),
    &foo__sub_mess__sub_sub_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__sub_mess__field_indices_by_name[] = {
  3,   /* field[3] = rep */
  4,   /* field[4] = sub1 */
  5,   /* field[5] = sub2 */
  0,   /* field[0] = test */
  1,   /* field[1] = val1 */
  2,   /* field[2] = val2 */
};
static const ProtobufCIntRange foo__sub_mess__number_ranges[2 + 1] =
{
  { 4, 0 },
  { 6, 1 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor foo__sub_mess__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.SubMess",
  "SubMess",
  "Foo__SubMess",
  "foo",
  sizeof(Foo__SubMess),
  6,
  foo__sub_mess__field_descriptors,
  foo__sub_mess__field_indices_by_name,
  2,  foo__sub_mess__number_ranges,
  (ProtobufCMessageInit) foo__sub_mess__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no15__field_descriptors[1] =
{
  {
    "test",
    15,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo15, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no15__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no15__number_ranges[1 + 1] =
{
  { 15, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no15__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo15",
  "TestFieldNo15",
  "Foo__TestFieldNo15",
  "foo",
  sizeof(Foo__TestFieldNo15),
  1,
  foo__test_field_no15__field_descriptors,
  foo__test_field_no15__field_indices_by_name,
  1,  foo__test_field_no15__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no15__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no16__field_descriptors[1] =
{
  {
    "test",
    16,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo16, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no16__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no16__number_ranges[1 + 1] =
{
  { 16, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no16__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo16",
  "TestFieldNo16",
  "Foo__TestFieldNo16",
  "foo",
  sizeof(Foo__TestFieldNo16),
  1,
  foo__test_field_no16__field_descriptors,
  foo__test_field_no16__field_indices_by_name,
  1,  foo__test_field_no16__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no16__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no2047__field_descriptors[1] =
{
  {
    "test",
    2047,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo2047, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no2047__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no2047__number_ranges[1 + 1] =
{
  { 2047, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no2047__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo2047",
  "TestFieldNo2047",
  "Foo__TestFieldNo2047",
  "foo",
  sizeof(Foo__TestFieldNo2047),
  1,
  foo__test_field_no2047__field_descriptors,
  foo__test_field_no2047__field_indices_by_name,
  1,  foo__test_field_no2047__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no2047__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no2048__field_descriptors[1] =
{
  {
    "test",
    2048,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo2048, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no2048__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no2048__number_ranges[1 + 1] =
{
  { 2048, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no2048__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo2048",
  "TestFieldNo2048",
  "Foo__TestFieldNo2048",
  "foo",
  sizeof(Foo__TestFieldNo2048),
  1,
  foo__test_field_no2048__field_descriptors,
  foo__test_field_no2048__field_indices_by_name,
  1,  foo__test_field_no2048__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no2048__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no262143__field_descriptors[1] =
{
  {
    "test",
    262143,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo262143, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no262143__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no262143__number_ranges[1 + 1] =
{
  { 262143, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no262143__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo262143",
  "TestFieldNo262143",
  "Foo__TestFieldNo262143",
  "foo",
  sizeof(Foo__TestFieldNo262143),
  1,
  foo__test_field_no262143__field_descriptors,
  foo__test_field_no262143__field_indices_by_name,
  1,  foo__test_field_no262143__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no262143__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no262144__field_descriptors[1] =
{
  {
    "test",
    262144,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo262144, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no262144__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no262144__number_ranges[1 + 1] =
{
  { 262144, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no262144__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo262144",
  "TestFieldNo262144",
  "Foo__TestFieldNo262144",
  "foo",
  sizeof(Foo__TestFieldNo262144),
  1,
  foo__test_field_no262144__field_descriptors,
  foo__test_field_no262144__field_indices_by_name,
  1,  foo__test_field_no262144__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no262144__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no33554431__field_descriptors[1] =
{
  {
    "test",
    33554431,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo33554431, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no33554431__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no33554431__number_ranges[1 + 1] =
{
  { 33554431, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no33554431__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo33554431",
  "TestFieldNo33554431",
  "Foo__TestFieldNo33554431",
  "foo",
  sizeof(Foo__TestFieldNo33554431),
  1,
  foo__test_field_no33554431__field_descriptors,
  foo__test_field_no33554431__field_indices_by_name,
  1,  foo__test_field_no33554431__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no33554431__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_no33554432__field_descriptors[1] =
{
  {
    "test",
    33554432,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldNo33554432, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_no33554432__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_field_no33554432__number_ranges[1 + 1] =
{
  { 33554432, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_field_no33554432__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldNo33554432",
  "TestFieldNo33554432",
  "Foo__TestFieldNo33554432",
  "foo",
  sizeof(Foo__TestFieldNo33554432),
  1,
  foo__test_field_no33554432__field_descriptors,
  foo__test_field_no33554432__field_indices_by_name,
  1,  foo__test_field_no33554432__number_ranges,
  (ProtobufCMessageInit) foo__test_field_no33554432__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess__field_descriptors[18] =
{
  {
    "test_int32",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestMess, n_test_int32),
    offsetof(Foo__TestMess, test_int32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint32",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SINT32,
    offsetof(Foo__TestMess, n_test_sint32),
    offsetof(Foo__TestMess, test_sint32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed32",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SFIXED32,
    offsetof(Foo__TestMess, n_test_sfixed32),
    offsetof(Foo__TestMess, test_sfixed32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_int64",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Foo__TestMess, n_test_int64),
    offsetof(Foo__TestMess, test_int64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint64",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SINT64,
    offsetof(Foo__TestMess, n_test_sint64),
    offsetof(Foo__TestMess, test_sint64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed64",
    6,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SFIXED64,
    offsetof(Foo__TestMess, n_test_sfixed64),
    offsetof(Foo__TestMess, test_sfixed64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint32",
    7,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(Foo__TestMess, n_test_uint32),
    offsetof(Foo__TestMess, test_uint32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed32",
    8,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_FIXED32,
    offsetof(Foo__TestMess, n_test_fixed32),
    offsetof(Foo__TestMess, test_fixed32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint64",
    9,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Foo__TestMess, n_test_uint64),
    offsetof(Foo__TestMess, test_uint64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed64",
    10,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_FIXED64,
    offsetof(Foo__TestMess, n_test_fixed64),
    offsetof(Foo__TestMess, test_fixed64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_float",
    11,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(Foo__TestMess, n_test_float),
    offsetof(Foo__TestMess, test_float),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_double",
    12,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_DOUBLE,
    offsetof(Foo__TestMess, n_test_double),
    offsetof(Foo__TestMess, test_double),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_boolean",
    13,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(Foo__TestMess, n_test_boolean),
    offsetof(Foo__TestMess, test_boolean),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum_small",
    14,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMess, n_test_enum_small),
    offsetof(Foo__TestMess, test_enum_small),
    &foo__test_enum_small__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum",
    15,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMess, n_test_enum),
    offsetof(Foo__TestMess, test_enum),
    &foo__test_enum__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_string",
    16,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Foo__TestMess, n_test_string),
    offsetof(Foo__TestMess, test_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_bytes",
    17,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__TestMess, n_test_bytes),
    offsetof(Foo__TestMess, test_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_message",
    18,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Foo__TestMess, n_test_message),
    offsetof(Foo__TestMess, test_message),
    &foo__sub_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess__field_indices_by_name[] = {
  12,   /* field[12] = test_boolean */
  16,   /* field[16] = test_bytes */
  11,   /* field[11] = test_double */
  14,   /* field[14] = test_enum */
  13,   /* field[13] = test_enum_small */
  7,   /* field[7] = test_fixed32 */
  9,   /* field[9] = test_fixed64 */
  10,   /* field[10] = test_float */
  0,   /* field[0] = test_int32 */
  3,   /* field[3] = test_int64 */
  17,   /* field[17] = test_message */
  2,   /* field[2] = test_sfixed32 */
  5,   /* field[5] = test_sfixed64 */
  1,   /* field[1] = test_sint32 */
  4,   /* field[4] = test_sint64 */
  15,   /* field[15] = test_string */
  6,   /* field[6] = test_uint32 */
  8,   /* field[8] = test_uint64 */
};
static const ProtobufCIntRange foo__test_mess__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 18 }
};
const ProtobufCMessageDescriptor foo__test_mess__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMess",
  "TestMess",
  "Foo__TestMess",
  "foo",
  sizeof(Foo__TestMess),
  18,
  foo__test_mess__field_descriptors,
  foo__test_mess__field_indices_by_name,
  1,  foo__test_mess__number_ranges,
  (ProtobufCMessageInit) foo__test_mess__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_packed__field_descriptors[15] =
{
  {
    "test_int32",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestMessPacked, n_test_int32),
    offsetof(Foo__TestMessPacked, test_int32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint32",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SINT32,
    offsetof(Foo__TestMessPacked, n_test_sint32),
    offsetof(Foo__TestMessPacked, test_sint32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed32",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SFIXED32,
    offsetof(Foo__TestMessPacked, n_test_sfixed32),
    offsetof(Foo__TestMessPacked, test_sfixed32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_int64",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Foo__TestMessPacked, n_test_int64),
    offsetof(Foo__TestMessPacked, test_int64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint64",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SINT64,
    offsetof(Foo__TestMessPacked, n_test_sint64),
    offsetof(Foo__TestMessPacked, test_sint64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed64",
    6,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_SFIXED64,
    offsetof(Foo__TestMessPacked, n_test_sfixed64),
    offsetof(Foo__TestMessPacked, test_sfixed64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint32",
    7,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(Foo__TestMessPacked, n_test_uint32),
    offsetof(Foo__TestMessPacked, test_uint32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed32",
    8,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_FIXED32,
    offsetof(Foo__TestMessPacked, n_test_fixed32),
    offsetof(Foo__TestMessPacked, test_fixed32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint64",
    9,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Foo__TestMessPacked, n_test_uint64),
    offsetof(Foo__TestMessPacked, test_uint64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed64",
    10,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_FIXED64,
    offsetof(Foo__TestMessPacked, n_test_fixed64),
    offsetof(Foo__TestMessPacked, test_fixed64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_float",
    11,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(Foo__TestMessPacked, n_test_float),
    offsetof(Foo__TestMessPacked, test_float),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_double",
    12,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_DOUBLE,
    offsetof(Foo__TestMessPacked, n_test_double),
    offsetof(Foo__TestMessPacked, test_double),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_boolean",
    13,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(Foo__TestMessPacked, n_test_boolean),
    offsetof(Foo__TestMessPacked, test_boolean),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum_small",
    14,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMessPacked, n_test_enum_small),
    offsetof(Foo__TestMessPacked, test_enum_small),
    &foo__test_enum_small__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum",
    15,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMessPacked, n_test_enum),
    offsetof(Foo__TestMessPacked, test_enum),
    &foo__test_enum__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_packed__field_indices_by_name[] = {
  12,   /* field[12] = test_boolean */
  11,   /* field[11] = test_double */
  14,   /* field[14] = test_enum */
  13,   /* field[13] = test_enum_small */
  7,   /* field[7] = test_fixed32 */
  9,   /* field[9] = test_fixed64 */
  10,   /* field[10] = test_float */
  0,   /* field[0] = test_int32 */
  3,   /* field[3] = test_int64 */
  2,   /* field[2] = test_sfixed32 */
  5,   /* field[5] = test_sfixed64 */
  1,   /* field[1] = test_sint32 */
  4,   /* field[4] = test_sint64 */
  6,   /* field[6] = test_uint32 */
  8,   /* field[8] = test_uint64 */
};
static const ProtobufCIntRange foo__test_mess_packed__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 15 }
};
const ProtobufCMessageDescriptor foo__test_mess_packed__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessPacked",
  "TestMessPacked",
  "Foo__TestMessPacked",
  "foo",
  sizeof(Foo__TestMessPacked),
  15,
  foo__test_mess_packed__field_descriptors,
  foo__test_mess_packed__field_indices_by_name,
  1,  foo__test_mess_packed__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_packed__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_optional__field_descriptors[18] =
{
  {
    "test_int32",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestMessOptional, has_test_int32),
    offsetof(Foo__TestMessOptional, test_int32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint32",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SINT32,
    offsetof(Foo__TestMessOptional, has_test_sint32),
    offsetof(Foo__TestMessOptional, test_sint32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed32",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SFIXED32,
    offsetof(Foo__TestMessOptional, has_test_sfixed32),
    offsetof(Foo__TestMessOptional, test_sfixed32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_int64",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Foo__TestMessOptional, has_test_int64),
    offsetof(Foo__TestMessOptional, test_int64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint64",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SINT64,
    offsetof(Foo__TestMessOptional, has_test_sint64),
    offsetof(Foo__TestMessOptional, test_sint64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed64",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SFIXED64,
    offsetof(Foo__TestMessOptional, has_test_sfixed64),
    offsetof(Foo__TestMessOptional, test_sfixed64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint32",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(Foo__TestMessOptional, has_test_uint32),
    offsetof(Foo__TestMessOptional, test_uint32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed32",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FIXED32,
    offsetof(Foo__TestMessOptional, has_test_fixed32),
    offsetof(Foo__TestMessOptional, test_fixed32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint64",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Foo__TestMessOptional, has_test_uint64),
    offsetof(Foo__TestMessOptional, test_uint64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed64",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FIXED64,
    offsetof(Foo__TestMessOptional, has_test_fixed64),
    offsetof(Foo__TestMessOptional, test_fixed64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_float",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(Foo__TestMessOptional, has_test_float),
    offsetof(Foo__TestMessOptional, test_float),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_double",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_DOUBLE,
    offsetof(Foo__TestMessOptional, has_test_double),
    offsetof(Foo__TestMessOptional, test_double),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_boolean",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(Foo__TestMessOptional, has_test_boolean),
    offsetof(Foo__TestMessOptional, test_boolean),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum_small",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMessOptional, has_test_enum_small),
    offsetof(Foo__TestMessOptional, test_enum_small),
    &foo__test_enum_small__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum",
    15,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMessOptional, has_test_enum),
    offsetof(Foo__TestMessOptional, test_enum),
    &foo__test_enum__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_string",
    16,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessOptional, test_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_bytes",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__TestMessOptional, has_test_bytes),
    offsetof(Foo__TestMessOptional, test_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_message",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessOptional, test_message),
    &foo__sub_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_optional__field_indices_by_name[] = {
  12,   /* field[12] = test_boolean */
  16,   /* field[16] = test_bytes */
  11,   /* field[11] = test_double */
  14,   /* field[14] = test_enum */
  13,   /* field[13] = test_enum_small */
  7,   /* field[7] = test_fixed32 */
  9,   /* field[9] = test_fixed64 */
  10,   /* field[10] = test_float */
  0,   /* field[0] = test_int32 */
  3,   /* field[3] = test_int64 */
  17,   /* field[17] = test_message */
  2,   /* field[2] = test_sfixed32 */
  5,   /* field[5] = test_sfixed64 */
  1,   /* field[1] = test_sint32 */
  4,   /* field[4] = test_sint64 */
  15,   /* field[15] = test_string */
  6,   /* field[6] = test_uint32 */
  8,   /* field[8] = test_uint64 */
};
static const ProtobufCIntRange foo__test_mess_optional__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 18 }
};
const ProtobufCMessageDescriptor foo__test_mess_optional__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessOptional",
  "TestMessOptional",
  "Foo__TestMessOptional",
  "foo",
  sizeof(Foo__TestMessOptional),
  18,
  foo__test_mess_optional__field_descriptors,
  foo__test_mess_optional__field_indices_by_name,
  1,  foo__test_mess_optional__number_ranges,
  NULL, /* gen_init_helpers = false */
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_oneof__field_descriptors[19] =
{
  {
    "test_int32",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_int32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint32",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SINT32,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_sint32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed32",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SFIXED32,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_sfixed32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_int64",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT64,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_int64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sint64",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SINT64,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_sint64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_sfixed64",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_SFIXED64,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_sfixed64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint32",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_uint32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed32",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FIXED32,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_fixed32),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_uint64",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_uint64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_fixed64",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FIXED64,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_fixed64),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_float",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_float),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_double",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_DOUBLE,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_double),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_boolean",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_boolean),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum_small",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_enum_small),
    &foo__test_enum_small__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_enum",
    15,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_enum),
    &foo__test_enum__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_string",
    16,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_string),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_bytes",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_bytes),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "test_message",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Foo__TestMessOneof, test_oneof_case),
    offsetof(Foo__TestMessOneof, test_message),
    &foo__sub_mess__descriptor,
    NULL,
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "opt_int",
    19,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestMessOneof, has_opt_int),
    offsetof(Foo__TestMessOneof, opt_int),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_oneof__field_indices_by_name[] = {
  18,   /* field[18] = opt_int */
  12,   /* field[12] = test_boolean */
  16,   /* field[16] = test_bytes */
  11,   /* field[11] = test_double */
  14,   /* field[14] = test_enum */
  13,   /* field[13] = test_enum_small */
  7,   /* field[7] = test_fixed32 */
  9,   /* field[9] = test_fixed64 */
  10,   /* field[10] = test_float */
  0,   /* field[0] = test_int32 */
  3,   /* field[3] = test_int64 */
  17,   /* field[17] = test_message */
  2,   /* field[2] = test_sfixed32 */
  5,   /* field[5] = test_sfixed64 */
  1,   /* field[1] = test_sint32 */
  4,   /* field[4] = test_sint64 */
  15,   /* field[15] = test_string */
  6,   /* field[6] = test_uint32 */
  8,   /* field[8] = test_uint64 */
};
static const ProtobufCIntRange foo__test_mess_oneof__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 19 }
};
const ProtobufCMessageDescriptor foo__test_mess_oneof__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessOneof",
  "TestMessOneof",
  "Foo__TestMessOneof",
  "foo",
  sizeof(Foo__TestMessOneof),
  19,
  foo__test_mess_oneof__field_descriptors,
  foo__test_mess_oneof__field_indices_by_name,
  1,  foo__test_mess_oneof__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_oneof__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_int32__field_descriptors[1] =
{
  {
    "test",
    42,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredInt32, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_int32__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_int32__number_ranges[1 + 1] =
{
  { 42, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_int32__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredInt32",
  "TestMessRequiredInt32",
  "Foo__TestMessRequiredInt32",
  "foo",
  sizeof(Foo__TestMessRequiredInt32),
  1,
  foo__test_mess_required_int32__field_descriptors,
  foo__test_mess_required_int32__field_indices_by_name,
  1,  foo__test_mess_required_int32__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_int32__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_sint32__field_descriptors[1] =
{
  {
    "test",
    43,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_SINT32,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredSInt32, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_sint32__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_sint32__number_ranges[1 + 1] =
{
  { 43, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_sint32__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredSInt32",
  "TestMessRequiredSInt32",
  "Foo__TestMessRequiredSInt32",
  "foo",
  sizeof(Foo__TestMessRequiredSInt32),
  1,
  foo__test_mess_required_sint32__field_descriptors,
  foo__test_mess_required_sint32__field_indices_by_name,
  1,  foo__test_mess_required_sint32__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_sint32__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_sfixed32__field_descriptors[1] =
{
  {
    "test",
    100,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_SFIXED32,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredSFixed32, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_sfixed32__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_sfixed32__number_ranges[1 + 1] =
{
  { 100, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_sfixed32__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredSFixed32",
  "TestMessRequiredSFixed32",
  "Foo__TestMessRequiredSFixed32",
  "foo",
  sizeof(Foo__TestMessRequiredSFixed32),
  1,
  foo__test_mess_required_sfixed32__field_descriptors,
  foo__test_mess_required_sfixed32__field_indices_by_name,
  1,  foo__test_mess_required_sfixed32__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_sfixed32__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_int64__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT64,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredInt64, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_int64__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_int64__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_int64__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredInt64",
  "TestMessRequiredInt64",
  "Foo__TestMessRequiredInt64",
  "foo",
  sizeof(Foo__TestMessRequiredInt64),
  1,
  foo__test_mess_required_int64__field_descriptors,
  foo__test_mess_required_int64__field_indices_by_name,
  1,  foo__test_mess_required_int64__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_int64__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_sint64__field_descriptors[1] =
{
  {
    "test",
    11,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_SINT64,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredSInt64, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_sint64__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_sint64__number_ranges[1 + 1] =
{
  { 11, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_sint64__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredSInt64",
  "TestMessRequiredSInt64",
  "Foo__TestMessRequiredSInt64",
  "foo",
  sizeof(Foo__TestMessRequiredSInt64),
  1,
  foo__test_mess_required_sint64__field_descriptors,
  foo__test_mess_required_sint64__field_indices_by_name,
  1,  foo__test_mess_required_sint64__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_sint64__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_sfixed64__field_descriptors[1] =
{
  {
    "test",
    12,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_SFIXED64,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredSFixed64, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_sfixed64__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_sfixed64__number_ranges[1 + 1] =
{
  { 12, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_sfixed64__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredSFixed64",
  "TestMessRequiredSFixed64",
  "Foo__TestMessRequiredSFixed64",
  "foo",
  sizeof(Foo__TestMessRequiredSFixed64),
  1,
  foo__test_mess_required_sfixed64__field_descriptors,
  foo__test_mess_required_sfixed64__field_indices_by_name,
  1,  foo__test_mess_required_sfixed64__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_sfixed64__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_uint32__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredUInt32, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_uint32__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_uint32__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_uint32__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredUInt32",
  "TestMessRequiredUInt32",
  "Foo__TestMessRequiredUInt32",
  "foo",
  sizeof(Foo__TestMessRequiredUInt32),
  1,
  foo__test_mess_required_uint32__field_descriptors,
  foo__test_mess_required_uint32__field_indices_by_name,
  1,  foo__test_mess_required_uint32__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_uint32__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_fixed32__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_FIXED32,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredFixed32, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_fixed32__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_fixed32__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_fixed32__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredFixed32",
  "TestMessRequiredFixed32",
  "Foo__TestMessRequiredFixed32",
  "foo",
  sizeof(Foo__TestMessRequiredFixed32),
  1,
  foo__test_mess_required_fixed32__field_descriptors,
  foo__test_mess_required_fixed32__field_indices_by_name,
  1,  foo__test_mess_required_fixed32__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_fixed32__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_uint64__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredUInt64, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_uint64__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_uint64__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_uint64__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredUInt64",
  "TestMessRequiredUInt64",
  "Foo__TestMessRequiredUInt64",
  "foo",
  sizeof(Foo__TestMessRequiredUInt64),
  1,
  foo__test_mess_required_uint64__field_descriptors,
  foo__test_mess_required_uint64__field_indices_by_name,
  1,  foo__test_mess_required_uint64__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_uint64__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_fixed64__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_FIXED64,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredFixed64, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_fixed64__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_fixed64__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_fixed64__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredFixed64",
  "TestMessRequiredFixed64",
  "Foo__TestMessRequiredFixed64",
  "foo",
  sizeof(Foo__TestMessRequiredFixed64),
  1,
  foo__test_mess_required_fixed64__field_descriptors,
  foo__test_mess_required_fixed64__field_indices_by_name,
  1,  foo__test_mess_required_fixed64__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_fixed64__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_float__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_FLOAT,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredFloat, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_float__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_float__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_float__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredFloat",
  "TestMessRequiredFloat",
  "Foo__TestMessRequiredFloat",
  "foo",
  sizeof(Foo__TestMessRequiredFloat),
  1,
  foo__test_mess_required_float__field_descriptors,
  foo__test_mess_required_float__field_indices_by_name,
  1,  foo__test_mess_required_float__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_float__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_double__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_DOUBLE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredDouble, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_double__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_double__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_double__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredDouble",
  "TestMessRequiredDouble",
  "Foo__TestMessRequiredDouble",
  "foo",
  sizeof(Foo__TestMessRequiredDouble),
  1,
  foo__test_mess_required_double__field_descriptors,
  foo__test_mess_required_double__field_indices_by_name,
  1,  foo__test_mess_required_double__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_double__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_bool__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredBool, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_bool__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_bool__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_bool__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredBool",
  "TestMessRequiredBool",
  "Foo__TestMessRequiredBool",
  "foo",
  sizeof(Foo__TestMessRequiredBool),
  1,
  foo__test_mess_required_bool__field_descriptors,
  foo__test_mess_required_bool__field_indices_by_name,
  1,  foo__test_mess_required_bool__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_bool__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_enum__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredEnum, test),
    &foo__test_enum__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_enum__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_enum__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_enum__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredEnum",
  "TestMessRequiredEnum",
  "Foo__TestMessRequiredEnum",
  "foo",
  sizeof(Foo__TestMessRequiredEnum),
  1,
  foo__test_mess_required_enum__field_descriptors,
  foo__test_mess_required_enum__field_indices_by_name,
  1,  foo__test_mess_required_enum__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_enum__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_enum_small__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredEnumSmall, test),
    &foo__test_enum_small__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_enum_small__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_enum_small__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_enum_small__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredEnumSmall",
  "TestMessRequiredEnumSmall",
  "Foo__TestMessRequiredEnumSmall",
  "foo",
  sizeof(Foo__TestMessRequiredEnumSmall),
  1,
  foo__test_mess_required_enum_small__field_descriptors,
  foo__test_mess_required_enum_small__field_indices_by_name,
  1,  foo__test_mess_required_enum_small__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_enum_small__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_string__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredString, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_string__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_string__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_string__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredString",
  "TestMessRequiredString",
  "Foo__TestMessRequiredString",
  "foo",
  sizeof(Foo__TestMessRequiredString),
  1,
  foo__test_mess_required_string__field_descriptors,
  foo__test_mess_required_string__field_indices_by_name,
  1,  foo__test_mess_required_string__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_string__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_bytes__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredBytes, test),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_bytes__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_bytes__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_bytes__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredBytes",
  "TestMessRequiredBytes",
  "Foo__TestMessRequiredBytes",
  "foo",
  sizeof(Foo__TestMessRequiredBytes),
  1,
  foo__test_mess_required_bytes__field_descriptors,
  foo__test_mess_required_bytes__field_indices_by_name,
  1,  foo__test_mess_required_bytes__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_bytes__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_required_message__field_descriptors[1] =
{
  {
    "test",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessRequiredMessage, test),
    &foo__sub_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_required_message__field_indices_by_name[] = {
  0,   /* field[0] = test */
};
static const ProtobufCIntRange foo__test_mess_required_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_mess_required_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessRequiredMessage",
  "TestMessRequiredMessage",
  "Foo__TestMessRequiredMessage",
  "foo",
  sizeof(Foo__TestMessRequiredMessage),
  1,
  foo__test_mess_required_message__field_descriptors,
  foo__test_mess_required_message__field_indices_by_name,
  1,  foo__test_mess_required_message__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_required_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define foo__empty_mess__field_descriptors NULL
#define foo__empty_mess__field_indices_by_name NULL
#define foo__empty_mess__number_ranges NULL
const ProtobufCMessageDescriptor foo__empty_mess__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.EmptyMess",
  "EmptyMess",
  "Foo__EmptyMess",
  "foo",
  sizeof(Foo__EmptyMess),
  0,
  foo__empty_mess__field_descriptors,
  foo__empty_mess__field_indices_by_name,
  0,  foo__empty_mess__number_ranges,
  (ProtobufCMessageInit) foo__empty_mess__init,
  NULL,NULL,NULL    /* reserved[123] */
};
char foo__default_required_values__v_string__default_value[] = "hi mom\n";
uint8_t foo__default_required_values__v_bytes__default_value_data[] = "a \000 character";
static const int32_t foo__default_required_values__v_int32__default_value = -42;
static const uint32_t foo__default_required_values__v_uint32__default_value = 666u;
static const int32_t foo__default_required_values__v_int64__default_value = 100000;
static const uint32_t foo__default_required_values__v_uint64__default_value = 100001u;
static const float foo__default_required_values__v_float__default_value = 2.5;
static const double foo__default_required_values__v_double__default_value = 4.5;
static const ProtobufCBinaryData foo__default_required_values__v_bytes__default_value = { 13, foo__default_required_values__v_bytes__default_value_data };
static const ProtobufCFieldDescriptor foo__default_required_values__field_descriptors[8] =
{
  {
    "v_int32",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_int32),
    NULL,
    &foo__default_required_values__v_int32__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_uint32",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_uint32),
    NULL,
    &foo__default_required_values__v_uint32__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_int64",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_int64),
    NULL,
    &foo__default_required_values__v_int64__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_uint64",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_uint64),
    NULL,
    &foo__default_required_values__v_uint64__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_float",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_FLOAT,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_float),
    NULL,
    &foo__default_required_values__v_float__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_double",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_DOUBLE,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_double),
    NULL,
    &foo__default_required_values__v_double__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_string",
    7,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_string),
    NULL,
    &foo__default_required_values__v_string__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_bytes",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultRequiredValues, v_bytes),
    NULL,
    &foo__default_required_values__v_bytes__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__default_required_values__field_indices_by_name[] = {
  7,   /* field[7] = v_bytes */
  5,   /* field[5] = v_double */
  4,   /* field[4] = v_float */
  0,   /* field[0] = v_int32 */
  2,   /* field[2] = v_int64 */
  6,   /* field[6] = v_string */
  1,   /* field[1] = v_uint32 */
  3,   /* field[3] = v_uint64 */
};
static const ProtobufCIntRange foo__default_required_values__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 8 }
};
const ProtobufCMessageDescriptor foo__default_required_values__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.DefaultRequiredValues",
  "DefaultRequiredValues",
  "Foo__DefaultRequiredValues",
  "foo",
  sizeof(Foo__DefaultRequiredValues),
  8,
  foo__default_required_values__field_descriptors,
  foo__default_required_values__field_indices_by_name,
  1,  foo__default_required_values__number_ranges,
  (ProtobufCMessageInit) foo__default_required_values__init,
  NULL,NULL,NULL    /* reserved[123] */
};
char foo__default_optional_values__v_string__default_value[] = "hi mom\n";
uint8_t foo__default_optional_values__v_bytes__default_value_data[] = "a \000 character";
static const int32_t foo__default_optional_values__v_int32__default_value = -42;
static const uint32_t foo__default_optional_values__v_uint32__default_value = 666u;
static const int32_t foo__default_optional_values__v_int64__default_value = 100000;
static const uint32_t foo__default_optional_values__v_uint64__default_value = 100001u;
static const float foo__default_optional_values__v_float__default_value = 2.5;
static const double foo__default_optional_values__v_double__default_value = 4.5;
static const ProtobufCBinaryData foo__default_optional_values__v_bytes__default_value = { 13, foo__default_optional_values__v_bytes__default_value_data };
static const ProtobufCFieldDescriptor foo__default_optional_values__field_descriptors[8] =
{
  {
    "v_int32",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__DefaultOptionalValues, has_v_int32),
    offsetof(Foo__DefaultOptionalValues, v_int32),
    NULL,
    &foo__default_optional_values__v_int32__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_uint32",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(Foo__DefaultOptionalValues, has_v_uint32),
    offsetof(Foo__DefaultOptionalValues, v_uint32),
    NULL,
    &foo__default_optional_values__v_uint32__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_int64",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__DefaultOptionalValues, has_v_int64),
    offsetof(Foo__DefaultOptionalValues, v_int64),
    NULL,
    &foo__default_optional_values__v_int64__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_uint64",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(Foo__DefaultOptionalValues, has_v_uint64),
    offsetof(Foo__DefaultOptionalValues, v_uint64),
    NULL,
    &foo__default_optional_values__v_uint64__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_float",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_FLOAT,
    offsetof(Foo__DefaultOptionalValues, has_v_float),
    offsetof(Foo__DefaultOptionalValues, v_float),
    NULL,
    &foo__default_optional_values__v_float__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_double",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_DOUBLE,
    offsetof(Foo__DefaultOptionalValues, has_v_double),
    offsetof(Foo__DefaultOptionalValues, v_double),
    NULL,
    &foo__default_optional_values__v_double__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_string",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__DefaultOptionalValues, v_string),
    NULL,
    &foo__default_optional_values__v_string__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "v_bytes",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__DefaultOptionalValues, has_v_bytes),
    offsetof(Foo__DefaultOptionalValues, v_bytes),
    NULL,
    &foo__default_optional_values__v_bytes__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__default_optional_values__field_indices_by_name[] = {
  7,   /* field[7] = v_bytes */
  5,   /* field[5] = v_double */
  4,   /* field[4] = v_float */
  0,   /* field[0] = v_int32 */
  2,   /* field[2] = v_int64 */
  6,   /* field[6] = v_string */
  1,   /* field[1] = v_uint32 */
  3,   /* field[3] = v_uint64 */
};
static const ProtobufCIntRange foo__default_optional_values__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 8 }
};
const ProtobufCMessageDescriptor foo__default_optional_values__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.DefaultOptionalValues",
  "DefaultOptionalValues",
  "Foo__DefaultOptionalValues",
  "foo",
  sizeof(Foo__DefaultOptionalValues),
  8,
  foo__default_optional_values__field_descriptors,
  foo__default_optional_values__field_indices_by_name,
  1,  foo__default_optional_values__number_ranges,
  (ProtobufCMessageInit) foo__default_optional_values__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue foo__lower_case__case_enum__enum_values_by_number[2] =
{
  { "UPPER", "FOO__LOWER_CASE__CASE_ENUM__UPPER", 1 },
  { "lower", "FOO__LOWER_CASE__CASE_ENUM__lower", 2 },
};
static const ProtobufCIntRange foo__lower_case__case_enum__value_ranges[] = {
{1, 0},{0, 2}
};
static const ProtobufCEnumValueIndex foo__lower_case__case_enum__enum_values_by_name[2] =
{
  { "UPPER", 0 },
  { "lower", 1 },
};
const ProtobufCEnumDescriptor foo__lower_case__case_enum__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "foo.LowerCase.CaseEnum",
  "CaseEnum",
  "Foo__LowerCase__CaseEnum",
  "foo",
  2,
  foo__lower_case__case_enum__enum_values_by_number,
  2,
  foo__lower_case__case_enum__enum_values_by_name,
  1,
  foo__lower_case__case_enum__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const Foo__LowerCase__CaseEnum foo__lower_case__value__default_value = FOO__LOWER_CASE__CASE_ENUM__lower;
static const ProtobufCFieldDescriptor foo__lower_case__field_descriptors[1] =
{
  {
    "value",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_ENUM,
    offsetof(Foo__LowerCase, has_value),
    offsetof(Foo__LowerCase, value),
    &foo__lower_case__case_enum__descriptor,
    &foo__lower_case__value__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__lower_case__field_indices_by_name[] = {
  0,   /* field[0] = value */
};
static const ProtobufCIntRange foo__lower_case__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__lower_case__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.LowerCase",
  "LowerCase",
  "Foo__LowerCase",
  "foo",
  sizeof(Foo__LowerCase),
  1,
  foo__lower_case__field_descriptors,
  foo__lower_case__field_indices_by_name,
  1,  foo__lower_case__number_ranges,
  (ProtobufCMessageInit) foo__lower_case__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__alloc_values__field_descriptors[5] =
{
  {
    "o_bytes",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__AllocValues, has_o_bytes),
    offsetof(Foo__AllocValues, o_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "r_string",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Foo__AllocValues, n_r_string),
    offsetof(Foo__AllocValues, r_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "a_string",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__AllocValues, a_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "a_bytes",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Foo__AllocValues, a_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "a_mess",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__AllocValues, a_mess),
    &foo__default_required_values__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__alloc_values__field_indices_by_name[] = {
  3,   /* field[3] = a_bytes */
  4,   /* field[4] = a_mess */
  2,   /* field[2] = a_string */
  0,   /* field[0] = o_bytes */
  1,   /* field[1] = r_string */
};
static const ProtobufCIntRange foo__alloc_values__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor foo__alloc_values__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.AllocValues",
  "AllocValues",
  "Foo__AllocValues",
  "foo",
  sizeof(Foo__AllocValues),
  5,
  foo__alloc_values__field_descriptors,
  foo__alloc_values__field_indices_by_name,
  1,  foo__alloc_values__number_ranges,
  (ProtobufCMessageInit) foo__alloc_values__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_required_fields_bitmap__field_descriptors[129] =
{
  {
    "field1",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field1),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field2",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field2),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field3",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field3),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field4",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field4),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field5",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field5),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field6",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field6),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field7",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field7),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field8",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field8),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field9",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field9),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field10",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field10),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field11",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field11),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field12",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field12),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field13",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field13),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field14",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field14),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field15",
    15,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field15),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field16",
    16,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field16),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field17",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field17),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field18",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field18),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field19",
    19,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field19),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field20",
    20,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field20),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field21",
    21,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field21),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field22",
    22,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field22),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field23",
    23,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field23),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field24",
    24,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field24),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field25",
    25,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field25),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field26",
    26,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field26),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field27",
    27,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field27),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field28",
    28,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field28),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field29",
    29,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field29),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field30",
    30,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field30),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field31",
    31,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field31),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field32",
    32,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field32),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field33",
    33,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field33),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field34",
    34,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field34),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field35",
    35,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field35),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field36",
    36,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field36),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field37",
    37,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field37),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field38",
    38,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field38),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field39",
    39,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field39),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field40",
    40,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field40),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field41",
    41,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field41),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field42",
    42,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field42),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field43",
    43,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field43),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field44",
    44,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field44),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field45",
    45,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field45),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field46",
    46,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field46),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field47",
    47,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field47),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field48",
    48,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field48),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field49",
    49,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field49),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field50",
    50,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field50),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field51",
    51,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field51),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field52",
    52,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field52),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field53",
    53,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field53),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field54",
    54,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field54),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field55",
    55,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field55),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field56",
    56,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field56),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field57",
    57,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field57),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field58",
    58,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field58),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field59",
    59,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field59),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field60",
    60,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field60),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field61",
    61,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field61),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field62",
    62,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field62),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field63",
    63,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field63),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field64",
    64,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field64),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field65",
    65,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field65),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field66",
    66,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field66),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field67",
    67,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field67),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field68",
    68,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field68),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field69",
    69,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field69),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field70",
    70,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field70),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field71",
    71,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field71),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field72",
    72,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field72),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field73",
    73,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field73),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field74",
    74,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field74),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field75",
    75,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field75),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field76",
    76,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field76),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field77",
    77,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field77),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field78",
    78,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field78),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field79",
    79,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field79),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field80",
    80,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field80),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field81",
    81,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field81),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field82",
    82,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field82),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field83",
    83,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field83),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field84",
    84,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field84),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field85",
    85,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field85),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field86",
    86,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field86),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field87",
    87,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field87),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field88",
    88,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field88),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field89",
    89,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field89),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field90",
    90,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field90),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field91",
    91,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field91),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field92",
    92,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field92),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field93",
    93,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field93),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field94",
    94,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field94),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field95",
    95,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field95),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field96",
    96,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field96),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field97",
    97,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field97),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field98",
    98,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field98),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field99",
    99,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field99),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field100",
    100,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field100),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field101",
    101,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field101),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field102",
    102,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field102),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field103",
    103,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field103),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field104",
    104,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field104),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field105",
    105,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field105),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field106",
    106,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field106),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field107",
    107,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field107),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field108",
    108,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field108),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field109",
    109,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field109),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field110",
    110,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field110),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field111",
    111,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field111),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field112",
    112,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field112),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field113",
    113,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field113),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field114",
    114,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field114),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field115",
    115,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field115),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field116",
    116,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field116),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field117",
    117,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field117),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field118",
    118,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field118),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field119",
    119,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field119),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field120",
    120,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field120),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field121",
    121,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field121),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field122",
    122,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field122),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field123",
    123,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field123),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field124",
    124,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field124),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field125",
    125,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field125),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field126",
    126,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field126),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field127",
    127,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field127),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field128",
    128,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field128),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "field129",
    129,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestRequiredFieldsBitmap, field129),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_required_fields_bitmap__field_indices_by_name[] = {
  0,   /* field[0] = field1 */
  9,   /* field[9] = field10 */
  99,   /* field[99] = field100 */
  100,   /* field[100] = field101 */
  101,   /* field[101] = field102 */
  102,   /* field[102] = field103 */
  103,   /* field[103] = field104 */
  104,   /* field[104] = field105 */
  105,   /* field[105] = field106 */
  106,   /* field[106] = field107 */
  107,   /* field[107] = field108 */
  108,   /* field[108] = field109 */
  10,   /* field[10] = field11 */
  109,   /* field[109] = field110 */
  110,   /* field[110] = field111 */
  111,   /* field[111] = field112 */
  112,   /* field[112] = field113 */
  113,   /* field[113] = field114 */
  114,   /* field[114] = field115 */
  115,   /* field[115] = field116 */
  116,   /* field[116] = field117 */
  117,   /* field[117] = field118 */
  118,   /* field[118] = field119 */
  11,   /* field[11] = field12 */
  119,   /* field[119] = field120 */
  120,   /* field[120] = field121 */
  121,   /* field[121] = field122 */
  122,   /* field[122] = field123 */
  123,   /* field[123] = field124 */
  124,   /* field[124] = field125 */
  125,   /* field[125] = field126 */
  126,   /* field[126] = field127 */
  127,   /* field[127] = field128 */
  128,   /* field[128] = field129 */
  12,   /* field[12] = field13 */
  13,   /* field[13] = field14 */
  14,   /* field[14] = field15 */
  15,   /* field[15] = field16 */
  16,   /* field[16] = field17 */
  17,   /* field[17] = field18 */
  18,   /* field[18] = field19 */
  1,   /* field[1] = field2 */
  19,   /* field[19] = field20 */
  20,   /* field[20] = field21 */
  21,   /* field[21] = field22 */
  22,   /* field[22] = field23 */
  23,   /* field[23] = field24 */
  24,   /* field[24] = field25 */
  25,   /* field[25] = field26 */
  26,   /* field[26] = field27 */
  27,   /* field[27] = field28 */
  28,   /* field[28] = field29 */
  2,   /* field[2] = field3 */
  29,   /* field[29] = field30 */
  30,   /* field[30] = field31 */
  31,   /* field[31] = field32 */
  32,   /* field[32] = field33 */
  33,   /* field[33] = field34 */
  34,   /* field[34] = field35 */
  35,   /* field[35] = field36 */
  36,   /* field[36] = field37 */
  37,   /* field[37] = field38 */
  38,   /* field[38] = field39 */
  3,   /* field[3] = field4 */
  39,   /* field[39] = field40 */
  40,   /* field[40] = field41 */
  41,   /* field[41] = field42 */
  42,   /* field[42] = field43 */
  43,   /* field[43] = field44 */
  44,   /* field[44] = field45 */
  45,   /* field[45] = field46 */
  46,   /* field[46] = field47 */
  47,   /* field[47] = field48 */
  48,   /* field[48] = field49 */
  4,   /* field[4] = field5 */
  49,   /* field[49] = field50 */
  50,   /* field[50] = field51 */
  51,   /* field[51] = field52 */
  52,   /* field[52] = field53 */
  53,   /* field[53] = field54 */
  54,   /* field[54] = field55 */
  55,   /* field[55] = field56 */
  56,   /* field[56] = field57 */
  57,   /* field[57] = field58 */
  58,   /* field[58] = field59 */
  5,   /* field[5] = field6 */
  59,   /* field[59] = field60 */
  60,   /* field[60] = field61 */
  61,   /* field[61] = field62 */
  62,   /* field[62] = field63 */
  63,   /* field[63] = field64 */
  64,   /* field[64] = field65 */
  65,   /* field[65] = field66 */
  66,   /* field[66] = field67 */
  67,   /* field[67] = field68 */
  68,   /* field[68] = field69 */
  6,   /* field[6] = field7 */
  69,   /* field[69] = field70 */
  70,   /* field[70] = field71 */
  71,   /* field[71] = field72 */
  72,   /* field[72] = field73 */
  73,   /* field[73] = field74 */
  74,   /* field[74] = field75 */
  75,   /* field[75] = field76 */
  76,   /* field[76] = field77 */
  77,   /* field[77] = field78 */
  78,   /* field[78] = field79 */
  7,   /* field[7] = field8 */
  79,   /* field[79] = field80 */
  80,   /* field[80] = field81 */
  81,   /* field[81] = field82 */
  82,   /* field[82] = field83 */
  83,   /* field[83] = field84 */
  84,   /* field[84] = field85 */
  85,   /* field[85] = field86 */
  86,   /* field[86] = field87 */
  87,   /* field[87] = field88 */
  88,   /* field[88] = field89 */
  8,   /* field[8] = field9 */
  89,   /* field[89] = field90 */
  90,   /* field[90] = field91 */
  91,   /* field[91] = field92 */
  92,   /* field[92] = field93 */
  93,   /* field[93] = field94 */
  94,   /* field[94] = field95 */
  95,   /* field[95] = field96 */
  96,   /* field[96] = field97 */
  97,   /* field[97] = field98 */
  98,   /* field[98] = field99 */
};
static const ProtobufCIntRange foo__test_required_fields_bitmap__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 129 }
};
const ProtobufCMessageDescriptor foo__test_required_fields_bitmap__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestRequiredFieldsBitmap",
  "TestRequiredFieldsBitmap",
  "Foo__TestRequiredFieldsBitmap",
  "foo",
  sizeof(Foo__TestRequiredFieldsBitmap),
  129,
  foo__test_required_fields_bitmap__field_descriptors,
  foo__test_required_fields_bitmap__field_indices_by_name,
  1,  foo__test_required_fields_bitmap__number_ranges,
  (ProtobufCMessageInit) foo__test_required_fields_bitmap__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_field_flags__field_descriptors[6] =
{
  {
    "no_flags1",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestFieldFlags, has_no_flags1),
    offsetof(Foo__TestFieldFlags, no_flags1),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "no_flags2",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_INT32,
    0,   /* quantifier_offset */
    offsetof(Foo__TestFieldFlags, no_flags2),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "no_flags3",
    3,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestFieldFlags, n_no_flags3),
    offsetof(Foo__TestFieldFlags, no_flags3),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "packed",
    4,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestFieldFlags, n_packed),
    offsetof(Foo__TestFieldFlags, packed),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "packed_deprecated",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestFieldFlags, n_packed_deprecated),
    offsetof(Foo__TestFieldFlags, packed_deprecated),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_PACKED | PROTOBUF_C_FIELD_FLAG_DEPRECATED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "deprecated",
    6,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_INT32,
    offsetof(Foo__TestFieldFlags, n_deprecated),
    offsetof(Foo__TestFieldFlags, deprecated),
    NULL,
    NULL,
    PROTOBUF_C_FIELD_FLAG_DEPRECATED,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_field_flags__field_indices_by_name[] = {
  5,   /* field[5] = deprecated */
  0,   /* field[0] = no_flags1 */
  1,   /* field[1] = no_flags2 */
  2,   /* field[2] = no_flags3 */
  3,   /* field[3] = packed */
  4,   /* field[4] = packed_deprecated */
};
static const ProtobufCIntRange foo__test_field_flags__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor foo__test_field_flags__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestFieldFlags",
  "TestFieldFlags",
  "Foo__TestFieldFlags",
  "foo",
  sizeof(Foo__TestFieldFlags),
  6,
  foo__test_field_flags__field_descriptors,
  foo__test_field_flags__field_indices_by_name,
  1,  foo__test_field_flags__number_ranges,
  (ProtobufCMessageInit) foo__test_field_flags__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_message_check__sub_message__field_descriptors[1] =
{
  {
    "str",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessageCheck__SubMessage, str),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_message_check__sub_message__field_indices_by_name[] = {
  0,   /* field[0] = str */
};
static const ProtobufCIntRange foo__test_message_check__sub_message__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor foo__test_message_check__sub_message__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessageCheck.SubMessage",
  "SubMessage",
  "Foo__TestMessageCheck__SubMessage",
  "foo",
  sizeof(Foo__TestMessageCheck__SubMessage),
  1,
  foo__test_message_check__sub_message__field_descriptors,
  foo__test_message_check__sub_message__field_indices_by_name,
  1,  foo__test_message_check__sub_message__number_ranges,
  (ProtobufCMessageInit) foo__test_message_check__sub_message__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_message_check__field_descriptors[9] =
{
  {
    "required_msg",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessageCheck, required_msg),
    &foo__test_message_check__sub_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "repeated_msg",
    2,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(Foo__TestMessageCheck, n_repeated_msg),
    offsetof(Foo__TestMessageCheck, repeated_msg),
    &foo__test_message_check__sub_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "optional_msg",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessageCheck, optional_msg),
    &foo__test_message_check__sub_message__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "required_string",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessageCheck, required_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "repeated_string",
    5,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(Foo__TestMessageCheck, n_repeated_string),
    offsetof(Foo__TestMessageCheck, repeated_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "optional_string",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessageCheck, optional_string),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "required_bytes",
    7,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessageCheck, required_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "repeated_bytes",
    8,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__TestMessageCheck, n_repeated_bytes),
    offsetof(Foo__TestMessageCheck, repeated_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "optional_bytes",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(Foo__TestMessageCheck, has_optional_bytes),
    offsetof(Foo__TestMessageCheck, optional_bytes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_message_check__field_indices_by_name[] = {
  8,   /* field[8] = optional_bytes */
  2,   /* field[2] = optional_msg */
  5,   /* field[5] = optional_string */
  7,   /* field[7] = repeated_bytes */
  1,   /* field[1] = repeated_msg */
  4,   /* field[4] = repeated_string */
  6,   /* field[6] = required_bytes */
  0,   /* field[0] = required_msg */
  3,   /* field[3] = required_string */
};
static const ProtobufCIntRange foo__test_message_check__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 9 }
};
const ProtobufCMessageDescriptor foo__test_message_check__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessageCheck",
  "TestMessageCheck",
  "Foo__TestMessageCheck",
  "foo",
  sizeof(Foo__TestMessageCheck),
  9,
  foo__test_message_check__field_descriptors,
  foo__test_message_check__field_indices_by_name,
  1,  foo__test_message_check__number_ranges,
  (ProtobufCMessageInit) foo__test_message_check__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor foo__test_mess_sub_mess__field_descriptors[5] =
{
  {
    "rep_mess",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessSubMess, rep_mess),
    &foo__test_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "opt_mess",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessSubMess, opt_mess),
    &foo__test_mess_optional__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "oneof_mess",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessSubMess, oneof_mess),
    &foo__test_mess_oneof__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "req_mess",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessSubMess, req_mess),
    &foo__sub_mess__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "def_mess",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(Foo__TestMessSubMess, def_mess),
    &foo__default_optional_values__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned foo__test_mess_sub_mess__field_indices_by_name[] = {
  4,   /* field[4] = def_mess */
  2,   /* field[2] = oneof_mess */
  1,   /* field[1] = opt_mess */
  0,   /* field[0] = rep_mess */
  3,   /* field[3] = req_mess */
};
static const ProtobufCIntRange foo__test_mess_sub_mess__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor foo__test_mess_sub_mess__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "foo.TestMessSubMess",
  "TestMessSubMess",
  "Foo__TestMessSubMess",
  "foo",
  sizeof(Foo__TestMessSubMess),
  5,
  foo__test_mess_sub_mess__field_descriptors,
  foo__test_mess_sub_mess__field_indices_by_name,
  1,  foo__test_mess_sub_mess__number_ranges,
  (ProtobufCMessageInit) foo__test_mess_sub_mess__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue foo__test_enum_small__enum_values_by_number[3] =
{
  { "NEG_VALUE", "FOO__TEST_ENUM_SMALL__NEG_VALUE", -1 },
  { "VALUE", "FOO__TEST_ENUM_SMALL__VALUE", 0 },
  { "OTHER_VALUE", "FOO__TEST_ENUM_SMALL__OTHER_VALUE", 1 },
};
static const ProtobufCIntRange foo__test_enum_small__value_ranges[] = {
{-1, 0},{0, 3}
};
static const ProtobufCEnumValueIndex foo__test_enum_small__enum_values_by_name[3] =
{
  { "NEG_VALUE", 0 },
  { "OTHER_VALUE", 2 },
  { "VALUE", 1 },
};
const ProtobufCEnumDescriptor foo__test_enum_small__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "foo.TestEnumSmall",
  "TestEnumSmall",
  "Foo__TestEnumSmall",
  "foo",
  3,
  foo__test_enum_small__enum_values_by_number,
  3,
  foo__test_enum_small__enum_values_by_name,
  1,
  foo__test_enum_small__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCEnumValue foo__test_enum__enum_values_by_number[12] =
{
  { "VALUENEG123456", "FOO__TEST_ENUM__VALUENEG123456", -123456 },
  { "VALUENEG1", "FOO__TEST_ENUM__VALUENEG1", -1 },
  { "VALUE0", "FOO__TEST_ENUM__VALUE0", 0 },
  { "VALUE1", "FOO__TEST_ENUM__VALUE1", 1 },
  { "VALUE127", "FOO__TEST_ENUM__VALUE127", 127 },
  { "VALUE128", "FOO__TEST_ENUM__VALUE128", 128 },
  { "VALUE16383", "FOO__TEST_ENUM__VALUE16383", 16383 },
  { "VALUE16384", "FOO__TEST_ENUM__VALUE16384", 16384 },
  { "VALUE2097151", "FOO__TEST_ENUM__VALUE2097151", 2097151 },
  { "VALUE2097152", "FOO__TEST_ENUM__VALUE2097152", 2097152 },
  { "VALUE268435455", "FOO__TEST_ENUM__VALUE268435455", 268435455 },
  { "VALUE268435456", "FOO__TEST_ENUM__VALUE268435456", 268435456 },
};
static const ProtobufCIntRange foo__test_enum__value_ranges[] = {
{-123456, 0},{-1, 1},{127, 4},{16383, 6},{2097151, 8},{268435455, 10},{0, 12}
};
static const ProtobufCEnumValueIndex foo__test_enum__enum_values_by_name[12] =
{
  { "VALUE0", 2 },
  { "VALUE1", 3 },
  { "VALUE127", 4 },
  { "VALUE128", 5 },
  { "VALUE16383", 6 },
  { "VALUE16384", 7 },
  { "VALUE2097151", 8 },
  { "VALUE2097152", 9 },
  { "VALUE268435455", 10 },
  { "VALUE268435456", 11 },
  { "VALUENEG1", 1 },
  { "VALUENEG123456", 0 },
};
const ProtobufCEnumDescriptor foo__test_enum__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "foo.TestEnum",
  "TestEnum",
  "Foo__TestEnum",
  "foo",
  12,
  foo__test_enum__enum_values_by_number,
  12,
  foo__test_enum__enum_values_by_name,
  6,
  foo__test_enum__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCEnumValue foo__test_enum_dup_values__enum_values_by_number[4] =
{
  { "VALUE_A", "FOO__TEST_ENUM_DUP_VALUES__VALUE_A", 42 },
  { "VALUE_D", "FOO__TEST_ENUM_DUP_VALUES__VALUE_D", 666 },
  { "VALUE_F", "FOO__TEST_ENUM_DUP_VALUES__VALUE_F", 1000 },
  { "VALUE_BB", "FOO__TEST_ENUM_DUP_VALUES__VALUE_BB", 1001 },
};
static const ProtobufCIntRange foo__test_enum_dup_values__value_ranges[] = {
{42, 0},{666, 1},{1000, 2},{0, 4}
};
static const ProtobufCEnumValueIndex foo__test_enum_dup_values__enum_values_by_name[8] =
{
  { "VALUE_A", 0 },
  { "VALUE_AA", 2 },
  { "VALUE_B", 0 },
  { "VALUE_BB", 3 },
  { "VALUE_C", 0 },
  { "VALUE_D", 1 },
  { "VALUE_E", 1 },
  { "VALUE_F", 2 },
};
const ProtobufCEnumDescriptor foo__test_enum_dup_values__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "foo.TestEnumDupValues",
  "TestEnumDupValues",
  "Foo__TestEnumDupValues",
  "foo",
  4,
  foo__test_enum_dup_values__enum_values_by_number,
  8,
  foo__test_enum_dup_values__enum_values_by_name,
  3,
  foo__test_enum_dup_values__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};

Coverage Report

Created: 2024-11-21 06:05