context: // Generated by ProtoGen, Version=2.3.0.277, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
  #pragma warning disable 1591
  #region Designer generated code
  
  using pb = global::Google.ProtocolBuffers;
  using pbc = global::Google.ProtocolBuffers.Collections;
  using pbd = global::Google.ProtocolBuffers.Descriptors;
  using scg = global::System.Collections.Generic;
  namespace D3.Quests {
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
    public static partial class Quest {
    
      #region Extension registration
      public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
      }
      #endregion
      #region Static variables
      internal static pbd::MessageDescriptor internal__static_D3_Quests_QuestReward__Descriptor;
      internal static pb::FieldAccess.FieldAccessorTable<global::D3.Quests.QuestReward, global::D3.Quests.QuestReward.Builder> internal__static_D3_Quests_QuestReward__FieldAccessorTable;
      internal static pbd::MessageDescriptor internal__static_D3_Quests_QuestStepComplete__Descriptor;
      internal static pb::FieldAccess.FieldAccessorTable<global::D3.Quests.QuestStepComplete, global::D3.Quests.QuestStepComplete.Builder> internal__static_D3_Quests_QuestStepComplete__FieldAccessorTable;
      #endregion
      #region Descriptor
      public static pbd::FileDescriptor Descriptor {
        get { return descriptor; }
      }
      private static pbd::FileDescriptor descriptor;
      
      static Quest() {
        byte[] descriptorData = global::System.Convert.FromBase64String(
            "CgtRdWVzdC5wcm90bxIJRDMuUXVlc3RzGgtJdGVtcy5wcm90byJgCgtRdWVz" + 
            "dFJld2FyZBIVCgp4cF9ncmFudGVkGAEgASgFOgEwEhcKDGdvbGRfZ3JhbnRl" + 
            "ZBgCIAEoBToBMBIhCgRpdGVtGAMgASgLMhMuRDMuSXRlbXMuR2VuZXJhdG9y" + 
            "IlYKEVF1ZXN0U3RlcENvbXBsZXRlEhkKEWlzX3F1ZXN0X2NvbXBsZXRlGAEg" + 
            "AigIEiYKBnJld2FyZBgCIAEoCzIWLkQzLlF1ZXN0cy5RdWVzdFJld2FyZA==");
        pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
          descriptor = root;
          internal__static_D3_Quests_QuestReward__Descriptor = Descriptor.MessageTypes[0];
          internal__static_D3_Quests_QuestReward__FieldAccessorTable = 
              new pb::FieldAccess.FieldAccessorTable<global::D3.Quests.QuestReward, global::D3.Quests.QuestReward.Builder>(internal__static_D3_Quests_QuestReward__Descriptor,
                  new string[] { "XpGranted", "GoldGranted", "Item", });
          internal__static_D3_Quests_QuestStepComplete__Descriptor = Descriptor.MessageTypes[1];
          internal__static_D3_Quests_QuestStepComplete__FieldAccessorTable = 
              new pb::FieldAccess.FieldAccessorTable<global::D3.Quests.QuestStepComplete, global::D3.Quests.QuestStepComplete.Builder>(internal__static_D3_Quests_QuestStepComplete__Descriptor,
                  new string[] { "IsQuestComplete", "Reward", });
          return null;
        };
        pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
            new pbd::FileDescriptor[] {
            global::D3.Items.Items.Descriptor, 
            }, assigner);
      }
      #endregion
      
    }
    #region Messages
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
    public sealed partial class QuestReward : pb::GeneratedMessage<QuestReward, QuestReward.Builder> {
      private static readonly QuestReward defaultInstance = new Builder().BuildPartial();
      private static readonly string[] _questRewardFieldNames = new string[] { "gold_granted", "item", "xp_granted" };
      private static readonly uint[] _questRewardFieldTags = new uint[] { 16, 26, 8 };
      public static QuestReward DefaultInstance {
        get { return defaultInstance; }
      }
      
      public override QuestReward DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      protected override QuestReward ThisMessage {
        get { return this; }
      }
      
      public static pbd::MessageDescriptor Descriptor {
        get { return global::D3.Quests.Quest.internal__static_D3_Quests_QuestReward__Descriptor; }
      }
      
      protected override pb::FieldAccess.FieldAccessorTable<QuestReward, QuestReward.Builder> InternalFieldAccessors {
        get { return global::D3.Quests.Quest.internal__static_D3_Quests_QuestReward__FieldAccessorTable; }
      }
      
      public const int XpGrantedFieldNumber = 1;
      private bool hasXpGranted;
      private int xpGranted_;
      public bool HasXpGranted {
        get { return hasXpGranted; }
      }
      public int XpGranted {
        get { return xpGranted_; }
      }
      
      public const int GoldGrantedFieldNumber = 2;
      private bool hasGoldGranted;
      private int goldGranted_;
      public bool HasGoldGranted {
        get { return hasGoldGranted; }
      }
      public int GoldGranted {
        get { return goldGranted_; }
      }
      
      public const int ItemFieldNumber = 3;
      private bool hasItem;
      private global::D3.Items.Generator item_ = global::D3.Items.Generator.DefaultInstance;
      public bool HasItem {
        get { return hasItem; }
      }
      public global::D3.Items.Generator Item {
        get { return item_; }
      }
      
      public override bool IsInitialized {
        get {
          if (HasItem) {
            if (!Item.IsInitialized) return false;
          }
          return true;
        }
      }
      
      public override void WriteTo(pb::ICodedOutputStream output) {
        int size = SerializedSize;
        string[] field_names = _questRewardFieldNames;
        if (hasXpGranted) {
          output.WriteInt32(1, field_names[2], XpGranted);
        }
        if (hasGoldGranted) {
          output.WriteInt32(2, field_names[0], GoldGranted);
        }
        if (hasItem) {
          output.WriteMessage(3, field_names[1], Item);
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public override int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasXpGranted) {
            size += pb::CodedOutputStream.ComputeInt32Size(1, XpGranted);
          }
          if (hasGoldGranted) {
            size += pb::CodedOutputStream.ComputeInt32Size(2, GoldGranted);
          }
          if (hasItem) {
            size += pb::CodedOutputStream.ComputeMessageSize(3, Item);
          }
          size += UnknownFields.SerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static QuestReward ParseFrom(pb::ByteString data) {
        return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
      }
      public static QuestReward ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
      }
      public static QuestReward ParseFrom(byte[] data) {
        return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
      }
      public static QuestReward ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
      }
      public static QuestReward ParseFrom(global::System.IO.Stream input) {
        return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
      }
      public static QuestReward ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
      }
      public static QuestReward ParseDelimitedFrom(global::System.IO.Stream input) {
        return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
      }
      public static QuestReward ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
        return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
      }
      public static QuestReward ParseFrom(pb::ICodedInputStream input) {
        return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
      }
      public static QuestReward ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
      }
      public static Builder CreateBuilder() { return new Builder(); }
      public override Builder ToBuilder() { return CreateBuilder(this); }
      public override Builder CreateBuilderForType() { return new Builder(); }
      public static Builder CreateBuilder(QuestReward prototype) {
        return (Builder) new Builder().MergeFrom(prototype);
      }
      
      [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
      [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
      [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
      public sealed partial class Builder : pb::GeneratedBuilder<QuestReward, Builder> {
        protected override Builder ThisBuilder {
          get { return this; }
        }
        public Builder() {}
        
        QuestReward result = new QuestReward();
        
        protected override QuestReward MessageBeingBuilt {
          get { return result; }
        }
        
        public override Builder Clear() {
          result = new QuestReward();
          return this;
        }
        
        public override Builder Clone() {
          return new Builder().MergeFrom(result);
        }
        
        public override pbd::MessageDescriptor DescriptorForType {
          get { return global::D3.Quests.QuestReward.Descriptor; }
        }
        
        public override QuestReward DefaultInstanceForType {
          get { return global::D3.Quests.QuestReward.DefaultInstance; }
        }
        
        public override QuestReward BuildPartial() {
          if (result == null) {
            throw new global::System.InvalidOperationException("build() has already been called on this Builder");
          }
          QuestReward returnMe = result;
          result = null;
          return returnMe;
        }
        
        public override Builder MergeFrom(pb::IMessage other) {
          if (other is QuestReward) {
            return MergeFrom((QuestReward) other);
          } else {
            base.MergeFrom(other);
            return this;
          }
        }
        
        public override Builder MergeFrom(QuestReward other) {
          if (other == global::D3.Quests.QuestReward.DefaultInstance) return this;
          if (other.HasXpGranted) {
            XpGranted = other.XpGranted;
          }
          if (other.HasGoldGranted) {
            GoldGranted = other.GoldGranted;
          }
          if (other.HasItem) {
            MergeItem(other.Item);
          }
          this.MergeUnknownFields(other.UnknownFields);
          return this;
        }
        
        public override Builder MergeFrom(pb::ICodedInputStream input) {
          return MergeFrom(input, pb::ExtensionRegistry.Empty);
        }
        
        public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields = null;
          uint tag;
          string field_name;
          while (input.ReadTag(out tag, out field_name)) {
            if(tag == 0 && field_name != null) {
              int field_ordinal = global::System.Array.BinarySearch(_questRewardFieldNames, field_name, global::System.StringComparer.Ordinal);
              if(field_ordinal >= 0)
                tag = _questRewardFieldTags[field_ordinal];
              else {
                if (unknownFields == null) {
                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                }
                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                continue;
              }
            }
            switch (tag) {
              case 0: {
                throw pb::InvalidProtocolBufferException.InvalidTag();
              }
              default: {
                if (pb::WireFormat.IsEndGroupTag(tag)) {
                  if (unknownFields != null) {
                    this.UnknownFields = unknownFields.Build();
                  }
                  return this;
                }
                if (unknownFields == null) {
                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                }
                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                break;
              }
              case 8: {
                result.hasXpGranted = input.ReadInt32(ref result.xpGranted_);
                break;
              }
              case 16: {
                result.hasGoldGranted = input.ReadInt32(ref result.goldGranted_);
                break;
              }
              case 26: {
                global::D3.Items.Generator.Builder subBuilder = global::D3.Items.Generator.CreateBuilder();
                if (result.hasItem) {
                  subBuilder.MergeFrom(Item);
                }
                input.ReadMessage(subBuilder, extensionRegistry);
                Item = subBuilder.BuildPartial();
                break;
              }
            }
          }
          
          if (unknownFields != null) {
            this.UnknownFields = unknownFields.Build();
          }
          return this;
        }
        
        
        public bool HasXpGranted {
          get { return result.hasXpGranted; }
        }
        public int XpGranted {
          get { return result.XpGranted; }
          set { SetXpGranted(value); }
        }
        public Builder SetXpGranted(int value) {
          result.hasXpGranted = true;
          result.xpGranted_ = value;
          return this;
        }
        public Builder ClearXpGranted() {
          result.hasXpGranted = false;
          result.xpGranted_ = 0;
          return this;
        }
        
        public bool HasGoldGranted {
          get { return result.hasGoldGranted; }
        }
        public int GoldGranted {
          get { return result.GoldGranted; }
          set { SetGoldGranted(value); }
        }
        public Builder SetGoldGranted(int value) {
          result.hasGoldGranted = true;
          result.goldGranted_ = value;
          return this;
        }
        public Builder ClearGoldGranted() {
          result.hasGoldGranted = false;
          result.goldGranted_ = 0;
          return this;
        }
        
        public bool HasItem {
         get { return result.hasItem; }
        }
        public global::D3.Items.Generator Item {
          get { return result.Item; }
          set { SetItem(value); }
        }
        public Builder SetItem(global::D3.Items.Generator value) {
          pb::ThrowHelper.ThrowIfNull(value, "value");
          result.hasItem = true;
          result.item_ = value;
          return this;
        }
        public Builder SetItem(global::D3.Items.Generator.Builder builderForValue) {
          pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
          result.hasItem = true;
          result.item_ = builderForValue.Build();
          return this;
        }
        public Builder MergeItem(global::D3.Items.Generator value) {
          pb::ThrowHelper.ThrowIfNull(value, "value");
          if (result.hasItem &&
              result.item_ != global::D3.Items.Generator.DefaultInstance) {
              result.item_ = global::D3.Items.Generator.CreateBuilder(result.item_).MergeFrom(value).BuildPartial();
          } else {
            result.item_ = value;
          }
          result.hasItem = true;
          return this;
        }
        public Builder ClearItem() {
          result.hasItem = false;
          result.item_ = global::D3.Items.Generator.DefaultInstance;
          return this;
        }
      }
      static QuestReward() {
        object.ReferenceEquals(global::D3.Quests.Quest.Descriptor, null);
      }
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
    public sealed partial class QuestStepComplete : pb::GeneratedMessage<QuestStepComplete, QuestStepComplete.Builder> {
      private static readonly QuestStepComplete defaultInstance = new Builder().BuildPartial();
      private static readonly string[] _questStepCompleteFieldNames = new string[] { "is_quest_complete", "reward" };
      private static readonly uint[] _questStepCompleteFieldTags = new uint[] { 8, 18 };
      public static QuestStepComplete DefaultInstance {
        get { return defaultInstance; }
      }
      
      public override QuestStepComplete DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      protected override QuestStepComplete ThisMessage {
        get { return this; }
      }
      
      public static pbd::MessageDescriptor Descriptor {
        get { return global::D3.Quests.Quest.internal__static_D3_Quests_QuestStepComplete__Descriptor; }
      }
      
      protected override pb::FieldAccess.FieldAccessorTable<QuestStepComplete, QuestStepComplete.Builder> InternalFieldAccessors {
        get { return global::D3.Quests.Quest.internal__static_D3_Quests_QuestStepComplete__FieldAccessorTable; }
      }
      
      public const int IsQuestCompleteFieldNumber = 1;
      private bool hasIsQuestComplete;
      private bool isQuestComplete_;
      public bool HasIsQuestComplete {
        get { return hasIsQuestComplete; }
      }
      public bool IsQuestComplete {
        get { return isQuestComplete_; }
      }
      
      public const int RewardFieldNumber = 2;
      private bool hasReward;
      private global::D3.Quests.QuestReward reward_ = global::D3.Quests.QuestReward.DefaultInstance;
      public bool HasReward {
        get { return hasReward; }
      }
      public global::D3.Quests.QuestReward Reward {
        get { return reward_; }
      }
      
      public override bool IsInitialized {
        get {
          if (!hasIsQuestComplete) return false;
          if (HasReward) {
            if (!Reward.IsInitialized) return false;
          }
          return true;
        }
      }
      
      public override void WriteTo(pb::ICodedOutputStream output) {
        int size = SerializedSize;
        string[] field_names = _questStepCompleteFieldNames;
        if (hasIsQuestComplete) {
          output.WriteBool(1, field_names[0], IsQuestComplete);
        }
        if (hasReward) {
          output.WriteMessage(2, field_names[1], Reward);
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public override int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasIsQuestComplete) {
            size += pb::CodedOutputStream.ComputeBoolSize(1, IsQuestComplete);
          }
          if (hasReward) {
            size += pb::CodedOutputStream.ComputeMessageSize(2, Reward);
          }
          size += UnknownFields.SerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static QuestStepComplete ParseFrom(pb::ByteString data) {
        return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(byte[] data) {
        return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(global::System.IO.Stream input) {
        return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
      }
      public static QuestStepComplete ParseDelimitedFrom(global::System.IO.Stream input) {
        return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
      }
      public static QuestStepComplete ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
        return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(pb::ICodedInputStream input) {
        return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
      }
      public static QuestStepComplete ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
      }
      public static Builder CreateBuilder() { return new Builder(); }
      public override Builder ToBuilder() { return CreateBuilder(this); }
      public override Builder CreateBuilderForType() { return new Builder(); }
      public static Builder CreateBuilder(QuestStepComplete prototype) {
        return (Builder) new Builder().MergeFrom(prototype);
      }
      
      [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
      [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
      [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
      public sealed partial class Builder : pb::GeneratedBuilder<QuestStepComplete, Builder> {
        protected override Builder ThisBuilder {
          get { return this; }
        }
        public Builder() {}
        
        QuestStepComplete result = new QuestStepComplete();
        
        protected override QuestStepComplete MessageBeingBuilt {
          get { return result; }
        }
        
        public override Builder Clear() {
          result = new QuestStepComplete();
          return this;
        }
        
        public override Builder Clone() {
          return new Builder().MergeFrom(result);
        }
        
        public override pbd::MessageDescriptor DescriptorForType {
          get { return global::D3.Quests.QuestStepComplete.Descriptor; }
        }
        
        public override QuestStepComplete DefaultInstanceForType {
          get { return global::D3.Quests.QuestStepComplete.DefaultInstance; }
        }
        
        public override QuestStepComplete BuildPartial() {
          if (result == null) {
            throw new global::System.InvalidOperationException("build() has already been called on this Builder");
          }
          QuestStepComplete returnMe = result;
          result = null;
          return returnMe;
        }
        
        public override Builder MergeFrom(pb::IMessage other) {
          if (other is QuestStepComplete) {
            return MergeFrom((QuestStepComplete) other);
          } else {
            base.MergeFrom(other);
            return this;
          }
        }
        
        public override Builder MergeFrom(QuestStepComplete other) {
          if (other == global::D3.Quests.QuestStepComplete.DefaultInstance) return this;
          if (other.HasIsQuestComplete) {
            IsQuestComplete = other.IsQuestComplete;
          }
          if (other.HasReward) {
            MergeReward(other.Reward);
          }
          this.MergeUnknownFields(other.UnknownFields);
          return this;
        }
        
        public override Builder MergeFrom(pb::ICodedInputStream input) {
          return MergeFrom(input, pb::ExtensionRegistry.Empty);
        }
        
        public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields = null;
          uint tag;
          string field_name;
          while (input.ReadTag(out tag, out field_name)) {
            if(tag == 0 && field_name != null) {
              int field_ordinal = global::System.Array.BinarySearch(_questStepCompleteFieldNames, field_name, global::System.StringComparer.Ordinal);
              if(field_ordinal >= 0)
                tag = _questStepCompleteFieldTags[field_ordinal];
              else {
                if (unknownFields == null) {
                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                }
                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                continue;
              }
            }
            switch (tag) {
              case 0: {
                throw pb::InvalidProtocolBufferException.InvalidTag();
              }
              default: {
                if (pb::WireFormat.IsEndGroupTag(tag)) {
                  if (unknownFields != null) {
                    this.UnknownFields = unknownFields.Build();
                  }
                  return this;
                }
                if (unknownFields == null) {
                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                }
                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                break;
              }
              case 8: {
                result.hasIsQuestComplete = input.ReadBool(ref result.isQuestComplete_);
                break;
              }
              case 18: {
                global::D3.Quests.QuestReward.Builder subBuilder = global::D3.Quests.QuestReward.CreateBuilder();
                if (result.hasReward) {
                  subBuilder.MergeFrom(Reward);
                }
                input.ReadMessage(subBuilder, extensionRegistry);
                Reward = subBuilder.BuildPartial();
                break;
              }
            }
          }
          
          if (unknownFields != null) {
            this.UnknownFields = unknownFields.Build();
          }
          return this;
        }
        
        
        public bool HasIsQuestComplete {
          get { return result.hasIsQuestComplete; }
        }
        public bool IsQuestComplete {
          get { return result.IsQuestComplete; }
          set { SetIsQuestComplete(value); }
        }
        public Builder SetIsQuestComplete(bool value) {
          result.hasIsQuestComplete = true;
          result.isQuestComplete_ = value;
          return this;
        }
        public Builder ClearIsQuestComplete() {
          result.hasIsQuestComplete = false;
          result.isQuestComplete_ = false;
          return this;
        }
        
        public bool HasReward {
         get { return result.hasReward; }
        }
        public global::D3.Quests.QuestReward Reward {
          get { return result.Reward; }
  
gt:         set { SetReward(value); }