src/resultstore_reader.pb.cc

// This file is auto-generated by generate_proto_header.py, do not edit

// clang-format off

#include "resultstore_reader.pb.h"
#include "proto_reader.h"
#include "proto_wire.h"
#include "input_stream.h"

// Macros to reduce code duplication in generated files.
#define PROTO_READER_PARSE_LOOP_BEGIN                              \
    uint32_t tag;                                                  \
    int field_number;                                              \
    int wire_type;                                                 \
    while (ReadTag(input, &tag, &field_number, &wire_type)) {      \
      switch (field_number) {

#define PROTO_READER_PARSE_LOOP_END                                \
  default:                                                         \
    if (!SkipField(input, wire_type)) return false;                \
    break;                                                         \
  }                                                                \
  }                                                                \
  return true;

template <typename Msg, typename T>
inline bool ProtoReaderSetField(InputStream& input,
                                bool (*reader)(InputStream&, T*),
                                void (Msg::*setter)(const T&),
                                Msg* out) {
  T val;
  if (!reader(input, &val)) return false;
  (out->*setter)(val);
  return true;
}

template <typename Msg, typename T>
inline bool ProtoReaderAddField(InputStream& input,
                                bool (*reader)(InputStream&, T*),
                                void (Msg::*adder)(const T&),
                                Msg* out) {
  T val;
  if (!reader(input, &val)) return false;
  (out->*adder)(val);
  return true;
}

#define PROTO_READER_EQUALS_FIELD(member)                          \
  if (a.has_##member != b.has_##member) return false;              \
  if (a.has_##member && a.member != b.member) return false;

#define PROTO_READER_EQUALS_REPEATED(member)                       \
  if (a.member != b.member) return false;

#define PROTO_READER_DIFF_FIELD(member)                            \
  if (a.has_##member != b.has_##member) {                          \
    diffs->push_back(prefix + "." #member ": presence mismatch");  \
    equal = false;                                                 \
  } else if (a.has_##member) {                                     \
    equal &= Diff(a.member, b.member, diffs, prefix + "." #member);\
  }

#define PROTO_READER_DIFF_REPEATED(member)                         \
  if (a.member.size() != b.member.size()) {                        \
    diffs->push_back(prefix + "." #member ": size mismatch: " +    \
                     std::to_string(a.member.size()) + " != " +    \
                     std::to_string(b.member.size()));             \
    equal = false;                                                 \
  } else {                                                         \
    for (size_t i = 0; i < a.member.size(); ++i) {                 \
      equal &= Diff(a.member[i], b.member[i], diffs,               \
                    prefix + "." #member "[" +                     \
                    std::to_string(i) + "]");                      \
    }                                                              \
  }

#define PROTO_READER_CASE_SET(number, wire, reader, setter)        \
  case number:                                                     \
    if (wire_type != wire) return false;                           \
    if (!ProtoReaderSetField<classname_>(input, reader,            \
                                         &classname_::setter,      \
                                         out)) return false;       \
    break;

#define PROTO_READER_CASE_ADD(number, wire, reader, adder)         \
  case number:                                                     \
    if (wire_type != wire) return false;                           \
    if (!ProtoReaderAddField<classname_>(input, reader,            \
                                         &classname_::adder,       \
                                         out)) return false;       \
    break;

#define PROTO_READER_CASE_SET_CAST32(number, wire, reader, setter, type, cast) \
  case number: {                                                   \
    if (wire_type != wire) return false;                           \
    uint32_t raw_val;                                              \
    if (!reader(input, &raw_val)) return false;                    \
    out->setter(cast(raw_val));                                    \
    break;                                                         \
  }

#define PROTO_READER_CASE_SET_CAST64(number, wire, reader, setter, type, cast) \
  case number: {                                                   \
    if (wire_type != wire) return false;                           \
    uint64_t raw_val;                                              \
    if (!reader(input, &raw_val)) return false;                    \
    out->setter(cast(raw_val));                                    \
    break;                                                         \
  }

#define PROTO_READER_CASE_ADD_CAST32(number, wire, reader, adder, type, cast) \
  case number: {                                                   \
    if (wire_type != wire) return false;                           \
    uint32_t raw_val;                                              \
    if (!reader(input, &raw_val)) return false;                    \
    out->adder(cast(raw_val));                                     \
    break;                                                         \
  }

#define PROTO_READER_CASE_ADD_CAST64(number, wire, reader, adder, type, cast) \
  case number: {                                                   \
    if (wire_type != wire) return false;                           \
    uint64_t raw_val;                                              \
    if (!reader(input, &raw_val)) return false;                    \
    out->adder(cast(raw_val));                                     \
    break;                                                         \
  }

#define PROTO_READER_CASE_MESSAGE(number, member)                  \
  case number: {                                                   \
    if (wire_type != WIRETYPE_LENGTH_DELIMITED) return false;      \
    uint32_t size;                                                 \
    if (!ReadVarint32(input, &size)) return false;                 \
    LimitedInputStream limited(input, size);                       \
    if (!ParseFromStream(limited, out->mutable_##member())) return false; \
    break;                                                         \
  }

#define PROTO_READER_CASE_MESSAGE_ADD(number, member, type)        \
  case number: {                                                   \
    if (wire_type != WIRETYPE_LENGTH_DELIMITED) return false;      \
    uint32_t size;                                                 \
    if (!ReadVarint32(input, &size)) return false;                 \
    LimitedInputStream limited(input, size);                       \
    type msg;                                                      \
    if (!ParseFromStream(limited, &msg)) return false;             \
    out->add_##member(msg);                                        \
    break;                                                         \
  }

#define PROTO_READER_CASE_STRING(number, member)                   \
  case number:                                                     \
    if (wire_type != WIRETYPE_LENGTH_DELIMITED) return false;      \
    if (!ReadString(input, out->mutable_##member())) return false; \
    break;

#define PROTO_READER_CASE_ENUM(number, setter, type)               \
  case number: {                                                   \
    if (wire_type != WIRETYPE_VARINT) return false;                \
    uint32_t raw_val;                                              \
    if (!ReadVarint32(input, &raw_val)) return false;              \
    out->setter(static_cast<type>(raw_val));                       \
    break;                                                         \
  }

#define PROTO_READER_CASE_ENUM_ADD(number, adder, type)            \
  case number: {                                                   \
    if (wire_type != WIRETYPE_VARINT) return false;                \
    uint32_t raw_val;                                              \
    if (!ReadVarint32(input, &raw_val)) return false;              \
    out->adder(static_cast<type>(raw_val));                        \
    break;                                                         \
  }

namespace rs {
namespace google {
namespace api {
bool ParseFromStream(InputStream& input, Http* out) {
  using classname_ = Http;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(1, rules, ::rs::google::api::HttpRule)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_fully_decode_reserved_expansion, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Http& a, const Http& b) {
  PROTO_READER_EQUALS_REPEATED(rules_);
  PROTO_READER_EQUALS_FIELD(fully_decode_reserved_expansion_);
  return true;
}

bool Diff(const Http& a, const Http& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(rules_);
  PROTO_READER_DIFF_FIELD(fully_decode_reserved_expansion_);
  return equal;
}

bool ParseFromStream(InputStream& input, CustomHttpPattern* out) {
  using classname_ = CustomHttpPattern;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, kind)
    PROTO_READER_CASE_STRING(2, path)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CustomHttpPattern& a, const CustomHttpPattern& b) {
  PROTO_READER_EQUALS_FIELD(kind_);
  PROTO_READER_EQUALS_FIELD(path_);
  return true;
}

bool Diff(const CustomHttpPattern& a, const CustomHttpPattern& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(kind_);
  PROTO_READER_DIFF_FIELD(path_);
  return equal;
}

bool ParseFromStream(InputStream& input, HttpRule* out) {
  using classname_ = HttpRule;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, selector)
    PROTO_READER_CASE_STRING(2, get)
    PROTO_READER_CASE_STRING(3, put)
    PROTO_READER_CASE_STRING(4, post)
    PROTO_READER_CASE_STRING(5, delete)
    PROTO_READER_CASE_STRING(6, patch)
    PROTO_READER_CASE_MESSAGE(8, custom)
    PROTO_READER_CASE_STRING(7, body)
    PROTO_READER_CASE_STRING(12, response_body)
    PROTO_READER_CASE_MESSAGE_ADD(11, additional_bindings, ::rs::google::api::HttpRule)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const HttpRule& a, const HttpRule& b) {
  PROTO_READER_EQUALS_FIELD(selector_);
  PROTO_READER_EQUALS_FIELD(get_);
  PROTO_READER_EQUALS_FIELD(put_);
  PROTO_READER_EQUALS_FIELD(post_);
  PROTO_READER_EQUALS_FIELD(delete_);
  PROTO_READER_EQUALS_FIELD(patch_);
  PROTO_READER_EQUALS_FIELD(custom_);
  PROTO_READER_EQUALS_FIELD(body_);
  PROTO_READER_EQUALS_FIELD(response_body_);
  PROTO_READER_EQUALS_REPEATED(additional_bindings_);
  return true;
}

bool Diff(const HttpRule& a, const HttpRule& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(selector_);
  PROTO_READER_DIFF_FIELD(get_);
  PROTO_READER_DIFF_FIELD(put_);
  PROTO_READER_DIFF_FIELD(post_);
  PROTO_READER_DIFF_FIELD(delete_);
  PROTO_READER_DIFF_FIELD(patch_);
  PROTO_READER_DIFF_FIELD(custom_);
  PROTO_READER_DIFF_FIELD(body_);
  PROTO_READER_DIFF_FIELD(response_body_);
  PROTO_READER_DIFF_REPEATED(additional_bindings_);
  return equal;
}

}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
bool Diff(Edition a, Edition b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, FileDescriptorSet* out) {
  using classname_ = FileDescriptorSet;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(1, file, ::rs::google::protobuf::FileDescriptorProto)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileDescriptorSet& a, const FileDescriptorSet& b) {
  PROTO_READER_EQUALS_REPEATED(file_);
  return true;
}

bool Diff(const FileDescriptorSet& a, const FileDescriptorSet& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(file_);
  return equal;
}

bool Diff(FeatureSet::FieldPresence a, FeatureSet::FieldPresence b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FeatureSet::EnumType a, FeatureSet::EnumType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FeatureSet::RepeatedFieldEncoding a, FeatureSet::RepeatedFieldEncoding b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FeatureSet::Utf8Validation a, FeatureSet::Utf8Validation b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FeatureSet::MessageEncoding a, FeatureSet::MessageEncoding b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FeatureSet::JsonFormat a, FeatureSet::JsonFormat b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, FeatureSet* out) {
  using classname_ = FeatureSet;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_field_presence, ::rs::google::protobuf::FeatureSet::FieldPresence)
    PROTO_READER_CASE_ENUM(2, set_enum_type, ::rs::google::protobuf::FeatureSet::EnumType)
    PROTO_READER_CASE_ENUM(3, set_repeated_field_encoding, ::rs::google::protobuf::FeatureSet::RepeatedFieldEncoding)
    PROTO_READER_CASE_ENUM(4, set_utf8_validation, ::rs::google::protobuf::FeatureSet::Utf8Validation)
    PROTO_READER_CASE_ENUM(5, set_message_encoding, ::rs::google::protobuf::FeatureSet::MessageEncoding)
    PROTO_READER_CASE_ENUM(6, set_json_format, ::rs::google::protobuf::FeatureSet::JsonFormat)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FeatureSet& a, const FeatureSet& b) {
  PROTO_READER_EQUALS_FIELD(field_presence_);
  PROTO_READER_EQUALS_FIELD(enum_type_);
  PROTO_READER_EQUALS_FIELD(repeated_field_encoding_);
  PROTO_READER_EQUALS_FIELD(utf8_validation_);
  PROTO_READER_EQUALS_FIELD(message_encoding_);
  PROTO_READER_EQUALS_FIELD(json_format_);
  return true;
}

bool Diff(const FeatureSet& a, const FeatureSet& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(field_presence_);
  PROTO_READER_DIFF_FIELD(enum_type_);
  PROTO_READER_DIFF_FIELD(repeated_field_encoding_);
  PROTO_READER_DIFF_FIELD(utf8_validation_);
  PROTO_READER_DIFF_FIELD(message_encoding_);
  PROTO_READER_DIFF_FIELD(json_format_);
  return equal;
}

bool Diff(FileOptions::OptimizeMode a, FileOptions::OptimizeMode b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, FileOptions* out) {
  using classname_ = FileOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, java_package)
    PROTO_READER_CASE_STRING(8, java_outer_classname)
    PROTO_READER_CASE_SET_CAST32(10, WIRETYPE_VARINT, ReadVarint32, set_java_multiple_files, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(20, WIRETYPE_VARINT, ReadVarint32, set_java_generate_equals_and_hash, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(27, WIRETYPE_VARINT, ReadVarint32, set_java_string_check_utf8, bool, static_cast<bool>)
    PROTO_READER_CASE_ENUM(9, set_optimize_for, ::rs::google::protobuf::FileOptions::OptimizeMode)
    PROTO_READER_CASE_STRING(11, go_package)
    PROTO_READER_CASE_SET_CAST32(16, WIRETYPE_VARINT, ReadVarint32, set_cc_generic_services, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(17, WIRETYPE_VARINT, ReadVarint32, set_java_generic_services, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(18, WIRETYPE_VARINT, ReadVarint32, set_py_generic_services, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(23, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(31, WIRETYPE_VARINT, ReadVarint32, set_cc_enable_arenas, bool, static_cast<bool>)
    PROTO_READER_CASE_STRING(36, objc_class_prefix)
    PROTO_READER_CASE_STRING(37, csharp_namespace)
    PROTO_READER_CASE_STRING(39, swift_prefix)
    PROTO_READER_CASE_STRING(40, php_class_prefix)
    PROTO_READER_CASE_STRING(41, php_namespace)
    PROTO_READER_CASE_STRING(44, php_metadata_namespace)
    PROTO_READER_CASE_STRING(45, ruby_package)
    PROTO_READER_CASE_MESSAGE(50, features)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileOptions& a, const FileOptions& b) {
  PROTO_READER_EQUALS_FIELD(java_package_);
  PROTO_READER_EQUALS_FIELD(java_outer_classname_);
  PROTO_READER_EQUALS_FIELD(java_multiple_files_);
  PROTO_READER_EQUALS_FIELD(java_generate_equals_and_hash_);
  PROTO_READER_EQUALS_FIELD(java_string_check_utf8_);
  PROTO_READER_EQUALS_FIELD(optimize_for_);
  PROTO_READER_EQUALS_FIELD(go_package_);
  PROTO_READER_EQUALS_FIELD(cc_generic_services_);
  PROTO_READER_EQUALS_FIELD(java_generic_services_);
  PROTO_READER_EQUALS_FIELD(py_generic_services_);
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_FIELD(cc_enable_arenas_);
  PROTO_READER_EQUALS_FIELD(objc_class_prefix_);
  PROTO_READER_EQUALS_FIELD(csharp_namespace_);
  PROTO_READER_EQUALS_FIELD(swift_prefix_);
  PROTO_READER_EQUALS_FIELD(php_class_prefix_);
  PROTO_READER_EQUALS_FIELD(php_namespace_);
  PROTO_READER_EQUALS_FIELD(php_metadata_namespace_);
  PROTO_READER_EQUALS_FIELD(ruby_package_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const FileOptions& a, const FileOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(java_package_);
  PROTO_READER_DIFF_FIELD(java_outer_classname_);
  PROTO_READER_DIFF_FIELD(java_multiple_files_);
  PROTO_READER_DIFF_FIELD(java_generate_equals_and_hash_);
  PROTO_READER_DIFF_FIELD(java_string_check_utf8_);
  PROTO_READER_DIFF_FIELD(optimize_for_);
  PROTO_READER_DIFF_FIELD(go_package_);
  PROTO_READER_DIFF_FIELD(cc_generic_services_);
  PROTO_READER_DIFF_FIELD(java_generic_services_);
  PROTO_READER_DIFF_FIELD(py_generic_services_);
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_FIELD(cc_enable_arenas_);
  PROTO_READER_DIFF_FIELD(objc_class_prefix_);
  PROTO_READER_DIFF_FIELD(csharp_namespace_);
  PROTO_READER_DIFF_FIELD(swift_prefix_);
  PROTO_READER_DIFF_FIELD(php_class_prefix_);
  PROTO_READER_DIFF_FIELD(php_namespace_);
  PROTO_READER_DIFF_FIELD(php_metadata_namespace_);
  PROTO_READER_DIFF_FIELD(ruby_package_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, SourceCodeInfo::Location* out) {
  using classname_ = SourceCodeInfo::Location;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ADD_CAST32(1, WIRETYPE_VARINT, ReadVarint32, add_path, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_ADD_CAST32(2, WIRETYPE_VARINT, ReadVarint32, add_span, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_STRING(3, leading_comments)
    PROTO_READER_CASE_STRING(4, trailing_comments)
    PROTO_READER_CASE_ADD(6, WIRETYPE_LENGTH_DELIMITED, ReadString, add_leading_detached_comments)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const SourceCodeInfo::Location& a, const SourceCodeInfo::Location& b) {
  PROTO_READER_EQUALS_REPEATED(path_);
  PROTO_READER_EQUALS_REPEATED(span_);
  PROTO_READER_EQUALS_FIELD(leading_comments_);
  PROTO_READER_EQUALS_FIELD(trailing_comments_);
  PROTO_READER_EQUALS_REPEATED(leading_detached_comments_);
  return true;
}

bool Diff(const SourceCodeInfo::Location& a, const SourceCodeInfo::Location& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(path_);
  PROTO_READER_DIFF_REPEATED(span_);
  PROTO_READER_DIFF_FIELD(leading_comments_);
  PROTO_READER_DIFF_FIELD(trailing_comments_);
  PROTO_READER_DIFF_REPEATED(leading_detached_comments_);
  return equal;
}

bool ParseFromStream(InputStream& input, SourceCodeInfo* out) {
  using classname_ = SourceCodeInfo;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(1, location, ::rs::google::protobuf::SourceCodeInfo::Location)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const SourceCodeInfo& a, const SourceCodeInfo& b) {
  PROTO_READER_EQUALS_REPEATED(location_);
  return true;
}

bool Diff(const SourceCodeInfo& a, const SourceCodeInfo& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(location_);
  return equal;
}

bool ParseFromStream(InputStream& input, FileDescriptorProto* out) {
  using classname_ = FileDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(2, package)
    PROTO_READER_CASE_ADD(3, WIRETYPE_LENGTH_DELIMITED, ReadString, add_dependency)
    PROTO_READER_CASE_ADD_CAST32(10, WIRETYPE_VARINT, ReadVarint32, add_public_dependency, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_ADD_CAST32(11, WIRETYPE_VARINT, ReadVarint32, add_weak_dependency, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_MESSAGE_ADD(4, message_type, ::rs::google::protobuf::DescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(5, enum_type, ::rs::google::protobuf::EnumDescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(6, service, ::rs::google::protobuf::ServiceDescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(7, extension, ::rs::google::protobuf::FieldDescriptorProto)
    PROTO_READER_CASE_MESSAGE(8, options)
    PROTO_READER_CASE_MESSAGE(9, source_code_info)
    PROTO_READER_CASE_STRING(12, syntax)
    PROTO_READER_CASE_ENUM(14, set_edition, ::rs::google::protobuf::Edition)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileDescriptorProto& a, const FileDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(package_);
  PROTO_READER_EQUALS_REPEATED(dependency_);
  PROTO_READER_EQUALS_REPEATED(public_dependency_);
  PROTO_READER_EQUALS_REPEATED(weak_dependency_);
  PROTO_READER_EQUALS_REPEATED(message_type_);
  PROTO_READER_EQUALS_REPEATED(enum_type_);
  PROTO_READER_EQUALS_REPEATED(service_);
  PROTO_READER_EQUALS_REPEATED(extension_);
  PROTO_READER_EQUALS_FIELD(options_);
  PROTO_READER_EQUALS_FIELD(source_code_info_);
  PROTO_READER_EQUALS_FIELD(syntax_);
  PROTO_READER_EQUALS_FIELD(edition_);
  return true;
}

bool Diff(const FileDescriptorProto& a, const FileDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(package_);
  PROTO_READER_DIFF_REPEATED(dependency_);
  PROTO_READER_DIFF_REPEATED(public_dependency_);
  PROTO_READER_DIFF_REPEATED(weak_dependency_);
  PROTO_READER_DIFF_REPEATED(message_type_);
  PROTO_READER_DIFF_REPEATED(enum_type_);
  PROTO_READER_DIFF_REPEATED(service_);
  PROTO_READER_DIFF_REPEATED(extension_);
  PROTO_READER_DIFF_FIELD(options_);
  PROTO_READER_DIFF_FIELD(source_code_info_);
  PROTO_READER_DIFF_FIELD(syntax_);
  PROTO_READER_DIFF_FIELD(edition_);
  return equal;
}

bool Diff(ExtensionRangeOptions::VerificationState a, ExtensionRangeOptions::VerificationState b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, ExtensionRangeOptions::Declaration* out) {
  using classname_ = ExtensionRangeOptions::Declaration;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_STRING(2, full_name)
    PROTO_READER_CASE_STRING(3, type)
    PROTO_READER_CASE_SET_CAST32(5, WIRETYPE_VARINT, ReadVarint32, set_reserved, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_repeated, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ExtensionRangeOptions::Declaration& a, const ExtensionRangeOptions::Declaration& b) {
  PROTO_READER_EQUALS_FIELD(number_);
  PROTO_READER_EQUALS_FIELD(full_name_);
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_FIELD(reserved_);
  PROTO_READER_EQUALS_FIELD(repeated_);
  return true;
}

bool Diff(const ExtensionRangeOptions::Declaration& a, const ExtensionRangeOptions::Declaration& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(number_);
  PROTO_READER_DIFF_FIELD(full_name_);
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_FIELD(reserved_);
  PROTO_READER_DIFF_FIELD(repeated_);
  return equal;
}

bool ParseFromStream(InputStream& input, ExtensionRangeOptions* out) {
  using classname_ = ExtensionRangeOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
    PROTO_READER_CASE_MESSAGE_ADD(2, declaration, ::rs::google::protobuf::ExtensionRangeOptions::Declaration)
    PROTO_READER_CASE_MESSAGE(50, features)
    PROTO_READER_CASE_ENUM(3, set_verification, ::rs::google::protobuf::ExtensionRangeOptions::VerificationState)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ExtensionRangeOptions& a, const ExtensionRangeOptions& b) {
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  PROTO_READER_EQUALS_REPEATED(declaration_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_FIELD(verification_);
  return true;
}

bool Diff(const ExtensionRangeOptions& a, const ExtensionRangeOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  PROTO_READER_DIFF_REPEATED(declaration_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_FIELD(verification_);
  return equal;
}

bool ParseFromStream(InputStream& input, MessageOptions* out) {
  using classname_ = MessageOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_message_set_wire_format, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_no_standard_descriptor_accessor, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(7, WIRETYPE_VARINT, ReadVarint32, set_map_entry, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(11, WIRETYPE_VARINT, ReadVarint32, set_deprecated_legacy_json_field_conflicts, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE(12, features)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MessageOptions& a, const MessageOptions& b) {
  PROTO_READER_EQUALS_FIELD(message_set_wire_format_);
  PROTO_READER_EQUALS_FIELD(no_standard_descriptor_accessor_);
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_FIELD(map_entry_);
  PROTO_READER_EQUALS_FIELD(deprecated_legacy_json_field_conflicts_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const MessageOptions& a, const MessageOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(message_set_wire_format_);
  PROTO_READER_DIFF_FIELD(no_standard_descriptor_accessor_);
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_FIELD(map_entry_);
  PROTO_READER_DIFF_FIELD(deprecated_legacy_json_field_conflicts_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, DescriptorProto::ExtensionRange* out) {
  using classname_ = DescriptorProto::ExtensionRange;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_start, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_end, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_MESSAGE(3, options)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DescriptorProto::ExtensionRange& a, const DescriptorProto::ExtensionRange& b) {
  PROTO_READER_EQUALS_FIELD(start_);
  PROTO_READER_EQUALS_FIELD(end_);
  PROTO_READER_EQUALS_FIELD(options_);
  return true;
}

bool Diff(const DescriptorProto::ExtensionRange& a, const DescriptorProto::ExtensionRange& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(start_);
  PROTO_READER_DIFF_FIELD(end_);
  PROTO_READER_DIFF_FIELD(options_);
  return equal;
}

bool ParseFromStream(InputStream& input, DescriptorProto::ReservedRange* out) {
  using classname_ = DescriptorProto::ReservedRange;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_start, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_end, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DescriptorProto::ReservedRange& a, const DescriptorProto::ReservedRange& b) {
  PROTO_READER_EQUALS_FIELD(start_);
  PROTO_READER_EQUALS_FIELD(end_);
  return true;
}

bool Diff(const DescriptorProto::ReservedRange& a, const DescriptorProto::ReservedRange& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(start_);
  PROTO_READER_DIFF_FIELD(end_);
  return equal;
}

bool ParseFromStream(InputStream& input, DescriptorProto* out) {
  using classname_ = DescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE_ADD(2, field, ::rs::google::protobuf::FieldDescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(6, extension, ::rs::google::protobuf::FieldDescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(3, nested_type, ::rs::google::protobuf::DescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(4, enum_type, ::rs::google::protobuf::EnumDescriptorProto)
    PROTO_READER_CASE_MESSAGE_ADD(5, extension_range, ::rs::google::protobuf::DescriptorProto::ExtensionRange)
    PROTO_READER_CASE_MESSAGE_ADD(8, oneof_decl, ::rs::google::protobuf::OneofDescriptorProto)
    PROTO_READER_CASE_MESSAGE(7, options)
    PROTO_READER_CASE_MESSAGE_ADD(9, reserved_range, ::rs::google::protobuf::DescriptorProto::ReservedRange)
    PROTO_READER_CASE_ADD(10, WIRETYPE_LENGTH_DELIMITED, ReadString, add_reserved_name)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DescriptorProto& a, const DescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_REPEATED(field_);
  PROTO_READER_EQUALS_REPEATED(extension_);
  PROTO_READER_EQUALS_REPEATED(nested_type_);
  PROTO_READER_EQUALS_REPEATED(enum_type_);
  PROTO_READER_EQUALS_REPEATED(extension_range_);
  PROTO_READER_EQUALS_REPEATED(oneof_decl_);
  PROTO_READER_EQUALS_FIELD(options_);
  PROTO_READER_EQUALS_REPEATED(reserved_range_);
  PROTO_READER_EQUALS_REPEATED(reserved_name_);
  return true;
}

bool Diff(const DescriptorProto& a, const DescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_REPEATED(field_);
  PROTO_READER_DIFF_REPEATED(extension_);
  PROTO_READER_DIFF_REPEATED(nested_type_);
  PROTO_READER_DIFF_REPEATED(enum_type_);
  PROTO_READER_DIFF_REPEATED(extension_range_);
  PROTO_READER_DIFF_REPEATED(oneof_decl_);
  PROTO_READER_DIFF_FIELD(options_);
  PROTO_READER_DIFF_REPEATED(reserved_range_);
  PROTO_READER_DIFF_REPEATED(reserved_name_);
  return equal;
}

bool Diff(FieldOptions::CType a, FieldOptions::CType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FieldOptions::JSType a, FieldOptions::JSType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FieldOptions::OptionRetention a, FieldOptions::OptionRetention b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FieldOptions::OptionTargetType a, FieldOptions::OptionTargetType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, FieldOptions::EditionDefault* out) {
  using classname_ = FieldOptions::EditionDefault;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(3, set_edition, ::rs::google::protobuf::Edition)
    PROTO_READER_CASE_STRING(2, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FieldOptions::EditionDefault& a, const FieldOptions::EditionDefault& b) {
  PROTO_READER_EQUALS_FIELD(edition_);
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const FieldOptions::EditionDefault& a, const FieldOptions::EditionDefault& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(edition_);
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, FieldOptions::FeatureSupport* out) {
  using classname_ = FieldOptions::FeatureSupport;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_edition_introduced, ::rs::google::protobuf::Edition)
    PROTO_READER_CASE_ENUM(2, set_edition_deprecated, ::rs::google::protobuf::Edition)
    PROTO_READER_CASE_STRING(3, deprecation_warning)
    PROTO_READER_CASE_ENUM(4, set_edition_removed, ::rs::google::protobuf::Edition)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FieldOptions::FeatureSupport& a, const FieldOptions::FeatureSupport& b) {
  PROTO_READER_EQUALS_FIELD(edition_introduced_);
  PROTO_READER_EQUALS_FIELD(edition_deprecated_);
  PROTO_READER_EQUALS_FIELD(deprecation_warning_);
  PROTO_READER_EQUALS_FIELD(edition_removed_);
  return true;
}

bool Diff(const FieldOptions::FeatureSupport& a, const FieldOptions::FeatureSupport& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(edition_introduced_);
  PROTO_READER_DIFF_FIELD(edition_deprecated_);
  PROTO_READER_DIFF_FIELD(deprecation_warning_);
  PROTO_READER_DIFF_FIELD(edition_removed_);
  return equal;
}

bool ParseFromStream(InputStream& input, FieldOptions* out) {
  using classname_ = FieldOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_ctype, ::rs::google::protobuf::FieldOptions::CType)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_packed, bool, static_cast<bool>)
    PROTO_READER_CASE_ENUM(6, set_jstype, ::rs::google::protobuf::FieldOptions::JSType)
    PROTO_READER_CASE_SET_CAST32(5, WIRETYPE_VARINT, ReadVarint32, set_lazy, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(15, WIRETYPE_VARINT, ReadVarint32, set_unverified_lazy, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(10, WIRETYPE_VARINT, ReadVarint32, set_weak, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(16, WIRETYPE_VARINT, ReadVarint32, set_debug_redact, bool, static_cast<bool>)
    PROTO_READER_CASE_ENUM(17, set_retention, ::rs::google::protobuf::FieldOptions::OptionRetention)
    PROTO_READER_CASE_ENUM_ADD(19, add_targets, ::rs::google::protobuf::FieldOptions::OptionTargetType)
    PROTO_READER_CASE_MESSAGE_ADD(20, edition_defaults, ::rs::google::protobuf::FieldOptions::EditionDefault)
    PROTO_READER_CASE_MESSAGE(21, features)
    PROTO_READER_CASE_MESSAGE(22, feature_support)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FieldOptions& a, const FieldOptions& b) {
  PROTO_READER_EQUALS_FIELD(ctype_);
  PROTO_READER_EQUALS_FIELD(packed_);
  PROTO_READER_EQUALS_FIELD(jstype_);
  PROTO_READER_EQUALS_FIELD(lazy_);
  PROTO_READER_EQUALS_FIELD(unverified_lazy_);
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_FIELD(weak_);
  PROTO_READER_EQUALS_FIELD(debug_redact_);
  PROTO_READER_EQUALS_FIELD(retention_);
  PROTO_READER_EQUALS_REPEATED(targets_);
  PROTO_READER_EQUALS_REPEATED(edition_defaults_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_FIELD(feature_support_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const FieldOptions& a, const FieldOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(ctype_);
  PROTO_READER_DIFF_FIELD(packed_);
  PROTO_READER_DIFF_FIELD(jstype_);
  PROTO_READER_DIFF_FIELD(lazy_);
  PROTO_READER_DIFF_FIELD(unverified_lazy_);
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_FIELD(weak_);
  PROTO_READER_DIFF_FIELD(debug_redact_);
  PROTO_READER_DIFF_FIELD(retention_);
  PROTO_READER_DIFF_REPEATED(targets_);
  PROTO_READER_DIFF_REPEATED(edition_defaults_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_FIELD(feature_support_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool Diff(FieldDescriptorProto::Type a, FieldDescriptorProto::Type b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(FieldDescriptorProto::Label a, FieldDescriptorProto::Label b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, FieldDescriptorProto* out) {
  using classname_ = FieldDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_ENUM(4, set_label, ::rs::google::protobuf::FieldDescriptorProto::Label)
    PROTO_READER_CASE_ENUM(5, set_type, ::rs::google::protobuf::FieldDescriptorProto::Type)
    PROTO_READER_CASE_STRING(6, type_name)
    PROTO_READER_CASE_STRING(2, extendee)
    PROTO_READER_CASE_STRING(7, default_value)
    PROTO_READER_CASE_SET_CAST32(9, WIRETYPE_VARINT, ReadVarint32, set_oneof_index, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_STRING(10, json_name)
    PROTO_READER_CASE_MESSAGE(8, options)
    PROTO_READER_CASE_SET_CAST32(17, WIRETYPE_VARINT, ReadVarint32, set_proto3_optional, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FieldDescriptorProto& a, const FieldDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(number_);
  PROTO_READER_EQUALS_FIELD(label_);
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_FIELD(type_name_);
  PROTO_READER_EQUALS_FIELD(extendee_);
  PROTO_READER_EQUALS_FIELD(default_value_);
  PROTO_READER_EQUALS_FIELD(oneof_index_);
  PROTO_READER_EQUALS_FIELD(json_name_);
  PROTO_READER_EQUALS_FIELD(options_);
  PROTO_READER_EQUALS_FIELD(proto3_optional_);
  return true;
}

bool Diff(const FieldDescriptorProto& a, const FieldDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(number_);
  PROTO_READER_DIFF_FIELD(label_);
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_FIELD(type_name_);
  PROTO_READER_DIFF_FIELD(extendee_);
  PROTO_READER_DIFF_FIELD(default_value_);
  PROTO_READER_DIFF_FIELD(oneof_index_);
  PROTO_READER_DIFF_FIELD(json_name_);
  PROTO_READER_DIFF_FIELD(options_);
  PROTO_READER_DIFF_FIELD(proto3_optional_);
  return equal;
}

bool ParseFromStream(InputStream& input, OneofOptions* out) {
  using classname_ = OneofOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, features)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const OneofOptions& a, const OneofOptions& b) {
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const OneofOptions& a, const OneofOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, OneofDescriptorProto* out) {
  using classname_ = OneofDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, options)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const OneofDescriptorProto& a, const OneofDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(options_);
  return true;
}

bool Diff(const OneofDescriptorProto& a, const OneofDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(options_);
  return equal;
}

bool ParseFromStream(InputStream& input, EnumOptions* out) {
  using classname_ = EnumOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_allow_alias, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_deprecated_legacy_json_field_conflicts, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE(7, features)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const EnumOptions& a, const EnumOptions& b) {
  PROTO_READER_EQUALS_FIELD(allow_alias_);
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_FIELD(deprecated_legacy_json_field_conflicts_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const EnumOptions& a, const EnumOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(allow_alias_);
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_FIELD(deprecated_legacy_json_field_conflicts_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, EnumDescriptorProto::EnumReservedRange* out) {
  using classname_ = EnumDescriptorProto::EnumReservedRange;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_start, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_end, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const EnumDescriptorProto::EnumReservedRange& a, const EnumDescriptorProto::EnumReservedRange& b) {
  PROTO_READER_EQUALS_FIELD(start_);
  PROTO_READER_EQUALS_FIELD(end_);
  return true;
}

bool Diff(const EnumDescriptorProto::EnumReservedRange& a, const EnumDescriptorProto::EnumReservedRange& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(start_);
  PROTO_READER_DIFF_FIELD(end_);
  return equal;
}

bool ParseFromStream(InputStream& input, EnumDescriptorProto* out) {
  using classname_ = EnumDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE_ADD(2, value, ::rs::google::protobuf::EnumValueDescriptorProto)
    PROTO_READER_CASE_MESSAGE(3, options)
    PROTO_READER_CASE_MESSAGE_ADD(4, reserved_range, ::rs::google::protobuf::EnumDescriptorProto::EnumReservedRange)
    PROTO_READER_CASE_ADD(5, WIRETYPE_LENGTH_DELIMITED, ReadString, add_reserved_name)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const EnumDescriptorProto& a, const EnumDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_REPEATED(value_);
  PROTO_READER_EQUALS_FIELD(options_);
  PROTO_READER_EQUALS_REPEATED(reserved_range_);
  PROTO_READER_EQUALS_REPEATED(reserved_name_);
  return true;
}

bool Diff(const EnumDescriptorProto& a, const EnumDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_REPEATED(value_);
  PROTO_READER_DIFF_FIELD(options_);
  PROTO_READER_DIFF_REPEATED(reserved_range_);
  PROTO_READER_DIFF_REPEATED(reserved_name_);
  return equal;
}

bool ParseFromStream(InputStream& input, EnumValueOptions* out) {
  using classname_ = EnumValueOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE(2, features)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_debug_redact, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE(4, feature_support)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const EnumValueOptions& a, const EnumValueOptions& b) {
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_FIELD(debug_redact_);
  PROTO_READER_EQUALS_FIELD(feature_support_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const EnumValueOptions& a, const EnumValueOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_FIELD(debug_redact_);
  PROTO_READER_DIFF_FIELD(feature_support_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, EnumValueDescriptorProto* out) {
  using classname_ = EnumValueDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_MESSAGE(3, options)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const EnumValueDescriptorProto& a, const EnumValueDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(number_);
  PROTO_READER_EQUALS_FIELD(options_);
  return true;
}

bool Diff(const EnumValueDescriptorProto& a, const EnumValueDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(number_);
  PROTO_READER_DIFF_FIELD(options_);
  return equal;
}

bool ParseFromStream(InputStream& input, ServiceOptions* out) {
  using classname_ = ServiceOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(34, features)
    PROTO_READER_CASE_SET_CAST32(33, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ServiceOptions& a, const ServiceOptions& b) {
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const ServiceOptions& a, const ServiceOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, ServiceDescriptorProto* out) {
  using classname_ = ServiceDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE_ADD(2, method, ::rs::google::protobuf::MethodDescriptorProto)
    PROTO_READER_CASE_MESSAGE(3, options)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ServiceDescriptorProto& a, const ServiceDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_REPEATED(method_);
  PROTO_READER_EQUALS_FIELD(options_);
  return true;
}

bool Diff(const ServiceDescriptorProto& a, const ServiceDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_REPEATED(method_);
  PROTO_READER_DIFF_FIELD(options_);
  return equal;
}

bool Diff(MethodOptions::IdempotencyLevel a, MethodOptions::IdempotencyLevel b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, MethodOptions* out) {
  using classname_ = MethodOptions;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(33, WIRETYPE_VARINT, ReadVarint32, set_deprecated, bool, static_cast<bool>)
    PROTO_READER_CASE_ENUM(34, set_idempotency_level, ::rs::google::protobuf::MethodOptions::IdempotencyLevel)
    PROTO_READER_CASE_MESSAGE(35, features)
    PROTO_READER_CASE_MESSAGE_ADD(999, uninterpreted_option, ::rs::google::protobuf::UninterpretedOption)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MethodOptions& a, const MethodOptions& b) {
  PROTO_READER_EQUALS_FIELD(deprecated_);
  PROTO_READER_EQUALS_FIELD(idempotency_level_);
  PROTO_READER_EQUALS_FIELD(features_);
  PROTO_READER_EQUALS_REPEATED(uninterpreted_option_);
  return true;
}

bool Diff(const MethodOptions& a, const MethodOptions& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(deprecated_);
  PROTO_READER_DIFF_FIELD(idempotency_level_);
  PROTO_READER_DIFF_FIELD(features_);
  PROTO_READER_DIFF_REPEATED(uninterpreted_option_);
  return equal;
}

bool ParseFromStream(InputStream& input, MethodDescriptorProto* out) {
  using classname_ = MethodDescriptorProto;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(2, input_type)
    PROTO_READER_CASE_STRING(3, output_type)
    PROTO_READER_CASE_MESSAGE(4, options)
    PROTO_READER_CASE_SET_CAST32(5, WIRETYPE_VARINT, ReadVarint32, set_client_streaming, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_server_streaming, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MethodDescriptorProto& a, const MethodDescriptorProto& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(input_type_);
  PROTO_READER_EQUALS_FIELD(output_type_);
  PROTO_READER_EQUALS_FIELD(options_);
  PROTO_READER_EQUALS_FIELD(client_streaming_);
  PROTO_READER_EQUALS_FIELD(server_streaming_);
  return true;
}

bool Diff(const MethodDescriptorProto& a, const MethodDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(input_type_);
  PROTO_READER_DIFF_FIELD(output_type_);
  PROTO_READER_DIFF_FIELD(options_);
  PROTO_READER_DIFF_FIELD(client_streaming_);
  PROTO_READER_DIFF_FIELD(server_streaming_);
  return equal;
}

bool ParseFromStream(InputStream& input, UninterpretedOption::NamePart* out) {
  using classname_ = UninterpretedOption::NamePart;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name_part)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_is_extension, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UninterpretedOption::NamePart& a, const UninterpretedOption::NamePart& b) {
  PROTO_READER_EQUALS_FIELD(name_part_);
  PROTO_READER_EQUALS_FIELD(is_extension_);
  return true;
}

bool Diff(const UninterpretedOption::NamePart& a, const UninterpretedOption::NamePart& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_part_);
  PROTO_READER_DIFF_FIELD(is_extension_);
  return equal;
}

bool ParseFromStream(InputStream& input, UninterpretedOption* out) {
  using classname_ = UninterpretedOption;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(2, name, ::rs::google::protobuf::UninterpretedOption::NamePart)
    PROTO_READER_CASE_STRING(3, identifier_value)
    PROTO_READER_CASE_SET(4, WIRETYPE_VARINT, ReadVarint64, set_positive_int_value)
    PROTO_READER_CASE_SET_CAST64(5, WIRETYPE_VARINT, ReadVarint64, set_negative_int_value, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET(6, WIRETYPE_FIXED64, ReadDouble, set_double_value)
    PROTO_READER_CASE_STRING(7, string_value)
    PROTO_READER_CASE_STRING(8, aggregate_value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UninterpretedOption& a, const UninterpretedOption& b) {
  PROTO_READER_EQUALS_REPEATED(name_);
  PROTO_READER_EQUALS_FIELD(identifier_value_);
  PROTO_READER_EQUALS_FIELD(positive_int_value_);
  PROTO_READER_EQUALS_FIELD(negative_int_value_);
  PROTO_READER_EQUALS_FIELD(double_value_);
  PROTO_READER_EQUALS_FIELD(string_value_);
  PROTO_READER_EQUALS_FIELD(aggregate_value_);
  return true;
}

bool Diff(const UninterpretedOption& a, const UninterpretedOption& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(name_);
  PROTO_READER_DIFF_FIELD(identifier_value_);
  PROTO_READER_DIFF_FIELD(positive_int_value_);
  PROTO_READER_DIFF_FIELD(negative_int_value_);
  PROTO_READER_DIFF_FIELD(double_value_);
  PROTO_READER_DIFF_FIELD(string_value_);
  PROTO_READER_DIFF_FIELD(aggregate_value_);
  return equal;
}

bool ParseFromStream(InputStream& input, FeatureSetDefaults::FeatureSetEditionDefault* out) {
  using classname_ = FeatureSetDefaults::FeatureSetEditionDefault;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(3, set_edition, ::rs::google::protobuf::Edition)
    PROTO_READER_CASE_MESSAGE(4, overridable_features)
    PROTO_READER_CASE_MESSAGE(5, fixed_features)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FeatureSetDefaults::FeatureSetEditionDefault& a, const FeatureSetDefaults::FeatureSetEditionDefault& b) {
  PROTO_READER_EQUALS_FIELD(edition_);
  PROTO_READER_EQUALS_FIELD(overridable_features_);
  PROTO_READER_EQUALS_FIELD(fixed_features_);
  return true;
}

bool Diff(const FeatureSetDefaults::FeatureSetEditionDefault& a, const FeatureSetDefaults::FeatureSetEditionDefault& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(edition_);
  PROTO_READER_DIFF_FIELD(overridable_features_);
  PROTO_READER_DIFF_FIELD(fixed_features_);
  return equal;
}

bool ParseFromStream(InputStream& input, FeatureSetDefaults* out) {
  using classname_ = FeatureSetDefaults;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(1, defaults, ::rs::google::protobuf::FeatureSetDefaults::FeatureSetEditionDefault)
    PROTO_READER_CASE_ENUM(4, set_minimum_edition, ::rs::google::protobuf::Edition)
    PROTO_READER_CASE_ENUM(5, set_maximum_edition, ::rs::google::protobuf::Edition)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FeatureSetDefaults& a, const FeatureSetDefaults& b) {
  PROTO_READER_EQUALS_REPEATED(defaults_);
  PROTO_READER_EQUALS_FIELD(minimum_edition_);
  PROTO_READER_EQUALS_FIELD(maximum_edition_);
  return true;
}

bool Diff(const FeatureSetDefaults& a, const FeatureSetDefaults& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(defaults_);
  PROTO_READER_DIFF_FIELD(minimum_edition_);
  PROTO_READER_DIFF_FIELD(maximum_edition_);
  return equal;
}

bool Diff(GeneratedCodeInfo::Annotation::Semantic a, GeneratedCodeInfo::Annotation::Semantic b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, GeneratedCodeInfo::Annotation* out) {
  using classname_ = GeneratedCodeInfo::Annotation;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ADD_CAST32(1, WIRETYPE_VARINT, ReadVarint32, add_path, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_STRING(2, source_file)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_begin, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(4, WIRETYPE_VARINT, ReadVarint32, set_end, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_ENUM(5, set_semantic, ::rs::google::protobuf::GeneratedCodeInfo::Annotation::Semantic)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const GeneratedCodeInfo::Annotation& a, const GeneratedCodeInfo::Annotation& b) {
  PROTO_READER_EQUALS_REPEATED(path_);
  PROTO_READER_EQUALS_FIELD(source_file_);
  PROTO_READER_EQUALS_FIELD(begin_);
  PROTO_READER_EQUALS_FIELD(end_);
  PROTO_READER_EQUALS_FIELD(semantic_);
  return true;
}

bool Diff(const GeneratedCodeInfo::Annotation& a, const GeneratedCodeInfo::Annotation& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(path_);
  PROTO_READER_DIFF_FIELD(source_file_);
  PROTO_READER_DIFF_FIELD(begin_);
  PROTO_READER_DIFF_FIELD(end_);
  PROTO_READER_DIFF_FIELD(semantic_);
  return equal;
}

bool ParseFromStream(InputStream& input, GeneratedCodeInfo* out) {
  using classname_ = GeneratedCodeInfo;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(1, annotation, ::rs::google::protobuf::GeneratedCodeInfo::Annotation)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const GeneratedCodeInfo& a, const GeneratedCodeInfo& b) {
  PROTO_READER_EQUALS_REPEATED(annotation_);
  return true;
}

bool Diff(const GeneratedCodeInfo& a, const GeneratedCodeInfo& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(annotation_);
  return equal;
}

}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
}  // namespace api
}  // namespace google
namespace google {
namespace api {
bool Diff(LaunchStage a, LaunchStage b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, Duration* out) {
  using classname_ = Duration;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST64(1, WIRETYPE_VARINT, ReadVarint64, set_seconds, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_nanos, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Duration& a, const Duration& b) {
  PROTO_READER_EQUALS_FIELD(seconds_);
  PROTO_READER_EQUALS_FIELD(nanos_);
  return true;
}

bool Diff(const Duration& a, const Duration& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(seconds_);
  PROTO_READER_DIFF_FIELD(nanos_);
  return equal;
}

}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
bool Diff(ClientLibraryOrganization a, ClientLibraryOrganization b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(ClientLibraryDestination a, ClientLibraryDestination b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, SelectiveGapicGeneration* out) {
  using classname_ = SelectiveGapicGeneration;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ADD(1, WIRETYPE_LENGTH_DELIMITED, ReadString, add_methods)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_generate_omitted_as_internal, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const SelectiveGapicGeneration& a, const SelectiveGapicGeneration& b) {
  PROTO_READER_EQUALS_REPEATED(methods_);
  PROTO_READER_EQUALS_FIELD(generate_omitted_as_internal_);
  return true;
}

bool Diff(const SelectiveGapicGeneration& a, const SelectiveGapicGeneration& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(methods_);
  PROTO_READER_DIFF_FIELD(generate_omitted_as_internal_);
  return equal;
}

bool ParseFromStream(InputStream& input, CommonLanguageSettings* out) {
  using classname_ = CommonLanguageSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, reference_docs_uri)
    PROTO_READER_CASE_ENUM_ADD(2, add_destinations, ::rs::google::api::ClientLibraryDestination)
    PROTO_READER_CASE_MESSAGE(3, selective_gapic_generation)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CommonLanguageSettings& a, const CommonLanguageSettings& b) {
  PROTO_READER_EQUALS_FIELD(reference_docs_uri_);
  PROTO_READER_EQUALS_REPEATED(destinations_);
  PROTO_READER_EQUALS_FIELD(selective_gapic_generation_);
  return true;
}

bool Diff(const CommonLanguageSettings& a, const CommonLanguageSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(reference_docs_uri_);
  PROTO_READER_DIFF_REPEATED(destinations_);
  PROTO_READER_DIFF_FIELD(selective_gapic_generation_);
  return equal;
}

bool ParseFromStream(InputStream& input, CppSettings* out) {
  using classname_ = CppSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CppSettings& a, const CppSettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  return true;
}

bool Diff(const CppSettings& a, const CppSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  return equal;
}

bool ParseFromStream(InputStream& input, DotnetSettings::RenamedServicesEntry* out) {
  using classname_ = DotnetSettings::RenamedServicesEntry;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, key)
    PROTO_READER_CASE_STRING(2, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DotnetSettings::RenamedServicesEntry& a, const DotnetSettings::RenamedServicesEntry& b) {
  PROTO_READER_EQUALS_FIELD(key_);
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const DotnetSettings::RenamedServicesEntry& a, const DotnetSettings::RenamedServicesEntry& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(key_);
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, DotnetSettings::RenamedResourcesEntry* out) {
  using classname_ = DotnetSettings::RenamedResourcesEntry;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, key)
    PROTO_READER_CASE_STRING(2, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DotnetSettings::RenamedResourcesEntry& a, const DotnetSettings::RenamedResourcesEntry& b) {
  PROTO_READER_EQUALS_FIELD(key_);
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const DotnetSettings::RenamedResourcesEntry& a, const DotnetSettings::RenamedResourcesEntry& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(key_);
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, DotnetSettings* out) {
  using classname_ = DotnetSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
    PROTO_READER_CASE_MESSAGE_ADD(2, renamed_services, ::rs::google::api::DotnetSettings::RenamedServicesEntry)
    PROTO_READER_CASE_MESSAGE_ADD(3, renamed_resources, ::rs::google::api::DotnetSettings::RenamedResourcesEntry)
    PROTO_READER_CASE_ADD(4, WIRETYPE_LENGTH_DELIMITED, ReadString, add_ignored_resources)
    PROTO_READER_CASE_ADD(5, WIRETYPE_LENGTH_DELIMITED, ReadString, add_forced_namespace_aliases)
    PROTO_READER_CASE_ADD(6, WIRETYPE_LENGTH_DELIMITED, ReadString, add_handwritten_signatures)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DotnetSettings& a, const DotnetSettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  PROTO_READER_EQUALS_REPEATED(renamed_services_);
  PROTO_READER_EQUALS_REPEATED(renamed_resources_);
  PROTO_READER_EQUALS_REPEATED(ignored_resources_);
  PROTO_READER_EQUALS_REPEATED(forced_namespace_aliases_);
  PROTO_READER_EQUALS_REPEATED(handwritten_signatures_);
  return true;
}

bool Diff(const DotnetSettings& a, const DotnetSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  PROTO_READER_DIFF_REPEATED(renamed_services_);
  PROTO_READER_DIFF_REPEATED(renamed_resources_);
  PROTO_READER_DIFF_REPEATED(ignored_resources_);
  PROTO_READER_DIFF_REPEATED(forced_namespace_aliases_);
  PROTO_READER_DIFF_REPEATED(handwritten_signatures_);
  return equal;
}

bool ParseFromStream(InputStream& input, GoSettings::RenamedServicesEntry* out) {
  using classname_ = GoSettings::RenamedServicesEntry;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, key)
    PROTO_READER_CASE_STRING(2, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const GoSettings::RenamedServicesEntry& a, const GoSettings::RenamedServicesEntry& b) {
  PROTO_READER_EQUALS_FIELD(key_);
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const GoSettings::RenamedServicesEntry& a, const GoSettings::RenamedServicesEntry& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(key_);
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, GoSettings* out) {
  using classname_ = GoSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
    PROTO_READER_CASE_MESSAGE_ADD(2, renamed_services, ::rs::google::api::GoSettings::RenamedServicesEntry)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const GoSettings& a, const GoSettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  PROTO_READER_EQUALS_REPEATED(renamed_services_);
  return true;
}

bool Diff(const GoSettings& a, const GoSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  PROTO_READER_DIFF_REPEATED(renamed_services_);
  return equal;
}

bool ParseFromStream(InputStream& input, JavaSettings::ServiceClassNamesEntry* out) {
  using classname_ = JavaSettings::ServiceClassNamesEntry;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, key)
    PROTO_READER_CASE_STRING(2, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const JavaSettings::ServiceClassNamesEntry& a, const JavaSettings::ServiceClassNamesEntry& b) {
  PROTO_READER_EQUALS_FIELD(key_);
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const JavaSettings::ServiceClassNamesEntry& a, const JavaSettings::ServiceClassNamesEntry& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(key_);
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, JavaSettings* out) {
  using classname_ = JavaSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, library_package)
    PROTO_READER_CASE_MESSAGE_ADD(2, service_class_names, ::rs::google::api::JavaSettings::ServiceClassNamesEntry)
    PROTO_READER_CASE_MESSAGE(3, common)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const JavaSettings& a, const JavaSettings& b) {
  PROTO_READER_EQUALS_FIELD(library_package_);
  PROTO_READER_EQUALS_REPEATED(service_class_names_);
  PROTO_READER_EQUALS_FIELD(common_);
  return true;
}

bool Diff(const JavaSettings& a, const JavaSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(library_package_);
  PROTO_READER_DIFF_REPEATED(service_class_names_);
  PROTO_READER_DIFF_FIELD(common_);
  return equal;
}

bool ParseFromStream(InputStream& input, NodeSettings* out) {
  using classname_ = NodeSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const NodeSettings& a, const NodeSettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  return true;
}

bool Diff(const NodeSettings& a, const NodeSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  return equal;
}

bool ParseFromStream(InputStream& input, PhpSettings* out) {
  using classname_ = PhpSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const PhpSettings& a, const PhpSettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  return true;
}

bool Diff(const PhpSettings& a, const PhpSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  return equal;
}

bool ParseFromStream(InputStream& input, PythonSettings::ExperimentalFeatures* out) {
  using classname_ = PythonSettings::ExperimentalFeatures;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_rest_async_io_enabled, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_protobuf_pythonic_types_enabled, bool, static_cast<bool>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_unversioned_package_disabled, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const PythonSettings::ExperimentalFeatures& a, const PythonSettings::ExperimentalFeatures& b) {
  PROTO_READER_EQUALS_FIELD(rest_async_io_enabled_);
  PROTO_READER_EQUALS_FIELD(protobuf_pythonic_types_enabled_);
  PROTO_READER_EQUALS_FIELD(unversioned_package_disabled_);
  return true;
}

bool Diff(const PythonSettings::ExperimentalFeatures& a, const PythonSettings::ExperimentalFeatures& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(rest_async_io_enabled_);
  PROTO_READER_DIFF_FIELD(protobuf_pythonic_types_enabled_);
  PROTO_READER_DIFF_FIELD(unversioned_package_disabled_);
  return equal;
}

bool ParseFromStream(InputStream& input, PythonSettings* out) {
  using classname_ = PythonSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
    PROTO_READER_CASE_MESSAGE(2, experimental_features)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const PythonSettings& a, const PythonSettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  PROTO_READER_EQUALS_FIELD(experimental_features_);
  return true;
}

bool Diff(const PythonSettings& a, const PythonSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  PROTO_READER_DIFF_FIELD(experimental_features_);
  return equal;
}

bool ParseFromStream(InputStream& input, RubySettings* out) {
  using classname_ = RubySettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, common)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const RubySettings& a, const RubySettings& b) {
  PROTO_READER_EQUALS_FIELD(common_);
  return true;
}

bool Diff(const RubySettings& a, const RubySettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(common_);
  return equal;
}

bool ParseFromStream(InputStream& input, ClientLibrarySettings* out) {
  using classname_ = ClientLibrarySettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, version)
    PROTO_READER_CASE_ENUM(2, set_launch_stage, ::rs::google::api::LaunchStage)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_rest_numeric_enums, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE(21, java_settings)
    PROTO_READER_CASE_MESSAGE(22, cpp_settings)
    PROTO_READER_CASE_MESSAGE(23, php_settings)
    PROTO_READER_CASE_MESSAGE(24, python_settings)
    PROTO_READER_CASE_MESSAGE(25, node_settings)
    PROTO_READER_CASE_MESSAGE(26, dotnet_settings)
    PROTO_READER_CASE_MESSAGE(27, ruby_settings)
    PROTO_READER_CASE_MESSAGE(28, go_settings)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ClientLibrarySettings& a, const ClientLibrarySettings& b) {
  PROTO_READER_EQUALS_FIELD(version_);
  PROTO_READER_EQUALS_FIELD(launch_stage_);
  PROTO_READER_EQUALS_FIELD(rest_numeric_enums_);
  PROTO_READER_EQUALS_FIELD(java_settings_);
  PROTO_READER_EQUALS_FIELD(cpp_settings_);
  PROTO_READER_EQUALS_FIELD(php_settings_);
  PROTO_READER_EQUALS_FIELD(python_settings_);
  PROTO_READER_EQUALS_FIELD(node_settings_);
  PROTO_READER_EQUALS_FIELD(dotnet_settings_);
  PROTO_READER_EQUALS_FIELD(ruby_settings_);
  PROTO_READER_EQUALS_FIELD(go_settings_);
  return true;
}

bool Diff(const ClientLibrarySettings& a, const ClientLibrarySettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(version_);
  PROTO_READER_DIFF_FIELD(launch_stage_);
  PROTO_READER_DIFF_FIELD(rest_numeric_enums_);
  PROTO_READER_DIFF_FIELD(java_settings_);
  PROTO_READER_DIFF_FIELD(cpp_settings_);
  PROTO_READER_DIFF_FIELD(php_settings_);
  PROTO_READER_DIFF_FIELD(python_settings_);
  PROTO_READER_DIFF_FIELD(node_settings_);
  PROTO_READER_DIFF_FIELD(dotnet_settings_);
  PROTO_READER_DIFF_FIELD(ruby_settings_);
  PROTO_READER_DIFF_FIELD(go_settings_);
  return equal;
}

bool ParseFromStream(InputStream& input, Publishing* out) {
  using classname_ = Publishing;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(2, method_settings, ::rs::google::api::MethodSettings)
    PROTO_READER_CASE_STRING(101, new_issue_uri)
    PROTO_READER_CASE_STRING(102, documentation_uri)
    PROTO_READER_CASE_STRING(103, api_short_name)
    PROTO_READER_CASE_STRING(104, github_label)
    PROTO_READER_CASE_ADD(105, WIRETYPE_LENGTH_DELIMITED, ReadString, add_codeowner_github_teams)
    PROTO_READER_CASE_STRING(106, doc_tag_prefix)
    PROTO_READER_CASE_ENUM(107, set_organization, ::rs::google::api::ClientLibraryOrganization)
    PROTO_READER_CASE_MESSAGE_ADD(109, library_settings, ::rs::google::api::ClientLibrarySettings)
    PROTO_READER_CASE_STRING(110, proto_reference_documentation_uri)
    PROTO_READER_CASE_STRING(111, rest_reference_documentation_uri)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Publishing& a, const Publishing& b) {
  PROTO_READER_EQUALS_REPEATED(method_settings_);
  PROTO_READER_EQUALS_FIELD(new_issue_uri_);
  PROTO_READER_EQUALS_FIELD(documentation_uri_);
  PROTO_READER_EQUALS_FIELD(api_short_name_);
  PROTO_READER_EQUALS_FIELD(github_label_);
  PROTO_READER_EQUALS_REPEATED(codeowner_github_teams_);
  PROTO_READER_EQUALS_FIELD(doc_tag_prefix_);
  PROTO_READER_EQUALS_FIELD(organization_);
  PROTO_READER_EQUALS_REPEATED(library_settings_);
  PROTO_READER_EQUALS_FIELD(proto_reference_documentation_uri_);
  PROTO_READER_EQUALS_FIELD(rest_reference_documentation_uri_);
  return true;
}

bool Diff(const Publishing& a, const Publishing& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(method_settings_);
  PROTO_READER_DIFF_FIELD(new_issue_uri_);
  PROTO_READER_DIFF_FIELD(documentation_uri_);
  PROTO_READER_DIFF_FIELD(api_short_name_);
  PROTO_READER_DIFF_FIELD(github_label_);
  PROTO_READER_DIFF_REPEATED(codeowner_github_teams_);
  PROTO_READER_DIFF_FIELD(doc_tag_prefix_);
  PROTO_READER_DIFF_FIELD(organization_);
  PROTO_READER_DIFF_REPEATED(library_settings_);
  PROTO_READER_DIFF_FIELD(proto_reference_documentation_uri_);
  PROTO_READER_DIFF_FIELD(rest_reference_documentation_uri_);
  return equal;
}

bool ParseFromStream(InputStream& input, MethodSettings::LongRunning* out) {
  using classname_ = MethodSettings::LongRunning;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, initial_poll_delay)
    PROTO_READER_CASE_SET(2, WIRETYPE_FIXED32, ReadFloat, set_poll_delay_multiplier)
    PROTO_READER_CASE_MESSAGE(3, max_poll_delay)
    PROTO_READER_CASE_MESSAGE(4, total_poll_timeout)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MethodSettings::LongRunning& a, const MethodSettings::LongRunning& b) {
  PROTO_READER_EQUALS_FIELD(initial_poll_delay_);
  PROTO_READER_EQUALS_FIELD(poll_delay_multiplier_);
  PROTO_READER_EQUALS_FIELD(max_poll_delay_);
  PROTO_READER_EQUALS_FIELD(total_poll_timeout_);
  return true;
}

bool Diff(const MethodSettings::LongRunning& a, const MethodSettings::LongRunning& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(initial_poll_delay_);
  PROTO_READER_DIFF_FIELD(poll_delay_multiplier_);
  PROTO_READER_DIFF_FIELD(max_poll_delay_);
  PROTO_READER_DIFF_FIELD(total_poll_timeout_);
  return equal;
}

bool ParseFromStream(InputStream& input, MethodSettings* out) {
  using classname_ = MethodSettings;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, selector)
    PROTO_READER_CASE_MESSAGE(2, long_running)
    PROTO_READER_CASE_ADD(3, WIRETYPE_LENGTH_DELIMITED, ReadString, add_auto_populated_fields)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MethodSettings& a, const MethodSettings& b) {
  PROTO_READER_EQUALS_FIELD(selector_);
  PROTO_READER_EQUALS_FIELD(long_running_);
  PROTO_READER_EQUALS_REPEATED(auto_populated_fields_);
  return true;
}

bool Diff(const MethodSettings& a, const MethodSettings& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(selector_);
  PROTO_READER_DIFF_FIELD(long_running_);
  PROTO_READER_DIFF_REPEATED(auto_populated_fields_);
  return equal;
}

}  // namespace api
}  // namespace google
namespace google {
namespace api {
bool Diff(FieldBehavior a, FieldBehavior b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

}  // namespace api
}  // namespace google
namespace google {
namespace api {
bool Diff(ResourceDescriptor::History a, ResourceDescriptor::History b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(ResourceDescriptor::Style a, ResourceDescriptor::Style b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, ResourceDescriptor* out) {
  using classname_ = ResourceDescriptor;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, type)
    PROTO_READER_CASE_ADD(2, WIRETYPE_LENGTH_DELIMITED, ReadString, add_pattern)
    PROTO_READER_CASE_STRING(3, name_field)
    PROTO_READER_CASE_ENUM(4, set_history, ::rs::google::api::ResourceDescriptor::History)
    PROTO_READER_CASE_STRING(5, plural)
    PROTO_READER_CASE_STRING(6, singular)
    PROTO_READER_CASE_ENUM_ADD(10, add_style, ::rs::google::api::ResourceDescriptor::Style)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ResourceDescriptor& a, const ResourceDescriptor& b) {
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_REPEATED(pattern_);
  PROTO_READER_EQUALS_FIELD(name_field_);
  PROTO_READER_EQUALS_FIELD(history_);
  PROTO_READER_EQUALS_FIELD(plural_);
  PROTO_READER_EQUALS_FIELD(singular_);
  PROTO_READER_EQUALS_REPEATED(style_);
  return true;
}

bool Diff(const ResourceDescriptor& a, const ResourceDescriptor& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_REPEATED(pattern_);
  PROTO_READER_DIFF_FIELD(name_field_);
  PROTO_READER_DIFF_FIELD(history_);
  PROTO_READER_DIFF_FIELD(plural_);
  PROTO_READER_DIFF_FIELD(singular_);
  PROTO_READER_DIFF_REPEATED(style_);
  return equal;
}

bool ParseFromStream(InputStream& input, ResourceReference* out) {
  using classname_ = ResourceReference;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, type)
    PROTO_READER_CASE_STRING(2, child_type)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ResourceReference& a, const ResourceReference& b) {
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_FIELD(child_type_);
  return true;
}

bool Diff(const ResourceReference& a, const ResourceReference& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_FIELD(child_type_);
  return equal;
}

}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, Timestamp* out) {
  using classname_ = Timestamp;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST64(1, WIRETYPE_VARINT, ReadVarint64, set_seconds, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_nanos, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Timestamp& a, const Timestamp& b) {
  PROTO_READER_EQUALS_FIELD(seconds_);
  PROTO_READER_EQUALS_FIELD(nanos_);
  return true;
}

bool Diff(const Timestamp& a, const Timestamp& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(seconds_);
  PROTO_READER_DIFF_FIELD(nanos_);
  return equal;
}

}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(Language a, Language b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(Status a, Status b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(UploadStatus a, UploadStatus b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, StatusAttributes* out) {
  using classname_ = StatusAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_status, ::rs::google::devtools::resultstore::v2::Status)
    PROTO_READER_CASE_STRING(2, description)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const StatusAttributes& a, const StatusAttributes& b) {
  PROTO_READER_EQUALS_FIELD(status_);
  PROTO_READER_EQUALS_FIELD(description_);
  return true;
}

bool Diff(const StatusAttributes& a, const StatusAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(status_);
  PROTO_READER_DIFF_FIELD(description_);
  return equal;
}

bool ParseFromStream(InputStream& input, Property* out) {
  using classname_ = Property;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, key)
    PROTO_READER_CASE_STRING(2, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Property& a, const Property& b) {
  PROTO_READER_EQUALS_FIELD(key_);
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const Property& a, const Property& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(key_);
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, Timing* out) {
  using classname_ = Timing;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, start_time)
    PROTO_READER_CASE_MESSAGE(2, duration)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Timing& a, const Timing& b) {
  PROTO_READER_EQUALS_FIELD(start_time_);
  PROTO_READER_EQUALS_FIELD(duration_);
  return true;
}

bool Diff(const Timing& a, const Timing& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(start_time_);
  PROTO_READER_DIFF_FIELD(duration_);
  return equal;
}

bool ParseFromStream(InputStream& input, Dependency::Id* out) {
  using classname_ = Dependency::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(2, target_id)
    PROTO_READER_CASE_STRING(3, configuration_id)
    PROTO_READER_CASE_STRING(4, action_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Dependency::Id& a, const Dependency::Id& b) {
  PROTO_READER_EQUALS_FIELD(target_id_);
  PROTO_READER_EQUALS_FIELD(configuration_id_);
  PROTO_READER_EQUALS_FIELD(action_id_);
  return true;
}

bool Diff(const Dependency::Id& a, const Dependency::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(target_id_);
  PROTO_READER_DIFF_FIELD(configuration_id_);
  PROTO_READER_DIFF_FIELD(action_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, Dependency* out) {
  using classname_ = Dependency;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, target)
    PROTO_READER_CASE_STRING(2, configured_target)
    PROTO_READER_CASE_STRING(3, action)
    PROTO_READER_CASE_MESSAGE(5, id)
    PROTO_READER_CASE_STRING(4, label)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Dependency& a, const Dependency& b) {
  PROTO_READER_EQUALS_FIELD(target_);
  PROTO_READER_EQUALS_FIELD(configured_target_);
  PROTO_READER_EQUALS_FIELD(action_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(label_);
  return true;
}

bool Diff(const Dependency& a, const Dependency& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(target_);
  PROTO_READER_DIFF_FIELD(configured_target_);
  PROTO_READER_DIFF_FIELD(action_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(label_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, LineCoverage* out) {
  using classname_ = LineCoverage;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, instrumented_lines)
    PROTO_READER_CASE_STRING(2, executed_lines)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const LineCoverage& a, const LineCoverage& b) {
  PROTO_READER_EQUALS_FIELD(instrumented_lines_);
  PROTO_READER_EQUALS_FIELD(executed_lines_);
  return true;
}

bool Diff(const LineCoverage& a, const LineCoverage& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(instrumented_lines_);
  PROTO_READER_DIFF_FIELD(executed_lines_);
  return equal;
}

bool ParseFromStream(InputStream& input, BranchCoverage* out) {
  using classname_ = BranchCoverage;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, branch_present)
    PROTO_READER_CASE_ADD_CAST32(2, WIRETYPE_VARINT, ReadVarint32, add_branches_in_line, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_STRING(3, executed)
    PROTO_READER_CASE_STRING(4, taken)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const BranchCoverage& a, const BranchCoverage& b) {
  PROTO_READER_EQUALS_FIELD(branch_present_);
  PROTO_READER_EQUALS_REPEATED(branches_in_line_);
  PROTO_READER_EQUALS_FIELD(executed_);
  PROTO_READER_EQUALS_FIELD(taken_);
  return true;
}

bool Diff(const BranchCoverage& a, const BranchCoverage& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(branch_present_);
  PROTO_READER_DIFF_REPEATED(branches_in_line_);
  PROTO_READER_DIFF_FIELD(executed_);
  PROTO_READER_DIFF_FIELD(taken_);
  return equal;
}

bool ParseFromStream(InputStream& input, FileCoverage* out) {
  using classname_ = FileCoverage;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, path)
    PROTO_READER_CASE_MESSAGE(2, line_coverage)
    PROTO_READER_CASE_MESSAGE(3, branch_coverage)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileCoverage& a, const FileCoverage& b) {
  PROTO_READER_EQUALS_FIELD(path_);
  PROTO_READER_EQUALS_FIELD(line_coverage_);
  PROTO_READER_EQUALS_FIELD(branch_coverage_);
  return true;
}

bool Diff(const FileCoverage& a, const FileCoverage& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(path_);
  PROTO_READER_DIFF_FIELD(line_coverage_);
  PROTO_READER_DIFF_FIELD(branch_coverage_);
  return equal;
}

bool ParseFromStream(InputStream& input, ActionCoverage* out) {
  using classname_ = ActionCoverage;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(2, file_coverages, ::rs::google::devtools::resultstore::v2::FileCoverage)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ActionCoverage& a, const ActionCoverage& b) {
  PROTO_READER_EQUALS_REPEATED(file_coverages_);
  return true;
}

bool Diff(const ActionCoverage& a, const ActionCoverage& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(file_coverages_);
  return equal;
}

bool ParseFromStream(InputStream& input, AggregateCoverage* out) {
  using classname_ = AggregateCoverage;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE_ADD(1, file_coverages, ::rs::google::devtools::resultstore::v2::FileCoverage)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const AggregateCoverage& a, const AggregateCoverage& b) {
  PROTO_READER_EQUALS_REPEATED(file_coverages_);
  return true;
}

bool Diff(const AggregateCoverage& a, const AggregateCoverage& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(file_coverages_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, DoubleValue* out) {
  using classname_ = DoubleValue;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET(1, WIRETYPE_FIXED64, ReadDouble, set_value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DoubleValue& a, const DoubleValue& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const DoubleValue& a, const DoubleValue& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, FloatValue* out) {
  using classname_ = FloatValue;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET(1, WIRETYPE_FIXED32, ReadFloat, set_value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FloatValue& a, const FloatValue& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const FloatValue& a, const FloatValue& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, Int64Value* out) {
  using classname_ = Int64Value;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST64(1, WIRETYPE_VARINT, ReadVarint64, set_value, int64_t, static_cast<int64_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Int64Value& a, const Int64Value& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const Int64Value& a, const Int64Value& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, UInt64Value* out) {
  using classname_ = UInt64Value;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET(1, WIRETYPE_VARINT, ReadVarint64, set_value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UInt64Value& a, const UInt64Value& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const UInt64Value& a, const UInt64Value& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, Int32Value* out) {
  using classname_ = Int32Value;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_value, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Int32Value& a, const Int32Value& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const Int32Value& a, const Int32Value& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, UInt32Value* out) {
  using classname_ = UInt32Value;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET(1, WIRETYPE_VARINT, ReadVarint32, set_value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UInt32Value& a, const UInt32Value& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const UInt32Value& a, const UInt32Value& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, BoolValue* out) {
  using classname_ = BoolValue;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_value, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const BoolValue& a, const BoolValue& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const BoolValue& a, const BoolValue& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, StringValue* out) {
  using classname_ = StringValue;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const StringValue& a, const StringValue& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const StringValue& a, const StringValue& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

bool ParseFromStream(InputStream& input, BytesValue* out) {
  using classname_ = BytesValue;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, value)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const BytesValue& a, const BytesValue& b) {
  PROTO_READER_EQUALS_FIELD(value_);
  return true;
}

bool Diff(const BytesValue& a, const BytesValue& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(value_);
  return equal;
}

}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, ArchiveEntry* out) {
  using classname_ = ArchiveEntry;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, path)
    PROTO_READER_CASE_MESSAGE(2, length)
    PROTO_READER_CASE_STRING(3, content_type)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ArchiveEntry& a, const ArchiveEntry& b) {
  PROTO_READER_EQUALS_FIELD(path_);
  PROTO_READER_EQUALS_FIELD(length_);
  PROTO_READER_EQUALS_FIELD(content_type_);
  return true;
}

bool Diff(const ArchiveEntry& a, const ArchiveEntry& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(path_);
  PROTO_READER_DIFF_FIELD(length_);
  PROTO_READER_DIFF_FIELD(content_type_);
  return equal;
}

bool Diff(File::HashType a, File::HashType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, File* out) {
  using classname_ = File;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, uid)
    PROTO_READER_CASE_STRING(2, uri)
    PROTO_READER_CASE_MESSAGE(3, length)
    PROTO_READER_CASE_STRING(4, content_type)
    PROTO_READER_CASE_MESSAGE(5, archive_entry)
    PROTO_READER_CASE_STRING(6, content_viewer)
    PROTO_READER_CASE_SET_CAST32(7, WIRETYPE_VARINT, ReadVarint32, set_hidden, bool, static_cast<bool>)
    PROTO_READER_CASE_STRING(8, description)
    PROTO_READER_CASE_STRING(9, digest)
    PROTO_READER_CASE_ENUM(10, set_hash_type, ::rs::google::devtools::resultstore::v2::File::HashType)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const File& a, const File& b) {
  PROTO_READER_EQUALS_FIELD(uid_);
  PROTO_READER_EQUALS_FIELD(uri_);
  PROTO_READER_EQUALS_FIELD(length_);
  PROTO_READER_EQUALS_FIELD(content_type_);
  PROTO_READER_EQUALS_FIELD(archive_entry_);
  PROTO_READER_EQUALS_FIELD(content_viewer_);
  PROTO_READER_EQUALS_FIELD(hidden_);
  PROTO_READER_EQUALS_FIELD(description_);
  PROTO_READER_EQUALS_FIELD(digest_);
  PROTO_READER_EQUALS_FIELD(hash_type_);
  return true;
}

bool Diff(const File& a, const File& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(uid_);
  PROTO_READER_DIFF_FIELD(uri_);
  PROTO_READER_DIFF_FIELD(length_);
  PROTO_READER_DIFF_FIELD(content_type_);
  PROTO_READER_DIFF_FIELD(archive_entry_);
  PROTO_READER_DIFF_FIELD(content_viewer_);
  PROTO_READER_DIFF_FIELD(hidden_);
  PROTO_READER_DIFF_FIELD(description_);
  PROTO_READER_DIFF_FIELD(digest_);
  PROTO_READER_DIFF_FIELD(hash_type_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(FileProcessingErrorType a, FileProcessingErrorType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, FileProcessingErrors* out) {
  using classname_ = FileProcessingErrors;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, file_uid)
    PROTO_READER_CASE_MESSAGE_ADD(3, file_processing_errors, ::rs::google::devtools::resultstore::v2::FileProcessingError)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileProcessingErrors& a, const FileProcessingErrors& b) {
  PROTO_READER_EQUALS_FIELD(file_uid_);
  PROTO_READER_EQUALS_REPEATED(file_processing_errors_);
  return true;
}

bool Diff(const FileProcessingErrors& a, const FileProcessingErrors& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(file_uid_);
  PROTO_READER_DIFF_REPEATED(file_processing_errors_);
  return equal;
}

bool ParseFromStream(InputStream& input, FileProcessingError* out) {
  using classname_ = FileProcessingError;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_type, ::rs::google::devtools::resultstore::v2::FileProcessingErrorType)
    PROTO_READER_CASE_STRING(2, message)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileProcessingError& a, const FileProcessingError& b) {
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_FIELD(message_);
  return true;
}

bool Diff(const FileProcessingError& a, const FileProcessingError& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_FIELD(message_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, TestSuite* out) {
  using classname_ = TestSuite;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, suite_name)
    PROTO_READER_CASE_MESSAGE_ADD(2, tests, ::rs::google::devtools::resultstore::v2::Test)
    PROTO_READER_CASE_MESSAGE_ADD(3, failures, ::rs::google::devtools::resultstore::v2::TestFailure)
    PROTO_READER_CASE_MESSAGE_ADD(4, errors, ::rs::google::devtools::resultstore::v2::TestError)
    PROTO_READER_CASE_MESSAGE(6, timing)
    PROTO_READER_CASE_MESSAGE_ADD(7, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_MESSAGE_ADD(8, files, ::rs::google::devtools::resultstore::v2::File)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestSuite& a, const TestSuite& b) {
  PROTO_READER_EQUALS_FIELD(suite_name_);
  PROTO_READER_EQUALS_REPEATED(tests_);
  PROTO_READER_EQUALS_REPEATED(failures_);
  PROTO_READER_EQUALS_REPEATED(errors_);
  PROTO_READER_EQUALS_FIELD(timing_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_REPEATED(files_);
  return true;
}

bool Diff(const TestSuite& a, const TestSuite& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(suite_name_);
  PROTO_READER_DIFF_REPEATED(tests_);
  PROTO_READER_DIFF_REPEATED(failures_);
  PROTO_READER_DIFF_REPEATED(errors_);
  PROTO_READER_DIFF_FIELD(timing_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_REPEATED(files_);
  return equal;
}

bool Diff(TestCase::Result a, TestCase::Result b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, TestCase* out) {
  using classname_ = TestCase;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, case_name)
    PROTO_READER_CASE_STRING(2, class_name)
    PROTO_READER_CASE_ENUM(3, set_result, ::rs::google::devtools::resultstore::v2::TestCase::Result)
    PROTO_READER_CASE_MESSAGE_ADD(4, failures, ::rs::google::devtools::resultstore::v2::TestFailure)
    PROTO_READER_CASE_MESSAGE_ADD(5, errors, ::rs::google::devtools::resultstore::v2::TestError)
    PROTO_READER_CASE_MESSAGE(7, timing)
    PROTO_READER_CASE_MESSAGE_ADD(8, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_MESSAGE_ADD(9, files, ::rs::google::devtools::resultstore::v2::File)
    PROTO_READER_CASE_SET_CAST32(10, WIRETYPE_VARINT, ReadVarint32, set_retry_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(11, WIRETYPE_VARINT, ReadVarint32, set_repeat_number, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestCase& a, const TestCase& b) {
  PROTO_READER_EQUALS_FIELD(case_name_);
  PROTO_READER_EQUALS_FIELD(class_name_);
  PROTO_READER_EQUALS_FIELD(result_);
  PROTO_READER_EQUALS_REPEATED(failures_);
  PROTO_READER_EQUALS_REPEATED(errors_);
  PROTO_READER_EQUALS_FIELD(timing_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_REPEATED(files_);
  PROTO_READER_EQUALS_FIELD(retry_number_);
  PROTO_READER_EQUALS_FIELD(repeat_number_);
  return true;
}

bool Diff(const TestCase& a, const TestCase& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(case_name_);
  PROTO_READER_DIFF_FIELD(class_name_);
  PROTO_READER_DIFF_FIELD(result_);
  PROTO_READER_DIFF_REPEATED(failures_);
  PROTO_READER_DIFF_REPEATED(errors_);
  PROTO_READER_DIFF_FIELD(timing_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_REPEATED(files_);
  PROTO_READER_DIFF_FIELD(retry_number_);
  PROTO_READER_DIFF_FIELD(repeat_number_);
  return equal;
}

bool ParseFromStream(InputStream& input, Test* out) {
  using classname_ = Test;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, test_case)
    PROTO_READER_CASE_MESSAGE(2, test_suite)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Test& a, const Test& b) {
  PROTO_READER_EQUALS_FIELD(test_case_);
  PROTO_READER_EQUALS_FIELD(test_suite_);
  return true;
}

bool Diff(const Test& a, const Test& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(test_case_);
  PROTO_READER_DIFF_FIELD(test_suite_);
  return equal;
}

bool ParseFromStream(InputStream& input, TestFailure* out) {
  using classname_ = TestFailure;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, failure_message)
    PROTO_READER_CASE_STRING(2, exception_type)
    PROTO_READER_CASE_STRING(3, stack_trace)
    PROTO_READER_CASE_ADD(4, WIRETYPE_LENGTH_DELIMITED, ReadString, add_expected)
    PROTO_READER_CASE_ADD(5, WIRETYPE_LENGTH_DELIMITED, ReadString, add_actual)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestFailure& a, const TestFailure& b) {
  PROTO_READER_EQUALS_FIELD(failure_message_);
  PROTO_READER_EQUALS_FIELD(exception_type_);
  PROTO_READER_EQUALS_FIELD(stack_trace_);
  PROTO_READER_EQUALS_REPEATED(expected_);
  PROTO_READER_EQUALS_REPEATED(actual_);
  return true;
}

bool Diff(const TestFailure& a, const TestFailure& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(failure_message_);
  PROTO_READER_DIFF_FIELD(exception_type_);
  PROTO_READER_DIFF_FIELD(stack_trace_);
  PROTO_READER_DIFF_REPEATED(expected_);
  PROTO_READER_DIFF_REPEATED(actual_);
  return equal;
}

bool ParseFromStream(InputStream& input, TestError* out) {
  using classname_ = TestError;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, error_message)
    PROTO_READER_CASE_STRING(2, exception_type)
    PROTO_READER_CASE_STRING(3, stack_trace)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestError& a, const TestError& b) {
  PROTO_READER_EQUALS_FIELD(error_message_);
  PROTO_READER_EQUALS_FIELD(exception_type_);
  PROTO_READER_EQUALS_FIELD(stack_trace_);
  return true;
}

bool Diff(const TestError& a, const TestError& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(error_message_);
  PROTO_READER_DIFF_FIELD(exception_type_);
  PROTO_READER_DIFF_FIELD(stack_trace_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(ExecutionStrategy a, ExecutionStrategy b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(TestCaching a, TestCaching b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, InputFileInfo* out) {
  using classname_ = InputFileInfo;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST64(1, WIRETYPE_VARINT, ReadVarint64, set_count, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET_CAST64(2, WIRETYPE_VARINT, ReadVarint64, set_distinct_count, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET_CAST64(3, WIRETYPE_VARINT, ReadVarint64, set_count_limit, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET_CAST64(4, WIRETYPE_VARINT, ReadVarint64, set_distinct_bytes, int64_t, static_cast<int64_t>)
    PROTO_READER_CASE_SET_CAST64(5, WIRETYPE_VARINT, ReadVarint64, set_distinct_byte_limit, int64_t, static_cast<int64_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const InputFileInfo& a, const InputFileInfo& b) {
  PROTO_READER_EQUALS_FIELD(count_);
  PROTO_READER_EQUALS_FIELD(distinct_count_);
  PROTO_READER_EQUALS_FIELD(count_limit_);
  PROTO_READER_EQUALS_FIELD(distinct_bytes_);
  PROTO_READER_EQUALS_FIELD(distinct_byte_limit_);
  return true;
}

bool Diff(const InputFileInfo& a, const InputFileInfo& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(count_);
  PROTO_READER_DIFF_FIELD(distinct_count_);
  PROTO_READER_DIFF_FIELD(count_limit_);
  PROTO_READER_DIFF_FIELD(distinct_bytes_);
  PROTO_READER_DIFF_FIELD(distinct_byte_limit_);
  return equal;
}

bool ParseFromStream(InputStream& input, ActionAttributes* out) {
  using classname_ = ActionAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_execution_strategy, ::rs::google::devtools::resultstore::v2::ExecutionStrategy)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_exit_code, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_STRING(3, hostname)
    PROTO_READER_CASE_MESSAGE(4, input_file_info)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ActionAttributes& a, const ActionAttributes& b) {
  PROTO_READER_EQUALS_FIELD(execution_strategy_);
  PROTO_READER_EQUALS_FIELD(exit_code_);
  PROTO_READER_EQUALS_FIELD(hostname_);
  PROTO_READER_EQUALS_FIELD(input_file_info_);
  return true;
}

bool Diff(const ActionAttributes& a, const ActionAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(execution_strategy_);
  PROTO_READER_DIFF_FIELD(exit_code_);
  PROTO_READER_DIFF_FIELD(hostname_);
  PROTO_READER_DIFF_FIELD(input_file_info_);
  return equal;
}

bool ParseFromStream(InputStream& input, BuildAction* out) {
  using classname_ = BuildAction;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, type)
    PROTO_READER_CASE_STRING(2, primary_input_path)
    PROTO_READER_CASE_STRING(3, primary_output_path)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const BuildAction& a, const BuildAction& b) {
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_FIELD(primary_input_path_);
  PROTO_READER_EQUALS_FIELD(primary_output_path_);
  return true;
}

bool Diff(const BuildAction& a, const BuildAction& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_FIELD(primary_input_path_);
  PROTO_READER_DIFF_FIELD(primary_output_path_);
  return equal;
}

bool ParseFromStream(InputStream& input, LocalTestTiming* out) {
  using classname_ = LocalTestTiming;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, test_process_duration)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const LocalTestTiming& a, const LocalTestTiming& b) {
  PROTO_READER_EQUALS_FIELD(test_process_duration_);
  return true;
}

bool Diff(const LocalTestTiming& a, const LocalTestTiming& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(test_process_duration_);
  return equal;
}

bool ParseFromStream(InputStream& input, RemoteTestTiming* out) {
  using classname_ = RemoteTestTiming;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, local_analysis_duration)
    PROTO_READER_CASE_MESSAGE_ADD(2, attempts, ::rs::google::devtools::resultstore::v2::RemoteTestAttemptTiming)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const RemoteTestTiming& a, const RemoteTestTiming& b) {
  PROTO_READER_EQUALS_FIELD(local_analysis_duration_);
  PROTO_READER_EQUALS_REPEATED(attempts_);
  return true;
}

bool Diff(const RemoteTestTiming& a, const RemoteTestTiming& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(local_analysis_duration_);
  PROTO_READER_DIFF_REPEATED(attempts_);
  return equal;
}

bool ParseFromStream(InputStream& input, TestTiming* out) {
  using classname_ = TestTiming;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, local)
    PROTO_READER_CASE_MESSAGE(2, remote)
    PROTO_READER_CASE_MESSAGE(3, system_time_duration)
    PROTO_READER_CASE_MESSAGE(4, user_time_duration)
    PROTO_READER_CASE_ENUM(5, set_test_caching, ::rs::google::devtools::resultstore::v2::TestCaching)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestTiming& a, const TestTiming& b) {
  PROTO_READER_EQUALS_FIELD(local_);
  PROTO_READER_EQUALS_FIELD(remote_);
  PROTO_READER_EQUALS_FIELD(system_time_duration_);
  PROTO_READER_EQUALS_FIELD(user_time_duration_);
  PROTO_READER_EQUALS_FIELD(test_caching_);
  return true;
}

bool Diff(const TestTiming& a, const TestTiming& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(local_);
  PROTO_READER_DIFF_FIELD(remote_);
  PROTO_READER_DIFF_FIELD(system_time_duration_);
  PROTO_READER_DIFF_FIELD(user_time_duration_);
  PROTO_READER_DIFF_FIELD(test_caching_);
  return equal;
}

bool ParseFromStream(InputStream& input, TestAction* out) {
  using classname_ = TestAction;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, test_timing)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_shard_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_run_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(4, WIRETYPE_VARINT, ReadVarint32, set_attempt_number, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_MESSAGE(5, test_suite)
    PROTO_READER_CASE_MESSAGE_ADD(8, warnings, ::rs::google::devtools::resultstore::v2::TestWarning)
    PROTO_READER_CASE_SET_CAST64(10, WIRETYPE_VARINT, ReadVarint64, set_estimated_memory_bytes, int64_t, static_cast<int64_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestAction& a, const TestAction& b) {
  PROTO_READER_EQUALS_FIELD(test_timing_);
  PROTO_READER_EQUALS_FIELD(shard_number_);
  PROTO_READER_EQUALS_FIELD(run_number_);
  PROTO_READER_EQUALS_FIELD(attempt_number_);
  PROTO_READER_EQUALS_FIELD(test_suite_);
  PROTO_READER_EQUALS_REPEATED(warnings_);
  PROTO_READER_EQUALS_FIELD(estimated_memory_bytes_);
  return true;
}

bool Diff(const TestAction& a, const TestAction& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(test_timing_);
  PROTO_READER_DIFF_FIELD(shard_number_);
  PROTO_READER_DIFF_FIELD(run_number_);
  PROTO_READER_DIFF_FIELD(attempt_number_);
  PROTO_READER_DIFF_FIELD(test_suite_);
  PROTO_READER_DIFF_REPEATED(warnings_);
  PROTO_READER_DIFF_FIELD(estimated_memory_bytes_);
  return equal;
}

bool ParseFromStream(InputStream& input, Action::Id* out) {
  using classname_ = Action::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, invocation_id)
    PROTO_READER_CASE_STRING(2, target_id)
    PROTO_READER_CASE_STRING(3, configuration_id)
    PROTO_READER_CASE_STRING(4, action_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Action::Id& a, const Action::Id& b) {
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  PROTO_READER_EQUALS_FIELD(target_id_);
  PROTO_READER_EQUALS_FIELD(configuration_id_);
  PROTO_READER_EQUALS_FIELD(action_id_);
  return true;
}

bool Diff(const Action::Id& a, const Action::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_id_);
  PROTO_READER_DIFF_FIELD(target_id_);
  PROTO_READER_DIFF_FIELD(configuration_id_);
  PROTO_READER_DIFF_FIELD(action_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, Action* out) {
  using classname_ = Action;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
    PROTO_READER_CASE_MESSAGE(3, status_attributes)
    PROTO_READER_CASE_MESSAGE(4, timing)
    PROTO_READER_CASE_MESSAGE(9, build_action)
    PROTO_READER_CASE_MESSAGE(10, test_action)
    PROTO_READER_CASE_MESSAGE(5, action_attributes)
    PROTO_READER_CASE_MESSAGE_ADD(14, action_dependencies, ::rs::google::devtools::resultstore::v2::Dependency)
    PROTO_READER_CASE_MESSAGE_ADD(7, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_MESSAGE_ADD(8, files, ::rs::google::devtools::resultstore::v2::File)
    PROTO_READER_CASE_ADD(15, WIRETYPE_LENGTH_DELIMITED, ReadString, add_file_sets)
    PROTO_READER_CASE_MESSAGE(11, coverage)
    PROTO_READER_CASE_MESSAGE_ADD(13, file_processing_errors, ::rs::google::devtools::resultstore::v2::FileProcessingErrors)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Action& a, const Action& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(status_attributes_);
  PROTO_READER_EQUALS_FIELD(timing_);
  PROTO_READER_EQUALS_FIELD(build_action_);
  PROTO_READER_EQUALS_FIELD(test_action_);
  PROTO_READER_EQUALS_FIELD(action_attributes_);
  PROTO_READER_EQUALS_REPEATED(action_dependencies_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_REPEATED(files_);
  PROTO_READER_EQUALS_REPEATED(file_sets_);
  PROTO_READER_EQUALS_FIELD(coverage_);
  PROTO_READER_EQUALS_REPEATED(file_processing_errors_);
  return true;
}

bool Diff(const Action& a, const Action& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(status_attributes_);
  PROTO_READER_DIFF_FIELD(timing_);
  PROTO_READER_DIFF_FIELD(build_action_);
  PROTO_READER_DIFF_FIELD(test_action_);
  PROTO_READER_DIFF_FIELD(action_attributes_);
  PROTO_READER_DIFF_REPEATED(action_dependencies_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_REPEATED(files_);
  PROTO_READER_DIFF_REPEATED(file_sets_);
  PROTO_READER_DIFF_FIELD(coverage_);
  PROTO_READER_DIFF_REPEATED(file_processing_errors_);
  return equal;
}

bool ParseFromStream(InputStream& input, RemoteTestAttemptTiming* out) {
  using classname_ = RemoteTestAttemptTiming;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, queue_duration)
    PROTO_READER_CASE_MESSAGE(2, upload_duration)
    PROTO_READER_CASE_MESSAGE(3, machine_setup_duration)
    PROTO_READER_CASE_MESSAGE(4, test_process_duration)
    PROTO_READER_CASE_MESSAGE(5, download_duration)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const RemoteTestAttemptTiming& a, const RemoteTestAttemptTiming& b) {
  PROTO_READER_EQUALS_FIELD(queue_duration_);
  PROTO_READER_EQUALS_FIELD(upload_duration_);
  PROTO_READER_EQUALS_FIELD(machine_setup_duration_);
  PROTO_READER_EQUALS_FIELD(test_process_duration_);
  PROTO_READER_EQUALS_FIELD(download_duration_);
  return true;
}

bool Diff(const RemoteTestAttemptTiming& a, const RemoteTestAttemptTiming& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(queue_duration_);
  PROTO_READER_DIFF_FIELD(upload_duration_);
  PROTO_READER_DIFF_FIELD(machine_setup_duration_);
  PROTO_READER_DIFF_FIELD(test_process_duration_);
  PROTO_READER_DIFF_FIELD(download_duration_);
  return equal;
}

bool ParseFromStream(InputStream& input, TestWarning* out) {
  using classname_ = TestWarning;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, warning_message)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestWarning& a, const TestWarning& b) {
  PROTO_READER_EQUALS_FIELD(warning_message_);
  return true;
}

bool Diff(const TestWarning& a, const TestWarning& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(warning_message_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, ConfigurationAttributes* out) {
  using classname_ = ConfigurationAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, cpu)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ConfigurationAttributes& a, const ConfigurationAttributes& b) {
  PROTO_READER_EQUALS_FIELD(cpu_);
  return true;
}

bool Diff(const ConfigurationAttributes& a, const ConfigurationAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(cpu_);
  return equal;
}

bool ParseFromStream(InputStream& input, Configuration::Id* out) {
  using classname_ = Configuration::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, invocation_id)
    PROTO_READER_CASE_STRING(2, configuration_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Configuration::Id& a, const Configuration::Id& b) {
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  PROTO_READER_EQUALS_FIELD(configuration_id_);
  return true;
}

bool Diff(const Configuration::Id& a, const Configuration::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_id_);
  PROTO_READER_DIFF_FIELD(configuration_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, Configuration* out) {
  using classname_ = Configuration;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
    PROTO_READER_CASE_MESSAGE(3, status_attributes)
    PROTO_READER_CASE_MESSAGE(5, configuration_attributes)
    PROTO_READER_CASE_MESSAGE_ADD(6, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_STRING(8, display_name)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Configuration& a, const Configuration& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(status_attributes_);
  PROTO_READER_EQUALS_FIELD(configuration_attributes_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_FIELD(display_name_);
  return true;
}

bool Diff(const Configuration& a, const Configuration& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(status_attributes_);
  PROTO_READER_DIFF_FIELD(configuration_attributes_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_FIELD(display_name_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, ConfiguredTestAttributes* out) {
  using classname_ = ConfiguredTestAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_total_run_count, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_total_shard_count, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_MESSAGE(5, timeout_duration)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ConfiguredTestAttributes& a, const ConfiguredTestAttributes& b) {
  PROTO_READER_EQUALS_FIELD(total_run_count_);
  PROTO_READER_EQUALS_FIELD(total_shard_count_);
  PROTO_READER_EQUALS_FIELD(timeout_duration_);
  return true;
}

bool Diff(const ConfiguredTestAttributes& a, const ConfiguredTestAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(total_run_count_);
  PROTO_READER_DIFF_FIELD(total_shard_count_);
  PROTO_READER_DIFF_FIELD(timeout_duration_);
  return equal;
}

bool ParseFromStream(InputStream& input, ConfiguredTarget::Id* out) {
  using classname_ = ConfiguredTarget::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, invocation_id)
    PROTO_READER_CASE_STRING(2, target_id)
    PROTO_READER_CASE_STRING(3, configuration_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ConfiguredTarget::Id& a, const ConfiguredTarget::Id& b) {
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  PROTO_READER_EQUALS_FIELD(target_id_);
  PROTO_READER_EQUALS_FIELD(configuration_id_);
  return true;
}

bool Diff(const ConfiguredTarget::Id& a, const ConfiguredTarget::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_id_);
  PROTO_READER_DIFF_FIELD(target_id_);
  PROTO_READER_DIFF_FIELD(configuration_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, ConfiguredTarget* out) {
  using classname_ = ConfiguredTarget;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
    PROTO_READER_CASE_MESSAGE(3, status_attributes)
    PROTO_READER_CASE_MESSAGE(4, timing)
    PROTO_READER_CASE_MESSAGE(6, test_attributes)
    PROTO_READER_CASE_MESSAGE_ADD(7, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_MESSAGE_ADD(8, files, ::rs::google::devtools::resultstore::v2::File)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const ConfiguredTarget& a, const ConfiguredTarget& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(status_attributes_);
  PROTO_READER_EQUALS_FIELD(timing_);
  PROTO_READER_EQUALS_FIELD(test_attributes_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_REPEATED(files_);
  return true;
}

bool Diff(const ConfiguredTarget& a, const ConfiguredTarget& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(status_attributes_);
  PROTO_READER_DIFF_FIELD(timing_);
  PROTO_READER_DIFF_FIELD(test_attributes_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_REPEATED(files_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, FileSet::Id* out) {
  using classname_ = FileSet::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, invocation_id)
    PROTO_READER_CASE_STRING(2, file_set_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileSet::Id& a, const FileSet::Id& b) {
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  PROTO_READER_EQUALS_FIELD(file_set_id_);
  return true;
}

bool Diff(const FileSet::Id& a, const FileSet::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_id_);
  PROTO_READER_DIFF_FIELD(file_set_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, FileSet* out) {
  using classname_ = FileSet;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
    PROTO_READER_CASE_ADD(3, WIRETYPE_LENGTH_DELIMITED, ReadString, add_file_sets)
    PROTO_READER_CASE_MESSAGE_ADD(4, files, ::rs::google::devtools::resultstore::v2::File)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FileSet& a, const FileSet& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_REPEATED(file_sets_);
  PROTO_READER_EQUALS_REPEATED(files_);
  return true;
}

bool Diff(const FileSet& a, const FileSet& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_REPEATED(file_sets_);
  PROTO_READER_DIFF_REPEATED(files_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, LineCoverageSummary* out) {
  using classname_ = LineCoverageSummary;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_instrumented_line_count, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_executed_line_count, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const LineCoverageSummary& a, const LineCoverageSummary& b) {
  PROTO_READER_EQUALS_FIELD(instrumented_line_count_);
  PROTO_READER_EQUALS_FIELD(executed_line_count_);
  return true;
}

bool Diff(const LineCoverageSummary& a, const LineCoverageSummary& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(instrumented_line_count_);
  PROTO_READER_DIFF_FIELD(executed_line_count_);
  return equal;
}

bool ParseFromStream(InputStream& input, BranchCoverageSummary* out) {
  using classname_ = BranchCoverageSummary;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_SET_CAST32(1, WIRETYPE_VARINT, ReadVarint32, set_total_branch_count, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(2, WIRETYPE_VARINT, ReadVarint32, set_executed_branch_count, int32_t, static_cast<int32_t>)
    PROTO_READER_CASE_SET_CAST32(3, WIRETYPE_VARINT, ReadVarint32, set_taken_branch_count, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const BranchCoverageSummary& a, const BranchCoverageSummary& b) {
  PROTO_READER_EQUALS_FIELD(total_branch_count_);
  PROTO_READER_EQUALS_FIELD(executed_branch_count_);
  PROTO_READER_EQUALS_FIELD(taken_branch_count_);
  return true;
}

bool Diff(const BranchCoverageSummary& a, const BranchCoverageSummary& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(total_branch_count_);
  PROTO_READER_DIFF_FIELD(executed_branch_count_);
  PROTO_READER_DIFF_FIELD(taken_branch_count_);
  return equal;
}

bool ParseFromStream(InputStream& input, LanguageCoverageSummary* out) {
  using classname_ = LanguageCoverageSummary;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_language, ::rs::google::devtools::resultstore::v2::Language)
    PROTO_READER_CASE_MESSAGE(2, line_summary)
    PROTO_READER_CASE_MESSAGE(3, branch_summary)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const LanguageCoverageSummary& a, const LanguageCoverageSummary& b) {
  PROTO_READER_EQUALS_FIELD(language_);
  PROTO_READER_EQUALS_FIELD(line_summary_);
  PROTO_READER_EQUALS_FIELD(branch_summary_);
  return true;
}

bool Diff(const LanguageCoverageSummary& a, const LanguageCoverageSummary& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(language_);
  PROTO_READER_DIFF_FIELD(line_summary_);
  PROTO_READER_DIFF_FIELD(branch_summary_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, InvocationAttributes* out) {
  using classname_ = InvocationAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, project_id)
    PROTO_READER_CASE_ADD(2, WIRETYPE_LENGTH_DELIMITED, ReadString, add_users)
    PROTO_READER_CASE_ADD(3, WIRETYPE_LENGTH_DELIMITED, ReadString, add_labels)
    PROTO_READER_CASE_STRING(4, description)
    PROTO_READER_CASE_MESSAGE_ADD(6, invocation_contexts, ::rs::google::devtools::resultstore::v2::InvocationContext)
    PROTO_READER_CASE_SET_CAST32(7, WIRETYPE_VARINT, ReadVarint32, set_exit_code, int32_t, static_cast<int32_t>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const InvocationAttributes& a, const InvocationAttributes& b) {
  PROTO_READER_EQUALS_FIELD(project_id_);
  PROTO_READER_EQUALS_REPEATED(users_);
  PROTO_READER_EQUALS_REPEATED(labels_);
  PROTO_READER_EQUALS_FIELD(description_);
  PROTO_READER_EQUALS_REPEATED(invocation_contexts_);
  PROTO_READER_EQUALS_FIELD(exit_code_);
  return true;
}

bool Diff(const InvocationAttributes& a, const InvocationAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(project_id_);
  PROTO_READER_DIFF_REPEATED(users_);
  PROTO_READER_DIFF_REPEATED(labels_);
  PROTO_READER_DIFF_FIELD(description_);
  PROTO_READER_DIFF_REPEATED(invocation_contexts_);
  PROTO_READER_DIFF_FIELD(exit_code_);
  return equal;
}

bool ParseFromStream(InputStream& input, WorkspaceContext* out) {
  using classname_ = WorkspaceContext;
  PROTO_READER_PARSE_LOOP_BEGIN
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const WorkspaceContext& a, const WorkspaceContext& b) {
  return true;
}

bool Diff(const WorkspaceContext& a, const WorkspaceContext& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  return equal;
}

bool ParseFromStream(InputStream& input, WorkspaceInfo* out) {
  using classname_ = WorkspaceInfo;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, workspace_context)
    PROTO_READER_CASE_STRING(3, hostname)
    PROTO_READER_CASE_STRING(4, working_directory)
    PROTO_READER_CASE_STRING(5, tool_tag)
    PROTO_READER_CASE_MESSAGE_ADD(7, command_lines, ::rs::google::devtools::resultstore::v2::CommandLine)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const WorkspaceInfo& a, const WorkspaceInfo& b) {
  PROTO_READER_EQUALS_FIELD(workspace_context_);
  PROTO_READER_EQUALS_FIELD(hostname_);
  PROTO_READER_EQUALS_FIELD(working_directory_);
  PROTO_READER_EQUALS_FIELD(tool_tag_);
  PROTO_READER_EQUALS_REPEATED(command_lines_);
  return true;
}

bool Diff(const WorkspaceInfo& a, const WorkspaceInfo& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(workspace_context_);
  PROTO_READER_DIFF_FIELD(hostname_);
  PROTO_READER_DIFF_FIELD(working_directory_);
  PROTO_READER_DIFF_FIELD(tool_tag_);
  PROTO_READER_DIFF_REPEATED(command_lines_);
  return equal;
}

bool ParseFromStream(InputStream& input, Invocation::Id* out) {
  using classname_ = Invocation::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, invocation_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Invocation::Id& a, const Invocation::Id& b) {
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  return true;
}

bool Diff(const Invocation::Id& a, const Invocation::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, Invocation* out) {
  using classname_ = Invocation;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
    PROTO_READER_CASE_MESSAGE(3, status_attributes)
    PROTO_READER_CASE_MESSAGE(4, timing)
    PROTO_READER_CASE_MESSAGE(5, invocation_attributes)
    PROTO_READER_CASE_MESSAGE(6, workspace_info)
    PROTO_READER_CASE_MESSAGE_ADD(7, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_MESSAGE_ADD(8, files, ::rs::google::devtools::resultstore::v2::File)
    PROTO_READER_CASE_MESSAGE_ADD(9, coverage_summaries, ::rs::google::devtools::resultstore::v2::LanguageCoverageSummary)
    PROTO_READER_CASE_MESSAGE(10, aggregate_coverage)
    PROTO_READER_CASE_MESSAGE_ADD(11, file_processing_errors, ::rs::google::devtools::resultstore::v2::FileProcessingErrors)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Invocation& a, const Invocation& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(status_attributes_);
  PROTO_READER_EQUALS_FIELD(timing_);
  PROTO_READER_EQUALS_FIELD(invocation_attributes_);
  PROTO_READER_EQUALS_FIELD(workspace_info_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_REPEATED(files_);
  PROTO_READER_EQUALS_REPEATED(coverage_summaries_);
  PROTO_READER_EQUALS_FIELD(aggregate_coverage_);
  PROTO_READER_EQUALS_REPEATED(file_processing_errors_);
  return true;
}

bool Diff(const Invocation& a, const Invocation& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(status_attributes_);
  PROTO_READER_DIFF_FIELD(timing_);
  PROTO_READER_DIFF_FIELD(invocation_attributes_);
  PROTO_READER_DIFF_FIELD(workspace_info_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_REPEATED(files_);
  PROTO_READER_DIFF_REPEATED(coverage_summaries_);
  PROTO_READER_DIFF_FIELD(aggregate_coverage_);
  PROTO_READER_DIFF_REPEATED(file_processing_errors_);
  return equal;
}

bool ParseFromStream(InputStream& input, CommandLine* out) {
  using classname_ = CommandLine;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, label)
    PROTO_READER_CASE_STRING(2, tool)
    PROTO_READER_CASE_ADD(3, WIRETYPE_LENGTH_DELIMITED, ReadString, add_args)
    PROTO_READER_CASE_STRING(4, command)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CommandLine& a, const CommandLine& b) {
  PROTO_READER_EQUALS_FIELD(label_);
  PROTO_READER_EQUALS_FIELD(tool_);
  PROTO_READER_EQUALS_REPEATED(args_);
  PROTO_READER_EQUALS_FIELD(command_);
  return true;
}

bool Diff(const CommandLine& a, const CommandLine& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(label_);
  PROTO_READER_DIFF_FIELD(tool_);
  PROTO_READER_DIFF_REPEATED(args_);
  PROTO_READER_DIFF_FIELD(command_);
  return equal;
}

bool ParseFromStream(InputStream& input, InvocationContext* out) {
  using classname_ = InvocationContext;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, display_name)
    PROTO_READER_CASE_STRING(2, url)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const InvocationContext& a, const InvocationContext& b) {
  PROTO_READER_EQUALS_FIELD(display_name_);
  PROTO_READER_EQUALS_FIELD(url_);
  return true;
}

bool Diff(const InvocationContext& a, const InvocationContext& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(display_name_);
  PROTO_READER_DIFF_FIELD(url_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(TargetType a, TargetType b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool Diff(TestSize a, TestSize b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, TargetAttributes* out) {
  using classname_ = TargetAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_type, ::rs::google::devtools::resultstore::v2::TargetType)
    PROTO_READER_CASE_ENUM(2, set_language, ::rs::google::devtools::resultstore::v2::Language)
    PROTO_READER_CASE_ADD(3, WIRETYPE_LENGTH_DELIMITED, ReadString, add_tags)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TargetAttributes& a, const TargetAttributes& b) {
  PROTO_READER_EQUALS_FIELD(type_);
  PROTO_READER_EQUALS_FIELD(language_);
  PROTO_READER_EQUALS_REPEATED(tags_);
  return true;
}

bool Diff(const TargetAttributes& a, const TargetAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(type_);
  PROTO_READER_DIFF_FIELD(language_);
  PROTO_READER_DIFF_REPEATED(tags_);
  return equal;
}

bool ParseFromStream(InputStream& input, TestAttributes* out) {
  using classname_ = TestAttributes;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ENUM(1, set_size, ::rs::google::devtools::resultstore::v2::TestSize)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TestAttributes& a, const TestAttributes& b) {
  PROTO_READER_EQUALS_FIELD(size_);
  return true;
}

bool Diff(const TestAttributes& a, const TestAttributes& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(size_);
  return equal;
}

bool ParseFromStream(InputStream& input, Target::Id* out) {
  using classname_ = Target::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, invocation_id)
    PROTO_READER_CASE_STRING(2, target_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Target::Id& a, const Target::Id& b) {
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  PROTO_READER_EQUALS_FIELD(target_id_);
  return true;
}

bool Diff(const Target::Id& a, const Target::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_id_);
  PROTO_READER_DIFF_FIELD(target_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, Target* out) {
  using classname_ = Target;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
    PROTO_READER_CASE_MESSAGE(3, status_attributes)
    PROTO_READER_CASE_MESSAGE(4, timing)
    PROTO_READER_CASE_MESSAGE(5, target_attributes)
    PROTO_READER_CASE_MESSAGE(6, test_attributes)
    PROTO_READER_CASE_MESSAGE_ADD(7, properties, ::rs::google::devtools::resultstore::v2::Property)
    PROTO_READER_CASE_MESSAGE_ADD(8, files, ::rs::google::devtools::resultstore::v2::File)
    PROTO_READER_CASE_SET_CAST32(10, WIRETYPE_VARINT, ReadVarint32, set_visible, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Target& a, const Target& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(status_attributes_);
  PROTO_READER_EQUALS_FIELD(timing_);
  PROTO_READER_EQUALS_FIELD(target_attributes_);
  PROTO_READER_EQUALS_FIELD(test_attributes_);
  PROTO_READER_EQUALS_REPEATED(properties_);
  PROTO_READER_EQUALS_REPEATED(files_);
  PROTO_READER_EQUALS_FIELD(visible_);
  return true;
}

bool Diff(const Target& a, const Target& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(status_attributes_);
  PROTO_READER_DIFF_FIELD(timing_);
  PROTO_READER_DIFF_FIELD(target_attributes_);
  PROTO_READER_DIFF_FIELD(test_attributes_);
  PROTO_READER_DIFF_REPEATED(properties_);
  PROTO_READER_DIFF_REPEATED(files_);
  PROTO_READER_DIFF_FIELD(visible_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, UploadMetadata* out) {
  using classname_ = UploadMetadata;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(2, resume_token)
    PROTO_READER_CASE_STRING(3, uploader_state)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UploadMetadata& a, const UploadMetadata& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(resume_token_);
  PROTO_READER_EQUALS_FIELD(uploader_state_);
  return true;
}

bool Diff(const UploadMetadata& a, const UploadMetadata& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(resume_token_);
  PROTO_READER_DIFF_FIELD(uploader_state_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, Empty* out) {
  using classname_ = Empty;
  PROTO_READER_PARSE_LOOP_BEGIN
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const Empty& a, const Empty& b) {
  return true;
}

bool Diff(const Empty& a, const Empty& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  return equal;
}

}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, FieldMask* out) {
  using classname_ = FieldMask;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_ADD(1, WIRETYPE_LENGTH_DELIMITED, ReadString, add_paths)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FieldMask& a, const FieldMask& b) {
  PROTO_READER_EQUALS_REPEATED(paths_);
  return true;
}

bool Diff(const FieldMask& a, const FieldMask& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_REPEATED(paths_);
  return equal;
}

}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, CreateInvocationRequest* out) {
  using classname_ = CreateInvocationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_STRING(2, invocation_id)
    PROTO_READER_CASE_MESSAGE(3, invocation)
    PROTO_READER_CASE_STRING(4, authorization_token)
    PROTO_READER_CASE_MESSAGE(6, auto_finalize_time)
    PROTO_READER_CASE_STRING(7, initial_resume_token)
    PROTO_READER_CASE_STRING(8, uploader_state)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CreateInvocationRequest& a, const CreateInvocationRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(invocation_id_);
  PROTO_READER_EQUALS_FIELD(invocation_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(auto_finalize_time_);
  PROTO_READER_EQUALS_FIELD(initial_resume_token_);
  PROTO_READER_EQUALS_FIELD(uploader_state_);
  return true;
}

bool Diff(const CreateInvocationRequest& a, const CreateInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(invocation_id_);
  PROTO_READER_DIFF_FIELD(invocation_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(auto_finalize_time_);
  PROTO_READER_DIFF_FIELD(initial_resume_token_);
  PROTO_READER_DIFF_FIELD(uploader_state_);
  return equal;
}

bool ParseFromStream(InputStream& input, UpdateInvocationRequest* out) {
  using classname_ = UpdateInvocationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(3, invocation)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UpdateInvocationRequest& a, const UpdateInvocationRequest& b) {
  PROTO_READER_EQUALS_FIELD(invocation_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const UpdateInvocationRequest& a, const UpdateInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(invocation_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, MergeInvocationRequest* out) {
  using classname_ = MergeInvocationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_MESSAGE(3, invocation)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MergeInvocationRequest& a, const MergeInvocationRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(invocation_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const MergeInvocationRequest& a, const MergeInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(invocation_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, TouchInvocationRequest* out) {
  using classname_ = TouchInvocationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(2, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TouchInvocationRequest& a, const TouchInvocationRequest& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const TouchInvocationRequest& a, const TouchInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, TouchInvocationResponse* out) {
  using classname_ = TouchInvocationResponse;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const TouchInvocationResponse& a, const TouchInvocationResponse& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  return true;
}

bool Diff(const TouchInvocationResponse& a, const TouchInvocationResponse& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  return equal;
}

bool ParseFromStream(InputStream& input, DeleteInvocationRequest* out) {
  using classname_ = DeleteInvocationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const DeleteInvocationRequest& a, const DeleteInvocationRequest& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  return true;
}

bool Diff(const DeleteInvocationRequest& a, const DeleteInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  return equal;
}

bool ParseFromStream(InputStream& input, FinalizeInvocationRequest* out) {
  using classname_ = FinalizeInvocationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(3, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FinalizeInvocationRequest& a, const FinalizeInvocationRequest& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const FinalizeInvocationRequest& a, const FinalizeInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, FinalizeInvocationResponse* out) {
  using classname_ = FinalizeInvocationResponse;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FinalizeInvocationResponse& a, const FinalizeInvocationResponse& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  return true;
}

bool Diff(const FinalizeInvocationResponse& a, const FinalizeInvocationResponse& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  return equal;
}

bool ParseFromStream(InputStream& input, CreateTargetRequest* out) {
  using classname_ = CreateTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_STRING(2, parent)
    PROTO_READER_CASE_STRING(3, target_id)
    PROTO_READER_CASE_MESSAGE(4, target)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CreateTargetRequest& a, const CreateTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(parent_);
  PROTO_READER_EQUALS_FIELD(target_id_);
  PROTO_READER_EQUALS_FIELD(target_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const CreateTargetRequest& a, const CreateTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(parent_);
  PROTO_READER_DIFF_FIELD(target_id_);
  PROTO_READER_DIFF_FIELD(target_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, UpdateTargetRequest* out) {
  using classname_ = UpdateTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(3, target)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UpdateTargetRequest& a, const UpdateTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(target_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const UpdateTargetRequest& a, const UpdateTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(target_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, MergeTargetRequest* out) {
  using classname_ = MergeTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_MESSAGE(3, target)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MergeTargetRequest& a, const MergeTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(target_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const MergeTargetRequest& a, const MergeTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(target_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, FinalizeTargetRequest* out) {
  using classname_ = FinalizeTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(3, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FinalizeTargetRequest& a, const FinalizeTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const FinalizeTargetRequest& a, const FinalizeTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, FinalizeTargetResponse* out) {
  using classname_ = FinalizeTargetResponse;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FinalizeTargetResponse& a, const FinalizeTargetResponse& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  return true;
}

bool Diff(const FinalizeTargetResponse& a, const FinalizeTargetResponse& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  return equal;
}

bool ParseFromStream(InputStream& input, CreateConfiguredTargetRequest* out) {
  using classname_ = CreateConfiguredTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_STRING(2, parent)
    PROTO_READER_CASE_STRING(3, config_id)
    PROTO_READER_CASE_MESSAGE(4, configured_target)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CreateConfiguredTargetRequest& a, const CreateConfiguredTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(parent_);
  PROTO_READER_EQUALS_FIELD(config_id_);
  PROTO_READER_EQUALS_FIELD(configured_target_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const CreateConfiguredTargetRequest& a, const CreateConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(parent_);
  PROTO_READER_DIFF_FIELD(config_id_);
  PROTO_READER_DIFF_FIELD(configured_target_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, UpdateConfiguredTargetRequest* out) {
  using classname_ = UpdateConfiguredTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(3, configured_target)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UpdateConfiguredTargetRequest& a, const UpdateConfiguredTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(configured_target_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const UpdateConfiguredTargetRequest& a, const UpdateConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(configured_target_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, MergeConfiguredTargetRequest* out) {
  using classname_ = MergeConfiguredTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_MESSAGE(3, configured_target)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MergeConfiguredTargetRequest& a, const MergeConfiguredTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(configured_target_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const MergeConfiguredTargetRequest& a, const MergeConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(configured_target_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, FinalizeConfiguredTargetRequest* out) {
  using classname_ = FinalizeConfiguredTargetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(3, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FinalizeConfiguredTargetRequest& a, const FinalizeConfiguredTargetRequest& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const FinalizeConfiguredTargetRequest& a, const FinalizeConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, FinalizeConfiguredTargetResponse* out) {
  using classname_ = FinalizeConfiguredTargetResponse;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_MESSAGE(2, id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const FinalizeConfiguredTargetResponse& a, const FinalizeConfiguredTargetResponse& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(id_);
  return true;
}

bool Diff(const FinalizeConfiguredTargetResponse& a, const FinalizeConfiguredTargetResponse& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(id_);
  return equal;
}

bool ParseFromStream(InputStream& input, CreateActionRequest* out) {
  using classname_ = CreateActionRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_STRING(2, parent)
    PROTO_READER_CASE_STRING(3, action_id)
    PROTO_READER_CASE_MESSAGE(4, action)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CreateActionRequest& a, const CreateActionRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(parent_);
  PROTO_READER_EQUALS_FIELD(action_id_);
  PROTO_READER_EQUALS_FIELD(action_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const CreateActionRequest& a, const CreateActionRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(parent_);
  PROTO_READER_DIFF_FIELD(action_id_);
  PROTO_READER_DIFF_FIELD(action_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, UpdateActionRequest* out) {
  using classname_ = UpdateActionRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(3, action)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UpdateActionRequest& a, const UpdateActionRequest& b) {
  PROTO_READER_EQUALS_FIELD(action_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const UpdateActionRequest& a, const UpdateActionRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(action_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, MergeActionRequest* out) {
  using classname_ = MergeActionRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_MESSAGE(3, action)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MergeActionRequest& a, const MergeActionRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(action_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const MergeActionRequest& a, const MergeActionRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(action_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, CreateConfigurationRequest* out) {
  using classname_ = CreateConfigurationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_STRING(2, parent)
    PROTO_READER_CASE_STRING(3, config_id)
    PROTO_READER_CASE_MESSAGE(4, configuration)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CreateConfigurationRequest& a, const CreateConfigurationRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(parent_);
  PROTO_READER_EQUALS_FIELD(config_id_);
  PROTO_READER_EQUALS_FIELD(configuration_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const CreateConfigurationRequest& a, const CreateConfigurationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(parent_);
  PROTO_READER_DIFF_FIELD(config_id_);
  PROTO_READER_DIFF_FIELD(configuration_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, UpdateConfigurationRequest* out) {
  using classname_ = UpdateConfigurationRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(3, configuration)
    PROTO_READER_CASE_MESSAGE(4, update_mask)
    PROTO_READER_CASE_STRING(5, authorization_token)
    PROTO_READER_CASE_SET_CAST32(6, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UpdateConfigurationRequest& a, const UpdateConfigurationRequest& b) {
  PROTO_READER_EQUALS_FIELD(configuration_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const UpdateConfigurationRequest& a, const UpdateConfigurationRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(configuration_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, CreateFileSetRequest* out) {
  using classname_ = CreateFileSetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_STRING(2, parent)
    PROTO_READER_CASE_STRING(3, file_set_id)
    PROTO_READER_CASE_MESSAGE(4, file_set)
    PROTO_READER_CASE_STRING(5, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const CreateFileSetRequest& a, const CreateFileSetRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(parent_);
  PROTO_READER_EQUALS_FIELD(file_set_id_);
  PROTO_READER_EQUALS_FIELD(file_set_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const CreateFileSetRequest& a, const CreateFileSetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(parent_);
  PROTO_READER_DIFF_FIELD(file_set_id_);
  PROTO_READER_DIFF_FIELD(file_set_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

bool ParseFromStream(InputStream& input, UpdateFileSetRequest* out) {
  using classname_ = UpdateFileSetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, file_set)
    PROTO_READER_CASE_MESSAGE(2, update_mask)
    PROTO_READER_CASE_STRING(3, authorization_token)
    PROTO_READER_CASE_SET_CAST32(4, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UpdateFileSetRequest& a, const UpdateFileSetRequest& b) {
  PROTO_READER_EQUALS_FIELD(file_set_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const UpdateFileSetRequest& a, const UpdateFileSetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(file_set_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, MergeFileSetRequest* out) {
  using classname_ = MergeFileSetRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, request_id)
    PROTO_READER_CASE_MESSAGE(2, file_set)
    PROTO_READER_CASE_MESSAGE(3, update_mask)
    PROTO_READER_CASE_STRING(4, authorization_token)
    PROTO_READER_CASE_SET_CAST32(5, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const MergeFileSetRequest& a, const MergeFileSetRequest& b) {
  PROTO_READER_EQUALS_FIELD(request_id_);
  PROTO_READER_EQUALS_FIELD(file_set_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  return true;
}

bool Diff(const MergeFileSetRequest& a, const MergeFileSetRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(request_id_);
  PROTO_READER_DIFF_FIELD(file_set_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  return equal;
}

bool ParseFromStream(InputStream& input, UploadBatchRequest* out) {
  using classname_ = UploadBatchRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, parent)
    PROTO_READER_CASE_STRING(2, authorization_token)
    PROTO_READER_CASE_STRING(3, next_resume_token)
    PROTO_READER_CASE_STRING(4, resume_token)
    PROTO_READER_CASE_STRING(6, uploader_state)
    PROTO_READER_CASE_MESSAGE_ADD(5, upload_requests, ::rs::google::devtools::resultstore::v2::UploadRequest)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UploadBatchRequest& a, const UploadBatchRequest& b) {
  PROTO_READER_EQUALS_FIELD(parent_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  PROTO_READER_EQUALS_FIELD(next_resume_token_);
  PROTO_READER_EQUALS_FIELD(resume_token_);
  PROTO_READER_EQUALS_FIELD(uploader_state_);
  PROTO_READER_EQUALS_REPEATED(upload_requests_);
  return true;
}

bool Diff(const UploadBatchRequest& a, const UploadBatchRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(parent_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  PROTO_READER_DIFF_FIELD(next_resume_token_);
  PROTO_READER_DIFF_FIELD(resume_token_);
  PROTO_READER_DIFF_FIELD(uploader_state_);
  PROTO_READER_DIFF_REPEATED(upload_requests_);
  return equal;
}

bool ParseFromStream(InputStream& input, UploadBatchResponse* out) {
  using classname_ = UploadBatchResponse;
  PROTO_READER_PARSE_LOOP_BEGIN
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UploadBatchResponse& a, const UploadBatchResponse& b) {
  return true;
}

bool Diff(const UploadBatchResponse& a, const UploadBatchResponse& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  return equal;
}

bool Diff(UploadRequest::UploadOperation a, UploadRequest::UploadOperation b, std::vector<std::string>* diffs, const std::string& prefix) {
  if (a == b) return true;
  diffs->push_back(prefix + ": " + std::to_string(static_cast<int>(a)) + " != " + std::to_string(static_cast<int>(b)));
  return false;
}

bool ParseFromStream(InputStream& input, UploadRequest::Id* out) {
  using classname_ = UploadRequest::Id;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, target_id)
    PROTO_READER_CASE_STRING(2, configuration_id)
    PROTO_READER_CASE_STRING(3, action_id)
    PROTO_READER_CASE_STRING(4, file_set_id)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UploadRequest::Id& a, const UploadRequest::Id& b) {
  PROTO_READER_EQUALS_FIELD(target_id_);
  PROTO_READER_EQUALS_FIELD(configuration_id_);
  PROTO_READER_EQUALS_FIELD(action_id_);
  PROTO_READER_EQUALS_FIELD(file_set_id_);
  return true;
}

bool Diff(const UploadRequest::Id& a, const UploadRequest::Id& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(target_id_);
  PROTO_READER_DIFF_FIELD(configuration_id_);
  PROTO_READER_DIFF_FIELD(action_id_);
  PROTO_READER_DIFF_FIELD(file_set_id_);
  return equal;
}

bool ParseFromStream(InputStream& input, UploadRequest* out) {
  using classname_ = UploadRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_MESSAGE(1, id)
    PROTO_READER_CASE_ENUM(2, set_upload_operation, ::rs::google::devtools::resultstore::v2::UploadRequest::UploadOperation)
    PROTO_READER_CASE_MESSAGE(3, update_mask)
    PROTO_READER_CASE_SET_CAST32(10, WIRETYPE_VARINT, ReadVarint32, set_create_if_not_found, bool, static_cast<bool>)
    PROTO_READER_CASE_MESSAGE(4, invocation)
    PROTO_READER_CASE_MESSAGE(5, target)
    PROTO_READER_CASE_MESSAGE(6, configuration)
    PROTO_READER_CASE_MESSAGE(7, configured_target)
    PROTO_READER_CASE_MESSAGE(8, action)
    PROTO_READER_CASE_MESSAGE(9, file_set)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const UploadRequest& a, const UploadRequest& b) {
  PROTO_READER_EQUALS_FIELD(id_);
  PROTO_READER_EQUALS_FIELD(upload_operation_);
  PROTO_READER_EQUALS_FIELD(update_mask_);
  PROTO_READER_EQUALS_FIELD(create_if_not_found_);
  PROTO_READER_EQUALS_FIELD(invocation_);
  PROTO_READER_EQUALS_FIELD(target_);
  PROTO_READER_EQUALS_FIELD(configuration_);
  PROTO_READER_EQUALS_FIELD(configured_target_);
  PROTO_READER_EQUALS_FIELD(action_);
  PROTO_READER_EQUALS_FIELD(file_set_);
  return true;
}

bool Diff(const UploadRequest& a, const UploadRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(id_);
  PROTO_READER_DIFF_FIELD(upload_operation_);
  PROTO_READER_DIFF_FIELD(update_mask_);
  PROTO_READER_DIFF_FIELD(create_if_not_found_);
  PROTO_READER_DIFF_FIELD(invocation_);
  PROTO_READER_DIFF_FIELD(target_);
  PROTO_READER_DIFF_FIELD(configuration_);
  PROTO_READER_DIFF_FIELD(configured_target_);
  PROTO_READER_DIFF_FIELD(action_);
  PROTO_READER_DIFF_FIELD(file_set_);
  return equal;
}

bool ParseFromStream(InputStream& input, GetInvocationUploadMetadataRequest* out) {
  using classname_ = GetInvocationUploadMetadataRequest;
  PROTO_READER_PARSE_LOOP_BEGIN
    PROTO_READER_CASE_STRING(1, name)
    PROTO_READER_CASE_STRING(2, authorization_token)
  PROTO_READER_PARSE_LOOP_END
}
bool operator==(const GetInvocationUploadMetadataRequest& a, const GetInvocationUploadMetadataRequest& b) {
  PROTO_READER_EQUALS_FIELD(name_);
  PROTO_READER_EQUALS_FIELD(authorization_token_);
  return true;
}

bool Diff(const GetInvocationUploadMetadataRequest& a, const GetInvocationUploadMetadataRequest& b, std::vector<std::string>* diffs, const std::string& prefix) {
  using ::Diff;
  bool equal = true;
  PROTO_READER_DIFF_FIELD(name_);
  PROTO_READER_DIFF_FIELD(authorization_token_);
  return equal;
}

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
}  // namespace rs