// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: Alignments.proto

#ifndef PROTOBUF_Alignments_2eproto__INCLUDED
#define PROTOBUF_Alignments_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3000000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3000000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace goby {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_Alignments_2eproto();
void protobuf_AssignDesc_Alignments_2eproto();
void protobuf_ShutdownFile_Alignments_2eproto();

class AlignmentCollection;
class AlignmentEntry;
class AlignmentHeader;
class AlignmentIndex;
class AlignmentTooManyHits;
class AmbiguousLocation;
class IdentifierInfo;
class IdentifierMapping;
class ReadOriginInfo;
class RelatedAlignmentEntry;
class SequenceVariation;

// ===================================================================

class AlignmentCollection : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.AlignmentCollection) */ {
 public:
  AlignmentCollection();
  virtual ~AlignmentCollection();

  AlignmentCollection(const AlignmentCollection& from);

  inline AlignmentCollection& operator=(const AlignmentCollection& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentCollection& default_instance();

  void Swap(AlignmentCollection* other);

  // implements Message ----------------------------------------------

  inline AlignmentCollection* New() const { return New(NULL); }

  AlignmentCollection* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlignmentCollection& from);
  void MergeFrom(const AlignmentCollection& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AlignmentCollection* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .goby.AlignmentEntry alignment_entries = 1;
  int alignment_entries_size() const;
  void clear_alignment_entries();
  static const int kAlignmentEntriesFieldNumber = 1;
  const ::goby::AlignmentEntry& alignment_entries(int index) const;
  ::goby::AlignmentEntry* mutable_alignment_entries(int index);
  ::goby::AlignmentEntry* add_alignment_entries();
  ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >*
      mutable_alignment_entries();
  const ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >&
      alignment_entries() const;

  // @@protoc_insertion_point(class_scope:goby.AlignmentCollection)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry > alignment_entries_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static AlignmentCollection* default_instance_;
};
// -------------------------------------------------------------------

class AlignmentEntry : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.AlignmentEntry) */ {
 public:
  AlignmentEntry();
  virtual ~AlignmentEntry();

  AlignmentEntry(const AlignmentEntry& from);

  inline AlignmentEntry& operator=(const AlignmentEntry& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentEntry& default_instance();

  void Swap(AlignmentEntry* other);

  // implements Message ----------------------------------------------

  inline AlignmentEntry* New() const { return New(NULL); }

  AlignmentEntry* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlignmentEntry& from);
  void MergeFrom(const AlignmentEntry& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AlignmentEntry* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 multiplicity = 7;
  bool has_multiplicity() const;
  void clear_multiplicity();
  static const int kMultiplicityFieldNumber = 7;
  ::google::protobuf::uint32 multiplicity() const;
  void set_multiplicity(::google::protobuf::uint32 value);

  // optional uint32 query_index = 1;
  bool has_query_index() const;
  void clear_query_index();
  static const int kQueryIndexFieldNumber = 1;
  ::google::protobuf::uint32 query_index() const;
  void set_query_index(::google::protobuf::uint32 value);

  // optional uint32 target_index = 2;
  bool has_target_index() const;
  void clear_target_index();
  static const int kTargetIndexFieldNumber = 2;
  ::google::protobuf::uint32 target_index() const;
  void set_target_index(::google::protobuf::uint32 value);

  // optional uint32 position = 3;
  bool has_position() const;
  void clear_position();
  static const int kPositionFieldNumber = 3;
  ::google::protobuf::uint32 position() const;
  void set_position(::google::protobuf::uint32 value);

  // optional bool matching_reverse_strand = 6;
  bool has_matching_reverse_strand() const;
  void clear_matching_reverse_strand();
  static const int kMatchingReverseStrandFieldNumber = 6;
  bool matching_reverse_strand() const;
  void set_matching_reverse_strand(bool value);

  // optional uint32 query_position = 5;
  bool has_query_position() const;
  void clear_query_position();
  static const int kQueryPositionFieldNumber = 5;
  ::google::protobuf::uint32 query_position() const;
  void set_query_position(::google::protobuf::uint32 value);

  // optional float score = 4;
  bool has_score() const;
  void clear_score();
  static const int kScoreFieldNumber = 4;
  float score() const;
  void set_score(float value);

  // optional uint32 number_of_mismatches = 8;
  bool has_number_of_mismatches() const;
  void clear_number_of_mismatches();
  static const int kNumberOfMismatchesFieldNumber = 8;
  ::google::protobuf::uint32 number_of_mismatches() const;
  void set_number_of_mismatches(::google::protobuf::uint32 value);

  // optional uint32 number_of_indels = 9;
  bool has_number_of_indels() const;
  void clear_number_of_indels();
  static const int kNumberOfIndelsFieldNumber = 9;
  ::google::protobuf::uint32 number_of_indels() const;
  void set_number_of_indels(::google::protobuf::uint32 value);

  // optional uint32 query_aligned_length = 11;
  bool has_query_aligned_length() const;
  void clear_query_aligned_length();
  static const int kQueryAlignedLengthFieldNumber = 11;
  ::google::protobuf::uint32 query_aligned_length() const;
  void set_query_aligned_length(::google::protobuf::uint32 value);

  // optional uint32 target_aligned_length = 12;
  bool has_target_aligned_length() const;
  void clear_target_aligned_length();
  static const int kTargetAlignedLengthFieldNumber = 12;
  ::google::protobuf::uint32 target_aligned_length() const;
  void set_target_aligned_length(::google::protobuf::uint32 value);

  // repeated .goby.SequenceVariation sequence_variations = 13;
  int sequence_variations_size() const;
  void clear_sequence_variations();
  static const int kSequenceVariationsFieldNumber = 13;
  const ::goby::SequenceVariation& sequence_variations(int index) const;
  ::goby::SequenceVariation* mutable_sequence_variations(int index);
  ::goby::SequenceVariation* add_sequence_variations();
  ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >*
      mutable_sequence_variations();
  const ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >&
      sequence_variations() const;

  // optional uint32 query_length = 10;
  bool has_query_length() const;
  void clear_query_length();
  static const int kQueryLengthFieldNumber = 10;
  ::google::protobuf::uint32 query_length() const;
  void set_query_length(::google::protobuf::uint32 value);

  // optional int32 mapping_quality = 14;
  bool has_mapping_quality() const;
  void clear_mapping_quality();
  static const int kMappingQualityFieldNumber = 14;
  ::google::protobuf::int32 mapping_quality() const;
  void set_mapping_quality(::google::protobuf::int32 value);

  // optional uint32 pair_flags = 15;
  bool has_pair_flags() const;
  void clear_pair_flags();
  static const int kPairFlagsFieldNumber = 15;
  ::google::protobuf::uint32 pair_flags() const;
  void set_pair_flags(::google::protobuf::uint32 value);

  // optional .goby.RelatedAlignmentEntry pair_alignment_link = 16;
  bool has_pair_alignment_link() const;
  void clear_pair_alignment_link();
  static const int kPairAlignmentLinkFieldNumber = 16;
  const ::goby::RelatedAlignmentEntry& pair_alignment_link() const;
  ::goby::RelatedAlignmentEntry* mutable_pair_alignment_link();
  ::goby::RelatedAlignmentEntry* release_pair_alignment_link();
  void set_allocated_pair_alignment_link(::goby::RelatedAlignmentEntry* pair_alignment_link);

  // optional uint32 fragment_index = 17;
  bool has_fragment_index() const;
  void clear_fragment_index();
  static const int kFragmentIndexFieldNumber = 17;
  ::google::protobuf::uint32 fragment_index() const;
  void set_fragment_index(::google::protobuf::uint32 value);

  // optional .goby.RelatedAlignmentEntry spliced_forward_alignment_link = 18;
  bool has_spliced_forward_alignment_link() const;
  void clear_spliced_forward_alignment_link();
  static const int kSplicedForwardAlignmentLinkFieldNumber = 18;
  const ::goby::RelatedAlignmentEntry& spliced_forward_alignment_link() const;
  ::goby::RelatedAlignmentEntry* mutable_spliced_forward_alignment_link();
  ::goby::RelatedAlignmentEntry* release_spliced_forward_alignment_link();
  void set_allocated_spliced_forward_alignment_link(::goby::RelatedAlignmentEntry* spliced_forward_alignment_link);

  // optional .goby.RelatedAlignmentEntry spliced_backward_alignment_link = 22;
  bool has_spliced_backward_alignment_link() const;
  void clear_spliced_backward_alignment_link();
  static const int kSplicedBackwardAlignmentLinkFieldNumber = 22;
  const ::goby::RelatedAlignmentEntry& spliced_backward_alignment_link() const;
  ::goby::RelatedAlignmentEntry* mutable_spliced_backward_alignment_link();
  ::goby::RelatedAlignmentEntry* release_spliced_backward_alignment_link();
  void set_allocated_spliced_backward_alignment_link(::goby::RelatedAlignmentEntry* spliced_backward_alignment_link);

  // optional uint32 spliced_flags = 19;
  bool has_spliced_flags() const;
  void clear_spliced_flags();
  static const int kSplicedFlagsFieldNumber = 19;
  ::google::protobuf::uint32 spliced_flags() const;
  void set_spliced_flags(::google::protobuf::uint32 value);

  // optional sint32 insert_size = 20;
  bool has_insert_size() const;
  void clear_insert_size();
  static const int kInsertSizeFieldNumber = 20;
  ::google::protobuf::int32 insert_size() const;
  void set_insert_size(::google::protobuf::int32 value);

  // optional uint32 sample_index = 21;
  bool has_sample_index() const;
  void clear_sample_index();
  static const int kSampleIndexFieldNumber = 21;
  ::google::protobuf::uint32 sample_index() const;
  void set_sample_index(::google::protobuf::uint32 value);

  // optional uint32 query_index_occurrences = 25;
  bool has_query_index_occurrences() const;
  void clear_query_index_occurrences();
  static const int kQueryIndexOccurrencesFieldNumber = 25;
  ::google::protobuf::uint32 query_index_occurrences() const;
  void set_query_index_occurrences(::google::protobuf::uint32 value);

  // optional uint32 ambiguity = 27;
  bool has_ambiguity() const;
  void clear_ambiguity();
  static const int kAmbiguityFieldNumber = 27;
  ::google::protobuf::uint32 ambiguity() const;
  void set_ambiguity(::google::protobuf::uint32 value);

  // repeated string bam_attributes = 50;
  int bam_attributes_size() const;
  void clear_bam_attributes();
  static const int kBamAttributesFieldNumber = 50;
  const ::std::string& bam_attributes(int index) const;
  ::std::string* mutable_bam_attributes(int index);
  void set_bam_attributes(int index, const ::std::string& value);
  void set_bam_attributes(int index, const char* value);
  void set_bam_attributes(int index, const char* value, size_t size);
  ::std::string* add_bam_attributes();
  void add_bam_attributes(const ::std::string& value);
  void add_bam_attributes(const char* value);
  void add_bam_attributes(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& bam_attributes() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_bam_attributes();

  // optional bytes read_quality_scores = 55;
  bool has_read_quality_scores() const;
  void clear_read_quality_scores();
  static const int kReadQualityScoresFieldNumber = 55;
  const ::std::string& read_quality_scores() const;
  void set_read_quality_scores(const ::std::string& value);
  void set_read_quality_scores(const char* value);
  void set_read_quality_scores(const void* value, size_t size);
  ::std::string* mutable_read_quality_scores();
  ::std::string* release_read_quality_scores();
  void set_allocated_read_quality_scores(::std::string* read_quality_scores);

  // optional uint32 read_origin_index = 26;
  bool has_read_origin_index() const;
  void clear_read_origin_index();
  static const int kReadOriginIndexFieldNumber = 26;
  ::google::protobuf::uint32 read_origin_index() const;
  void set_read_origin_index(::google::protobuf::uint32 value);

  // optional string softClippedBasesLeft = 30;
  bool has_softclippedbasesleft() const;
  void clear_softclippedbasesleft();
  static const int kSoftClippedBasesLeftFieldNumber = 30;
  const ::std::string& softclippedbasesleft() const;
  void set_softclippedbasesleft(const ::std::string& value);
  void set_softclippedbasesleft(const char* value);
  void set_softclippedbasesleft(const char* value, size_t size);
  ::std::string* mutable_softclippedbasesleft();
  ::std::string* release_softclippedbasesleft();
  void set_allocated_softclippedbasesleft(::std::string* softclippedbasesleft);

  // optional string softClippedBasesRight = 31;
  bool has_softclippedbasesright() const;
  void clear_softclippedbasesright();
  static const int kSoftClippedBasesRightFieldNumber = 31;
  const ::std::string& softclippedbasesright() const;
  void set_softclippedbasesright(const ::std::string& value);
  void set_softclippedbasesright(const char* value);
  void set_softclippedbasesright(const char* value, size_t size);
  ::std::string* mutable_softclippedbasesright();
  ::std::string* release_softclippedbasesright();
  void set_allocated_softclippedbasesright(::std::string* softclippedbasesright);

  // optional bytes softClippedQualityLeft = 32;
  bool has_softclippedqualityleft() const;
  void clear_softclippedqualityleft();
  static const int kSoftClippedQualityLeftFieldNumber = 32;
  const ::std::string& softclippedqualityleft() const;
  void set_softclippedqualityleft(const ::std::string& value);
  void set_softclippedqualityleft(const char* value);
  void set_softclippedqualityleft(const void* value, size_t size);
  ::std::string* mutable_softclippedqualityleft();
  ::std::string* release_softclippedqualityleft();
  void set_allocated_softclippedqualityleft(::std::string* softclippedqualityleft);

  // optional bytes softClippedQualityRight = 33;
  bool has_softclippedqualityright() const;
  void clear_softclippedqualityright();
  static const int kSoftClippedQualityRightFieldNumber = 33;
  const ::std::string& softclippedqualityright() const;
  void set_softclippedqualityright(const ::std::string& value);
  void set_softclippedqualityright(const char* value);
  void set_softclippedqualityright(const void* value, size_t size);
  ::std::string* mutable_softclippedqualityright();
  ::std::string* release_softclippedqualityright();
  void set_allocated_softclippedqualityright(::std::string* softclippedqualityright);

  // optional string placedUnmappedSequence = 40;
  bool has_placedunmappedsequence() const;
  void clear_placedunmappedsequence();
  static const int kPlacedUnmappedSequenceFieldNumber = 40;
  const ::std::string& placedunmappedsequence() const;
  void set_placedunmappedsequence(const ::std::string& value);
  void set_placedunmappedsequence(const char* value);
  void set_placedunmappedsequence(const char* value, size_t size);
  ::std::string* mutable_placedunmappedsequence();
  ::std::string* release_placedunmappedsequence();
  void set_allocated_placedunmappedsequence(::std::string* placedunmappedsequence);

  // optional bytes placedUnmappedQuality = 41;
  bool has_placedunmappedquality() const;
  void clear_placedunmappedquality();
  static const int kPlacedUnmappedQualityFieldNumber = 41;
  const ::std::string& placedunmappedquality() const;
  void set_placedunmappedquality(const ::std::string& value);
  void set_placedunmappedquality(const char* value);
  void set_placedunmappedquality(const void* value, size_t size);
  ::std::string* mutable_placedunmappedquality();
  ::std::string* release_placedunmappedquality();
  void set_allocated_placedunmappedquality(::std::string* placedunmappedquality);

  // optional string readName = 42;
  bool has_readname() const;
  void clear_readname();
  static const int kReadNameFieldNumber = 42;
  const ::std::string& readname() const;
  void set_readname(const ::std::string& value);
  void set_readname(const char* value);
  void set_readname(const char* value, size_t size);
  ::std::string* mutable_readname();
  ::std::string* release_readname();
  void set_allocated_readname(::std::string* readname);

  // @@protoc_insertion_point(class_scope:goby.AlignmentEntry)
 private:
  inline void set_has_multiplicity();
  inline void clear_has_multiplicity();
  inline void set_has_query_index();
  inline void clear_has_query_index();
  inline void set_has_target_index();
  inline void clear_has_target_index();
  inline void set_has_position();
  inline void clear_has_position();
  inline void set_has_matching_reverse_strand();
  inline void clear_has_matching_reverse_strand();
  inline void set_has_query_position();
  inline void clear_has_query_position();
  inline void set_has_score();
  inline void clear_has_score();
  inline void set_has_number_of_mismatches();
  inline void clear_has_number_of_mismatches();
  inline void set_has_number_of_indels();
  inline void clear_has_number_of_indels();
  inline void set_has_query_aligned_length();
  inline void clear_has_query_aligned_length();
  inline void set_has_target_aligned_length();
  inline void clear_has_target_aligned_length();
  inline void set_has_query_length();
  inline void clear_has_query_length();
  inline void set_has_mapping_quality();
  inline void clear_has_mapping_quality();
  inline void set_has_pair_flags();
  inline void clear_has_pair_flags();
  inline void set_has_pair_alignment_link();
  inline void clear_has_pair_alignment_link();
  inline void set_has_fragment_index();
  inline void clear_has_fragment_index();
  inline void set_has_spliced_forward_alignment_link();
  inline void clear_has_spliced_forward_alignment_link();
  inline void set_has_spliced_backward_alignment_link();
  inline void clear_has_spliced_backward_alignment_link();
  inline void set_has_spliced_flags();
  inline void clear_has_spliced_flags();
  inline void set_has_insert_size();
  inline void clear_has_insert_size();
  inline void set_has_sample_index();
  inline void clear_has_sample_index();
  inline void set_has_query_index_occurrences();
  inline void clear_has_query_index_occurrences();
  inline void set_has_ambiguity();
  inline void clear_has_ambiguity();
  inline void set_has_read_quality_scores();
  inline void clear_has_read_quality_scores();
  inline void set_has_read_origin_index();
  inline void clear_has_read_origin_index();
  inline void set_has_softclippedbasesleft();
  inline void clear_has_softclippedbasesleft();
  inline void set_has_softclippedbasesright();
  inline void clear_has_softclippedbasesright();
  inline void set_has_softclippedqualityleft();
  inline void clear_has_softclippedqualityleft();
  inline void set_has_softclippedqualityright();
  inline void clear_has_softclippedqualityright();
  inline void set_has_placedunmappedsequence();
  inline void clear_has_placedunmappedsequence();
  inline void set_has_placedunmappedquality();
  inline void clear_has_placedunmappedquality();
  inline void set_has_readname();
  inline void clear_has_readname();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[2];
  ::google::protobuf::uint32 multiplicity_;
  ::google::protobuf::uint32 query_index_;
  ::google::protobuf::uint32 target_index_;
  ::google::protobuf::uint32 position_;
  bool matching_reverse_strand_;
  ::google::protobuf::uint32 query_position_;
  float score_;
  ::google::protobuf::uint32 number_of_mismatches_;
  ::google::protobuf::uint32 number_of_indels_;
  ::google::protobuf::uint32 query_aligned_length_;
  ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation > sequence_variations_;
  ::google::protobuf::uint32 target_aligned_length_;
  ::google::protobuf::uint32 query_length_;
  ::google::protobuf::int32 mapping_quality_;
  ::google::protobuf::uint32 pair_flags_;
  ::goby::RelatedAlignmentEntry* pair_alignment_link_;
  ::goby::RelatedAlignmentEntry* spliced_forward_alignment_link_;
  ::google::protobuf::uint32 fragment_index_;
  ::google::protobuf::uint32 spliced_flags_;
  ::goby::RelatedAlignmentEntry* spliced_backward_alignment_link_;
  ::google::protobuf::int32 insert_size_;
  ::google::protobuf::uint32 sample_index_;
  ::google::protobuf::uint32 query_index_occurrences_;
  ::google::protobuf::uint32 ambiguity_;
  ::google::protobuf::RepeatedPtrField< ::std::string> bam_attributes_;
  ::google::protobuf::internal::ArenaStringPtr read_quality_scores_;
  ::google::protobuf::internal::ArenaStringPtr softclippedbasesleft_;
  ::google::protobuf::internal::ArenaStringPtr softclippedbasesright_;
  ::google::protobuf::internal::ArenaStringPtr softclippedqualityleft_;
  ::google::protobuf::internal::ArenaStringPtr softclippedqualityright_;
  ::google::protobuf::internal::ArenaStringPtr placedunmappedsequence_;
  ::google::protobuf::internal::ArenaStringPtr placedunmappedquality_;
  ::google::protobuf::internal::ArenaStringPtr readname_;
  ::google::protobuf::uint32 read_origin_index_;
  mutable int _cached_size_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static AlignmentEntry* default_instance_;
};
// -------------------------------------------------------------------

class RelatedAlignmentEntry : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.RelatedAlignmentEntry) */ {
 public:
  RelatedAlignmentEntry();
  virtual ~RelatedAlignmentEntry();

  RelatedAlignmentEntry(const RelatedAlignmentEntry& from);

  inline RelatedAlignmentEntry& operator=(const RelatedAlignmentEntry& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RelatedAlignmentEntry& default_instance();

  void Swap(RelatedAlignmentEntry* other);

  // implements Message ----------------------------------------------

  inline RelatedAlignmentEntry* New() const { return New(NULL); }

  RelatedAlignmentEntry* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RelatedAlignmentEntry& from);
  void MergeFrom(const RelatedAlignmentEntry& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RelatedAlignmentEntry* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 target_index = 1;
  bool has_target_index() const;
  void clear_target_index();
  static const int kTargetIndexFieldNumber = 1;
  ::google::protobuf::uint32 target_index() const;
  void set_target_index(::google::protobuf::uint32 value);

  // optional uint32 position = 2;
  bool has_position() const;
  void clear_position();
  static const int kPositionFieldNumber = 2;
  ::google::protobuf::uint32 position() const;
  void set_position(::google::protobuf::uint32 value);

  // optional uint32 fragment_index = 3;
  bool has_fragment_index() const;
  void clear_fragment_index();
  static const int kFragmentIndexFieldNumber = 3;
  ::google::protobuf::uint32 fragment_index() const;
  void set_fragment_index(::google::protobuf::uint32 value);

  // optional uint32 optimized_index = 50;
  bool has_optimized_index() const;
  void clear_optimized_index();
  static const int kOptimizedIndexFieldNumber = 50;
  ::google::protobuf::uint32 optimized_index() const;
  void set_optimized_index(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:goby.RelatedAlignmentEntry)
 private:
  inline void set_has_target_index();
  inline void clear_has_target_index();
  inline void set_has_position();
  inline void clear_has_position();
  inline void set_has_fragment_index();
  inline void clear_has_fragment_index();
  inline void set_has_optimized_index();
  inline void clear_has_optimized_index();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 target_index_;
  ::google::protobuf::uint32 position_;
  ::google::protobuf::uint32 fragment_index_;
  ::google::protobuf::uint32 optimized_index_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static RelatedAlignmentEntry* default_instance_;
};
// -------------------------------------------------------------------

class SequenceVariation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.SequenceVariation) */ {
 public:
  SequenceVariation();
  virtual ~SequenceVariation();

  SequenceVariation(const SequenceVariation& from);

  inline SequenceVariation& operator=(const SequenceVariation& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SequenceVariation& default_instance();

  void Swap(SequenceVariation* other);

  // implements Message ----------------------------------------------

  inline SequenceVariation* New() const { return New(NULL); }

  SequenceVariation* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SequenceVariation& from);
  void MergeFrom(const SequenceVariation& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SequenceVariation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string from = 2;
  bool has_from() const;
  void clear_from();
  static const int kFromFieldNumber = 2;
  const ::std::string& from() const;
  void set_from(const ::std::string& value);
  void set_from(const char* value);
  void set_from(const char* value, size_t size);
  ::std::string* mutable_from();
  ::std::string* release_from();
  void set_allocated_from(::std::string* from);

  // optional string to = 1;
  bool has_to() const;
  void clear_to();
  static const int kToFieldNumber = 1;
  const ::std::string& to() const;
  void set_to(const ::std::string& value);
  void set_to(const char* value);
  void set_to(const char* value, size_t size);
  ::std::string* mutable_to();
  ::std::string* release_to();
  void set_allocated_to(::std::string* to);

  // optional uint32 position = 3;
  bool has_position() const;
  void clear_position();
  static const int kPositionFieldNumber = 3;
  ::google::protobuf::uint32 position() const;
  void set_position(::google::protobuf::uint32 value);

  // optional uint32 read_index = 5;
  bool has_read_index() const;
  void clear_read_index();
  static const int kReadIndexFieldNumber = 5;
  ::google::protobuf::uint32 read_index() const;
  void set_read_index(::google::protobuf::uint32 value);

  // optional bytes to_quality = 4;
  bool has_to_quality() const;
  void clear_to_quality();
  static const int kToQualityFieldNumber = 4;
  const ::std::string& to_quality() const;
  void set_to_quality(const ::std::string& value);
  void set_to_quality(const char* value);
  void set_to_quality(const void* value, size_t size);
  ::std::string* mutable_to_quality();
  ::std::string* release_to_quality();
  void set_allocated_to_quality(::std::string* to_quality);

  // @@protoc_insertion_point(class_scope:goby.SequenceVariation)
 private:
  inline void set_has_from();
  inline void clear_has_from();
  inline void set_has_to();
  inline void clear_has_to();
  inline void set_has_position();
  inline void clear_has_position();
  inline void set_has_read_index();
  inline void clear_has_read_index();
  inline void set_has_to_quality();
  inline void clear_has_to_quality();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr from_;
  ::google::protobuf::internal::ArenaStringPtr to_;
  ::google::protobuf::uint32 position_;
  ::google::protobuf::uint32 read_index_;
  ::google::protobuf::internal::ArenaStringPtr to_quality_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static SequenceVariation* default_instance_;
};
// -------------------------------------------------------------------

class AlignmentHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.AlignmentHeader) */ {
 public:
  AlignmentHeader();
  virtual ~AlignmentHeader();

  AlignmentHeader(const AlignmentHeader& from);

  inline AlignmentHeader& operator=(const AlignmentHeader& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentHeader& default_instance();

  void Swap(AlignmentHeader* other);

  // implements Message ----------------------------------------------

  inline AlignmentHeader* New() const { return New(NULL); }

  AlignmentHeader* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlignmentHeader& from);
  void MergeFrom(const AlignmentHeader& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AlignmentHeader* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 smallest_split_query_index = 9;
  bool has_smallest_split_query_index() const;
  void clear_smallest_split_query_index();
  static const int kSmallestSplitQueryIndexFieldNumber = 9;
  ::google::protobuf::uint32 smallest_split_query_index() const;
  void set_smallest_split_query_index(::google::protobuf::uint32 value);

  // optional uint32 largest_split_query_index = 11;
  bool has_largest_split_query_index() const;
  void clear_largest_split_query_index();
  static const int kLargestSplitQueryIndexFieldNumber = 11;
  ::google::protobuf::uint32 largest_split_query_index() const;
  void set_largest_split_query_index(::google::protobuf::uint32 value);

  // optional .goby.IdentifierMapping query_name_mapping = 1;
  bool has_query_name_mapping() const;
  void clear_query_name_mapping();
  static const int kQueryNameMappingFieldNumber = 1;
  const ::goby::IdentifierMapping& query_name_mapping() const;
  ::goby::IdentifierMapping* mutable_query_name_mapping();
  ::goby::IdentifierMapping* release_query_name_mapping();
  void set_allocated_query_name_mapping(::goby::IdentifierMapping* query_name_mapping);

  // optional .goby.IdentifierMapping target_name_mapping = 2;
  bool has_target_name_mapping() const;
  void clear_target_name_mapping();
  static const int kTargetNameMappingFieldNumber = 2;
  const ::goby::IdentifierMapping& target_name_mapping() const;
  ::goby::IdentifierMapping* mutable_target_name_mapping();
  ::goby::IdentifierMapping* release_target_name_mapping();
  void set_allocated_target_name_mapping(::goby::IdentifierMapping* target_name_mapping);

  // optional uint32 number_of_queries = 5;
  bool has_number_of_queries() const;
  void clear_number_of_queries();
  static const int kNumberOfQueriesFieldNumber = 5;
  ::google::protobuf::uint32 number_of_queries() const;
  void set_number_of_queries(::google::protobuf::uint32 value);

  // optional uint32 number_of_targets = 6;
  bool has_number_of_targets() const;
  void clear_number_of_targets();
  static const int kNumberOfTargetsFieldNumber = 6;
  ::google::protobuf::uint32 number_of_targets() const;
  void set_number_of_targets(::google::protobuf::uint32 value);

  // optional uint32 number_of_aligned_reads = 7;
  bool has_number_of_aligned_reads() const;
  void clear_number_of_aligned_reads();
  static const int kNumberOfAlignedReadsFieldNumber = 7;
  ::google::protobuf::uint32 number_of_aligned_reads() const;
  void set_number_of_aligned_reads(::google::protobuf::uint32 value);

  // repeated uint32 query_length = 3 [deprecated = true];
  GOOGLE_PROTOBUF_DEPRECATED_ATTR int query_length_size() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_query_length();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kQueryLengthFieldNumber = 3;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::uint32 query_length(int index) const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_query_length(int index, ::google::protobuf::uint32 value);
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void add_query_length(::google::protobuf::uint32 value);
  GOOGLE_PROTOBUF_DEPRECATED_ATTR const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      query_length() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_query_length();

  // optional uint32 constant_query_length = 10;
  bool has_constant_query_length() const;
  void clear_constant_query_length();
  static const int kConstantQueryLengthFieldNumber = 10;
  ::google::protobuf::uint32 constant_query_length() const;
  void set_constant_query_length(::google::protobuf::uint32 value);

  // repeated uint32 target_length = 8;
  int target_length_size() const;
  void clear_target_length();
  static const int kTargetLengthFieldNumber = 8;
  ::google::protobuf::uint32 target_length(int index) const;
  void set_target_length(int index, ::google::protobuf::uint32 value);
  void add_target_length(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      target_length() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_target_length();

  // optional bool sorted = 13;
  bool has_sorted() const;
  void clear_sorted();
  static const int kSortedFieldNumber = 13;
  bool sorted() const;
  void set_sorted(bool value);

  // optional bool indexed = 14;
  bool has_indexed() const;
  void clear_indexed();
  static const int kIndexedFieldNumber = 14;
  bool indexed() const;
  void set_indexed(bool value);

  // optional bool query_lengths_stored_in_entries = 15;
  bool has_query_lengths_stored_in_entries() const;
  void clear_query_lengths_stored_in_entries();
  static const int kQueryLengthsStoredInEntriesFieldNumber = 15;
  bool query_lengths_stored_in_entries() const;
  void set_query_lengths_stored_in_entries(bool value);

  // optional string aligner_name = 17;
  bool has_aligner_name() const;
  void clear_aligner_name();
  static const int kAlignerNameFieldNumber = 17;
  const ::std::string& aligner_name() const;
  void set_aligner_name(const ::std::string& value);
  void set_aligner_name(const char* value);
  void set_aligner_name(const char* value, size_t size);
  ::std::string* mutable_aligner_name();
  ::std::string* release_aligner_name();
  void set_allocated_aligner_name(::std::string* aligner_name);

  // optional string aligner_version = 18;
  bool has_aligner_version() const;
  void clear_aligner_version();
  static const int kAlignerVersionFieldNumber = 18;
  const ::std::string& aligner_version() const;
  void set_aligner_version(const ::std::string& value);
  void set_aligner_version(const char* value);
  void set_aligner_version(const char* value, size_t size);
  ::std::string* mutable_aligner_version();
  ::std::string* release_aligner_version();
  void set_allocated_aligner_version(::std::string* aligner_version);

  // optional string version = 25;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 25;
  const ::std::string& version() const;
  void set_version(const ::std::string& value);
  void set_version(const char* value);
  void set_version(const char* value, size_t size);
  ::std::string* mutable_version();
  ::std::string* release_version();
  void set_allocated_version(::std::string* version);

  // repeated string sample_basename = 30;
  int sample_basename_size() const;
  void clear_sample_basename();
  static const int kSampleBasenameFieldNumber = 30;
  const ::std::string& sample_basename(int index) const;
  ::std::string* mutable_sample_basename(int index);
  void set_sample_basename(int index, const ::std::string& value);
  void set_sample_basename(int index, const char* value);
  void set_sample_basename(int index, const char* value, size_t size);
  ::std::string* add_sample_basename();
  void add_sample_basename(const ::std::string& value);
  void add_sample_basename(const char* value);
  void add_sample_basename(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& sample_basename() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_sample_basename();

  // optional bool query_indices_were_permuted = 26;
  bool has_query_indices_were_permuted() const;
  void clear_query_indices_were_permuted();
  static const int kQueryIndicesWerePermutedFieldNumber = 26;
  bool query_indices_were_permuted() const;
  void set_query_indices_were_permuted(bool value);

  // optional bool query_index_occurrences = 35;
  bool has_query_index_occurrences() const;
  void clear_query_index_occurrences();
  static const int kQueryIndexOccurrencesFieldNumber = 35;
  bool query_index_occurrences() const;
  void set_query_index_occurrences(bool value);

  // optional bool ambiguity_stored_in_entries = 36;
  bool has_ambiguity_stored_in_entries() const;
  void clear_ambiguity_stored_in_entries();
  static const int kAmbiguityStoredInEntriesFieldNumber = 36;
  bool ambiguity_stored_in_entries() const;
  void set_ambiguity_stored_in_entries(bool value);

  // optional bool all_read_quality_scores = 40;
  bool has_all_read_quality_scores() const;
  void clear_all_read_quality_scores();
  static const int kAllReadQualityScoresFieldNumber = 40;
  bool all_read_quality_scores() const;
  void set_all_read_quality_scores(bool value);

  // repeated .goby.ReadOriginInfo read_origin = 27;
  int read_origin_size() const;
  void clear_read_origin();
  static const int kReadOriginFieldNumber = 27;
  const ::goby::ReadOriginInfo& read_origin(int index) const;
  ::goby::ReadOriginInfo* mutable_read_origin(int index);
  ::goby::ReadOriginInfo* add_read_origin();
  ::google::protobuf::RepeatedPtrField< ::goby::ReadOriginInfo >*
      mutable_read_origin();
  const ::google::protobuf::RepeatedPtrField< ::goby::ReadOriginInfo >&
      read_origin() const;

  // @@protoc_insertion_point(class_scope:goby.AlignmentHeader)
 private:
  inline void set_has_smallest_split_query_index();
  inline void clear_has_smallest_split_query_index();
  inline void set_has_largest_split_query_index();
  inline void clear_has_largest_split_query_index();
  inline void set_has_query_name_mapping();
  inline void clear_has_query_name_mapping();
  inline void set_has_target_name_mapping();
  inline void clear_has_target_name_mapping();
  inline void set_has_number_of_queries();
  inline void clear_has_number_of_queries();
  inline void set_has_number_of_targets();
  inline void clear_has_number_of_targets();
  inline void set_has_number_of_aligned_reads();
  inline void clear_has_number_of_aligned_reads();
  inline void set_has_constant_query_length();
  inline void clear_has_constant_query_length();
  inline void set_has_sorted();
  inline void clear_has_sorted();
  inline void set_has_indexed();
  inline void clear_has_indexed();
  inline void set_has_query_lengths_stored_in_entries();
  inline void clear_has_query_lengths_stored_in_entries();
  inline void set_has_aligner_name();
  inline void clear_has_aligner_name();
  inline void set_has_aligner_version();
  inline void clear_has_aligner_version();
  inline void set_has_version();
  inline void clear_has_version();
  inline void set_has_query_indices_were_permuted();
  inline void clear_has_query_indices_were_permuted();
  inline void set_has_query_index_occurrences();
  inline void clear_has_query_index_occurrences();
  inline void set_has_ambiguity_stored_in_entries();
  inline void clear_has_ambiguity_stored_in_entries();
  inline void set_has_all_read_quality_scores();
  inline void clear_has_all_read_quality_scores();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 smallest_split_query_index_;
  ::google::protobuf::uint32 largest_split_query_index_;
  ::goby::IdentifierMapping* query_name_mapping_;
  ::goby::IdentifierMapping* target_name_mapping_;
  ::google::protobuf::uint32 number_of_queries_;
  ::google::protobuf::uint32 number_of_targets_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > query_length_;
  ::google::protobuf::uint32 number_of_aligned_reads_;
  ::google::protobuf::uint32 constant_query_length_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > target_length_;
  ::google::protobuf::internal::ArenaStringPtr aligner_name_;
  ::google::protobuf::internal::ArenaStringPtr aligner_version_;
  ::google::protobuf::internal::ArenaStringPtr version_;
  bool sorted_;
  bool indexed_;
  bool query_lengths_stored_in_entries_;
  bool query_indices_were_permuted_;
  bool query_index_occurrences_;
  bool ambiguity_stored_in_entries_;
  bool all_read_quality_scores_;
  ::google::protobuf::RepeatedPtrField< ::std::string> sample_basename_;
  ::google::protobuf::RepeatedPtrField< ::goby::ReadOriginInfo > read_origin_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static AlignmentHeader* default_instance_;
};
// -------------------------------------------------------------------

class IdentifierMapping : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.IdentifierMapping) */ {
 public:
  IdentifierMapping();
  virtual ~IdentifierMapping();

  IdentifierMapping(const IdentifierMapping& from);

  inline IdentifierMapping& operator=(const IdentifierMapping& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const IdentifierMapping& default_instance();

  void Swap(IdentifierMapping* other);

  // implements Message ----------------------------------------------

  inline IdentifierMapping* New() const { return New(NULL); }

  IdentifierMapping* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const IdentifierMapping& from);
  void MergeFrom(const IdentifierMapping& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(IdentifierMapping* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .goby.IdentifierInfo mappings = 1;
  int mappings_size() const;
  void clear_mappings();
  static const int kMappingsFieldNumber = 1;
  const ::goby::IdentifierInfo& mappings(int index) const;
  ::goby::IdentifierInfo* mutable_mappings(int index);
  ::goby::IdentifierInfo* add_mappings();
  ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >*
      mutable_mappings();
  const ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >&
      mappings() const;

  // @@protoc_insertion_point(class_scope:goby.IdentifierMapping)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo > mappings_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static IdentifierMapping* default_instance_;
};
// -------------------------------------------------------------------

class IdentifierInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.IdentifierInfo) */ {
 public:
  IdentifierInfo();
  virtual ~IdentifierInfo();

  IdentifierInfo(const IdentifierInfo& from);

  inline IdentifierInfo& operator=(const IdentifierInfo& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const IdentifierInfo& default_instance();

  void Swap(IdentifierInfo* other);

  // implements Message ----------------------------------------------

  inline IdentifierInfo* New() const { return New(NULL); }

  IdentifierInfo* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const IdentifierInfo& from);
  void MergeFrom(const IdentifierInfo& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(IdentifierInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // required uint32 index = 2;
  bool has_index() const;
  void clear_index();
  static const int kIndexFieldNumber = 2;
  ::google::protobuf::uint32 index() const;
  void set_index(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:goby.IdentifierInfo)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_index();
  inline void clear_has_index();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::uint32 index_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static IdentifierInfo* default_instance_;
};
// -------------------------------------------------------------------

class ReadOriginInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.ReadOriginInfo) */ {
 public:
  ReadOriginInfo();
  virtual ~ReadOriginInfo();

  ReadOriginInfo(const ReadOriginInfo& from);

  inline ReadOriginInfo& operator=(const ReadOriginInfo& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ReadOriginInfo& default_instance();

  void Swap(ReadOriginInfo* other);

  // implements Message ----------------------------------------------

  inline ReadOriginInfo* New() const { return New(NULL); }

  ReadOriginInfo* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ReadOriginInfo& from);
  void MergeFrom(const ReadOriginInfo& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReadOriginInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 origin_index = 1;
  bool has_origin_index() const;
  void clear_origin_index();
  static const int kOriginIndexFieldNumber = 1;
  ::google::protobuf::uint32 origin_index() const;
  void set_origin_index(::google::protobuf::uint32 value);

  // required string origin_id = 2;
  bool has_origin_id() const;
  void clear_origin_id();
  static const int kOriginIdFieldNumber = 2;
  const ::std::string& origin_id() const;
  void set_origin_id(const ::std::string& value);
  void set_origin_id(const char* value);
  void set_origin_id(const char* value, size_t size);
  ::std::string* mutable_origin_id();
  ::std::string* release_origin_id();
  void set_allocated_origin_id(::std::string* origin_id);

  // optional string sample = 4;
  bool has_sample() const;
  void clear_sample();
  static const int kSampleFieldNumber = 4;
  const ::std::string& sample() const;
  void set_sample(const ::std::string& value);
  void set_sample(const char* value);
  void set_sample(const char* value, size_t size);
  ::std::string* mutable_sample();
  ::std::string* release_sample();
  void set_allocated_sample(::std::string* sample);

  // optional string platform = 5;
  bool has_platform() const;
  void clear_platform();
  static const int kPlatformFieldNumber = 5;
  const ::std::string& platform() const;
  void set_platform(const ::std::string& value);
  void set_platform(const char* value);
  void set_platform(const char* value, size_t size);
  ::std::string* mutable_platform();
  ::std::string* release_platform();
  void set_allocated_platform(::std::string* platform);

  // optional string library = 8;
  bool has_library() const;
  void clear_library();
  static const int kLibraryFieldNumber = 8;
  const ::std::string& library() const;
  void set_library(const ::std::string& value);
  void set_library(const char* value);
  void set_library(const char* value, size_t size);
  ::std::string* mutable_library();
  ::std::string* release_library();
  void set_allocated_library(::std::string* library);

  // optional string platform_unit = 12;
  bool has_platform_unit() const;
  void clear_platform_unit();
  static const int kPlatformUnitFieldNumber = 12;
  const ::std::string& platform_unit() const;
  void set_platform_unit(const ::std::string& value);
  void set_platform_unit(const char* value);
  void set_platform_unit(const char* value, size_t size);
  ::std::string* mutable_platform_unit();
  ::std::string* release_platform_unit();
  void set_allocated_platform_unit(::std::string* platform_unit);

  // optional string run_date = 6;
  bool has_run_date() const;
  void clear_run_date();
  static const int kRunDateFieldNumber = 6;
  const ::std::string& run_date() const;
  void set_run_date(const ::std::string& value);
  void set_run_date(const char* value);
  void set_run_date(const char* value, size_t size);
  ::std::string* mutable_run_date();
  ::std::string* release_run_date();
  void set_allocated_run_date(::std::string* run_date);

  // @@protoc_insertion_point(class_scope:goby.ReadOriginInfo)
 private:
  inline void set_has_origin_index();
  inline void clear_has_origin_index();
  inline void set_has_origin_id();
  inline void clear_has_origin_id();
  inline void set_has_sample();
  inline void clear_has_sample();
  inline void set_has_platform();
  inline void clear_has_platform();
  inline void set_has_library();
  inline void clear_has_library();
  inline void set_has_platform_unit();
  inline void clear_has_platform_unit();
  inline void set_has_run_date();
  inline void clear_has_run_date();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr origin_id_;
  ::google::protobuf::internal::ArenaStringPtr sample_;
  ::google::protobuf::internal::ArenaStringPtr platform_;
  ::google::protobuf::internal::ArenaStringPtr library_;
  ::google::protobuf::internal::ArenaStringPtr platform_unit_;
  ::google::protobuf::internal::ArenaStringPtr run_date_;
  ::google::protobuf::uint32 origin_index_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static ReadOriginInfo* default_instance_;
};
// -------------------------------------------------------------------

class AlignmentTooManyHits : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.AlignmentTooManyHits) */ {
 public:
  AlignmentTooManyHits();
  virtual ~AlignmentTooManyHits();

  AlignmentTooManyHits(const AlignmentTooManyHits& from);

  inline AlignmentTooManyHits& operator=(const AlignmentTooManyHits& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentTooManyHits& default_instance();

  void Swap(AlignmentTooManyHits* other);

  // implements Message ----------------------------------------------

  inline AlignmentTooManyHits* New() const { return New(NULL); }

  AlignmentTooManyHits* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlignmentTooManyHits& from);
  void MergeFrom(const AlignmentTooManyHits& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AlignmentTooManyHits* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 aligner_threshold = 2;
  bool has_aligner_threshold() const;
  void clear_aligner_threshold();
  static const int kAlignerThresholdFieldNumber = 2;
  ::google::protobuf::uint32 aligner_threshold() const;
  void set_aligner_threshold(::google::protobuf::uint32 value);

  // repeated .goby.AmbiguousLocation hits = 1;
  int hits_size() const;
  void clear_hits();
  static const int kHitsFieldNumber = 1;
  const ::goby::AmbiguousLocation& hits(int index) const;
  ::goby::AmbiguousLocation* mutable_hits(int index);
  ::goby::AmbiguousLocation* add_hits();
  ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >*
      mutable_hits();
  const ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >&
      hits() const;

  // @@protoc_insertion_point(class_scope:goby.AlignmentTooManyHits)
 private:
  inline void set_has_aligner_threshold();
  inline void clear_has_aligner_threshold();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation > hits_;
  ::google::protobuf::uint32 aligner_threshold_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static AlignmentTooManyHits* default_instance_;
};
// -------------------------------------------------------------------

class AmbiguousLocation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.AmbiguousLocation) */ {
 public:
  AmbiguousLocation();
  virtual ~AmbiguousLocation();

  AmbiguousLocation(const AmbiguousLocation& from);

  inline AmbiguousLocation& operator=(const AmbiguousLocation& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AmbiguousLocation& default_instance();

  void Swap(AmbiguousLocation* other);

  // implements Message ----------------------------------------------

  inline AmbiguousLocation* New() const { return New(NULL); }

  AmbiguousLocation* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AmbiguousLocation& from);
  void MergeFrom(const AmbiguousLocation& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AmbiguousLocation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 query_index = 1;
  bool has_query_index() const;
  void clear_query_index();
  static const int kQueryIndexFieldNumber = 1;
  ::google::protobuf::uint32 query_index() const;
  void set_query_index(::google::protobuf::uint32 value);

  // required uint32 at_least_number_of_hits = 2;
  bool has_at_least_number_of_hits() const;
  void clear_at_least_number_of_hits();
  static const int kAtLeastNumberOfHitsFieldNumber = 2;
  ::google::protobuf::uint32 at_least_number_of_hits() const;
  void set_at_least_number_of_hits(::google::protobuf::uint32 value);

  // optional uint32 length_of_match = 3;
  bool has_length_of_match() const;
  void clear_length_of_match();
  static const int kLengthOfMatchFieldNumber = 3;
  ::google::protobuf::uint32 length_of_match() const;
  void set_length_of_match(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:goby.AmbiguousLocation)
 private:
  inline void set_has_query_index();
  inline void clear_has_query_index();
  inline void set_has_at_least_number_of_hits();
  inline void clear_has_at_least_number_of_hits();
  inline void set_has_length_of_match();
  inline void clear_has_length_of_match();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 query_index_;
  ::google::protobuf::uint32 at_least_number_of_hits_;
  ::google::protobuf::uint32 length_of_match_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static AmbiguousLocation* default_instance_;
};
// -------------------------------------------------------------------

class AlignmentIndex : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.AlignmentIndex) */ {
 public:
  AlignmentIndex();
  virtual ~AlignmentIndex();

  AlignmentIndex(const AlignmentIndex& from);

  inline AlignmentIndex& operator=(const AlignmentIndex& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentIndex& default_instance();

  void Swap(AlignmentIndex* other);

  // implements Message ----------------------------------------------

  inline AlignmentIndex* New() const { return New(NULL); }

  AlignmentIndex* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlignmentIndex& from);
  void MergeFrom(const AlignmentIndex& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AlignmentIndex* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated uint32 target_position_offsets = 1 [packed = true];
  int target_position_offsets_size() const;
  void clear_target_position_offsets();
  static const int kTargetPositionOffsetsFieldNumber = 1;
  ::google::protobuf::uint32 target_position_offsets(int index) const;
  void set_target_position_offsets(int index, ::google::protobuf::uint32 value);
  void add_target_position_offsets(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      target_position_offsets() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_target_position_offsets();

  // repeated uint64 offsets = 2 [packed = true];
  int offsets_size() const;
  void clear_offsets();
  static const int kOffsetsFieldNumber = 2;
  ::google::protobuf::uint64 offsets(int index) const;
  void set_offsets(int index, ::google::protobuf::uint64 value);
  void add_offsets(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      offsets() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_offsets();

  // repeated uint64 absolute_positions = 3 [packed = true];
  int absolute_positions_size() const;
  void clear_absolute_positions();
  static const int kAbsolutePositionsFieldNumber = 3;
  ::google::protobuf::uint64 absolute_positions(int index) const;
  void set_absolute_positions(int index, ::google::protobuf::uint64 value);
  void add_absolute_positions(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      absolute_positions() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_absolute_positions();

  // @@protoc_insertion_point(class_scope:goby.AlignmentIndex)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > target_position_offsets_;
  mutable int _target_position_offsets_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > offsets_;
  mutable int _offsets_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > absolute_positions_;
  mutable int _absolute_positions_cached_byte_size_;
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();

  void InitAsDefaultInstance();
  static AlignmentIndex* default_instance_;
};
// ===================================================================


// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// AlignmentCollection

// repeated .goby.AlignmentEntry alignment_entries = 1;
inline int AlignmentCollection::alignment_entries_size() const {
  return alignment_entries_.size();
}
inline void AlignmentCollection::clear_alignment_entries() {
  alignment_entries_.Clear();
}
inline const ::goby::AlignmentEntry& AlignmentCollection::alignment_entries(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentCollection.alignment_entries)
  return alignment_entries_.Get(index);
}
inline ::goby::AlignmentEntry* AlignmentCollection::mutable_alignment_entries(int index) {
  // @@protoc_insertion_point(field_mutable:goby.AlignmentCollection.alignment_entries)
  return alignment_entries_.Mutable(index);
}
inline ::goby::AlignmentEntry* AlignmentCollection::add_alignment_entries() {
  // @@protoc_insertion_point(field_add:goby.AlignmentCollection.alignment_entries)
  return alignment_entries_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >*
AlignmentCollection::mutable_alignment_entries() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentCollection.alignment_entries)
  return &alignment_entries_;
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >&
AlignmentCollection::alignment_entries() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentCollection.alignment_entries)
  return alignment_entries_;
}

// -------------------------------------------------------------------

// AlignmentEntry

// optional uint32 multiplicity = 7;
inline bool AlignmentEntry::has_multiplicity() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AlignmentEntry::set_has_multiplicity() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AlignmentEntry::clear_has_multiplicity() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AlignmentEntry::clear_multiplicity() {
  multiplicity_ = 0u;
  clear_has_multiplicity();
}
inline ::google::protobuf::uint32 AlignmentEntry::multiplicity() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.multiplicity)
  return multiplicity_;
}
inline void AlignmentEntry::set_multiplicity(::google::protobuf::uint32 value) {
  set_has_multiplicity();
  multiplicity_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.multiplicity)
}

// optional uint32 query_index = 1;
inline bool AlignmentEntry::has_query_index() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AlignmentEntry::set_has_query_index() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AlignmentEntry::clear_has_query_index() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AlignmentEntry::clear_query_index() {
  query_index_ = 0u;
  clear_has_query_index();
}
inline ::google::protobuf::uint32 AlignmentEntry::query_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.query_index)
  return query_index_;
}
inline void AlignmentEntry::set_query_index(::google::protobuf::uint32 value) {
  set_has_query_index();
  query_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.query_index)
}

// optional uint32 target_index = 2;
inline bool AlignmentEntry::has_target_index() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AlignmentEntry::set_has_target_index() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AlignmentEntry::clear_has_target_index() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AlignmentEntry::clear_target_index() {
  target_index_ = 0u;
  clear_has_target_index();
}
inline ::google::protobuf::uint32 AlignmentEntry::target_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.target_index)
  return target_index_;
}
inline void AlignmentEntry::set_target_index(::google::protobuf::uint32 value) {
  set_has_target_index();
  target_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.target_index)
}

// optional uint32 position = 3;
inline bool AlignmentEntry::has_position() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AlignmentEntry::set_has_position() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AlignmentEntry::clear_has_position() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AlignmentEntry::clear_position() {
  position_ = 0u;
  clear_has_position();
}
inline ::google::protobuf::uint32 AlignmentEntry::position() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.position)
  return position_;
}
inline void AlignmentEntry::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.position)
}

// optional bool matching_reverse_strand = 6;
inline bool AlignmentEntry::has_matching_reverse_strand() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AlignmentEntry::set_has_matching_reverse_strand() {
  _has_bits_[0] |= 0x00000010u;
}
inline void AlignmentEntry::clear_has_matching_reverse_strand() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void AlignmentEntry::clear_matching_reverse_strand() {
  matching_reverse_strand_ = false;
  clear_has_matching_reverse_strand();
}
inline bool AlignmentEntry::matching_reverse_strand() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.matching_reverse_strand)
  return matching_reverse_strand_;
}
inline void AlignmentEntry::set_matching_reverse_strand(bool value) {
  set_has_matching_reverse_strand();
  matching_reverse_strand_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.matching_reverse_strand)
}

// optional uint32 query_position = 5;
inline bool AlignmentEntry::has_query_position() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AlignmentEntry::set_has_query_position() {
  _has_bits_[0] |= 0x00000020u;
}
inline void AlignmentEntry::clear_has_query_position() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void AlignmentEntry::clear_query_position() {
  query_position_ = 0u;
  clear_has_query_position();
}
inline ::google::protobuf::uint32 AlignmentEntry::query_position() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.query_position)
  return query_position_;
}
inline void AlignmentEntry::set_query_position(::google::protobuf::uint32 value) {
  set_has_query_position();
  query_position_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.query_position)
}

// optional float score = 4;
inline bool AlignmentEntry::has_score() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AlignmentEntry::set_has_score() {
  _has_bits_[0] |= 0x00000040u;
}
inline void AlignmentEntry::clear_has_score() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void AlignmentEntry::clear_score() {
  score_ = 0;
  clear_has_score();
}
inline float AlignmentEntry::score() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.score)
  return score_;
}
inline void AlignmentEntry::set_score(float value) {
  set_has_score();
  score_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.score)
}

// optional uint32 number_of_mismatches = 8;
inline bool AlignmentEntry::has_number_of_mismatches() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AlignmentEntry::set_has_number_of_mismatches() {
  _has_bits_[0] |= 0x00000080u;
}
inline void AlignmentEntry::clear_has_number_of_mismatches() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void AlignmentEntry::clear_number_of_mismatches() {
  number_of_mismatches_ = 0u;
  clear_has_number_of_mismatches();
}
inline ::google::protobuf::uint32 AlignmentEntry::number_of_mismatches() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.number_of_mismatches)
  return number_of_mismatches_;
}
inline void AlignmentEntry::set_number_of_mismatches(::google::protobuf::uint32 value) {
  set_has_number_of_mismatches();
  number_of_mismatches_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.number_of_mismatches)
}

// optional uint32 number_of_indels = 9;
inline bool AlignmentEntry::has_number_of_indels() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void AlignmentEntry::set_has_number_of_indels() {
  _has_bits_[0] |= 0x00000100u;
}
inline void AlignmentEntry::clear_has_number_of_indels() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void AlignmentEntry::clear_number_of_indels() {
  number_of_indels_ = 0u;
  clear_has_number_of_indels();
}
inline ::google::protobuf::uint32 AlignmentEntry::number_of_indels() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.number_of_indels)
  return number_of_indels_;
}
inline void AlignmentEntry::set_number_of_indels(::google::protobuf::uint32 value) {
  set_has_number_of_indels();
  number_of_indels_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.number_of_indels)
}

// optional uint32 query_aligned_length = 11;
inline bool AlignmentEntry::has_query_aligned_length() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void AlignmentEntry::set_has_query_aligned_length() {
  _has_bits_[0] |= 0x00000200u;
}
inline void AlignmentEntry::clear_has_query_aligned_length() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void AlignmentEntry::clear_query_aligned_length() {
  query_aligned_length_ = 0u;
  clear_has_query_aligned_length();
}
inline ::google::protobuf::uint32 AlignmentEntry::query_aligned_length() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.query_aligned_length)
  return query_aligned_length_;
}
inline void AlignmentEntry::set_query_aligned_length(::google::protobuf::uint32 value) {
  set_has_query_aligned_length();
  query_aligned_length_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.query_aligned_length)
}

// optional uint32 target_aligned_length = 12;
inline bool AlignmentEntry::has_target_aligned_length() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void AlignmentEntry::set_has_target_aligned_length() {
  _has_bits_[0] |= 0x00000400u;
}
inline void AlignmentEntry::clear_has_target_aligned_length() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void AlignmentEntry::clear_target_aligned_length() {
  target_aligned_length_ = 0u;
  clear_has_target_aligned_length();
}
inline ::google::protobuf::uint32 AlignmentEntry::target_aligned_length() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.target_aligned_length)
  return target_aligned_length_;
}
inline void AlignmentEntry::set_target_aligned_length(::google::protobuf::uint32 value) {
  set_has_target_aligned_length();
  target_aligned_length_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.target_aligned_length)
}

// repeated .goby.SequenceVariation sequence_variations = 13;
inline int AlignmentEntry::sequence_variations_size() const {
  return sequence_variations_.size();
}
inline void AlignmentEntry::clear_sequence_variations() {
  sequence_variations_.Clear();
}
inline const ::goby::SequenceVariation& AlignmentEntry::sequence_variations(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.sequence_variations)
  return sequence_variations_.Get(index);
}
inline ::goby::SequenceVariation* AlignmentEntry::mutable_sequence_variations(int index) {
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.sequence_variations)
  return sequence_variations_.Mutable(index);
}
inline ::goby::SequenceVariation* AlignmentEntry::add_sequence_variations() {
  // @@protoc_insertion_point(field_add:goby.AlignmentEntry.sequence_variations)
  return sequence_variations_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >*
AlignmentEntry::mutable_sequence_variations() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentEntry.sequence_variations)
  return &sequence_variations_;
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >&
AlignmentEntry::sequence_variations() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentEntry.sequence_variations)
  return sequence_variations_;
}

// optional uint32 query_length = 10;
inline bool AlignmentEntry::has_query_length() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void AlignmentEntry::set_has_query_length() {
  _has_bits_[0] |= 0x00001000u;
}
inline void AlignmentEntry::clear_has_query_length() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void AlignmentEntry::clear_query_length() {
  query_length_ = 0u;
  clear_has_query_length();
}
inline ::google::protobuf::uint32 AlignmentEntry::query_length() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.query_length)
  return query_length_;
}
inline void AlignmentEntry::set_query_length(::google::protobuf::uint32 value) {
  set_has_query_length();
  query_length_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.query_length)
}

// optional int32 mapping_quality = 14;
inline bool AlignmentEntry::has_mapping_quality() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void AlignmentEntry::set_has_mapping_quality() {
  _has_bits_[0] |= 0x00002000u;
}
inline void AlignmentEntry::clear_has_mapping_quality() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void AlignmentEntry::clear_mapping_quality() {
  mapping_quality_ = 0;
  clear_has_mapping_quality();
}
inline ::google::protobuf::int32 AlignmentEntry::mapping_quality() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.mapping_quality)
  return mapping_quality_;
}
inline void AlignmentEntry::set_mapping_quality(::google::protobuf::int32 value) {
  set_has_mapping_quality();
  mapping_quality_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.mapping_quality)
}

// optional uint32 pair_flags = 15;
inline bool AlignmentEntry::has_pair_flags() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void AlignmentEntry::set_has_pair_flags() {
  _has_bits_[0] |= 0x00004000u;
}
inline void AlignmentEntry::clear_has_pair_flags() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void AlignmentEntry::clear_pair_flags() {
  pair_flags_ = 0u;
  clear_has_pair_flags();
}
inline ::google::protobuf::uint32 AlignmentEntry::pair_flags() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.pair_flags)
  return pair_flags_;
}
inline void AlignmentEntry::set_pair_flags(::google::protobuf::uint32 value) {
  set_has_pair_flags();
  pair_flags_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.pair_flags)
}

// optional .goby.RelatedAlignmentEntry pair_alignment_link = 16;
inline bool AlignmentEntry::has_pair_alignment_link() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void AlignmentEntry::set_has_pair_alignment_link() {
  _has_bits_[0] |= 0x00008000u;
}
inline void AlignmentEntry::clear_has_pair_alignment_link() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void AlignmentEntry::clear_pair_alignment_link() {
  if (pair_alignment_link_ != NULL) pair_alignment_link_->::goby::RelatedAlignmentEntry::Clear();
  clear_has_pair_alignment_link();
}
inline const ::goby::RelatedAlignmentEntry& AlignmentEntry::pair_alignment_link() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.pair_alignment_link)
  return pair_alignment_link_ != NULL ? *pair_alignment_link_ : *default_instance_->pair_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::mutable_pair_alignment_link() {
  set_has_pair_alignment_link();
  if (pair_alignment_link_ == NULL) {
    pair_alignment_link_ = new ::goby::RelatedAlignmentEntry;
  }
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.pair_alignment_link)
  return pair_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::release_pair_alignment_link() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.pair_alignment_link)
  clear_has_pair_alignment_link();
  ::goby::RelatedAlignmentEntry* temp = pair_alignment_link_;
  pair_alignment_link_ = NULL;
  return temp;
}
inline void AlignmentEntry::set_allocated_pair_alignment_link(::goby::RelatedAlignmentEntry* pair_alignment_link) {
  delete pair_alignment_link_;
  pair_alignment_link_ = pair_alignment_link;
  if (pair_alignment_link) {
    set_has_pair_alignment_link();
  } else {
    clear_has_pair_alignment_link();
  }
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.pair_alignment_link)
}

// optional uint32 fragment_index = 17;
inline bool AlignmentEntry::has_fragment_index() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void AlignmentEntry::set_has_fragment_index() {
  _has_bits_[0] |= 0x00010000u;
}
inline void AlignmentEntry::clear_has_fragment_index() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void AlignmentEntry::clear_fragment_index() {
  fragment_index_ = 0u;
  clear_has_fragment_index();
}
inline ::google::protobuf::uint32 AlignmentEntry::fragment_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.fragment_index)
  return fragment_index_;
}
inline void AlignmentEntry::set_fragment_index(::google::protobuf::uint32 value) {
  set_has_fragment_index();
  fragment_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.fragment_index)
}

// optional .goby.RelatedAlignmentEntry spliced_forward_alignment_link = 18;
inline bool AlignmentEntry::has_spliced_forward_alignment_link() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void AlignmentEntry::set_has_spliced_forward_alignment_link() {
  _has_bits_[0] |= 0x00020000u;
}
inline void AlignmentEntry::clear_has_spliced_forward_alignment_link() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void AlignmentEntry::clear_spliced_forward_alignment_link() {
  if (spliced_forward_alignment_link_ != NULL) spliced_forward_alignment_link_->::goby::RelatedAlignmentEntry::Clear();
  clear_has_spliced_forward_alignment_link();
}
inline const ::goby::RelatedAlignmentEntry& AlignmentEntry::spliced_forward_alignment_link() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.spliced_forward_alignment_link)
  return spliced_forward_alignment_link_ != NULL ? *spliced_forward_alignment_link_ : *default_instance_->spliced_forward_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::mutable_spliced_forward_alignment_link() {
  set_has_spliced_forward_alignment_link();
  if (spliced_forward_alignment_link_ == NULL) {
    spliced_forward_alignment_link_ = new ::goby::RelatedAlignmentEntry;
  }
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.spliced_forward_alignment_link)
  return spliced_forward_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::release_spliced_forward_alignment_link() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.spliced_forward_alignment_link)
  clear_has_spliced_forward_alignment_link();
  ::goby::RelatedAlignmentEntry* temp = spliced_forward_alignment_link_;
  spliced_forward_alignment_link_ = NULL;
  return temp;
}
inline void AlignmentEntry::set_allocated_spliced_forward_alignment_link(::goby::RelatedAlignmentEntry* spliced_forward_alignment_link) {
  delete spliced_forward_alignment_link_;
  spliced_forward_alignment_link_ = spliced_forward_alignment_link;
  if (spliced_forward_alignment_link) {
    set_has_spliced_forward_alignment_link();
  } else {
    clear_has_spliced_forward_alignment_link();
  }
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.spliced_forward_alignment_link)
}

// optional .goby.RelatedAlignmentEntry spliced_backward_alignment_link = 22;
inline bool AlignmentEntry::has_spliced_backward_alignment_link() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void AlignmentEntry::set_has_spliced_backward_alignment_link() {
  _has_bits_[0] |= 0x00040000u;
}
inline void AlignmentEntry::clear_has_spliced_backward_alignment_link() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void AlignmentEntry::clear_spliced_backward_alignment_link() {
  if (spliced_backward_alignment_link_ != NULL) spliced_backward_alignment_link_->::goby::RelatedAlignmentEntry::Clear();
  clear_has_spliced_backward_alignment_link();
}
inline const ::goby::RelatedAlignmentEntry& AlignmentEntry::spliced_backward_alignment_link() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.spliced_backward_alignment_link)
  return spliced_backward_alignment_link_ != NULL ? *spliced_backward_alignment_link_ : *default_instance_->spliced_backward_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::mutable_spliced_backward_alignment_link() {
  set_has_spliced_backward_alignment_link();
  if (spliced_backward_alignment_link_ == NULL) {
    spliced_backward_alignment_link_ = new ::goby::RelatedAlignmentEntry;
  }
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.spliced_backward_alignment_link)
  return spliced_backward_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::release_spliced_backward_alignment_link() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.spliced_backward_alignment_link)
  clear_has_spliced_backward_alignment_link();
  ::goby::RelatedAlignmentEntry* temp = spliced_backward_alignment_link_;
  spliced_backward_alignment_link_ = NULL;
  return temp;
}
inline void AlignmentEntry::set_allocated_spliced_backward_alignment_link(::goby::RelatedAlignmentEntry* spliced_backward_alignment_link) {
  delete spliced_backward_alignment_link_;
  spliced_backward_alignment_link_ = spliced_backward_alignment_link;
  if (spliced_backward_alignment_link) {
    set_has_spliced_backward_alignment_link();
  } else {
    clear_has_spliced_backward_alignment_link();
  }
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.spliced_backward_alignment_link)
}

// optional uint32 spliced_flags = 19;
inline bool AlignmentEntry::has_spliced_flags() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void AlignmentEntry::set_has_spliced_flags() {
  _has_bits_[0] |= 0x00080000u;
}
inline void AlignmentEntry::clear_has_spliced_flags() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void AlignmentEntry::clear_spliced_flags() {
  spliced_flags_ = 0u;
  clear_has_spliced_flags();
}
inline ::google::protobuf::uint32 AlignmentEntry::spliced_flags() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.spliced_flags)
  return spliced_flags_;
}
inline void AlignmentEntry::set_spliced_flags(::google::protobuf::uint32 value) {
  set_has_spliced_flags();
  spliced_flags_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.spliced_flags)
}

// optional sint32 insert_size = 20;
inline bool AlignmentEntry::has_insert_size() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void AlignmentEntry::set_has_insert_size() {
  _has_bits_[0] |= 0x00100000u;
}
inline void AlignmentEntry::clear_has_insert_size() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void AlignmentEntry::clear_insert_size() {
  insert_size_ = 0;
  clear_has_insert_size();
}
inline ::google::protobuf::int32 AlignmentEntry::insert_size() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.insert_size)
  return insert_size_;
}
inline void AlignmentEntry::set_insert_size(::google::protobuf::int32 value) {
  set_has_insert_size();
  insert_size_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.insert_size)
}

// optional uint32 sample_index = 21;
inline bool AlignmentEntry::has_sample_index() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void AlignmentEntry::set_has_sample_index() {
  _has_bits_[0] |= 0x00200000u;
}
inline void AlignmentEntry::clear_has_sample_index() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void AlignmentEntry::clear_sample_index() {
  sample_index_ = 0u;
  clear_has_sample_index();
}
inline ::google::protobuf::uint32 AlignmentEntry::sample_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.sample_index)
  return sample_index_;
}
inline void AlignmentEntry::set_sample_index(::google::protobuf::uint32 value) {
  set_has_sample_index();
  sample_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.sample_index)
}

// optional uint32 query_index_occurrences = 25;
inline bool AlignmentEntry::has_query_index_occurrences() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void AlignmentEntry::set_has_query_index_occurrences() {
  _has_bits_[0] |= 0x00400000u;
}
inline void AlignmentEntry::clear_has_query_index_occurrences() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void AlignmentEntry::clear_query_index_occurrences() {
  query_index_occurrences_ = 0u;
  clear_has_query_index_occurrences();
}
inline ::google::protobuf::uint32 AlignmentEntry::query_index_occurrences() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.query_index_occurrences)
  return query_index_occurrences_;
}
inline void AlignmentEntry::set_query_index_occurrences(::google::protobuf::uint32 value) {
  set_has_query_index_occurrences();
  query_index_occurrences_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.query_index_occurrences)
}

// optional uint32 ambiguity = 27;
inline bool AlignmentEntry::has_ambiguity() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void AlignmentEntry::set_has_ambiguity() {
  _has_bits_[0] |= 0x00800000u;
}
inline void AlignmentEntry::clear_has_ambiguity() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void AlignmentEntry::clear_ambiguity() {
  ambiguity_ = 0u;
  clear_has_ambiguity();
}
inline ::google::protobuf::uint32 AlignmentEntry::ambiguity() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.ambiguity)
  return ambiguity_;
}
inline void AlignmentEntry::set_ambiguity(::google::protobuf::uint32 value) {
  set_has_ambiguity();
  ambiguity_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.ambiguity)
}

// repeated string bam_attributes = 50;
inline int AlignmentEntry::bam_attributes_size() const {
  return bam_attributes_.size();
}
inline void AlignmentEntry::clear_bam_attributes() {
  bam_attributes_.Clear();
}
inline const ::std::string& AlignmentEntry::bam_attributes(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.bam_attributes)
  return bam_attributes_.Get(index);
}
inline ::std::string* AlignmentEntry::mutable_bam_attributes(int index) {
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.bam_attributes)
  return bam_attributes_.Mutable(index);
}
inline void AlignmentEntry::set_bam_attributes(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.bam_attributes)
  bam_attributes_.Mutable(index)->assign(value);
}
inline void AlignmentEntry::set_bam_attributes(int index, const char* value) {
  bam_attributes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.bam_attributes)
}
inline void AlignmentEntry::set_bam_attributes(int index, const char* value, size_t size) {
  bam_attributes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.bam_attributes)
}
inline ::std::string* AlignmentEntry::add_bam_attributes() {
  // @@protoc_insertion_point(field_add_mutable:goby.AlignmentEntry.bam_attributes)
  return bam_attributes_.Add();
}
inline void AlignmentEntry::add_bam_attributes(const ::std::string& value) {
  bam_attributes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentEntry.bam_attributes)
}
inline void AlignmentEntry::add_bam_attributes(const char* value) {
  bam_attributes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.AlignmentEntry.bam_attributes)
}
inline void AlignmentEntry::add_bam_attributes(const char* value, size_t size) {
  bam_attributes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.AlignmentEntry.bam_attributes)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
AlignmentEntry::bam_attributes() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentEntry.bam_attributes)
  return bam_attributes_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
AlignmentEntry::mutable_bam_attributes() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentEntry.bam_attributes)
  return &bam_attributes_;
}

// optional bytes read_quality_scores = 55;
inline bool AlignmentEntry::has_read_quality_scores() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void AlignmentEntry::set_has_read_quality_scores() {
  _has_bits_[0] |= 0x02000000u;
}
inline void AlignmentEntry::clear_has_read_quality_scores() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void AlignmentEntry::clear_read_quality_scores() {
  read_quality_scores_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_read_quality_scores();
}
inline const ::std::string& AlignmentEntry::read_quality_scores() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.read_quality_scores)
  return read_quality_scores_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_read_quality_scores(const ::std::string& value) {
  set_has_read_quality_scores();
  read_quality_scores_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.read_quality_scores)
}
inline void AlignmentEntry::set_read_quality_scores(const char* value) {
  set_has_read_quality_scores();
  read_quality_scores_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.read_quality_scores)
}
inline void AlignmentEntry::set_read_quality_scores(const void* value, size_t size) {
  set_has_read_quality_scores();
  read_quality_scores_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.read_quality_scores)
}
inline ::std::string* AlignmentEntry::mutable_read_quality_scores() {
  set_has_read_quality_scores();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.read_quality_scores)
  return read_quality_scores_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_read_quality_scores() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.read_quality_scores)
  clear_has_read_quality_scores();
  return read_quality_scores_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_read_quality_scores(::std::string* read_quality_scores) {
  if (read_quality_scores != NULL) {
    set_has_read_quality_scores();
  } else {
    clear_has_read_quality_scores();
  }
  read_quality_scores_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), read_quality_scores);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.read_quality_scores)
}

// optional uint32 read_origin_index = 26;
inline bool AlignmentEntry::has_read_origin_index() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void AlignmentEntry::set_has_read_origin_index() {
  _has_bits_[0] |= 0x04000000u;
}
inline void AlignmentEntry::clear_has_read_origin_index() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void AlignmentEntry::clear_read_origin_index() {
  read_origin_index_ = 0u;
  clear_has_read_origin_index();
}
inline ::google::protobuf::uint32 AlignmentEntry::read_origin_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.read_origin_index)
  return read_origin_index_;
}
inline void AlignmentEntry::set_read_origin_index(::google::protobuf::uint32 value) {
  set_has_read_origin_index();
  read_origin_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.read_origin_index)
}

// optional string softClippedBasesLeft = 30;
inline bool AlignmentEntry::has_softclippedbasesleft() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void AlignmentEntry::set_has_softclippedbasesleft() {
  _has_bits_[0] |= 0x08000000u;
}
inline void AlignmentEntry::clear_has_softclippedbasesleft() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void AlignmentEntry::clear_softclippedbasesleft() {
  softclippedbasesleft_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_softclippedbasesleft();
}
inline const ::std::string& AlignmentEntry::softclippedbasesleft() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.softClippedBasesLeft)
  return softclippedbasesleft_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_softclippedbasesleft(const ::std::string& value) {
  set_has_softclippedbasesleft();
  softclippedbasesleft_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.softClippedBasesLeft)
}
inline void AlignmentEntry::set_softclippedbasesleft(const char* value) {
  set_has_softclippedbasesleft();
  softclippedbasesleft_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.softClippedBasesLeft)
}
inline void AlignmentEntry::set_softclippedbasesleft(const char* value, size_t size) {
  set_has_softclippedbasesleft();
  softclippedbasesleft_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.softClippedBasesLeft)
}
inline ::std::string* AlignmentEntry::mutable_softclippedbasesleft() {
  set_has_softclippedbasesleft();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.softClippedBasesLeft)
  return softclippedbasesleft_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_softclippedbasesleft() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.softClippedBasesLeft)
  clear_has_softclippedbasesleft();
  return softclippedbasesleft_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_softclippedbasesleft(::std::string* softclippedbasesleft) {
  if (softclippedbasesleft != NULL) {
    set_has_softclippedbasesleft();
  } else {
    clear_has_softclippedbasesleft();
  }
  softclippedbasesleft_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softclippedbasesleft);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.softClippedBasesLeft)
}

// optional string softClippedBasesRight = 31;
inline bool AlignmentEntry::has_softclippedbasesright() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void AlignmentEntry::set_has_softclippedbasesright() {
  _has_bits_[0] |= 0x10000000u;
}
inline void AlignmentEntry::clear_has_softclippedbasesright() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void AlignmentEntry::clear_softclippedbasesright() {
  softclippedbasesright_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_softclippedbasesright();
}
inline const ::std::string& AlignmentEntry::softclippedbasesright() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.softClippedBasesRight)
  return softclippedbasesright_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_softclippedbasesright(const ::std::string& value) {
  set_has_softclippedbasesright();
  softclippedbasesright_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.softClippedBasesRight)
}
inline void AlignmentEntry::set_softclippedbasesright(const char* value) {
  set_has_softclippedbasesright();
  softclippedbasesright_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.softClippedBasesRight)
}
inline void AlignmentEntry::set_softclippedbasesright(const char* value, size_t size) {
  set_has_softclippedbasesright();
  softclippedbasesright_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.softClippedBasesRight)
}
inline ::std::string* AlignmentEntry::mutable_softclippedbasesright() {
  set_has_softclippedbasesright();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.softClippedBasesRight)
  return softclippedbasesright_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_softclippedbasesright() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.softClippedBasesRight)
  clear_has_softclippedbasesright();
  return softclippedbasesright_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_softclippedbasesright(::std::string* softclippedbasesright) {
  if (softclippedbasesright != NULL) {
    set_has_softclippedbasesright();
  } else {
    clear_has_softclippedbasesright();
  }
  softclippedbasesright_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softclippedbasesright);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.softClippedBasesRight)
}

// optional bytes softClippedQualityLeft = 32;
inline bool AlignmentEntry::has_softclippedqualityleft() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void AlignmentEntry::set_has_softclippedqualityleft() {
  _has_bits_[0] |= 0x20000000u;
}
inline void AlignmentEntry::clear_has_softclippedqualityleft() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void AlignmentEntry::clear_softclippedqualityleft() {
  softclippedqualityleft_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_softclippedqualityleft();
}
inline const ::std::string& AlignmentEntry::softclippedqualityleft() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.softClippedQualityLeft)
  return softclippedqualityleft_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_softclippedqualityleft(const ::std::string& value) {
  set_has_softclippedqualityleft();
  softclippedqualityleft_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.softClippedQualityLeft)
}
inline void AlignmentEntry::set_softclippedqualityleft(const char* value) {
  set_has_softclippedqualityleft();
  softclippedqualityleft_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.softClippedQualityLeft)
}
inline void AlignmentEntry::set_softclippedqualityleft(const void* value, size_t size) {
  set_has_softclippedqualityleft();
  softclippedqualityleft_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.softClippedQualityLeft)
}
inline ::std::string* AlignmentEntry::mutable_softclippedqualityleft() {
  set_has_softclippedqualityleft();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.softClippedQualityLeft)
  return softclippedqualityleft_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_softclippedqualityleft() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.softClippedQualityLeft)
  clear_has_softclippedqualityleft();
  return softclippedqualityleft_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_softclippedqualityleft(::std::string* softclippedqualityleft) {
  if (softclippedqualityleft != NULL) {
    set_has_softclippedqualityleft();
  } else {
    clear_has_softclippedqualityleft();
  }
  softclippedqualityleft_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softclippedqualityleft);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.softClippedQualityLeft)
}

// optional bytes softClippedQualityRight = 33;
inline bool AlignmentEntry::has_softclippedqualityright() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void AlignmentEntry::set_has_softclippedqualityright() {
  _has_bits_[0] |= 0x40000000u;
}
inline void AlignmentEntry::clear_has_softclippedqualityright() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void AlignmentEntry::clear_softclippedqualityright() {
  softclippedqualityright_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_softclippedqualityright();
}
inline const ::std::string& AlignmentEntry::softclippedqualityright() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.softClippedQualityRight)
  return softclippedqualityright_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_softclippedqualityright(const ::std::string& value) {
  set_has_softclippedqualityright();
  softclippedqualityright_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.softClippedQualityRight)
}
inline void AlignmentEntry::set_softclippedqualityright(const char* value) {
  set_has_softclippedqualityright();
  softclippedqualityright_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.softClippedQualityRight)
}
inline void AlignmentEntry::set_softclippedqualityright(const void* value, size_t size) {
  set_has_softclippedqualityright();
  softclippedqualityright_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.softClippedQualityRight)
}
inline ::std::string* AlignmentEntry::mutable_softclippedqualityright() {
  set_has_softclippedqualityright();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.softClippedQualityRight)
  return softclippedqualityright_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_softclippedqualityright() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.softClippedQualityRight)
  clear_has_softclippedqualityright();
  return softclippedqualityright_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_softclippedqualityright(::std::string* softclippedqualityright) {
  if (softclippedqualityright != NULL) {
    set_has_softclippedqualityright();
  } else {
    clear_has_softclippedqualityright();
  }
  softclippedqualityright_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), softclippedqualityright);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.softClippedQualityRight)
}

// optional string placedUnmappedSequence = 40;
inline bool AlignmentEntry::has_placedunmappedsequence() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void AlignmentEntry::set_has_placedunmappedsequence() {
  _has_bits_[0] |= 0x80000000u;
}
inline void AlignmentEntry::clear_has_placedunmappedsequence() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void AlignmentEntry::clear_placedunmappedsequence() {
  placedunmappedsequence_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_placedunmappedsequence();
}
inline const ::std::string& AlignmentEntry::placedunmappedsequence() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.placedUnmappedSequence)
  return placedunmappedsequence_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_placedunmappedsequence(const ::std::string& value) {
  set_has_placedunmappedsequence();
  placedunmappedsequence_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.placedUnmappedSequence)
}
inline void AlignmentEntry::set_placedunmappedsequence(const char* value) {
  set_has_placedunmappedsequence();
  placedunmappedsequence_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.placedUnmappedSequence)
}
inline void AlignmentEntry::set_placedunmappedsequence(const char* value, size_t size) {
  set_has_placedunmappedsequence();
  placedunmappedsequence_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.placedUnmappedSequence)
}
inline ::std::string* AlignmentEntry::mutable_placedunmappedsequence() {
  set_has_placedunmappedsequence();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.placedUnmappedSequence)
  return placedunmappedsequence_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_placedunmappedsequence() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.placedUnmappedSequence)
  clear_has_placedunmappedsequence();
  return placedunmappedsequence_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_placedunmappedsequence(::std::string* placedunmappedsequence) {
  if (placedunmappedsequence != NULL) {
    set_has_placedunmappedsequence();
  } else {
    clear_has_placedunmappedsequence();
  }
  placedunmappedsequence_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), placedunmappedsequence);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.placedUnmappedSequence)
}

// optional bytes placedUnmappedQuality = 41;
inline bool AlignmentEntry::has_placedunmappedquality() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void AlignmentEntry::set_has_placedunmappedquality() {
  _has_bits_[1] |= 0x00000001u;
}
inline void AlignmentEntry::clear_has_placedunmappedquality() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void AlignmentEntry::clear_placedunmappedquality() {
  placedunmappedquality_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_placedunmappedquality();
}
inline const ::std::string& AlignmentEntry::placedunmappedquality() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.placedUnmappedQuality)
  return placedunmappedquality_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_placedunmappedquality(const ::std::string& value) {
  set_has_placedunmappedquality();
  placedunmappedquality_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.placedUnmappedQuality)
}
inline void AlignmentEntry::set_placedunmappedquality(const char* value) {
  set_has_placedunmappedquality();
  placedunmappedquality_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.placedUnmappedQuality)
}
inline void AlignmentEntry::set_placedunmappedquality(const void* value, size_t size) {
  set_has_placedunmappedquality();
  placedunmappedquality_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.placedUnmappedQuality)
}
inline ::std::string* AlignmentEntry::mutable_placedunmappedquality() {
  set_has_placedunmappedquality();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.placedUnmappedQuality)
  return placedunmappedquality_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_placedunmappedquality() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.placedUnmappedQuality)
  clear_has_placedunmappedquality();
  return placedunmappedquality_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_placedunmappedquality(::std::string* placedunmappedquality) {
  if (placedunmappedquality != NULL) {
    set_has_placedunmappedquality();
  } else {
    clear_has_placedunmappedquality();
  }
  placedunmappedquality_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), placedunmappedquality);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.placedUnmappedQuality)
}

// optional string readName = 42;
inline bool AlignmentEntry::has_readname() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void AlignmentEntry::set_has_readname() {
  _has_bits_[1] |= 0x00000002u;
}
inline void AlignmentEntry::clear_has_readname() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void AlignmentEntry::clear_readname() {
  readname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_readname();
}
inline const ::std::string& AlignmentEntry::readname() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentEntry.readName)
  return readname_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_readname(const ::std::string& value) {
  set_has_readname();
  readname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentEntry.readName)
}
inline void AlignmentEntry::set_readname(const char* value) {
  set_has_readname();
  readname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentEntry.readName)
}
inline void AlignmentEntry::set_readname(const char* value, size_t size) {
  set_has_readname();
  readname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentEntry.readName)
}
inline ::std::string* AlignmentEntry::mutable_readname() {
  set_has_readname();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentEntry.readName)
  return readname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentEntry::release_readname() {
  // @@protoc_insertion_point(field_release:goby.AlignmentEntry.readName)
  clear_has_readname();
  return readname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentEntry::set_allocated_readname(::std::string* readname) {
  if (readname != NULL) {
    set_has_readname();
  } else {
    clear_has_readname();
  }
  readname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), readname);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentEntry.readName)
}

// -------------------------------------------------------------------

// RelatedAlignmentEntry

// optional uint32 target_index = 1;
inline bool RelatedAlignmentEntry::has_target_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RelatedAlignmentEntry::set_has_target_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RelatedAlignmentEntry::clear_has_target_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RelatedAlignmentEntry::clear_target_index() {
  target_index_ = 0u;
  clear_has_target_index();
}
inline ::google::protobuf::uint32 RelatedAlignmentEntry::target_index() const {
  // @@protoc_insertion_point(field_get:goby.RelatedAlignmentEntry.target_index)
  return target_index_;
}
inline void RelatedAlignmentEntry::set_target_index(::google::protobuf::uint32 value) {
  set_has_target_index();
  target_index_ = value;
  // @@protoc_insertion_point(field_set:goby.RelatedAlignmentEntry.target_index)
}

// optional uint32 position = 2;
inline bool RelatedAlignmentEntry::has_position() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RelatedAlignmentEntry::set_has_position() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RelatedAlignmentEntry::clear_has_position() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RelatedAlignmentEntry::clear_position() {
  position_ = 0u;
  clear_has_position();
}
inline ::google::protobuf::uint32 RelatedAlignmentEntry::position() const {
  // @@protoc_insertion_point(field_get:goby.RelatedAlignmentEntry.position)
  return position_;
}
inline void RelatedAlignmentEntry::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
  // @@protoc_insertion_point(field_set:goby.RelatedAlignmentEntry.position)
}

// optional uint32 fragment_index = 3;
inline bool RelatedAlignmentEntry::has_fragment_index() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RelatedAlignmentEntry::set_has_fragment_index() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RelatedAlignmentEntry::clear_has_fragment_index() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RelatedAlignmentEntry::clear_fragment_index() {
  fragment_index_ = 0u;
  clear_has_fragment_index();
}
inline ::google::protobuf::uint32 RelatedAlignmentEntry::fragment_index() const {
  // @@protoc_insertion_point(field_get:goby.RelatedAlignmentEntry.fragment_index)
  return fragment_index_;
}
inline void RelatedAlignmentEntry::set_fragment_index(::google::protobuf::uint32 value) {
  set_has_fragment_index();
  fragment_index_ = value;
  // @@protoc_insertion_point(field_set:goby.RelatedAlignmentEntry.fragment_index)
}

// optional uint32 optimized_index = 50;
inline bool RelatedAlignmentEntry::has_optimized_index() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RelatedAlignmentEntry::set_has_optimized_index() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RelatedAlignmentEntry::clear_has_optimized_index() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void RelatedAlignmentEntry::clear_optimized_index() {
  optimized_index_ = 0u;
  clear_has_optimized_index();
}
inline ::google::protobuf::uint32 RelatedAlignmentEntry::optimized_index() const {
  // @@protoc_insertion_point(field_get:goby.RelatedAlignmentEntry.optimized_index)
  return optimized_index_;
}
inline void RelatedAlignmentEntry::set_optimized_index(::google::protobuf::uint32 value) {
  set_has_optimized_index();
  optimized_index_ = value;
  // @@protoc_insertion_point(field_set:goby.RelatedAlignmentEntry.optimized_index)
}

// -------------------------------------------------------------------

// SequenceVariation

// optional string from = 2;
inline bool SequenceVariation::has_from() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SequenceVariation::set_has_from() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SequenceVariation::clear_has_from() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SequenceVariation::clear_from() {
  from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_from();
}
inline const ::std::string& SequenceVariation::from() const {
  // @@protoc_insertion_point(field_get:goby.SequenceVariation.from)
  return from_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SequenceVariation::set_from(const ::std::string& value) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.SequenceVariation.from)
}
inline void SequenceVariation::set_from(const char* value) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.SequenceVariation.from)
}
inline void SequenceVariation::set_from(const char* value, size_t size) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.SequenceVariation.from)
}
inline ::std::string* SequenceVariation::mutable_from() {
  set_has_from();
  // @@protoc_insertion_point(field_mutable:goby.SequenceVariation.from)
  return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SequenceVariation::release_from() {
  // @@protoc_insertion_point(field_release:goby.SequenceVariation.from)
  clear_has_from();
  return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SequenceVariation::set_allocated_from(::std::string* from) {
  if (from != NULL) {
    set_has_from();
  } else {
    clear_has_from();
  }
  from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from);
  // @@protoc_insertion_point(field_set_allocated:goby.SequenceVariation.from)
}

// optional string to = 1;
inline bool SequenceVariation::has_to() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SequenceVariation::set_has_to() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SequenceVariation::clear_has_to() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SequenceVariation::clear_to() {
  to_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_to();
}
inline const ::std::string& SequenceVariation::to() const {
  // @@protoc_insertion_point(field_get:goby.SequenceVariation.to)
  return to_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SequenceVariation::set_to(const ::std::string& value) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.SequenceVariation.to)
}
inline void SequenceVariation::set_to(const char* value) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.SequenceVariation.to)
}
inline void SequenceVariation::set_to(const char* value, size_t size) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.SequenceVariation.to)
}
inline ::std::string* SequenceVariation::mutable_to() {
  set_has_to();
  // @@protoc_insertion_point(field_mutable:goby.SequenceVariation.to)
  return to_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SequenceVariation::release_to() {
  // @@protoc_insertion_point(field_release:goby.SequenceVariation.to)
  clear_has_to();
  return to_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SequenceVariation::set_allocated_to(::std::string* to) {
  if (to != NULL) {
    set_has_to();
  } else {
    clear_has_to();
  }
  to_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to);
  // @@protoc_insertion_point(field_set_allocated:goby.SequenceVariation.to)
}

// optional uint32 position = 3;
inline bool SequenceVariation::has_position() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SequenceVariation::set_has_position() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SequenceVariation::clear_has_position() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SequenceVariation::clear_position() {
  position_ = 0u;
  clear_has_position();
}
inline ::google::protobuf::uint32 SequenceVariation::position() const {
  // @@protoc_insertion_point(field_get:goby.SequenceVariation.position)
  return position_;
}
inline void SequenceVariation::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
  // @@protoc_insertion_point(field_set:goby.SequenceVariation.position)
}

// optional uint32 read_index = 5;
inline bool SequenceVariation::has_read_index() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SequenceVariation::set_has_read_index() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SequenceVariation::clear_has_read_index() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SequenceVariation::clear_read_index() {
  read_index_ = 0u;
  clear_has_read_index();
}
inline ::google::protobuf::uint32 SequenceVariation::read_index() const {
  // @@protoc_insertion_point(field_get:goby.SequenceVariation.read_index)
  return read_index_;
}
inline void SequenceVariation::set_read_index(::google::protobuf::uint32 value) {
  set_has_read_index();
  read_index_ = value;
  // @@protoc_insertion_point(field_set:goby.SequenceVariation.read_index)
}

// optional bytes to_quality = 4;
inline bool SequenceVariation::has_to_quality() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SequenceVariation::set_has_to_quality() {
  _has_bits_[0] |= 0x00000010u;
}
inline void SequenceVariation::clear_has_to_quality() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void SequenceVariation::clear_to_quality() {
  to_quality_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_to_quality();
}
inline const ::std::string& SequenceVariation::to_quality() const {
  // @@protoc_insertion_point(field_get:goby.SequenceVariation.to_quality)
  return to_quality_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SequenceVariation::set_to_quality(const ::std::string& value) {
  set_has_to_quality();
  to_quality_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.SequenceVariation.to_quality)
}
inline void SequenceVariation::set_to_quality(const char* value) {
  set_has_to_quality();
  to_quality_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.SequenceVariation.to_quality)
}
inline void SequenceVariation::set_to_quality(const void* value, size_t size) {
  set_has_to_quality();
  to_quality_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.SequenceVariation.to_quality)
}
inline ::std::string* SequenceVariation::mutable_to_quality() {
  set_has_to_quality();
  // @@protoc_insertion_point(field_mutable:goby.SequenceVariation.to_quality)
  return to_quality_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SequenceVariation::release_to_quality() {
  // @@protoc_insertion_point(field_release:goby.SequenceVariation.to_quality)
  clear_has_to_quality();
  return to_quality_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SequenceVariation::set_allocated_to_quality(::std::string* to_quality) {
  if (to_quality != NULL) {
    set_has_to_quality();
  } else {
    clear_has_to_quality();
  }
  to_quality_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to_quality);
  // @@protoc_insertion_point(field_set_allocated:goby.SequenceVariation.to_quality)
}

// -------------------------------------------------------------------

// AlignmentHeader

// optional uint32 smallest_split_query_index = 9;
inline bool AlignmentHeader::has_smallest_split_query_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AlignmentHeader::set_has_smallest_split_query_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AlignmentHeader::clear_has_smallest_split_query_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AlignmentHeader::clear_smallest_split_query_index() {
  smallest_split_query_index_ = 0u;
  clear_has_smallest_split_query_index();
}
inline ::google::protobuf::uint32 AlignmentHeader::smallest_split_query_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.smallest_split_query_index)
  return smallest_split_query_index_;
}
inline void AlignmentHeader::set_smallest_split_query_index(::google::protobuf::uint32 value) {
  set_has_smallest_split_query_index();
  smallest_split_query_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.smallest_split_query_index)
}

// optional uint32 largest_split_query_index = 11;
inline bool AlignmentHeader::has_largest_split_query_index() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AlignmentHeader::set_has_largest_split_query_index() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AlignmentHeader::clear_has_largest_split_query_index() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AlignmentHeader::clear_largest_split_query_index() {
  largest_split_query_index_ = 0u;
  clear_has_largest_split_query_index();
}
inline ::google::protobuf::uint32 AlignmentHeader::largest_split_query_index() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.largest_split_query_index)
  return largest_split_query_index_;
}
inline void AlignmentHeader::set_largest_split_query_index(::google::protobuf::uint32 value) {
  set_has_largest_split_query_index();
  largest_split_query_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.largest_split_query_index)
}

// optional .goby.IdentifierMapping query_name_mapping = 1;
inline bool AlignmentHeader::has_query_name_mapping() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AlignmentHeader::set_has_query_name_mapping() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AlignmentHeader::clear_has_query_name_mapping() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AlignmentHeader::clear_query_name_mapping() {
  if (query_name_mapping_ != NULL) query_name_mapping_->::goby::IdentifierMapping::Clear();
  clear_has_query_name_mapping();
}
inline const ::goby::IdentifierMapping& AlignmentHeader::query_name_mapping() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.query_name_mapping)
  return query_name_mapping_ != NULL ? *query_name_mapping_ : *default_instance_->query_name_mapping_;
}
inline ::goby::IdentifierMapping* AlignmentHeader::mutable_query_name_mapping() {
  set_has_query_name_mapping();
  if (query_name_mapping_ == NULL) {
    query_name_mapping_ = new ::goby::IdentifierMapping;
  }
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.query_name_mapping)
  return query_name_mapping_;
}
inline ::goby::IdentifierMapping* AlignmentHeader::release_query_name_mapping() {
  // @@protoc_insertion_point(field_release:goby.AlignmentHeader.query_name_mapping)
  clear_has_query_name_mapping();
  ::goby::IdentifierMapping* temp = query_name_mapping_;
  query_name_mapping_ = NULL;
  return temp;
}
inline void AlignmentHeader::set_allocated_query_name_mapping(::goby::IdentifierMapping* query_name_mapping) {
  delete query_name_mapping_;
  query_name_mapping_ = query_name_mapping;
  if (query_name_mapping) {
    set_has_query_name_mapping();
  } else {
    clear_has_query_name_mapping();
  }
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentHeader.query_name_mapping)
}

// optional .goby.IdentifierMapping target_name_mapping = 2;
inline bool AlignmentHeader::has_target_name_mapping() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AlignmentHeader::set_has_target_name_mapping() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AlignmentHeader::clear_has_target_name_mapping() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AlignmentHeader::clear_target_name_mapping() {
  if (target_name_mapping_ != NULL) target_name_mapping_->::goby::IdentifierMapping::Clear();
  clear_has_target_name_mapping();
}
inline const ::goby::IdentifierMapping& AlignmentHeader::target_name_mapping() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.target_name_mapping)
  return target_name_mapping_ != NULL ? *target_name_mapping_ : *default_instance_->target_name_mapping_;
}
inline ::goby::IdentifierMapping* AlignmentHeader::mutable_target_name_mapping() {
  set_has_target_name_mapping();
  if (target_name_mapping_ == NULL) {
    target_name_mapping_ = new ::goby::IdentifierMapping;
  }
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.target_name_mapping)
  return target_name_mapping_;
}
inline ::goby::IdentifierMapping* AlignmentHeader::release_target_name_mapping() {
  // @@protoc_insertion_point(field_release:goby.AlignmentHeader.target_name_mapping)
  clear_has_target_name_mapping();
  ::goby::IdentifierMapping* temp = target_name_mapping_;
  target_name_mapping_ = NULL;
  return temp;
}
inline void AlignmentHeader::set_allocated_target_name_mapping(::goby::IdentifierMapping* target_name_mapping) {
  delete target_name_mapping_;
  target_name_mapping_ = target_name_mapping;
  if (target_name_mapping) {
    set_has_target_name_mapping();
  } else {
    clear_has_target_name_mapping();
  }
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentHeader.target_name_mapping)
}

// optional uint32 number_of_queries = 5;
inline bool AlignmentHeader::has_number_of_queries() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AlignmentHeader::set_has_number_of_queries() {
  _has_bits_[0] |= 0x00000010u;
}
inline void AlignmentHeader::clear_has_number_of_queries() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void AlignmentHeader::clear_number_of_queries() {
  number_of_queries_ = 0u;
  clear_has_number_of_queries();
}
inline ::google::protobuf::uint32 AlignmentHeader::number_of_queries() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.number_of_queries)
  return number_of_queries_;
}
inline void AlignmentHeader::set_number_of_queries(::google::protobuf::uint32 value) {
  set_has_number_of_queries();
  number_of_queries_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.number_of_queries)
}

// optional uint32 number_of_targets = 6;
inline bool AlignmentHeader::has_number_of_targets() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AlignmentHeader::set_has_number_of_targets() {
  _has_bits_[0] |= 0x00000020u;
}
inline void AlignmentHeader::clear_has_number_of_targets() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void AlignmentHeader::clear_number_of_targets() {
  number_of_targets_ = 0u;
  clear_has_number_of_targets();
}
inline ::google::protobuf::uint32 AlignmentHeader::number_of_targets() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.number_of_targets)
  return number_of_targets_;
}
inline void AlignmentHeader::set_number_of_targets(::google::protobuf::uint32 value) {
  set_has_number_of_targets();
  number_of_targets_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.number_of_targets)
}

// optional uint32 number_of_aligned_reads = 7;
inline bool AlignmentHeader::has_number_of_aligned_reads() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AlignmentHeader::set_has_number_of_aligned_reads() {
  _has_bits_[0] |= 0x00000040u;
}
inline void AlignmentHeader::clear_has_number_of_aligned_reads() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void AlignmentHeader::clear_number_of_aligned_reads() {
  number_of_aligned_reads_ = 0u;
  clear_has_number_of_aligned_reads();
}
inline ::google::protobuf::uint32 AlignmentHeader::number_of_aligned_reads() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.number_of_aligned_reads)
  return number_of_aligned_reads_;
}
inline void AlignmentHeader::set_number_of_aligned_reads(::google::protobuf::uint32 value) {
  set_has_number_of_aligned_reads();
  number_of_aligned_reads_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.number_of_aligned_reads)
}

// repeated uint32 query_length = 3 [deprecated = true];
inline int AlignmentHeader::query_length_size() const {
  return query_length_.size();
}
inline void AlignmentHeader::clear_query_length() {
  query_length_.Clear();
}
inline ::google::protobuf::uint32 AlignmentHeader::query_length(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.query_length)
  return query_length_.Get(index);
}
inline void AlignmentHeader::set_query_length(int index, ::google::protobuf::uint32 value) {
  query_length_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.query_length)
}
inline void AlignmentHeader::add_query_length(::google::protobuf::uint32 value) {
  query_length_.Add(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentHeader.query_length)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
AlignmentHeader::query_length() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentHeader.query_length)
  return query_length_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
AlignmentHeader::mutable_query_length() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentHeader.query_length)
  return &query_length_;
}

// optional uint32 constant_query_length = 10;
inline bool AlignmentHeader::has_constant_query_length() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void AlignmentHeader::set_has_constant_query_length() {
  _has_bits_[0] |= 0x00000100u;
}
inline void AlignmentHeader::clear_has_constant_query_length() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void AlignmentHeader::clear_constant_query_length() {
  constant_query_length_ = 0u;
  clear_has_constant_query_length();
}
inline ::google::protobuf::uint32 AlignmentHeader::constant_query_length() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.constant_query_length)
  return constant_query_length_;
}
inline void AlignmentHeader::set_constant_query_length(::google::protobuf::uint32 value) {
  set_has_constant_query_length();
  constant_query_length_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.constant_query_length)
}

// repeated uint32 target_length = 8;
inline int AlignmentHeader::target_length_size() const {
  return target_length_.size();
}
inline void AlignmentHeader::clear_target_length() {
  target_length_.Clear();
}
inline ::google::protobuf::uint32 AlignmentHeader::target_length(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.target_length)
  return target_length_.Get(index);
}
inline void AlignmentHeader::set_target_length(int index, ::google::protobuf::uint32 value) {
  target_length_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.target_length)
}
inline void AlignmentHeader::add_target_length(::google::protobuf::uint32 value) {
  target_length_.Add(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentHeader.target_length)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
AlignmentHeader::target_length() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentHeader.target_length)
  return target_length_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
AlignmentHeader::mutable_target_length() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentHeader.target_length)
  return &target_length_;
}

// optional bool sorted = 13;
inline bool AlignmentHeader::has_sorted() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void AlignmentHeader::set_has_sorted() {
  _has_bits_[0] |= 0x00000400u;
}
inline void AlignmentHeader::clear_has_sorted() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void AlignmentHeader::clear_sorted() {
  sorted_ = false;
  clear_has_sorted();
}
inline bool AlignmentHeader::sorted() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.sorted)
  return sorted_;
}
inline void AlignmentHeader::set_sorted(bool value) {
  set_has_sorted();
  sorted_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.sorted)
}

// optional bool indexed = 14;
inline bool AlignmentHeader::has_indexed() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void AlignmentHeader::set_has_indexed() {
  _has_bits_[0] |= 0x00000800u;
}
inline void AlignmentHeader::clear_has_indexed() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void AlignmentHeader::clear_indexed() {
  indexed_ = false;
  clear_has_indexed();
}
inline bool AlignmentHeader::indexed() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.indexed)
  return indexed_;
}
inline void AlignmentHeader::set_indexed(bool value) {
  set_has_indexed();
  indexed_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.indexed)
}

// optional bool query_lengths_stored_in_entries = 15;
inline bool AlignmentHeader::has_query_lengths_stored_in_entries() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void AlignmentHeader::set_has_query_lengths_stored_in_entries() {
  _has_bits_[0] |= 0x00001000u;
}
inline void AlignmentHeader::clear_has_query_lengths_stored_in_entries() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void AlignmentHeader::clear_query_lengths_stored_in_entries() {
  query_lengths_stored_in_entries_ = false;
  clear_has_query_lengths_stored_in_entries();
}
inline bool AlignmentHeader::query_lengths_stored_in_entries() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.query_lengths_stored_in_entries)
  return query_lengths_stored_in_entries_;
}
inline void AlignmentHeader::set_query_lengths_stored_in_entries(bool value) {
  set_has_query_lengths_stored_in_entries();
  query_lengths_stored_in_entries_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.query_lengths_stored_in_entries)
}

// optional string aligner_name = 17;
inline bool AlignmentHeader::has_aligner_name() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void AlignmentHeader::set_has_aligner_name() {
  _has_bits_[0] |= 0x00002000u;
}
inline void AlignmentHeader::clear_has_aligner_name() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void AlignmentHeader::clear_aligner_name() {
  aligner_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_aligner_name();
}
inline const ::std::string& AlignmentHeader::aligner_name() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.aligner_name)
  return aligner_name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentHeader::set_aligner_name(const ::std::string& value) {
  set_has_aligner_name();
  aligner_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.aligner_name)
}
inline void AlignmentHeader::set_aligner_name(const char* value) {
  set_has_aligner_name();
  aligner_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentHeader.aligner_name)
}
inline void AlignmentHeader::set_aligner_name(const char* value, size_t size) {
  set_has_aligner_name();
  aligner_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentHeader.aligner_name)
}
inline ::std::string* AlignmentHeader::mutable_aligner_name() {
  set_has_aligner_name();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.aligner_name)
  return aligner_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentHeader::release_aligner_name() {
  // @@protoc_insertion_point(field_release:goby.AlignmentHeader.aligner_name)
  clear_has_aligner_name();
  return aligner_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentHeader::set_allocated_aligner_name(::std::string* aligner_name) {
  if (aligner_name != NULL) {
    set_has_aligner_name();
  } else {
    clear_has_aligner_name();
  }
  aligner_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), aligner_name);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentHeader.aligner_name)
}

// optional string aligner_version = 18;
inline bool AlignmentHeader::has_aligner_version() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void AlignmentHeader::set_has_aligner_version() {
  _has_bits_[0] |= 0x00004000u;
}
inline void AlignmentHeader::clear_has_aligner_version() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void AlignmentHeader::clear_aligner_version() {
  aligner_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_aligner_version();
}
inline const ::std::string& AlignmentHeader::aligner_version() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.aligner_version)
  return aligner_version_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentHeader::set_aligner_version(const ::std::string& value) {
  set_has_aligner_version();
  aligner_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.aligner_version)
}
inline void AlignmentHeader::set_aligner_version(const char* value) {
  set_has_aligner_version();
  aligner_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentHeader.aligner_version)
}
inline void AlignmentHeader::set_aligner_version(const char* value, size_t size) {
  set_has_aligner_version();
  aligner_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentHeader.aligner_version)
}
inline ::std::string* AlignmentHeader::mutable_aligner_version() {
  set_has_aligner_version();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.aligner_version)
  return aligner_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentHeader::release_aligner_version() {
  // @@protoc_insertion_point(field_release:goby.AlignmentHeader.aligner_version)
  clear_has_aligner_version();
  return aligner_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentHeader::set_allocated_aligner_version(::std::string* aligner_version) {
  if (aligner_version != NULL) {
    set_has_aligner_version();
  } else {
    clear_has_aligner_version();
  }
  aligner_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), aligner_version);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentHeader.aligner_version)
}

// optional string version = 25;
inline bool AlignmentHeader::has_version() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void AlignmentHeader::set_has_version() {
  _has_bits_[0] |= 0x00008000u;
}
inline void AlignmentHeader::clear_has_version() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void AlignmentHeader::clear_version() {
  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_version();
}
inline const ::std::string& AlignmentHeader::version() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.version)
  return version_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentHeader::set_version(const ::std::string& value) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.version)
}
inline void AlignmentHeader::set_version(const char* value) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.AlignmentHeader.version)
}
inline void AlignmentHeader::set_version(const char* value, size_t size) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentHeader.version)
}
inline ::std::string* AlignmentHeader::mutable_version() {
  set_has_version();
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.version)
  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AlignmentHeader::release_version() {
  // @@protoc_insertion_point(field_release:goby.AlignmentHeader.version)
  clear_has_version();
  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AlignmentHeader::set_allocated_version(::std::string* version) {
  if (version != NULL) {
    set_has_version();
  } else {
    clear_has_version();
  }
  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
  // @@protoc_insertion_point(field_set_allocated:goby.AlignmentHeader.version)
}

// repeated string sample_basename = 30;
inline int AlignmentHeader::sample_basename_size() const {
  return sample_basename_.size();
}
inline void AlignmentHeader::clear_sample_basename() {
  sample_basename_.Clear();
}
inline const ::std::string& AlignmentHeader::sample_basename(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.sample_basename)
  return sample_basename_.Get(index);
}
inline ::std::string* AlignmentHeader::mutable_sample_basename(int index) {
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.sample_basename)
  return sample_basename_.Mutable(index);
}
inline void AlignmentHeader::set_sample_basename(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.sample_basename)
  sample_basename_.Mutable(index)->assign(value);
}
inline void AlignmentHeader::set_sample_basename(int index, const char* value) {
  sample_basename_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.AlignmentHeader.sample_basename)
}
inline void AlignmentHeader::set_sample_basename(int index, const char* value, size_t size) {
  sample_basename_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.AlignmentHeader.sample_basename)
}
inline ::std::string* AlignmentHeader::add_sample_basename() {
  // @@protoc_insertion_point(field_add_mutable:goby.AlignmentHeader.sample_basename)
  return sample_basename_.Add();
}
inline void AlignmentHeader::add_sample_basename(const ::std::string& value) {
  sample_basename_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentHeader.sample_basename)
}
inline void AlignmentHeader::add_sample_basename(const char* value) {
  sample_basename_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.AlignmentHeader.sample_basename)
}
inline void AlignmentHeader::add_sample_basename(const char* value, size_t size) {
  sample_basename_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.AlignmentHeader.sample_basename)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
AlignmentHeader::sample_basename() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentHeader.sample_basename)
  return sample_basename_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
AlignmentHeader::mutable_sample_basename() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentHeader.sample_basename)
  return &sample_basename_;
}

// optional bool query_indices_were_permuted = 26;
inline bool AlignmentHeader::has_query_indices_were_permuted() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void AlignmentHeader::set_has_query_indices_were_permuted() {
  _has_bits_[0] |= 0x00020000u;
}
inline void AlignmentHeader::clear_has_query_indices_were_permuted() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void AlignmentHeader::clear_query_indices_were_permuted() {
  query_indices_were_permuted_ = false;
  clear_has_query_indices_were_permuted();
}
inline bool AlignmentHeader::query_indices_were_permuted() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.query_indices_were_permuted)
  return query_indices_were_permuted_;
}
inline void AlignmentHeader::set_query_indices_were_permuted(bool value) {
  set_has_query_indices_were_permuted();
  query_indices_were_permuted_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.query_indices_were_permuted)
}

// optional bool query_index_occurrences = 35;
inline bool AlignmentHeader::has_query_index_occurrences() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void AlignmentHeader::set_has_query_index_occurrences() {
  _has_bits_[0] |= 0x00040000u;
}
inline void AlignmentHeader::clear_has_query_index_occurrences() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void AlignmentHeader::clear_query_index_occurrences() {
  query_index_occurrences_ = false;
  clear_has_query_index_occurrences();
}
inline bool AlignmentHeader::query_index_occurrences() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.query_index_occurrences)
  return query_index_occurrences_;
}
inline void AlignmentHeader::set_query_index_occurrences(bool value) {
  set_has_query_index_occurrences();
  query_index_occurrences_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.query_index_occurrences)
}

// optional bool ambiguity_stored_in_entries = 36;
inline bool AlignmentHeader::has_ambiguity_stored_in_entries() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void AlignmentHeader::set_has_ambiguity_stored_in_entries() {
  _has_bits_[0] |= 0x00080000u;
}
inline void AlignmentHeader::clear_has_ambiguity_stored_in_entries() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void AlignmentHeader::clear_ambiguity_stored_in_entries() {
  ambiguity_stored_in_entries_ = false;
  clear_has_ambiguity_stored_in_entries();
}
inline bool AlignmentHeader::ambiguity_stored_in_entries() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.ambiguity_stored_in_entries)
  return ambiguity_stored_in_entries_;
}
inline void AlignmentHeader::set_ambiguity_stored_in_entries(bool value) {
  set_has_ambiguity_stored_in_entries();
  ambiguity_stored_in_entries_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.ambiguity_stored_in_entries)
}

// optional bool all_read_quality_scores = 40;
inline bool AlignmentHeader::has_all_read_quality_scores() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void AlignmentHeader::set_has_all_read_quality_scores() {
  _has_bits_[0] |= 0x00100000u;
}
inline void AlignmentHeader::clear_has_all_read_quality_scores() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void AlignmentHeader::clear_all_read_quality_scores() {
  all_read_quality_scores_ = false;
  clear_has_all_read_quality_scores();
}
inline bool AlignmentHeader::all_read_quality_scores() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.all_read_quality_scores)
  return all_read_quality_scores_;
}
inline void AlignmentHeader::set_all_read_quality_scores(bool value) {
  set_has_all_read_quality_scores();
  all_read_quality_scores_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentHeader.all_read_quality_scores)
}

// repeated .goby.ReadOriginInfo read_origin = 27;
inline int AlignmentHeader::read_origin_size() const {
  return read_origin_.size();
}
inline void AlignmentHeader::clear_read_origin() {
  read_origin_.Clear();
}
inline const ::goby::ReadOriginInfo& AlignmentHeader::read_origin(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentHeader.read_origin)
  return read_origin_.Get(index);
}
inline ::goby::ReadOriginInfo* AlignmentHeader::mutable_read_origin(int index) {
  // @@protoc_insertion_point(field_mutable:goby.AlignmentHeader.read_origin)
  return read_origin_.Mutable(index);
}
inline ::goby::ReadOriginInfo* AlignmentHeader::add_read_origin() {
  // @@protoc_insertion_point(field_add:goby.AlignmentHeader.read_origin)
  return read_origin_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::goby::ReadOriginInfo >*
AlignmentHeader::mutable_read_origin() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentHeader.read_origin)
  return &read_origin_;
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::ReadOriginInfo >&
AlignmentHeader::read_origin() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentHeader.read_origin)
  return read_origin_;
}

// -------------------------------------------------------------------

// IdentifierMapping

// repeated .goby.IdentifierInfo mappings = 1;
inline int IdentifierMapping::mappings_size() const {
  return mappings_.size();
}
inline void IdentifierMapping::clear_mappings() {
  mappings_.Clear();
}
inline const ::goby::IdentifierInfo& IdentifierMapping::mappings(int index) const {
  // @@protoc_insertion_point(field_get:goby.IdentifierMapping.mappings)
  return mappings_.Get(index);
}
inline ::goby::IdentifierInfo* IdentifierMapping::mutable_mappings(int index) {
  // @@protoc_insertion_point(field_mutable:goby.IdentifierMapping.mappings)
  return mappings_.Mutable(index);
}
inline ::goby::IdentifierInfo* IdentifierMapping::add_mappings() {
  // @@protoc_insertion_point(field_add:goby.IdentifierMapping.mappings)
  return mappings_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >*
IdentifierMapping::mutable_mappings() {
  // @@protoc_insertion_point(field_mutable_list:goby.IdentifierMapping.mappings)
  return &mappings_;
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >&
IdentifierMapping::mappings() const {
  // @@protoc_insertion_point(field_list:goby.IdentifierMapping.mappings)
  return mappings_;
}

// -------------------------------------------------------------------

// IdentifierInfo

// required string name = 1;
inline bool IdentifierInfo::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void IdentifierInfo::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void IdentifierInfo::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void IdentifierInfo::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& IdentifierInfo::name() const {
  // @@protoc_insertion_point(field_get:goby.IdentifierInfo.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void IdentifierInfo::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.IdentifierInfo.name)
}
inline void IdentifierInfo::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.IdentifierInfo.name)
}
inline void IdentifierInfo::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.IdentifierInfo.name)
}
inline ::std::string* IdentifierInfo::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:goby.IdentifierInfo.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* IdentifierInfo::release_name() {
  // @@protoc_insertion_point(field_release:goby.IdentifierInfo.name)
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void IdentifierInfo::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:goby.IdentifierInfo.name)
}

// required uint32 index = 2;
inline bool IdentifierInfo::has_index() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void IdentifierInfo::set_has_index() {
  _has_bits_[0] |= 0x00000002u;
}
inline void IdentifierInfo::clear_has_index() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void IdentifierInfo::clear_index() {
  index_ = 0u;
  clear_has_index();
}
inline ::google::protobuf::uint32 IdentifierInfo::index() const {
  // @@protoc_insertion_point(field_get:goby.IdentifierInfo.index)
  return index_;
}
inline void IdentifierInfo::set_index(::google::protobuf::uint32 value) {
  set_has_index();
  index_ = value;
  // @@protoc_insertion_point(field_set:goby.IdentifierInfo.index)
}

// -------------------------------------------------------------------

// ReadOriginInfo

// required uint32 origin_index = 1;
inline bool ReadOriginInfo::has_origin_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReadOriginInfo::set_has_origin_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReadOriginInfo::clear_has_origin_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReadOriginInfo::clear_origin_index() {
  origin_index_ = 0u;
  clear_has_origin_index();
}
inline ::google::protobuf::uint32 ReadOriginInfo::origin_index() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.origin_index)
  return origin_index_;
}
inline void ReadOriginInfo::set_origin_index(::google::protobuf::uint32 value) {
  set_has_origin_index();
  origin_index_ = value;
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.origin_index)
}

// required string origin_id = 2;
inline bool ReadOriginInfo::has_origin_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReadOriginInfo::set_has_origin_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReadOriginInfo::clear_has_origin_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReadOriginInfo::clear_origin_id() {
  origin_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_origin_id();
}
inline const ::std::string& ReadOriginInfo::origin_id() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.origin_id)
  return origin_id_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_origin_id(const ::std::string& value) {
  set_has_origin_id();
  origin_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.origin_id)
}
inline void ReadOriginInfo::set_origin_id(const char* value) {
  set_has_origin_id();
  origin_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.ReadOriginInfo.origin_id)
}
inline void ReadOriginInfo::set_origin_id(const char* value, size_t size) {
  set_has_origin_id();
  origin_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.ReadOriginInfo.origin_id)
}
inline ::std::string* ReadOriginInfo::mutable_origin_id() {
  set_has_origin_id();
  // @@protoc_insertion_point(field_mutable:goby.ReadOriginInfo.origin_id)
  return origin_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadOriginInfo::release_origin_id() {
  // @@protoc_insertion_point(field_release:goby.ReadOriginInfo.origin_id)
  clear_has_origin_id();
  return origin_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_allocated_origin_id(::std::string* origin_id) {
  if (origin_id != NULL) {
    set_has_origin_id();
  } else {
    clear_has_origin_id();
  }
  origin_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), origin_id);
  // @@protoc_insertion_point(field_set_allocated:goby.ReadOriginInfo.origin_id)
}

// optional string sample = 4;
inline bool ReadOriginInfo::has_sample() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReadOriginInfo::set_has_sample() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ReadOriginInfo::clear_has_sample() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ReadOriginInfo::clear_sample() {
  sample_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_sample();
}
inline const ::std::string& ReadOriginInfo::sample() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.sample)
  return sample_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_sample(const ::std::string& value) {
  set_has_sample();
  sample_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.sample)
}
inline void ReadOriginInfo::set_sample(const char* value) {
  set_has_sample();
  sample_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.ReadOriginInfo.sample)
}
inline void ReadOriginInfo::set_sample(const char* value, size_t size) {
  set_has_sample();
  sample_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.ReadOriginInfo.sample)
}
inline ::std::string* ReadOriginInfo::mutable_sample() {
  set_has_sample();
  // @@protoc_insertion_point(field_mutable:goby.ReadOriginInfo.sample)
  return sample_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadOriginInfo::release_sample() {
  // @@protoc_insertion_point(field_release:goby.ReadOriginInfo.sample)
  clear_has_sample();
  return sample_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_allocated_sample(::std::string* sample) {
  if (sample != NULL) {
    set_has_sample();
  } else {
    clear_has_sample();
  }
  sample_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sample);
  // @@protoc_insertion_point(field_set_allocated:goby.ReadOriginInfo.sample)
}

// optional string platform = 5;
inline bool ReadOriginInfo::has_platform() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ReadOriginInfo::set_has_platform() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ReadOriginInfo::clear_has_platform() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ReadOriginInfo::clear_platform() {
  platform_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_platform();
}
inline const ::std::string& ReadOriginInfo::platform() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.platform)
  return platform_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_platform(const ::std::string& value) {
  set_has_platform();
  platform_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.platform)
}
inline void ReadOriginInfo::set_platform(const char* value) {
  set_has_platform();
  platform_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.ReadOriginInfo.platform)
}
inline void ReadOriginInfo::set_platform(const char* value, size_t size) {
  set_has_platform();
  platform_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.ReadOriginInfo.platform)
}
inline ::std::string* ReadOriginInfo::mutable_platform() {
  set_has_platform();
  // @@protoc_insertion_point(field_mutable:goby.ReadOriginInfo.platform)
  return platform_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadOriginInfo::release_platform() {
  // @@protoc_insertion_point(field_release:goby.ReadOriginInfo.platform)
  clear_has_platform();
  return platform_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_allocated_platform(::std::string* platform) {
  if (platform != NULL) {
    set_has_platform();
  } else {
    clear_has_platform();
  }
  platform_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), platform);
  // @@protoc_insertion_point(field_set_allocated:goby.ReadOriginInfo.platform)
}

// optional string library = 8;
inline bool ReadOriginInfo::has_library() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ReadOriginInfo::set_has_library() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ReadOriginInfo::clear_has_library() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ReadOriginInfo::clear_library() {
  library_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_library();
}
inline const ::std::string& ReadOriginInfo::library() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.library)
  return library_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_library(const ::std::string& value) {
  set_has_library();
  library_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.library)
}
inline void ReadOriginInfo::set_library(const char* value) {
  set_has_library();
  library_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.ReadOriginInfo.library)
}
inline void ReadOriginInfo::set_library(const char* value, size_t size) {
  set_has_library();
  library_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.ReadOriginInfo.library)
}
inline ::std::string* ReadOriginInfo::mutable_library() {
  set_has_library();
  // @@protoc_insertion_point(field_mutable:goby.ReadOriginInfo.library)
  return library_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadOriginInfo::release_library() {
  // @@protoc_insertion_point(field_release:goby.ReadOriginInfo.library)
  clear_has_library();
  return library_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_allocated_library(::std::string* library) {
  if (library != NULL) {
    set_has_library();
  } else {
    clear_has_library();
  }
  library_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), library);
  // @@protoc_insertion_point(field_set_allocated:goby.ReadOriginInfo.library)
}

// optional string platform_unit = 12;
inline bool ReadOriginInfo::has_platform_unit() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ReadOriginInfo::set_has_platform_unit() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ReadOriginInfo::clear_has_platform_unit() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ReadOriginInfo::clear_platform_unit() {
  platform_unit_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_platform_unit();
}
inline const ::std::string& ReadOriginInfo::platform_unit() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.platform_unit)
  return platform_unit_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_platform_unit(const ::std::string& value) {
  set_has_platform_unit();
  platform_unit_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.platform_unit)
}
inline void ReadOriginInfo::set_platform_unit(const char* value) {
  set_has_platform_unit();
  platform_unit_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.ReadOriginInfo.platform_unit)
}
inline void ReadOriginInfo::set_platform_unit(const char* value, size_t size) {
  set_has_platform_unit();
  platform_unit_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.ReadOriginInfo.platform_unit)
}
inline ::std::string* ReadOriginInfo::mutable_platform_unit() {
  set_has_platform_unit();
  // @@protoc_insertion_point(field_mutable:goby.ReadOriginInfo.platform_unit)
  return platform_unit_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadOriginInfo::release_platform_unit() {
  // @@protoc_insertion_point(field_release:goby.ReadOriginInfo.platform_unit)
  clear_has_platform_unit();
  return platform_unit_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_allocated_platform_unit(::std::string* platform_unit) {
  if (platform_unit != NULL) {
    set_has_platform_unit();
  } else {
    clear_has_platform_unit();
  }
  platform_unit_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), platform_unit);
  // @@protoc_insertion_point(field_set_allocated:goby.ReadOriginInfo.platform_unit)
}

// optional string run_date = 6;
inline bool ReadOriginInfo::has_run_date() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ReadOriginInfo::set_has_run_date() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ReadOriginInfo::clear_has_run_date() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ReadOriginInfo::clear_run_date() {
  run_date_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_run_date();
}
inline const ::std::string& ReadOriginInfo::run_date() const {
  // @@protoc_insertion_point(field_get:goby.ReadOriginInfo.run_date)
  return run_date_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_run_date(const ::std::string& value) {
  set_has_run_date();
  run_date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.ReadOriginInfo.run_date)
}
inline void ReadOriginInfo::set_run_date(const char* value) {
  set_has_run_date();
  run_date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.ReadOriginInfo.run_date)
}
inline void ReadOriginInfo::set_run_date(const char* value, size_t size) {
  set_has_run_date();
  run_date_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.ReadOriginInfo.run_date)
}
inline ::std::string* ReadOriginInfo::mutable_run_date() {
  set_has_run_date();
  // @@protoc_insertion_point(field_mutable:goby.ReadOriginInfo.run_date)
  return run_date_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadOriginInfo::release_run_date() {
  // @@protoc_insertion_point(field_release:goby.ReadOriginInfo.run_date)
  clear_has_run_date();
  return run_date_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadOriginInfo::set_allocated_run_date(::std::string* run_date) {
  if (run_date != NULL) {
    set_has_run_date();
  } else {
    clear_has_run_date();
  }
  run_date_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), run_date);
  // @@protoc_insertion_point(field_set_allocated:goby.ReadOriginInfo.run_date)
}

// -------------------------------------------------------------------

// AlignmentTooManyHits

// required uint32 aligner_threshold = 2;
inline bool AlignmentTooManyHits::has_aligner_threshold() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AlignmentTooManyHits::set_has_aligner_threshold() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AlignmentTooManyHits::clear_has_aligner_threshold() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AlignmentTooManyHits::clear_aligner_threshold() {
  aligner_threshold_ = 0u;
  clear_has_aligner_threshold();
}
inline ::google::protobuf::uint32 AlignmentTooManyHits::aligner_threshold() const {
  // @@protoc_insertion_point(field_get:goby.AlignmentTooManyHits.aligner_threshold)
  return aligner_threshold_;
}
inline void AlignmentTooManyHits::set_aligner_threshold(::google::protobuf::uint32 value) {
  set_has_aligner_threshold();
  aligner_threshold_ = value;
  // @@protoc_insertion_point(field_set:goby.AlignmentTooManyHits.aligner_threshold)
}

// repeated .goby.AmbiguousLocation hits = 1;
inline int AlignmentTooManyHits::hits_size() const {
  return hits_.size();
}
inline void AlignmentTooManyHits::clear_hits() {
  hits_.Clear();
}
inline const ::goby::AmbiguousLocation& AlignmentTooManyHits::hits(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentTooManyHits.hits)
  return hits_.Get(index);
}
inline ::goby::AmbiguousLocation* AlignmentTooManyHits::mutable_hits(int index) {
  // @@protoc_insertion_point(field_mutable:goby.AlignmentTooManyHits.hits)
  return hits_.Mutable(index);
}
inline ::goby::AmbiguousLocation* AlignmentTooManyHits::add_hits() {
  // @@protoc_insertion_point(field_add:goby.AlignmentTooManyHits.hits)
  return hits_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >*
AlignmentTooManyHits::mutable_hits() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentTooManyHits.hits)
  return &hits_;
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >&
AlignmentTooManyHits::hits() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentTooManyHits.hits)
  return hits_;
}

// -------------------------------------------------------------------

// AmbiguousLocation

// required uint32 query_index = 1;
inline bool AmbiguousLocation::has_query_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AmbiguousLocation::set_has_query_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AmbiguousLocation::clear_has_query_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AmbiguousLocation::clear_query_index() {
  query_index_ = 0u;
  clear_has_query_index();
}
inline ::google::protobuf::uint32 AmbiguousLocation::query_index() const {
  // @@protoc_insertion_point(field_get:goby.AmbiguousLocation.query_index)
  return query_index_;
}
inline void AmbiguousLocation::set_query_index(::google::protobuf::uint32 value) {
  set_has_query_index();
  query_index_ = value;
  // @@protoc_insertion_point(field_set:goby.AmbiguousLocation.query_index)
}

// required uint32 at_least_number_of_hits = 2;
inline bool AmbiguousLocation::has_at_least_number_of_hits() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AmbiguousLocation::set_has_at_least_number_of_hits() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AmbiguousLocation::clear_has_at_least_number_of_hits() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AmbiguousLocation::clear_at_least_number_of_hits() {
  at_least_number_of_hits_ = 0u;
  clear_has_at_least_number_of_hits();
}
inline ::google::protobuf::uint32 AmbiguousLocation::at_least_number_of_hits() const {
  // @@protoc_insertion_point(field_get:goby.AmbiguousLocation.at_least_number_of_hits)
  return at_least_number_of_hits_;
}
inline void AmbiguousLocation::set_at_least_number_of_hits(::google::protobuf::uint32 value) {
  set_has_at_least_number_of_hits();
  at_least_number_of_hits_ = value;
  // @@protoc_insertion_point(field_set:goby.AmbiguousLocation.at_least_number_of_hits)
}

// optional uint32 length_of_match = 3;
inline bool AmbiguousLocation::has_length_of_match() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AmbiguousLocation::set_has_length_of_match() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AmbiguousLocation::clear_has_length_of_match() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AmbiguousLocation::clear_length_of_match() {
  length_of_match_ = 0u;
  clear_has_length_of_match();
}
inline ::google::protobuf::uint32 AmbiguousLocation::length_of_match() const {
  // @@protoc_insertion_point(field_get:goby.AmbiguousLocation.length_of_match)
  return length_of_match_;
}
inline void AmbiguousLocation::set_length_of_match(::google::protobuf::uint32 value) {
  set_has_length_of_match();
  length_of_match_ = value;
  // @@protoc_insertion_point(field_set:goby.AmbiguousLocation.length_of_match)
}

// -------------------------------------------------------------------

// AlignmentIndex

// repeated uint32 target_position_offsets = 1 [packed = true];
inline int AlignmentIndex::target_position_offsets_size() const {
  return target_position_offsets_.size();
}
inline void AlignmentIndex::clear_target_position_offsets() {
  target_position_offsets_.Clear();
}
inline ::google::protobuf::uint32 AlignmentIndex::target_position_offsets(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentIndex.target_position_offsets)
  return target_position_offsets_.Get(index);
}
inline void AlignmentIndex::set_target_position_offsets(int index, ::google::protobuf::uint32 value) {
  target_position_offsets_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.AlignmentIndex.target_position_offsets)
}
inline void AlignmentIndex::add_target_position_offsets(::google::protobuf::uint32 value) {
  target_position_offsets_.Add(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentIndex.target_position_offsets)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
AlignmentIndex::target_position_offsets() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentIndex.target_position_offsets)
  return target_position_offsets_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
AlignmentIndex::mutable_target_position_offsets() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentIndex.target_position_offsets)
  return &target_position_offsets_;
}

// repeated uint64 offsets = 2 [packed = true];
inline int AlignmentIndex::offsets_size() const {
  return offsets_.size();
}
inline void AlignmentIndex::clear_offsets() {
  offsets_.Clear();
}
inline ::google::protobuf::uint64 AlignmentIndex::offsets(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentIndex.offsets)
  return offsets_.Get(index);
}
inline void AlignmentIndex::set_offsets(int index, ::google::protobuf::uint64 value) {
  offsets_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.AlignmentIndex.offsets)
}
inline void AlignmentIndex::add_offsets(::google::protobuf::uint64 value) {
  offsets_.Add(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentIndex.offsets)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
AlignmentIndex::offsets() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentIndex.offsets)
  return offsets_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
AlignmentIndex::mutable_offsets() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentIndex.offsets)
  return &offsets_;
}

// repeated uint64 absolute_positions = 3 [packed = true];
inline int AlignmentIndex::absolute_positions_size() const {
  return absolute_positions_.size();
}
inline void AlignmentIndex::clear_absolute_positions() {
  absolute_positions_.Clear();
}
inline ::google::protobuf::uint64 AlignmentIndex::absolute_positions(int index) const {
  // @@protoc_insertion_point(field_get:goby.AlignmentIndex.absolute_positions)
  return absolute_positions_.Get(index);
}
inline void AlignmentIndex::set_absolute_positions(int index, ::google::protobuf::uint64 value) {
  absolute_positions_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.AlignmentIndex.absolute_positions)
}
inline void AlignmentIndex::add_absolute_positions(::google::protobuf::uint64 value) {
  absolute_positions_.Add(value);
  // @@protoc_insertion_point(field_add:goby.AlignmentIndex.absolute_positions)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
AlignmentIndex::absolute_positions() const {
  // @@protoc_insertion_point(field_list:goby.AlignmentIndex.absolute_positions)
  return absolute_positions_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
AlignmentIndex::mutable_absolute_positions() {
  // @@protoc_insertion_point(field_mutable_list:goby.AlignmentIndex.absolute_positions)
  return &absolute_positions_;
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace goby

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_Alignments_2eproto__INCLUDED
