// 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 < 2004000
#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 2004001 < 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/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.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 RelatedAlignmentEntry;
class SequenceVariation;
class AlignmentHeader;
class IdentifierMapping;
class IdentifierInfo;
class AlignmentTooManyHits;
class AmbiguousLocation;
class AlignmentIndex;

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

class AlignmentCollection : public ::google::protobuf::Message {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentCollection& default_instance();
  
  void Swap(AlignmentCollection* other);
  
  // implements Message ----------------------------------------------
  
  AlignmentCollection* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated .goby.AlignmentEntry alignment_entries = 1;
  inline int alignment_entries_size() const;
  inline void clear_alignment_entries();
  static const int kAlignmentEntriesFieldNumber = 1;
  inline const ::goby::AlignmentEntry& alignment_entries(int index) const;
  inline ::goby::AlignmentEntry* mutable_alignment_entries(int index);
  inline ::goby::AlignmentEntry* add_alignment_entries();
  inline const ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >&
      alignment_entries() const;
  inline ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >*
      mutable_alignment_entries();
  
  // @@protoc_insertion_point(class_scope:goby.AlignmentCollection)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry > alignment_entries_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentEntry& default_instance();
  
  void Swap(AlignmentEntry* other);
  
  // implements Message ----------------------------------------------
  
  AlignmentEntry* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 multiplicity = 7;
  inline bool has_multiplicity() const;
  inline void clear_multiplicity();
  static const int kMultiplicityFieldNumber = 7;
  inline ::google::protobuf::uint32 multiplicity() const;
  inline void set_multiplicity(::google::protobuf::uint32 value);
  
  // required uint32 query_index = 1;
  inline bool has_query_index() const;
  inline void clear_query_index();
  static const int kQueryIndexFieldNumber = 1;
  inline ::google::protobuf::uint32 query_index() const;
  inline void set_query_index(::google::protobuf::uint32 value);
  
  // required uint32 target_index = 2;
  inline bool has_target_index() const;
  inline void clear_target_index();
  static const int kTargetIndexFieldNumber = 2;
  inline ::google::protobuf::uint32 target_index() const;
  inline void set_target_index(::google::protobuf::uint32 value);
  
  // required uint32 position = 3;
  inline bool has_position() const;
  inline void clear_position();
  static const int kPositionFieldNumber = 3;
  inline ::google::protobuf::uint32 position() const;
  inline void set_position(::google::protobuf::uint32 value);
  
  // required bool matching_reverse_strand = 6;
  inline bool has_matching_reverse_strand() const;
  inline void clear_matching_reverse_strand();
  static const int kMatchingReverseStrandFieldNumber = 6;
  inline bool matching_reverse_strand() const;
  inline void set_matching_reverse_strand(bool value);
  
  // optional uint32 query_position = 5;
  inline bool has_query_position() const;
  inline void clear_query_position();
  static const int kQueryPositionFieldNumber = 5;
  inline ::google::protobuf::uint32 query_position() const;
  inline void set_query_position(::google::protobuf::uint32 value);
  
  // optional float score = 4;
  inline bool has_score() const;
  inline void clear_score();
  static const int kScoreFieldNumber = 4;
  inline float score() const;
  inline void set_score(float value);
  
  // optional uint32 number_of_mismatches = 8;
  inline bool has_number_of_mismatches() const;
  inline void clear_number_of_mismatches();
  static const int kNumberOfMismatchesFieldNumber = 8;
  inline ::google::protobuf::uint32 number_of_mismatches() const;
  inline void set_number_of_mismatches(::google::protobuf::uint32 value);
  
  // optional uint32 number_of_indels = 9;
  inline bool has_number_of_indels() const;
  inline void clear_number_of_indels();
  static const int kNumberOfIndelsFieldNumber = 9;
  inline ::google::protobuf::uint32 number_of_indels() const;
  inline void set_number_of_indels(::google::protobuf::uint32 value);
  
  // optional uint32 query_aligned_length = 11;
  inline bool has_query_aligned_length() const;
  inline void clear_query_aligned_length();
  static const int kQueryAlignedLengthFieldNumber = 11;
  inline ::google::protobuf::uint32 query_aligned_length() const;
  inline void set_query_aligned_length(::google::protobuf::uint32 value);
  
  // optional uint32 target_aligned_length = 12;
  inline bool has_target_aligned_length() const;
  inline void clear_target_aligned_length();
  static const int kTargetAlignedLengthFieldNumber = 12;
  inline ::google::protobuf::uint32 target_aligned_length() const;
  inline void set_target_aligned_length(::google::protobuf::uint32 value);
  
  // repeated .goby.SequenceVariation sequence_variations = 13;
  inline int sequence_variations_size() const;
  inline void clear_sequence_variations();
  static const int kSequenceVariationsFieldNumber = 13;
  inline const ::goby::SequenceVariation& sequence_variations(int index) const;
  inline ::goby::SequenceVariation* mutable_sequence_variations(int index);
  inline ::goby::SequenceVariation* add_sequence_variations();
  inline const ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >&
      sequence_variations() const;
  inline ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >*
      mutable_sequence_variations();
  
  // optional uint32 query_length = 10;
  inline bool has_query_length() const;
  inline void clear_query_length();
  static const int kQueryLengthFieldNumber = 10;
  inline ::google::protobuf::uint32 query_length() const;
  inline void set_query_length(::google::protobuf::uint32 value);
  
  // optional int32 mapping_quality = 14;
  inline bool has_mapping_quality() const;
  inline void clear_mapping_quality();
  static const int kMappingQualityFieldNumber = 14;
  inline ::google::protobuf::int32 mapping_quality() const;
  inline void set_mapping_quality(::google::protobuf::int32 value);
  
  // optional uint32 pair_flags = 15;
  inline bool has_pair_flags() const;
  inline void clear_pair_flags();
  static const int kPairFlagsFieldNumber = 15;
  inline ::google::protobuf::uint32 pair_flags() const;
  inline void set_pair_flags(::google::protobuf::uint32 value);
  
  // optional .goby.RelatedAlignmentEntry pair_alignment_link = 16;
  inline bool has_pair_alignment_link() const;
  inline void clear_pair_alignment_link();
  static const int kPairAlignmentLinkFieldNumber = 16;
  inline const ::goby::RelatedAlignmentEntry& pair_alignment_link() const;
  inline ::goby::RelatedAlignmentEntry* mutable_pair_alignment_link();
  inline ::goby::RelatedAlignmentEntry* release_pair_alignment_link();
  
  // optional uint32 fragment_index = 17;
  inline bool has_fragment_index() const;
  inline void clear_fragment_index();
  static const int kFragmentIndexFieldNumber = 17;
  inline ::google::protobuf::uint32 fragment_index() const;
  inline void set_fragment_index(::google::protobuf::uint32 value);
  
  // optional .goby.RelatedAlignmentEntry spliced_forward_alignment_link = 18;
  inline bool has_spliced_forward_alignment_link() const;
  inline void clear_spliced_forward_alignment_link();
  static const int kSplicedForwardAlignmentLinkFieldNumber = 18;
  inline const ::goby::RelatedAlignmentEntry& spliced_forward_alignment_link() const;
  inline ::goby::RelatedAlignmentEntry* mutable_spliced_forward_alignment_link();
  inline ::goby::RelatedAlignmentEntry* release_spliced_forward_alignment_link();
  
  // optional .goby.RelatedAlignmentEntry spliced_backward_alignment_link = 22;
  inline bool has_spliced_backward_alignment_link() const;
  inline void clear_spliced_backward_alignment_link();
  static const int kSplicedBackwardAlignmentLinkFieldNumber = 22;
  inline const ::goby::RelatedAlignmentEntry& spliced_backward_alignment_link() const;
  inline ::goby::RelatedAlignmentEntry* mutable_spliced_backward_alignment_link();
  inline ::goby::RelatedAlignmentEntry* release_spliced_backward_alignment_link();
  
  // optional uint32 spliced_flags = 19;
  inline bool has_spliced_flags() const;
  inline void clear_spliced_flags();
  static const int kSplicedFlagsFieldNumber = 19;
  inline ::google::protobuf::uint32 spliced_flags() const;
  inline void set_spliced_flags(::google::protobuf::uint32 value);
  
  // optional uint32 insert_size = 20;
  inline bool has_insert_size() const;
  inline void clear_insert_size();
  static const int kInsertSizeFieldNumber = 20;
  inline ::google::protobuf::uint32 insert_size() const;
  inline void set_insert_size(::google::protobuf::uint32 value);
  
  // optional uint32 sample_index = 21;
  inline bool has_sample_index() const;
  inline void clear_sample_index();
  static const int kSampleIndexFieldNumber = 21;
  inline ::google::protobuf::uint32 sample_index() const;
  inline void set_sample_index(::google::protobuf::uint32 value);
  
  // @@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();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::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::uint32 insert_size_;
  ::google::protobuf::uint32 sample_index_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(22 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const RelatedAlignmentEntry& default_instance();
  
  void Swap(RelatedAlignmentEntry* other);
  
  // implements Message ----------------------------------------------
  
  RelatedAlignmentEntry* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 target_index = 1;
  inline bool has_target_index() const;
  inline void clear_target_index();
  static const int kTargetIndexFieldNumber = 1;
  inline ::google::protobuf::uint32 target_index() const;
  inline void set_target_index(::google::protobuf::uint32 value);
  
  // required uint32 position = 2;
  inline bool has_position() const;
  inline void clear_position();
  static const int kPositionFieldNumber = 2;
  inline ::google::protobuf::uint32 position() const;
  inline void set_position(::google::protobuf::uint32 value);
  
  // required uint32 fragment_index = 3;
  inline bool has_fragment_index() const;
  inline void clear_fragment_index();
  static const int kFragmentIndexFieldNumber = 3;
  inline ::google::protobuf::uint32 fragment_index() const;
  inline void set_fragment_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();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint32 target_index_;
  ::google::protobuf::uint32 position_;
  ::google::protobuf::uint32 fragment_index_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const SequenceVariation& default_instance();
  
  void Swap(SequenceVariation* other);
  
  // implements Message ----------------------------------------------
  
  SequenceVariation* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string from = 2;
  inline bool has_from() const;
  inline void clear_from();
  static const int kFromFieldNumber = 2;
  inline const ::std::string& from() const;
  inline void set_from(const ::std::string& value);
  inline void set_from(const char* value);
  inline void set_from(const char* value, size_t size);
  inline ::std::string* mutable_from();
  inline ::std::string* release_from();
  
  // required string to = 1;
  inline bool has_to() const;
  inline void clear_to();
  static const int kToFieldNumber = 1;
  inline const ::std::string& to() const;
  inline void set_to(const ::std::string& value);
  inline void set_to(const char* value);
  inline void set_to(const char* value, size_t size);
  inline ::std::string* mutable_to();
  inline ::std::string* release_to();
  
  // required uint32 position = 3;
  inline bool has_position() const;
  inline void clear_position();
  static const int kPositionFieldNumber = 3;
  inline ::google::protobuf::uint32 position() const;
  inline void set_position(::google::protobuf::uint32 value);
  
  // required uint32 read_index = 5;
  inline bool has_read_index() const;
  inline void clear_read_index();
  static const int kReadIndexFieldNumber = 5;
  inline ::google::protobuf::uint32 read_index() const;
  inline void set_read_index(::google::protobuf::uint32 value);
  
  // optional bytes to_quality = 4;
  inline bool has_to_quality() const;
  inline void clear_to_quality();
  static const int kToQualityFieldNumber = 4;
  inline const ::std::string& to_quality() const;
  inline void set_to_quality(const ::std::string& value);
  inline void set_to_quality(const char* value);
  inline void set_to_quality(const void* value, size_t size);
  inline ::std::string* mutable_to_quality();
  inline ::std::string* release_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::UnknownFieldSet _unknown_fields_;
  
  ::std::string* from_;
  ::std::string* to_;
  ::google::protobuf::uint32 position_;
  ::google::protobuf::uint32 read_index_;
  ::std::string* to_quality_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentHeader& default_instance();
  
  void Swap(AlignmentHeader* other);
  
  // implements Message ----------------------------------------------
  
  AlignmentHeader* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 smallest_split_query_index = 9;
  inline bool has_smallest_split_query_index() const;
  inline void clear_smallest_split_query_index();
  static const int kSmallestSplitQueryIndexFieldNumber = 9;
  inline ::google::protobuf::uint32 smallest_split_query_index() const;
  inline void set_smallest_split_query_index(::google::protobuf::uint32 value);
  
  // optional uint32 largest_split_query_index = 11;
  inline bool has_largest_split_query_index() const;
  inline void clear_largest_split_query_index();
  static const int kLargestSplitQueryIndexFieldNumber = 11;
  inline ::google::protobuf::uint32 largest_split_query_index() const;
  inline void set_largest_split_query_index(::google::protobuf::uint32 value);
  
  // optional .goby.IdentifierMapping query_name_mapping = 1;
  inline bool has_query_name_mapping() const;
  inline void clear_query_name_mapping();
  static const int kQueryNameMappingFieldNumber = 1;
  inline const ::goby::IdentifierMapping& query_name_mapping() const;
  inline ::goby::IdentifierMapping* mutable_query_name_mapping();
  inline ::goby::IdentifierMapping* release_query_name_mapping();
  
  // optional .goby.IdentifierMapping target_name_mapping = 2;
  inline bool has_target_name_mapping() const;
  inline void clear_target_name_mapping();
  static const int kTargetNameMappingFieldNumber = 2;
  inline const ::goby::IdentifierMapping& target_name_mapping() const;
  inline ::goby::IdentifierMapping* mutable_target_name_mapping();
  inline ::goby::IdentifierMapping* release_target_name_mapping();
  
  // optional uint32 number_of_queries = 5;
  inline bool has_number_of_queries() const;
  inline void clear_number_of_queries();
  static const int kNumberOfQueriesFieldNumber = 5;
  inline ::google::protobuf::uint32 number_of_queries() const;
  inline void set_number_of_queries(::google::protobuf::uint32 value);
  
  // optional uint32 number_of_targets = 6;
  inline bool has_number_of_targets() const;
  inline void clear_number_of_targets();
  static const int kNumberOfTargetsFieldNumber = 6;
  inline ::google::protobuf::uint32 number_of_targets() const;
  inline void set_number_of_targets(::google::protobuf::uint32 value);
  
  // optional uint32 number_of_aligned_reads = 7;
  inline bool has_number_of_aligned_reads() const;
  inline void clear_number_of_aligned_reads();
  static const int kNumberOfAlignedReadsFieldNumber = 7;
  inline ::google::protobuf::uint32 number_of_aligned_reads() const;
  inline void set_number_of_aligned_reads(::google::protobuf::uint32 value);
  
  // repeated uint32 query_length = 3 [deprecated = true];
  inline int query_length_size() const PROTOBUF_DEPRECATED;
  inline void clear_query_length() PROTOBUF_DEPRECATED;
  static const int kQueryLengthFieldNumber = 3;
  inline ::google::protobuf::uint32 query_length(int index) const PROTOBUF_DEPRECATED;
  inline void set_query_length(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
  inline void add_query_length(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      query_length() const PROTOBUF_DEPRECATED;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_query_length() PROTOBUF_DEPRECATED;
  
  // optional uint32 constant_query_length = 10;
  inline bool has_constant_query_length() const;
  inline void clear_constant_query_length();
  static const int kConstantQueryLengthFieldNumber = 10;
  inline ::google::protobuf::uint32 constant_query_length() const;
  inline void set_constant_query_length(::google::protobuf::uint32 value);
  
  // repeated uint32 target_length = 8;
  inline int target_length_size() const;
  inline void clear_target_length();
  static const int kTargetLengthFieldNumber = 8;
  inline ::google::protobuf::uint32 target_length(int index) const;
  inline void set_target_length(int index, ::google::protobuf::uint32 value);
  inline void add_target_length(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      target_length() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_target_length();
  
  // optional bool sorted = 13;
  inline bool has_sorted() const;
  inline void clear_sorted();
  static const int kSortedFieldNumber = 13;
  inline bool sorted() const;
  inline void set_sorted(bool value);
  
  // optional bool indexed = 14;
  inline bool has_indexed() const;
  inline void clear_indexed();
  static const int kIndexedFieldNumber = 14;
  inline bool indexed() const;
  inline void set_indexed(bool value);
  
  // optional bool query_lengths_stored_in_entries = 15;
  inline bool has_query_lengths_stored_in_entries() const;
  inline void clear_query_lengths_stored_in_entries();
  static const int kQueryLengthsStoredInEntriesFieldNumber = 15;
  inline bool query_lengths_stored_in_entries() const;
  inline void set_query_lengths_stored_in_entries(bool value);
  
  // optional string aligner_name = 17;
  inline bool has_aligner_name() const;
  inline void clear_aligner_name();
  static const int kAlignerNameFieldNumber = 17;
  inline const ::std::string& aligner_name() const;
  inline void set_aligner_name(const ::std::string& value);
  inline void set_aligner_name(const char* value);
  inline void set_aligner_name(const char* value, size_t size);
  inline ::std::string* mutable_aligner_name();
  inline ::std::string* release_aligner_name();
  
  // optional string aligner_version = 18;
  inline bool has_aligner_version() const;
  inline void clear_aligner_version();
  static const int kAlignerVersionFieldNumber = 18;
  inline const ::std::string& aligner_version() const;
  inline void set_aligner_version(const ::std::string& value);
  inline void set_aligner_version(const char* value);
  inline void set_aligner_version(const char* value, size_t size);
  inline ::std::string* mutable_aligner_version();
  inline ::std::string* release_aligner_version();
  
  // optional string version = 25;
  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 25;
  inline const ::std::string& version() const;
  inline void set_version(const ::std::string& value);
  inline void set_version(const char* value);
  inline void set_version(const char* value, size_t size);
  inline ::std::string* mutable_version();
  inline ::std::string* release_version();
  
  // repeated string sample_basename = 30;
  inline int sample_basename_size() const;
  inline void clear_sample_basename();
  static const int kSampleBasenameFieldNumber = 30;
  inline const ::std::string& sample_basename(int index) const;
  inline ::std::string* mutable_sample_basename(int index);
  inline void set_sample_basename(int index, const ::std::string& value);
  inline void set_sample_basename(int index, const char* value);
  inline void set_sample_basename(int index, const char* value, size_t size);
  inline ::std::string* add_sample_basename();
  inline void add_sample_basename(const ::std::string& value);
  inline void add_sample_basename(const char* value);
  inline void add_sample_basename(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& sample_basename() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_sample_basename();
  
  // @@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();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::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_;
  ::std::string* aligner_name_;
  ::std::string* aligner_version_;
  ::std::string* version_;
  ::google::protobuf::RepeatedPtrField< ::std::string> sample_basename_;
  bool sorted_;
  bool indexed_;
  bool query_lengths_stored_in_entries_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const IdentifierMapping& default_instance();
  
  void Swap(IdentifierMapping* other);
  
  // implements Message ----------------------------------------------
  
  IdentifierMapping* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated .goby.IdentifierInfo mappings = 1;
  inline int mappings_size() const;
  inline void clear_mappings();
  static const int kMappingsFieldNumber = 1;
  inline const ::goby::IdentifierInfo& mappings(int index) const;
  inline ::goby::IdentifierInfo* mutable_mappings(int index);
  inline ::goby::IdentifierInfo* add_mappings();
  inline const ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >&
      mappings() const;
  inline ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >*
      mutable_mappings();
  
  // @@protoc_insertion_point(class_scope:goby.IdentifierMapping)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo > mappings_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const IdentifierInfo& default_instance();
  
  void Swap(IdentifierInfo* other);
  
  // implements Message ----------------------------------------------
  
  IdentifierInfo* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // required uint32 index = 2;
  inline bool has_index() const;
  inline void clear_index();
  static const int kIndexFieldNumber = 2;
  inline ::google::protobuf::uint32 index() const;
  inline 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();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* name_;
  ::google::protobuf::uint32 index_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  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 AlignmentTooManyHits : public ::google::protobuf::Message {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentTooManyHits& default_instance();
  
  void Swap(AlignmentTooManyHits* other);
  
  // implements Message ----------------------------------------------
  
  AlignmentTooManyHits* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 aligner_threshold = 2;
  inline bool has_aligner_threshold() const;
  inline void clear_aligner_threshold();
  static const int kAlignerThresholdFieldNumber = 2;
  inline ::google::protobuf::uint32 aligner_threshold() const;
  inline void set_aligner_threshold(::google::protobuf::uint32 value);
  
  // repeated .goby.AmbiguousLocation hits = 1;
  inline int hits_size() const;
  inline void clear_hits();
  static const int kHitsFieldNumber = 1;
  inline const ::goby::AmbiguousLocation& hits(int index) const;
  inline ::goby::AmbiguousLocation* mutable_hits(int index);
  inline ::goby::AmbiguousLocation* add_hits();
  inline const ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >&
      hits() const;
  inline ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >*
      mutable_hits();
  
  // @@protoc_insertion_point(class_scope:goby.AlignmentTooManyHits)
 private:
  inline void set_has_aligner_threshold();
  inline void clear_has_aligner_threshold();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation > hits_;
  ::google::protobuf::uint32 aligner_threshold_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AmbiguousLocation& default_instance();
  
  void Swap(AmbiguousLocation* other);
  
  // implements Message ----------------------------------------------
  
  AmbiguousLocation* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 query_index = 1;
  inline bool has_query_index() const;
  inline void clear_query_index();
  static const int kQueryIndexFieldNumber = 1;
  inline ::google::protobuf::uint32 query_index() const;
  inline void set_query_index(::google::protobuf::uint32 value);
  
  // required uint32 at_least_number_of_hits = 2;
  inline bool has_at_least_number_of_hits() const;
  inline void clear_at_least_number_of_hits();
  static const int kAtLeastNumberOfHitsFieldNumber = 2;
  inline ::google::protobuf::uint32 at_least_number_of_hits() const;
  inline void set_at_least_number_of_hits(::google::protobuf::uint32 value);
  
  // optional uint32 length_of_match = 3;
  inline bool has_length_of_match() const;
  inline void clear_length_of_match();
  static const int kLengthOfMatchFieldNumber = 3;
  inline ::google::protobuf::uint32 length_of_match() const;
  inline 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();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint32 query_index_;
  ::google::protobuf::uint32 at_least_number_of_hits_;
  ::google::protobuf::uint32 length_of_match_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  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 {
 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 _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlignmentIndex& default_instance();
  
  void Swap(AlignmentIndex* other);
  
  // implements Message ----------------------------------------------
  
  AlignmentIndex* New() 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* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated uint32 target_position_offsets = 1 [packed = true];
  inline int target_position_offsets_size() const;
  inline void clear_target_position_offsets();
  static const int kTargetPositionOffsetsFieldNumber = 1;
  inline ::google::protobuf::uint32 target_position_offsets(int index) const;
  inline void set_target_position_offsets(int index, ::google::protobuf::uint32 value);
  inline void add_target_position_offsets(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      target_position_offsets() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_target_position_offsets();
  
  // repeated uint64 offsets = 2 [packed = true];
  inline int offsets_size() const;
  inline void clear_offsets();
  static const int kOffsetsFieldNumber = 2;
  inline ::google::protobuf::uint64 offsets(int index) const;
  inline void set_offsets(int index, ::google::protobuf::uint64 value);
  inline void add_offsets(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      offsets() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_offsets();
  
  // repeated uint64 absolute_positions = 3 [packed = true];
  inline int absolute_positions_size() const;
  inline void clear_absolute_positions();
  static const int kAbsolutePositionsFieldNumber = 3;
  inline ::google::protobuf::uint64 absolute_positions(int index) const;
  inline void set_absolute_positions(int index, ::google::protobuf::uint64 value);
  inline void add_absolute_positions(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      absolute_positions() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_absolute_positions();
  
  // @@protoc_insertion_point(class_scope:goby.AlignmentIndex)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::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_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_Alignments_2eproto();
  friend void protobuf_AssignDesc_Alignments_2eproto();
  friend void protobuf_ShutdownFile_Alignments_2eproto();
  
  void InitAsDefaultInstance();
  static AlignmentIndex* default_instance_;
};
// ===================================================================


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

// 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 {
  return alignment_entries_.Get(index);
}
inline ::goby::AlignmentEntry* AlignmentCollection::mutable_alignment_entries(int index) {
  return alignment_entries_.Mutable(index);
}
inline ::goby::AlignmentEntry* AlignmentCollection::add_alignment_entries() {
  return alignment_entries_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >&
AlignmentCollection::alignment_entries() const {
  return alignment_entries_;
}
inline ::google::protobuf::RepeatedPtrField< ::goby::AlignmentEntry >*
AlignmentCollection::mutable_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 {
  return multiplicity_;
}
inline void AlignmentEntry::set_multiplicity(::google::protobuf::uint32 value) {
  set_has_multiplicity();
  multiplicity_ = value;
}

// required 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 {
  return query_index_;
}
inline void AlignmentEntry::set_query_index(::google::protobuf::uint32 value) {
  set_has_query_index();
  query_index_ = value;
}

// required 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 {
  return target_index_;
}
inline void AlignmentEntry::set_target_index(::google::protobuf::uint32 value) {
  set_has_target_index();
  target_index_ = value;
}

// required 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 {
  return position_;
}
inline void AlignmentEntry::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
}

// required 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 {
  return matching_reverse_strand_;
}
inline void AlignmentEntry::set_matching_reverse_strand(bool value) {
  set_has_matching_reverse_strand();
  matching_reverse_strand_ = value;
}

// 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 {
  return query_position_;
}
inline void AlignmentEntry::set_query_position(::google::protobuf::uint32 value) {
  set_has_query_position();
  query_position_ = value;
}

// 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 {
  return score_;
}
inline void AlignmentEntry::set_score(float value) {
  set_has_score();
  score_ = value;
}

// 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 {
  return number_of_mismatches_;
}
inline void AlignmentEntry::set_number_of_mismatches(::google::protobuf::uint32 value) {
  set_has_number_of_mismatches();
  number_of_mismatches_ = value;
}

// 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 {
  return number_of_indels_;
}
inline void AlignmentEntry::set_number_of_indels(::google::protobuf::uint32 value) {
  set_has_number_of_indels();
  number_of_indels_ = value;
}

// 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 {
  return query_aligned_length_;
}
inline void AlignmentEntry::set_query_aligned_length(::google::protobuf::uint32 value) {
  set_has_query_aligned_length();
  query_aligned_length_ = value;
}

// 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 {
  return target_aligned_length_;
}
inline void AlignmentEntry::set_target_aligned_length(::google::protobuf::uint32 value) {
  set_has_target_aligned_length();
  target_aligned_length_ = value;
}

// 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 {
  return sequence_variations_.Get(index);
}
inline ::goby::SequenceVariation* AlignmentEntry::mutable_sequence_variations(int index) {
  return sequence_variations_.Mutable(index);
}
inline ::goby::SequenceVariation* AlignmentEntry::add_sequence_variations() {
  return sequence_variations_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >&
AlignmentEntry::sequence_variations() const {
  return sequence_variations_;
}
inline ::google::protobuf::RepeatedPtrField< ::goby::SequenceVariation >*
AlignmentEntry::mutable_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 {
  return query_length_;
}
inline void AlignmentEntry::set_query_length(::google::protobuf::uint32 value) {
  set_has_query_length();
  query_length_ = value;
}

// 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 {
  return mapping_quality_;
}
inline void AlignmentEntry::set_mapping_quality(::google::protobuf::int32 value) {
  set_has_mapping_quality();
  mapping_quality_ = value;
}

// 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 {
  return pair_flags_;
}
inline void AlignmentEntry::set_pair_flags(::google::protobuf::uint32 value) {
  set_has_pair_flags();
  pair_flags_ = value;
}

// 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 {
  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;
  return pair_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::release_pair_alignment_link() {
  clear_has_pair_alignment_link();
  ::goby::RelatedAlignmentEntry* temp = pair_alignment_link_;
  pair_alignment_link_ = NULL;
  return temp;
}

// 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 {
  return fragment_index_;
}
inline void AlignmentEntry::set_fragment_index(::google::protobuf::uint32 value) {
  set_has_fragment_index();
  fragment_index_ = value;
}

// 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 {
  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;
  return spliced_forward_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::release_spliced_forward_alignment_link() {
  clear_has_spliced_forward_alignment_link();
  ::goby::RelatedAlignmentEntry* temp = spliced_forward_alignment_link_;
  spliced_forward_alignment_link_ = NULL;
  return temp;
}

// 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 {
  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;
  return spliced_backward_alignment_link_;
}
inline ::goby::RelatedAlignmentEntry* AlignmentEntry::release_spliced_backward_alignment_link() {
  clear_has_spliced_backward_alignment_link();
  ::goby::RelatedAlignmentEntry* temp = spliced_backward_alignment_link_;
  spliced_backward_alignment_link_ = NULL;
  return temp;
}

// 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 {
  return spliced_flags_;
}
inline void AlignmentEntry::set_spliced_flags(::google::protobuf::uint32 value) {
  set_has_spliced_flags();
  spliced_flags_ = value;
}

// optional uint32 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_ = 0u;
  clear_has_insert_size();
}
inline ::google::protobuf::uint32 AlignmentEntry::insert_size() const {
  return insert_size_;
}
inline void AlignmentEntry::set_insert_size(::google::protobuf::uint32 value) {
  set_has_insert_size();
  insert_size_ = value;
}

// 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 {
  return sample_index_;
}
inline void AlignmentEntry::set_sample_index(::google::protobuf::uint32 value) {
  set_has_sample_index();
  sample_index_ = value;
}

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

// RelatedAlignmentEntry

// required 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 {
  return target_index_;
}
inline void RelatedAlignmentEntry::set_target_index(::google::protobuf::uint32 value) {
  set_has_target_index();
  target_index_ = value;
}

// required 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 {
  return position_;
}
inline void RelatedAlignmentEntry::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
}

// required 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 {
  return fragment_index_;
}
inline void RelatedAlignmentEntry::set_fragment_index(::google::protobuf::uint32 value) {
  set_has_fragment_index();
  fragment_index_ = value;
}

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

// SequenceVariation

// required 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() {
  if (from_ != &::google::protobuf::internal::kEmptyString) {
    from_->clear();
  }
  clear_has_from();
}
inline const ::std::string& SequenceVariation::from() const {
  return *from_;
}
inline void SequenceVariation::set_from(const ::std::string& value) {
  set_has_from();
  if (from_ == &::google::protobuf::internal::kEmptyString) {
    from_ = new ::std::string;
  }
  from_->assign(value);
}
inline void SequenceVariation::set_from(const char* value) {
  set_has_from();
  if (from_ == &::google::protobuf::internal::kEmptyString) {
    from_ = new ::std::string;
  }
  from_->assign(value);
}
inline void SequenceVariation::set_from(const char* value, size_t size) {
  set_has_from();
  if (from_ == &::google::protobuf::internal::kEmptyString) {
    from_ = new ::std::string;
  }
  from_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SequenceVariation::mutable_from() {
  set_has_from();
  if (from_ == &::google::protobuf::internal::kEmptyString) {
    from_ = new ::std::string;
  }
  return from_;
}
inline ::std::string* SequenceVariation::release_from() {
  clear_has_from();
  if (from_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = from_;
    from_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required 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() {
  if (to_ != &::google::protobuf::internal::kEmptyString) {
    to_->clear();
  }
  clear_has_to();
}
inline const ::std::string& SequenceVariation::to() const {
  return *to_;
}
inline void SequenceVariation::set_to(const ::std::string& value) {
  set_has_to();
  if (to_ == &::google::protobuf::internal::kEmptyString) {
    to_ = new ::std::string;
  }
  to_->assign(value);
}
inline void SequenceVariation::set_to(const char* value) {
  set_has_to();
  if (to_ == &::google::protobuf::internal::kEmptyString) {
    to_ = new ::std::string;
  }
  to_->assign(value);
}
inline void SequenceVariation::set_to(const char* value, size_t size) {
  set_has_to();
  if (to_ == &::google::protobuf::internal::kEmptyString) {
    to_ = new ::std::string;
  }
  to_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SequenceVariation::mutable_to() {
  set_has_to();
  if (to_ == &::google::protobuf::internal::kEmptyString) {
    to_ = new ::std::string;
  }
  return to_;
}
inline ::std::string* SequenceVariation::release_to() {
  clear_has_to();
  if (to_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = to_;
    to_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required 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 {
  return position_;
}
inline void SequenceVariation::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
}

// required 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 {
  return read_index_;
}
inline void SequenceVariation::set_read_index(::google::protobuf::uint32 value) {
  set_has_read_index();
  read_index_ = value;
}

// 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() {
  if (to_quality_ != &::google::protobuf::internal::kEmptyString) {
    to_quality_->clear();
  }
  clear_has_to_quality();
}
inline const ::std::string& SequenceVariation::to_quality() const {
  return *to_quality_;
}
inline void SequenceVariation::set_to_quality(const ::std::string& value) {
  set_has_to_quality();
  if (to_quality_ == &::google::protobuf::internal::kEmptyString) {
    to_quality_ = new ::std::string;
  }
  to_quality_->assign(value);
}
inline void SequenceVariation::set_to_quality(const char* value) {
  set_has_to_quality();
  if (to_quality_ == &::google::protobuf::internal::kEmptyString) {
    to_quality_ = new ::std::string;
  }
  to_quality_->assign(value);
}
inline void SequenceVariation::set_to_quality(const void* value, size_t size) {
  set_has_to_quality();
  if (to_quality_ == &::google::protobuf::internal::kEmptyString) {
    to_quality_ = new ::std::string;
  }
  to_quality_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SequenceVariation::mutable_to_quality() {
  set_has_to_quality();
  if (to_quality_ == &::google::protobuf::internal::kEmptyString) {
    to_quality_ = new ::std::string;
  }
  return to_quality_;
}
inline ::std::string* SequenceVariation::release_to_quality() {
  clear_has_to_quality();
  if (to_quality_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = to_quality_;
    to_quality_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// 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 {
  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;
}

// 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 {
  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;
}

// 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 {
  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;
  return query_name_mapping_;
}
inline ::goby::IdentifierMapping* AlignmentHeader::release_query_name_mapping() {
  clear_has_query_name_mapping();
  ::goby::IdentifierMapping* temp = query_name_mapping_;
  query_name_mapping_ = NULL;
  return temp;
}

// 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 {
  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;
  return target_name_mapping_;
}
inline ::goby::IdentifierMapping* AlignmentHeader::release_target_name_mapping() {
  clear_has_target_name_mapping();
  ::goby::IdentifierMapping* temp = target_name_mapping_;
  target_name_mapping_ = NULL;
  return temp;
}

// 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 {
  return number_of_queries_;
}
inline void AlignmentHeader::set_number_of_queries(::google::protobuf::uint32 value) {
  set_has_number_of_queries();
  number_of_queries_ = value;
}

// 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 {
  return number_of_targets_;
}
inline void AlignmentHeader::set_number_of_targets(::google::protobuf::uint32 value) {
  set_has_number_of_targets();
  number_of_targets_ = value;
}

// 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 {
  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;
}

// 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 {
  return query_length_.Get(index);
}
inline void AlignmentHeader::set_query_length(int index, ::google::protobuf::uint32 value) {
  query_length_.Set(index, value);
}
inline void AlignmentHeader::add_query_length(::google::protobuf::uint32 value) {
  query_length_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
AlignmentHeader::query_length() const {
  return query_length_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
AlignmentHeader::mutable_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 {
  return constant_query_length_;
}
inline void AlignmentHeader::set_constant_query_length(::google::protobuf::uint32 value) {
  set_has_constant_query_length();
  constant_query_length_ = value;
}

// 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 {
  return target_length_.Get(index);
}
inline void AlignmentHeader::set_target_length(int index, ::google::protobuf::uint32 value) {
  target_length_.Set(index, value);
}
inline void AlignmentHeader::add_target_length(::google::protobuf::uint32 value) {
  target_length_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
AlignmentHeader::target_length() const {
  return target_length_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
AlignmentHeader::mutable_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 {
  return sorted_;
}
inline void AlignmentHeader::set_sorted(bool value) {
  set_has_sorted();
  sorted_ = value;
}

// 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 {
  return indexed_;
}
inline void AlignmentHeader::set_indexed(bool value) {
  set_has_indexed();
  indexed_ = value;
}

// 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 {
  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;
}

// 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() {
  if (aligner_name_ != &::google::protobuf::internal::kEmptyString) {
    aligner_name_->clear();
  }
  clear_has_aligner_name();
}
inline const ::std::string& AlignmentHeader::aligner_name() const {
  return *aligner_name_;
}
inline void AlignmentHeader::set_aligner_name(const ::std::string& value) {
  set_has_aligner_name();
  if (aligner_name_ == &::google::protobuf::internal::kEmptyString) {
    aligner_name_ = new ::std::string;
  }
  aligner_name_->assign(value);
}
inline void AlignmentHeader::set_aligner_name(const char* value) {
  set_has_aligner_name();
  if (aligner_name_ == &::google::protobuf::internal::kEmptyString) {
    aligner_name_ = new ::std::string;
  }
  aligner_name_->assign(value);
}
inline void AlignmentHeader::set_aligner_name(const char* value, size_t size) {
  set_has_aligner_name();
  if (aligner_name_ == &::google::protobuf::internal::kEmptyString) {
    aligner_name_ = new ::std::string;
  }
  aligner_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* AlignmentHeader::mutable_aligner_name() {
  set_has_aligner_name();
  if (aligner_name_ == &::google::protobuf::internal::kEmptyString) {
    aligner_name_ = new ::std::string;
  }
  return aligner_name_;
}
inline ::std::string* AlignmentHeader::release_aligner_name() {
  clear_has_aligner_name();
  if (aligner_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = aligner_name_;
    aligner_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// 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() {
  if (aligner_version_ != &::google::protobuf::internal::kEmptyString) {
    aligner_version_->clear();
  }
  clear_has_aligner_version();
}
inline const ::std::string& AlignmentHeader::aligner_version() const {
  return *aligner_version_;
}
inline void AlignmentHeader::set_aligner_version(const ::std::string& value) {
  set_has_aligner_version();
  if (aligner_version_ == &::google::protobuf::internal::kEmptyString) {
    aligner_version_ = new ::std::string;
  }
  aligner_version_->assign(value);
}
inline void AlignmentHeader::set_aligner_version(const char* value) {
  set_has_aligner_version();
  if (aligner_version_ == &::google::protobuf::internal::kEmptyString) {
    aligner_version_ = new ::std::string;
  }
  aligner_version_->assign(value);
}
inline void AlignmentHeader::set_aligner_version(const char* value, size_t size) {
  set_has_aligner_version();
  if (aligner_version_ == &::google::protobuf::internal::kEmptyString) {
    aligner_version_ = new ::std::string;
  }
  aligner_version_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* AlignmentHeader::mutable_aligner_version() {
  set_has_aligner_version();
  if (aligner_version_ == &::google::protobuf::internal::kEmptyString) {
    aligner_version_ = new ::std::string;
  }
  return aligner_version_;
}
inline ::std::string* AlignmentHeader::release_aligner_version() {
  clear_has_aligner_version();
  if (aligner_version_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = aligner_version_;
    aligner_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// 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() {
  if (version_ != &::google::protobuf::internal::kEmptyString) {
    version_->clear();
  }
  clear_has_version();
}
inline const ::std::string& AlignmentHeader::version() const {
  return *version_;
}
inline void AlignmentHeader::set_version(const ::std::string& value) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  version_->assign(value);
}
inline void AlignmentHeader::set_version(const char* value) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  version_->assign(value);
}
inline void AlignmentHeader::set_version(const char* value, size_t size) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  version_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* AlignmentHeader::mutable_version() {
  set_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    version_ = new ::std::string;
  }
  return version_;
}
inline ::std::string* AlignmentHeader::release_version() {
  clear_has_version();
  if (version_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = version_;
    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// 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 {
  return sample_basename_.Get(index);
}
inline ::std::string* AlignmentHeader::mutable_sample_basename(int index) {
  return sample_basename_.Mutable(index);
}
inline void AlignmentHeader::set_sample_basename(int index, const ::std::string& value) {
  sample_basename_.Mutable(index)->assign(value);
}
inline void AlignmentHeader::set_sample_basename(int index, const char* value) {
  sample_basename_.Mutable(index)->assign(value);
}
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);
}
inline ::std::string* AlignmentHeader::add_sample_basename() {
  return sample_basename_.Add();
}
inline void AlignmentHeader::add_sample_basename(const ::std::string& value) {
  sample_basename_.Add()->assign(value);
}
inline void AlignmentHeader::add_sample_basename(const char* value) {
  sample_basename_.Add()->assign(value);
}
inline void AlignmentHeader::add_sample_basename(const char* value, size_t size) {
  sample_basename_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
AlignmentHeader::sample_basename() const {
  return sample_basename_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
AlignmentHeader::mutable_sample_basename() {
  return &sample_basename_;
}

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

// 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 {
  return mappings_.Get(index);
}
inline ::goby::IdentifierInfo* IdentifierMapping::mutable_mappings(int index) {
  return mappings_.Mutable(index);
}
inline ::goby::IdentifierInfo* IdentifierMapping::add_mappings() {
  return mappings_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >&
IdentifierMapping::mappings() const {
  return mappings_;
}
inline ::google::protobuf::RepeatedPtrField< ::goby::IdentifierInfo >*
IdentifierMapping::mutable_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() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& IdentifierInfo::name() const {
  return *name_;
}
inline void IdentifierInfo::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void IdentifierInfo::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void IdentifierInfo::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* IdentifierInfo::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* IdentifierInfo::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// 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 {
  return index_;
}
inline void IdentifierInfo::set_index(::google::protobuf::uint32 value) {
  set_has_index();
  index_ = value;
}

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

// 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 {
  return aligner_threshold_;
}
inline void AlignmentTooManyHits::set_aligner_threshold(::google::protobuf::uint32 value) {
  set_has_aligner_threshold();
  aligner_threshold_ = value;
}

// 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 {
  return hits_.Get(index);
}
inline ::goby::AmbiguousLocation* AlignmentTooManyHits::mutable_hits(int index) {
  return hits_.Mutable(index);
}
inline ::goby::AmbiguousLocation* AlignmentTooManyHits::add_hits() {
  return hits_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >&
AlignmentTooManyHits::hits() const {
  return hits_;
}
inline ::google::protobuf::RepeatedPtrField< ::goby::AmbiguousLocation >*
AlignmentTooManyHits::mutable_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 {
  return query_index_;
}
inline void AmbiguousLocation::set_query_index(::google::protobuf::uint32 value) {
  set_has_query_index();
  query_index_ = value;
}

// 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 {
  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;
}

// 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 {
  return length_of_match_;
}
inline void AmbiguousLocation::set_length_of_match(::google::protobuf::uint32 value) {
  set_has_length_of_match();
  length_of_match_ = value;
}

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

// 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 {
  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);
}
inline void AlignmentIndex::add_target_position_offsets(::google::protobuf::uint32 value) {
  target_position_offsets_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
AlignmentIndex::target_position_offsets() const {
  return target_position_offsets_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
AlignmentIndex::mutable_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 {
  return offsets_.Get(index);
}
inline void AlignmentIndex::set_offsets(int index, ::google::protobuf::uint64 value) {
  offsets_.Set(index, value);
}
inline void AlignmentIndex::add_offsets(::google::protobuf::uint64 value) {
  offsets_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
AlignmentIndex::offsets() const {
  return offsets_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
AlignmentIndex::mutable_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 {
  return absolute_positions_.Get(index);
}
inline void AlignmentIndex::set_absolute_positions(int index, ::google::protobuf::uint64 value) {
  absolute_positions_.Set(index, value);
}
inline void AlignmentIndex::add_absolute_positions(::google::protobuf::uint64 value) {
  absolute_positions_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
AlignmentIndex::absolute_positions() const {
  return absolute_positions_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
AlignmentIndex::mutable_absolute_positions() {
  return &absolute_positions_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace goby

#ifndef SWIG
namespace google {
namespace protobuf {


}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_Alignments_2eproto__INCLUDED
