CpModel.pb.cs

Go to the documentation of this file.

// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: ortools/sat/cp_model.proto
// </auto-generated>
#pragma warning disable 1591, 0612, 3021
#region Designer generated code
 
using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Google.OrTools.Sat {
 
  public static partial class CpModelReflection {
 
    #region Descriptor
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;
 
    static CpModelReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "ChpvcnRvb2xzL3NhdC9jcF9tb2RlbC5wcm90bxIXb3BlcmF0aW9uc19yZXNl",
            "YXJjaC5zYXQiNAoUSW50ZWdlclZhcmlhYmxlUHJvdG8SDAoEbmFtZRgBIAEo",
            "CRIOCgZkb21haW4YAiADKAMiJQoRQm9vbEFyZ3VtZW50UHJvdG8SEAoIbGl0",
            "ZXJhbHMYASADKAUiNAoUSW50ZWdlckFyZ3VtZW50UHJvdG8SDgoGdGFyZ2V0",
            "GAEgASgFEgwKBHZhcnMYAiADKAUiRQoVTGluZWFyRXhwcmVzc2lvblByb3Rv",
            "EgwKBHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygFEg4KBm9mZnNldBgDIAEo",
            "AyKUAQoTTGluZWFyQXJndW1lbnRQcm90bxI+CgZ0YXJnZXQYASABKAsyLi5v",
            "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5lYXJFeHByZXNzaW9uUHJvdG8S",
            "PQoFZXhwcnMYAiADKAsyLi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5l",
            "YXJFeHByZXNzaW9uUHJvdG8iKwobQWxsRGlmZmVyZW50Q29uc3RyYWludFBy",
            "b3RvEgwKBHZhcnMYASADKAUiRQoVTGluZWFyQ29uc3RyYWludFByb3RvEgwK",
            "BHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygDEg4KBmRvbWFpbhgDIAMoAyJF",
            "ChZFbGVtZW50Q29uc3RyYWludFByb3RvEg0KBWluZGV4GAEgASgFEg4KBnRh",
            "cmdldBgCIAEoBRIMCgR2YXJzGAMgAygFIkMKF0ludGVydmFsQ29uc3RyYWlu",
            "dFByb3RvEg0KBXN0YXJ0GAEgASgFEgsKA2VuZBgCIAEoBRIMCgRzaXplGAMg",
            "ASgFIi0KGE5vT3ZlcmxhcENvbnN0cmFpbnRQcm90bxIRCglpbnRlcnZhbHMY",
            "ASADKAUicAoaTm9PdmVybGFwMkRDb25zdHJhaW50UHJvdG8SEwoLeF9pbnRl",
            "cnZhbHMYASADKAUSEwoLeV9pbnRlcnZhbHMYAiADKAUSKAogYm94ZXNfd2l0",
            "aF9udWxsX2FyZWFfY2FuX292ZXJsYXAYAyABKAgiUQoZQ3VtdWxhdGl2ZUNv",
            "bnN0cmFpbnRQcm90bxIQCghjYXBhY2l0eRgBIAEoBRIRCglpbnRlcnZhbHMY",
            "AiADKAUSDwoHZGVtYW5kcxgDIAMoBSJxChhSZXNlcnZvaXJDb25zdHJhaW50",
            "UHJvdG8SEQoJbWluX2xldmVsGAEgASgDEhEKCW1heF9sZXZlbBgCIAEoAxIN",
            "CgV0aW1lcxgDIAMoBRIPCgdkZW1hbmRzGAQgAygDEg8KB2FjdGl2ZXMYBSAD",
            "KAUiSAoWQ2lyY3VpdENvbnN0cmFpbnRQcm90bxINCgV0YWlscxgDIAMoBRIN",
            "CgVoZWFkcxgEIAMoBRIQCghsaXRlcmFscxgFIAMoBSJqChVSb3V0ZXNDb25z",
            "dHJhaW50UHJvdG8SDQoFdGFpbHMYASADKAUSDQoFaGVhZHMYAiADKAUSEAoI",
            "bGl0ZXJhbHMYAyADKAUSDwoHZGVtYW5kcxgEIAMoBRIQCghjYXBhY2l0eRgF",
            "IAEoAyJMCh5DaXJjdWl0Q292ZXJpbmdDb25zdHJhaW50UHJvdG8SDQoFbmV4",
            "dHMYASADKAUSGwoTZGlzdGluZ3Vpc2hlZF9ub2RlcxgCIAMoAyJFChRUYWJs",
            "ZUNvbnN0cmFpbnRQcm90bxIMCgR2YXJzGAEgAygFEg4KBnZhbHVlcxgCIAMo",
            "AxIPCgduZWdhdGVkGAMgASgIIj0KFkludmVyc2VDb25zdHJhaW50UHJvdG8S",
            "EAoIZl9kaXJlY3QYASADKAUSEQoJZl9pbnZlcnNlGAIgAygFIqIBChhBdXRv",
            "bWF0b25Db25zdHJhaW50UHJvdG8SFgoOc3RhcnRpbmdfc3RhdGUYAiABKAMS",
            "FAoMZmluYWxfc3RhdGVzGAMgAygDEhcKD3RyYW5zaXRpb25fdGFpbBgEIAMo",
            "AxIXCg90cmFuc2l0aW9uX2hlYWQYBSADKAMSGAoQdHJhbnNpdGlvbl9sYWJl",
            "bBgGIAMoAxIMCgR2YXJzGAcgAygFIv8NCg9Db25zdHJhaW50UHJvdG8SDAoE",
            "bmFtZRgBIAEoCRIbChNlbmZvcmNlbWVudF9saXRlcmFsGAIgAygFEj0KB2Jv",
            "b2xfb3IYAyABKAsyKi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5Cb29sQXJn",
            "dW1lbnRQcm90b0gAEj4KCGJvb2xfYW5kGAQgASgLMioub3BlcmF0aW9uc19y",
            "ZXNlYXJjaC5zYXQuQm9vbEFyZ3VtZW50UHJvdG9IABJBCgthdF9tb3N0X29u",
            "ZRgaIAEoCzIqLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkJvb2xBcmd1bWVu",
            "dFByb3RvSAASPgoIYm9vbF94b3IYBSABKAsyKi5vcGVyYXRpb25zX3Jlc2Vh",
            "cmNoLnNhdC5Cb29sQXJndW1lbnRQcm90b0gAEkAKB2ludF9kaXYYByABKAsy",
            "LS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyQXJndW1lbnRQcm90",
            "b0gAEkAKB2ludF9tb2QYCCABKAsyLS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNh",
            "dC5JbnRlZ2VyQXJndW1lbnRQcm90b0gAEkAKB2ludF9tYXgYCSABKAsyLS5v",
            "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyQXJndW1lbnRQcm90b0gA",
            "Ej8KB2xpbl9tYXgYGyABKAsyLC5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5M",
            "aW5lYXJBcmd1bWVudFByb3RvSAASQAoHaW50X21pbhgKIAEoCzItLm9wZXJh",
            "dGlvbnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASPwoH",
            "bGluX21pbhgcIAEoCzIsLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkxpbmVh",
            "ckFyZ3VtZW50UHJvdG9IABJBCghpbnRfcHJvZBgLIAEoCzItLm9wZXJhdGlv",
            "bnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASQAoGbGlu",
            "ZWFyGAwgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuTGluZWFyQ29u",
            "c3RyYWludFByb3RvSAASSAoIYWxsX2RpZmYYDSABKAsyNC5vcGVyYXRpb25z",
            "X3Jlc2VhcmNoLnNhdC5BbGxEaWZmZXJlbnRDb25zdHJhaW50UHJvdG9IABJC",
            "CgdlbGVtZW50GA4gASgLMi8ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuRWxl",
            "bWVudENvbnN0cmFpbnRQcm90b0gAEkIKB2NpcmN1aXQYDyABKAsyLy5vcGVy",
            "YXRpb25zX3Jlc2VhcmNoLnNhdC5DaXJjdWl0Q29uc3RyYWludFByb3RvSAAS",
            "QAoGcm91dGVzGBcgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuUm91",
            "dGVzQ29uc3RyYWludFByb3RvSAASUwoQY2lyY3VpdF9jb3ZlcmluZxgZIAEo",
            "CzI3Lm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNpcmN1aXRDb3ZlcmluZ0Nv",
            "bnN0cmFpbnRQcm90b0gAEj4KBXRhYmxlGBAgASgLMi0ub3BlcmF0aW9uc19y",
            "ZXNlYXJjaC5zYXQuVGFibGVDb25zdHJhaW50UHJvdG9IABJGCglhdXRvbWF0",
            "b24YESABKAsyMS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5BdXRvbWF0b25D",
            "b25zdHJhaW50UHJvdG9IABJCCgdpbnZlcnNlGBIgASgLMi8ub3BlcmF0aW9u",
            "c19yZXNlYXJjaC5zYXQuSW52ZXJzZUNvbnN0cmFpbnRQcm90b0gAEkYKCXJl",
            "c2Vydm9pchgYIAEoCzIxLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LlJlc2Vy",
            "dm9pckNvbnN0cmFpbnRQcm90b0gAEkQKCGludGVydmFsGBMgASgLMjAub3Bl",
            "cmF0aW9uc19yZXNlYXJjaC5zYXQuSW50ZXJ2YWxDb25zdHJhaW50UHJvdG9I",
            "ABJHCgpub19vdmVybGFwGBQgASgLMjEub3BlcmF0aW9uc19yZXNlYXJjaC5z",
            "YXQuTm9PdmVybGFwQ29uc3RyYWludFByb3RvSAASTAoNbm9fb3ZlcmxhcF8y",
            "ZBgVIAEoCzIzLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0Lk5vT3ZlcmxhcDJE",
            "Q29uc3RyYWludFByb3RvSAASSAoKY3VtdWxhdGl2ZRgWIAEoCzIyLm9wZXJh",
            "dGlvbnNfcmVzZWFyY2guc2F0LkN1bXVsYXRpdmVDb25zdHJhaW50UHJvdG9I",
            "AEIMCgpjb25zdHJhaW50ImgKEENwT2JqZWN0aXZlUHJvdG8SDAoEdmFycxgB",
            "IAMoBRIOCgZjb2VmZnMYBCADKAMSDgoGb2Zmc2V0GAIgASgBEhYKDnNjYWxp",
            "bmdfZmFjdG9yGAMgASgBEg4KBmRvbWFpbhgFIAMoAyLVBQoVRGVjaXNpb25T",
            "dHJhdGVneVByb3RvEhEKCXZhcmlhYmxlcxgBIAMoBRJtCht2YXJpYWJsZV9z",
            "ZWxlY3Rpb25fc3RyYXRlZ3kYAiABKA4ySC5vcGVyYXRpb25zX3Jlc2VhcmNo",
            "LnNhdC5EZWNpc2lvblN0cmF0ZWd5UHJvdG8uVmFyaWFibGVTZWxlY3Rpb25T",
            "dHJhdGVneRJpChlkb21haW5fcmVkdWN0aW9uX3N0cmF0ZWd5GAMgASgOMkYu",
            "b3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3Rv",
            "LkRvbWFpblJlZHVjdGlvblN0cmF0ZWd5ElwKD3RyYW5zZm9ybWF0aW9ucxgE",
            "IAMoCzJDLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkRlY2lzaW9uU3RyYXRl",
            "Z3lQcm90by5BZmZpbmVUcmFuc2Zvcm1hdGlvbhpLChRBZmZpbmVUcmFuc2Zv",
            "cm1hdGlvbhILCgN2YXIYASABKAUSDgoGb2Zmc2V0GAIgASgDEhYKDnBvc2l0",
            "aXZlX2NvZWZmGAMgASgDIpQBChlWYXJpYWJsZVNlbGVjdGlvblN0cmF0ZWd5",
            "EhAKDENIT09TRV9GSVJTVBAAEhUKEUNIT09TRV9MT1dFU1RfTUlOEAESFgoS",
            "Q0hPT1NFX0hJR0hFU1RfTUFYEAISGgoWQ0hPT1NFX01JTl9ET01BSU5fU0la",
            "RRADEhoKFkNIT09TRV9NQVhfRE9NQUlOX1NJWkUQBCKMAQoXRG9tYWluUmVk",
            "dWN0aW9uU3RyYXRlZ3kSFAoQU0VMRUNUX01JTl9WQUxVRRAAEhQKEFNFTEVD",
            "VF9NQVhfVkFMVUUQARIVChFTRUxFQ1RfTE9XRVJfSEFMRhACEhUKEVNFTEVD",
            "VF9VUFBFUl9IQUxGEAMSFwoTU0VMRUNUX01FRElBTl9WQUxVRRAEIjkKGVBh",
            "cnRpYWxWYXJpYWJsZUFzc2lnbm1lbnQSDAoEdmFycxgBIAMoBRIOCgZ2YWx1",
            "ZXMYAiADKAMi7wIKDENwTW9kZWxQcm90bxIMCgRuYW1lGAEgASgJEkAKCXZh",
            "cmlhYmxlcxgCIAMoCzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVn",
            "ZXJWYXJpYWJsZVByb3RvEj0KC2NvbnN0cmFpbnRzGAMgAygLMigub3BlcmF0",
            "aW9uc19yZXNlYXJjaC5zYXQuQ29uc3RyYWludFByb3RvEjwKCW9iamVjdGl2",
            "ZRgEIAEoCzIpLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNwT2JqZWN0aXZl",
            "UHJvdG8SRwoPc2VhcmNoX3N0cmF0ZWd5GAUgAygLMi4ub3BlcmF0aW9uc19y",
            "ZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3RvEkkKDXNvbHV0aW9u",
            "X2hpbnQYBiABKAsyMi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5QYXJ0aWFs",
            "VmFyaWFibGVBc3NpZ25tZW50IrgEChBDcFNvbHZlclJlc3BvbnNlEjcKBnN0",
            "YXR1cxgBIAEoDjInLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNwU29sdmVy",
            "U3RhdHVzEhAKCHNvbHV0aW9uGAIgAygDEhcKD29iamVjdGl2ZV92YWx1ZRgD",
            "IAEoARIcChRiZXN0X29iamVjdGl2ZV9ib3VuZBgEIAEoARIdChVzb2x1dGlv",
            "bl9sb3dlcl9ib3VuZHMYEiADKAMSHQoVc29sdXRpb25fdXBwZXJfYm91bmRz",
            "GBMgAygDEkoKE3RpZ2h0ZW5lZF92YXJpYWJsZXMYFSADKAsyLS5vcGVyYXRp",
            "b25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyVmFyaWFibGVQcm90bxIgChhhbGxf",
            "c29sdXRpb25zX3dlcmVfZm91bmQYBSABKAgSFAoMbnVtX2Jvb2xlYW5zGAog",
            "ASgDEhUKDW51bV9jb25mbGljdHMYCyABKAMSFAoMbnVtX2JyYW5jaGVzGAwg",
            "ASgDEh8KF251bV9iaW5hcnlfcHJvcGFnYXRpb25zGA0gASgDEiAKGG51bV9p",
            "bnRlZ2VyX3Byb3BhZ2F0aW9ucxgOIAEoAxIRCgl3YWxsX3RpbWUYDyABKAES",
            "EQoJdXNlcl90aW1lGBAgASgBEhoKEmRldGVybWluaXN0aWNfdGltZRgRIAEo",
            "ARIXCg9wcmltYWxfaW50ZWdyYWwYFiABKAESFQoNc29sdXRpb25faW5mbxgU",
            "IAEoCSpbCg5DcFNvbHZlclN0YXR1cxILCgdVTktOT1dOEAASEQoNTU9ERUxf",
            "SU5WQUxJRBABEgwKCEZFQVNJQkxFEAISDgoKSU5GRUFTSUJMRRADEgsKB09Q",
            "VElNQUwQBEJAChZjb20uZ29vZ2xlLm9ydG9vbHMuc2F0Qg9DcE1vZGVsUHJv",
            "dG9idWZQAaoCEkdvb2dsZS5PclRvb2xzLlNhdGIGcHJvdG8z"));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.OrTools.Sat.CpSolverStatus), }, null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerVariableProto), global::Google.OrTools.Sat.IntegerVariableProto.Parser, new[]{ "Name", "Domain" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.BoolArgumentProto), global::Google.OrTools.Sat.BoolArgumentProto.Parser, new[]{ "Literals" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerArgumentProto), global::Google.OrTools.Sat.IntegerArgumentProto.Parser, new[]{ "Target", "Vars" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearExpressionProto), global::Google.OrTools.Sat.LinearExpressionProto.Parser, new[]{ "Vars", "Coeffs", "Offset" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearArgumentProto), global::Google.OrTools.Sat.LinearArgumentProto.Parser, new[]{ "Target", "Exprs" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AllDifferentConstraintProto), global::Google.OrTools.Sat.AllDifferentConstraintProto.Parser, new[]{ "Vars" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearConstraintProto), global::Google.OrTools.Sat.LinearConstraintProto.Parser, new[]{ "Vars", "Coeffs", "Domain" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ElementConstraintProto), global::Google.OrTools.Sat.ElementConstraintProto.Parser, new[]{ "Index", "Target", "Vars" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntervalConstraintProto), global::Google.OrTools.Sat.IntervalConstraintProto.Parser, new[]{ "Start", "End", "Size" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlapConstraintProto), global::Google.OrTools.Sat.NoOverlapConstraintProto.Parser, new[]{ "Intervals" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlap2DConstraintProto), global::Google.OrTools.Sat.NoOverlap2DConstraintProto.Parser, new[]{ "XIntervals", "YIntervals", "BoxesWithNullAreaCanOverlap" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CumulativeConstraintProto), global::Google.OrTools.Sat.CumulativeConstraintProto.Parser, new[]{ "Capacity", "Intervals", "Demands" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ReservoirConstraintProto), global::Google.OrTools.Sat.ReservoirConstraintProto.Parser, new[]{ "MinLevel", "MaxLevel", "Times", "Demands", "Actives" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitConstraintProto), global::Google.OrTools.Sat.CircuitConstraintProto.Parser, new[]{ "Tails", "Heads", "Literals" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.RoutesConstraintProto), global::Google.OrTools.Sat.RoutesConstraintProto.Parser, new[]{ "Tails", "Heads", "Literals", "Demands", "Capacity" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitCoveringConstraintProto), global::Google.OrTools.Sat.CircuitCoveringConstraintProto.Parser, new[]{ "Nexts", "DistinguishedNodes" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.TableConstraintProto), global::Google.OrTools.Sat.TableConstraintProto.Parser, new[]{ "Vars", "Values", "Negated" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.InverseConstraintProto), global::Google.OrTools.Sat.InverseConstraintProto.Parser, new[]{ "FDirect", "FInverse" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AutomatonConstraintProto), global::Google.OrTools.Sat.AutomatonConstraintProto.Parser, new[]{ "StartingState", "FinalStates", "TransitionTail", "TransitionHead", "TransitionLabel", "Vars" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ConstraintProto), global::Google.OrTools.Sat.ConstraintProto.Parser, new[]{ "Name", "EnforcementLiteral", "BoolOr", "BoolAnd", "AtMostOne", "BoolXor", "IntDiv", "IntMod", "IntMax", "LinMax", "IntMin", "LinMin", "IntProd", "Linear", "AllDiff", "Element", "Circuit", "Routes", "CircuitCovering", "Table", "Automaton", "Inverse", "Reservoir", "Interval", "NoOverlap", "NoOverlap2D", "Cumulative" }, new[]{ "Constraint" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpObjectiveProto), global::Google.OrTools.Sat.CpObjectiveProto.Parser, new[]{ "Vars", "Coeffs", "Offset", "ScalingFactor", "Domain" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DecisionStrategyProto), global::Google.OrTools.Sat.DecisionStrategyProto.Parser, new[]{ "Variables", "VariableSelectionStrategy", "DomainReductionStrategy", "Transformations" }, null, new[]{ typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy), typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation), global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser, new[]{ "Var", "Offset", "PositiveCoeff" }, null, null, null, null)}),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.PartialVariableAssignment), global::Google.OrTools.Sat.PartialVariableAssignment.Parser, new[]{ "Vars", "Values" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpModelProto), global::Google.OrTools.Sat.CpModelProto.Parser, new[]{ "Name", "Variables", "Constraints", "Objective", "SearchStrategy", "SolutionHint" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpSolverResponse), global::Google.OrTools.Sat.CpSolverResponse.Parser, new[]{ "Status", "Solution", "ObjectiveValue", "BestObjectiveBound", "SolutionLowerBounds", "SolutionUpperBounds", "TightenedVariables", "AllSolutionsWereFound", "NumBooleans", "NumConflicts", "NumBranches", "NumBinaryPropagations", "NumIntegerPropagations", "WallTime", "UserTime", "DeterministicTime", "PrimalIntegral", "SolutionInfo" }, null, null, null, null)
          }));
    }
    #endregion
 
  }
  #region Enums
  public enum CpSolverStatus {
    [pbr::OriginalName("UNKNOWN")] Unknown = 0,
    [pbr::OriginalName("MODEL_INVALID")] ModelInvalid = 1,
    [pbr::OriginalName("FEASIBLE")] Feasible = 2,
    [pbr::OriginalName("INFEASIBLE")] Infeasible = 3,
    [pbr::OriginalName("OPTIMAL")] Optimal = 4,
  }
 
  #endregion
 
  #region Messages
  public sealed partial class IntegerVariableProto : pb::IMessage<IntegerVariableProto> {
    private static readonly pb::MessageParser<IntegerVariableProto> _parser = new pb::MessageParser<IntegerVariableProto>(() => new IntegerVariableProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<IntegerVariableProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[0]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntegerVariableProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntegerVariableProto(IntegerVariableProto other) : this() {
      name_ = other.name_;
      domain_ = other.domain_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntegerVariableProto Clone() {
      return new IntegerVariableProto(this);
    }
 
    public const int NameFieldNumber = 1;
    private string name_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }
 
    public const int DomainFieldNumber = 2;
    private static readonly pb::FieldCodec<long> _repeated_domain_codec
        = pb::FieldCodec.ForInt64(18);
    private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Domain {
      get { return domain_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as IntegerVariableProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(IntegerVariableProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Name != other.Name) return false;
      if(!domain_.Equals(other.domain_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Name.Length != 0) hash ^= Name.GetHashCode();
      hash ^= domain_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      domain_.WriteTo(output, _repeated_domain_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      size += domain_.CalculateSize(_repeated_domain_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(IntegerVariableProto other) {
      if (other == null) {
        return;
      }
      if (other.Name.Length != 0) {
        Name = other.Name;
      }
      domain_.Add(other.domain_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18:
          case 16: {
            domain_.AddEntriesFrom(input, _repeated_domain_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class BoolArgumentProto : pb::IMessage<BoolArgumentProto> {
    private static readonly pb::MessageParser<BoolArgumentProto> _parser = new pb::MessageParser<BoolArgumentProto>(() => new BoolArgumentProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<BoolArgumentProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[1]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public BoolArgumentProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public BoolArgumentProto(BoolArgumentProto other) : this() {
      literals_ = other.literals_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public BoolArgumentProto Clone() {
      return new BoolArgumentProto(this);
    }
 
    public const int LiteralsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_literals_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Literals {
      get { return literals_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as BoolArgumentProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(BoolArgumentProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!literals_.Equals(other.literals_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= literals_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      literals_.WriteTo(output, _repeated_literals_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += literals_.CalculateSize(_repeated_literals_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(BoolArgumentProto other) {
      if (other == null) {
        return;
      }
      literals_.Add(other.literals_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            literals_.AddEntriesFrom(input, _repeated_literals_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class IntegerArgumentProto : pb::IMessage<IntegerArgumentProto> {
    private static readonly pb::MessageParser<IntegerArgumentProto> _parser = new pb::MessageParser<IntegerArgumentProto>(() => new IntegerArgumentProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<IntegerArgumentProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[2]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntegerArgumentProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntegerArgumentProto(IntegerArgumentProto other) : this() {
      target_ = other.target_;
      vars_ = other.vars_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntegerArgumentProto Clone() {
      return new IntegerArgumentProto(this);
    }
 
    public const int TargetFieldNumber = 1;
    private int target_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Target {
      get { return target_; }
      set {
        target_ = value;
      }
    }
 
    public const int VarsFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as IntegerArgumentProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(IntegerArgumentProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Target != other.Target) return false;
      if(!vars_.Equals(other.vars_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Target != 0) hash ^= Target.GetHashCode();
      hash ^= vars_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Target != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Target);
      }
      vars_.WriteTo(output, _repeated_vars_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Target != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
      }
      size += vars_.CalculateSize(_repeated_vars_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(IntegerArgumentProto other) {
      if (other == null) {
        return;
      }
      if (other.Target != 0) {
        Target = other.Target;
      }
      vars_.Add(other.vars_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Target = input.ReadInt32();
            break;
          }
          case 18:
          case 16: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class LinearExpressionProto : pb::IMessage<LinearExpressionProto> {
    private static readonly pb::MessageParser<LinearExpressionProto> _parser = new pb::MessageParser<LinearExpressionProto>(() => new LinearExpressionProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<LinearExpressionProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[3]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearExpressionProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearExpressionProto(LinearExpressionProto other) : this() {
      vars_ = other.vars_.Clone();
      coeffs_ = other.coeffs_.Clone();
      offset_ = other.offset_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearExpressionProto Clone() {
      return new LinearExpressionProto(this);
    }
 
    public const int VarsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    public const int CoeffsFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_coeffs_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> coeffs_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Coeffs {
      get { return coeffs_; }
    }
 
    public const int OffsetFieldNumber = 3;
    private long offset_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long Offset {
      get { return offset_; }
      set {
        offset_ = value;
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as LinearExpressionProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(LinearExpressionProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!vars_.Equals(other.vars_)) return false;
      if(!coeffs_.Equals(other.coeffs_)) return false;
      if (Offset != other.Offset) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= vars_.GetHashCode();
      hash ^= coeffs_.GetHashCode();
      if (Offset != 0L) hash ^= Offset.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      vars_.WriteTo(output, _repeated_vars_codec);
      coeffs_.WriteTo(output, _repeated_coeffs_codec);
      if (Offset != 0L) {
        output.WriteRawTag(24);
        output.WriteInt64(Offset);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += vars_.CalculateSize(_repeated_vars_codec);
      size += coeffs_.CalculateSize(_repeated_coeffs_codec);
      if (Offset != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(LinearExpressionProto other) {
      if (other == null) {
        return;
      }
      vars_.Add(other.vars_);
      coeffs_.Add(other.coeffs_);
      if (other.Offset != 0L) {
        Offset = other.Offset;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
          case 18:
          case 16: {
            coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
            break;
          }
          case 24: {
            Offset = input.ReadInt64();
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class LinearArgumentProto : pb::IMessage<LinearArgumentProto> {
    private static readonly pb::MessageParser<LinearArgumentProto> _parser = new pb::MessageParser<LinearArgumentProto>(() => new LinearArgumentProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<LinearArgumentProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[4]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearArgumentProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearArgumentProto(LinearArgumentProto other) : this() {
      target_ = other.target_ != null ? other.target_.Clone() : null;
      exprs_ = other.exprs_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearArgumentProto Clone() {
      return new LinearArgumentProto(this);
    }
 
    public const int TargetFieldNumber = 1;
    private global::Google.OrTools.Sat.LinearExpressionProto target_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.LinearExpressionProto Target {
      get { return target_; }
      set {
        target_ = value;
      }
    }
 
    public const int ExprsFieldNumber = 2;
    private static readonly pb::FieldCodec<global::Google.OrTools.Sat.LinearExpressionProto> _repeated_exprs_codec
        = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.LinearExpressionProto.Parser);
    private readonly pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> exprs_ = new pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> Exprs {
      get { return exprs_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as LinearArgumentProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(LinearArgumentProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!object.Equals(Target, other.Target)) return false;
      if(!exprs_.Equals(other.exprs_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (target_ != null) hash ^= Target.GetHashCode();
      hash ^= exprs_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (target_ != null) {
        output.WriteRawTag(10);
        output.WriteMessage(Target);
      }
      exprs_.WriteTo(output, _repeated_exprs_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (target_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Target);
      }
      size += exprs_.CalculateSize(_repeated_exprs_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(LinearArgumentProto other) {
      if (other == null) {
        return;
      }
      if (other.target_ != null) {
        if (target_ == null) {
          Target = new global::Google.OrTools.Sat.LinearExpressionProto();
        }
        Target.MergeFrom(other.Target);
      }
      exprs_.Add(other.exprs_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            if (target_ == null) {
              Target = new global::Google.OrTools.Sat.LinearExpressionProto();
            }
            input.ReadMessage(Target);
            break;
          }
          case 18: {
            exprs_.AddEntriesFrom(input, _repeated_exprs_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class AllDifferentConstraintProto : pb::IMessage<AllDifferentConstraintProto> {
    private static readonly pb::MessageParser<AllDifferentConstraintProto> _parser = new pb::MessageParser<AllDifferentConstraintProto>(() => new AllDifferentConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<AllDifferentConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[5]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllDifferentConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllDifferentConstraintProto(AllDifferentConstraintProto other) : this() {
      vars_ = other.vars_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AllDifferentConstraintProto Clone() {
      return new AllDifferentConstraintProto(this);
    }
 
    public const int VarsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as AllDifferentConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(AllDifferentConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!vars_.Equals(other.vars_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= vars_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      vars_.WriteTo(output, _repeated_vars_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += vars_.CalculateSize(_repeated_vars_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(AllDifferentConstraintProto other) {
      if (other == null) {
        return;
      }
      vars_.Add(other.vars_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class LinearConstraintProto : pb::IMessage<LinearConstraintProto> {
    private static readonly pb::MessageParser<LinearConstraintProto> _parser = new pb::MessageParser<LinearConstraintProto>(() => new LinearConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<LinearConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[6]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearConstraintProto(LinearConstraintProto other) : this() {
      vars_ = other.vars_.Clone();
      coeffs_ = other.coeffs_.Clone();
      domain_ = other.domain_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public LinearConstraintProto Clone() {
      return new LinearConstraintProto(this);
    }
 
    public const int VarsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    public const int CoeffsFieldNumber = 2;
    private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
        = pb::FieldCodec.ForInt64(18);
    private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Coeffs {
      get { return coeffs_; }
    }
 
    public const int DomainFieldNumber = 3;
    private static readonly pb::FieldCodec<long> _repeated_domain_codec
        = pb::FieldCodec.ForInt64(26);
    private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Domain {
      get { return domain_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as LinearConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(LinearConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!vars_.Equals(other.vars_)) return false;
      if(!coeffs_.Equals(other.coeffs_)) return false;
      if(!domain_.Equals(other.domain_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= vars_.GetHashCode();
      hash ^= coeffs_.GetHashCode();
      hash ^= domain_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      vars_.WriteTo(output, _repeated_vars_codec);
      coeffs_.WriteTo(output, _repeated_coeffs_codec);
      domain_.WriteTo(output, _repeated_domain_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += vars_.CalculateSize(_repeated_vars_codec);
      size += coeffs_.CalculateSize(_repeated_coeffs_codec);
      size += domain_.CalculateSize(_repeated_domain_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(LinearConstraintProto other) {
      if (other == null) {
        return;
      }
      vars_.Add(other.vars_);
      coeffs_.Add(other.coeffs_);
      domain_.Add(other.domain_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
          case 18:
          case 16: {
            coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
            break;
          }
          case 26:
          case 24: {
            domain_.AddEntriesFrom(input, _repeated_domain_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class ElementConstraintProto : pb::IMessage<ElementConstraintProto> {
    private static readonly pb::MessageParser<ElementConstraintProto> _parser = new pb::MessageParser<ElementConstraintProto>(() => new ElementConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ElementConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[7]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ElementConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ElementConstraintProto(ElementConstraintProto other) : this() {
      index_ = other.index_;
      target_ = other.target_;
      vars_ = other.vars_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ElementConstraintProto Clone() {
      return new ElementConstraintProto(this);
    }
 
    public const int IndexFieldNumber = 1;
    private int index_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Index {
      get { return index_; }
      set {
        index_ = value;
      }
    }
 
    public const int TargetFieldNumber = 2;
    private int target_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Target {
      get { return target_; }
      set {
        target_ = value;
      }
    }
 
    public const int VarsFieldNumber = 3;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(26);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ElementConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ElementConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Index != other.Index) return false;
      if (Target != other.Target) return false;
      if(!vars_.Equals(other.vars_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Index != 0) hash ^= Index.GetHashCode();
      if (Target != 0) hash ^= Target.GetHashCode();
      hash ^= vars_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Index != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Index);
      }
      if (Target != 0) {
        output.WriteRawTag(16);
        output.WriteInt32(Target);
      }
      vars_.WriteTo(output, _repeated_vars_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Index != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Index);
      }
      if (Target != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
      }
      size += vars_.CalculateSize(_repeated_vars_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ElementConstraintProto other) {
      if (other == null) {
        return;
      }
      if (other.Index != 0) {
        Index = other.Index;
      }
      if (other.Target != 0) {
        Target = other.Target;
      }
      vars_.Add(other.vars_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Index = input.ReadInt32();
            break;
          }
          case 16: {
            Target = input.ReadInt32();
            break;
          }
          case 26:
          case 24: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class IntervalConstraintProto : pb::IMessage<IntervalConstraintProto> {
    private static readonly pb::MessageParser<IntervalConstraintProto> _parser = new pb::MessageParser<IntervalConstraintProto>(() => new IntervalConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<IntervalConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[8]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntervalConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntervalConstraintProto(IntervalConstraintProto other) : this() {
      start_ = other.start_;
      end_ = other.end_;
      size_ = other.size_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public IntervalConstraintProto Clone() {
      return new IntervalConstraintProto(this);
    }
 
    public const int StartFieldNumber = 1;
    private int start_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Start {
      get { return start_; }
      set {
        start_ = value;
      }
    }
 
    public const int EndFieldNumber = 2;
    private int end_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int End {
      get { return end_; }
      set {
        end_ = value;
      }
    }
 
    public const int SizeFieldNumber = 3;
    private int size_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Size {
      get { return size_; }
      set {
        size_ = value;
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as IntervalConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(IntervalConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Start != other.Start) return false;
      if (End != other.End) return false;
      if (Size != other.Size) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Start != 0) hash ^= Start.GetHashCode();
      if (End != 0) hash ^= End.GetHashCode();
      if (Size != 0) hash ^= Size.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Start != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Start);
      }
      if (End != 0) {
        output.WriteRawTag(16);
        output.WriteInt32(End);
      }
      if (Size != 0) {
        output.WriteRawTag(24);
        output.WriteInt32(Size);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Start != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
      }
      if (End != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
      }
      if (Size != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Size);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(IntervalConstraintProto other) {
      if (other == null) {
        return;
      }
      if (other.Start != 0) {
        Start = other.Start;
      }
      if (other.End != 0) {
        End = other.End;
      }
      if (other.Size != 0) {
        Size = other.Size;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Start = input.ReadInt32();
            break;
          }
          case 16: {
            End = input.ReadInt32();
            break;
          }
          case 24: {
            Size = input.ReadInt32();
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class NoOverlapConstraintProto : pb::IMessage<NoOverlapConstraintProto> {
    private static readonly pb::MessageParser<NoOverlapConstraintProto> _parser = new pb::MessageParser<NoOverlapConstraintProto>(() => new NoOverlapConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<NoOverlapConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[9]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NoOverlapConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NoOverlapConstraintProto(NoOverlapConstraintProto other) : this() {
      intervals_ = other.intervals_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NoOverlapConstraintProto Clone() {
      return new NoOverlapConstraintProto(this);
    }
 
    public const int IntervalsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_intervals_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> intervals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Intervals {
      get { return intervals_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as NoOverlapConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(NoOverlapConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!intervals_.Equals(other.intervals_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= intervals_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      intervals_.WriteTo(output, _repeated_intervals_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += intervals_.CalculateSize(_repeated_intervals_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(NoOverlapConstraintProto other) {
      if (other == null) {
        return;
      }
      intervals_.Add(other.intervals_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class NoOverlap2DConstraintProto : pb::IMessage<NoOverlap2DConstraintProto> {
    private static readonly pb::MessageParser<NoOverlap2DConstraintProto> _parser = new pb::MessageParser<NoOverlap2DConstraintProto>(() => new NoOverlap2DConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<NoOverlap2DConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[10]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NoOverlap2DConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NoOverlap2DConstraintProto(NoOverlap2DConstraintProto other) : this() {
      xIntervals_ = other.xIntervals_.Clone();
      yIntervals_ = other.yIntervals_.Clone();
      boxesWithNullAreaCanOverlap_ = other.boxesWithNullAreaCanOverlap_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public NoOverlap2DConstraintProto Clone() {
      return new NoOverlap2DConstraintProto(this);
    }
 
    public const int XIntervalsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_xIntervals_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> xIntervals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> XIntervals {
      get { return xIntervals_; }
    }
 
    public const int YIntervalsFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_yIntervals_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> yIntervals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> YIntervals {
      get { return yIntervals_; }
    }
 
    public const int BoxesWithNullAreaCanOverlapFieldNumber = 3;
    private bool boxesWithNullAreaCanOverlap_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool BoxesWithNullAreaCanOverlap {
      get { return boxesWithNullAreaCanOverlap_; }
      set {
        boxesWithNullAreaCanOverlap_ = value;
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as NoOverlap2DConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(NoOverlap2DConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!xIntervals_.Equals(other.xIntervals_)) return false;
      if(!yIntervals_.Equals(other.yIntervals_)) return false;
      if (BoxesWithNullAreaCanOverlap != other.BoxesWithNullAreaCanOverlap) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= xIntervals_.GetHashCode();
      hash ^= yIntervals_.GetHashCode();
      if (BoxesWithNullAreaCanOverlap != false) hash ^= BoxesWithNullAreaCanOverlap.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      xIntervals_.WriteTo(output, _repeated_xIntervals_codec);
      yIntervals_.WriteTo(output, _repeated_yIntervals_codec);
      if (BoxesWithNullAreaCanOverlap != false) {
        output.WriteRawTag(24);
        output.WriteBool(BoxesWithNullAreaCanOverlap);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += xIntervals_.CalculateSize(_repeated_xIntervals_codec);
      size += yIntervals_.CalculateSize(_repeated_yIntervals_codec);
      if (BoxesWithNullAreaCanOverlap != false) {
        size += 1 + 1;
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(NoOverlap2DConstraintProto other) {
      if (other == null) {
        return;
      }
      xIntervals_.Add(other.xIntervals_);
      yIntervals_.Add(other.yIntervals_);
      if (other.BoxesWithNullAreaCanOverlap != false) {
        BoxesWithNullAreaCanOverlap = other.BoxesWithNullAreaCanOverlap;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            xIntervals_.AddEntriesFrom(input, _repeated_xIntervals_codec);
            break;
          }
          case 18:
          case 16: {
            yIntervals_.AddEntriesFrom(input, _repeated_yIntervals_codec);
            break;
          }
          case 24: {
            BoxesWithNullAreaCanOverlap = input.ReadBool();
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class CumulativeConstraintProto : pb::IMessage<CumulativeConstraintProto> {
    private static readonly pb::MessageParser<CumulativeConstraintProto> _parser = new pb::MessageParser<CumulativeConstraintProto>(() => new CumulativeConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CumulativeConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[11]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CumulativeConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CumulativeConstraintProto(CumulativeConstraintProto other) : this() {
      capacity_ = other.capacity_;
      intervals_ = other.intervals_.Clone();
      demands_ = other.demands_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CumulativeConstraintProto Clone() {
      return new CumulativeConstraintProto(this);
    }
 
    public const int CapacityFieldNumber = 1;
    private int capacity_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Capacity {
      get { return capacity_; }
      set {
        capacity_ = value;
      }
    }
 
    public const int IntervalsFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_intervals_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> intervals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Intervals {
      get { return intervals_; }
    }
 
    public const int DemandsFieldNumber = 3;
    private static readonly pb::FieldCodec<int> _repeated_demands_codec
        = pb::FieldCodec.ForInt32(26);
    private readonly pbc::RepeatedField<int> demands_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Demands {
      get { return demands_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CumulativeConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CumulativeConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Capacity != other.Capacity) return false;
      if(!intervals_.Equals(other.intervals_)) return false;
      if(!demands_.Equals(other.demands_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Capacity != 0) hash ^= Capacity.GetHashCode();
      hash ^= intervals_.GetHashCode();
      hash ^= demands_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Capacity != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Capacity);
      }
      intervals_.WriteTo(output, _repeated_intervals_codec);
      demands_.WriteTo(output, _repeated_demands_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Capacity != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Capacity);
      }
      size += intervals_.CalculateSize(_repeated_intervals_codec);
      size += demands_.CalculateSize(_repeated_demands_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CumulativeConstraintProto other) {
      if (other == null) {
        return;
      }
      if (other.Capacity != 0) {
        Capacity = other.Capacity;
      }
      intervals_.Add(other.intervals_);
      demands_.Add(other.demands_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Capacity = input.ReadInt32();
            break;
          }
          case 18:
          case 16: {
            intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
            break;
          }
          case 26:
          case 24: {
            demands_.AddEntriesFrom(input, _repeated_demands_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class ReservoirConstraintProto : pb::IMessage<ReservoirConstraintProto> {
    private static readonly pb::MessageParser<ReservoirConstraintProto> _parser = new pb::MessageParser<ReservoirConstraintProto>(() => new ReservoirConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservoirConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[12]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservoirConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservoirConstraintProto(ReservoirConstraintProto other) : this() {
      minLevel_ = other.minLevel_;
      maxLevel_ = other.maxLevel_;
      times_ = other.times_.Clone();
      demands_ = other.demands_.Clone();
      actives_ = other.actives_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservoirConstraintProto Clone() {
      return new ReservoirConstraintProto(this);
    }
 
    public const int MinLevelFieldNumber = 1;
    private long minLevel_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long MinLevel {
      get { return minLevel_; }
      set {
        minLevel_ = value;
      }
    }
 
    public const int MaxLevelFieldNumber = 2;
    private long maxLevel_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long MaxLevel {
      get { return maxLevel_; }
      set {
        maxLevel_ = value;
      }
    }
 
    public const int TimesFieldNumber = 3;
    private static readonly pb::FieldCodec<int> _repeated_times_codec
        = pb::FieldCodec.ForInt32(26);
    private readonly pbc::RepeatedField<int> times_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Times {
      get { return times_; }
    }
 
    public const int DemandsFieldNumber = 4;
    private static readonly pb::FieldCodec<long> _repeated_demands_codec
        = pb::FieldCodec.ForInt64(34);
    private readonly pbc::RepeatedField<long> demands_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Demands {
      get { return demands_; }
    }
 
    public const int ActivesFieldNumber = 5;
    private static readonly pb::FieldCodec<int> _repeated_actives_codec
        = pb::FieldCodec.ForInt32(42);
    private readonly pbc::RepeatedField<int> actives_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Actives {
      get { return actives_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservoirConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservoirConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (MinLevel != other.MinLevel) return false;
      if (MaxLevel != other.MaxLevel) return false;
      if(!times_.Equals(other.times_)) return false;
      if(!demands_.Equals(other.demands_)) return false;
      if(!actives_.Equals(other.actives_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (MinLevel != 0L) hash ^= MinLevel.GetHashCode();
      if (MaxLevel != 0L) hash ^= MaxLevel.GetHashCode();
      hash ^= times_.GetHashCode();
      hash ^= demands_.GetHashCode();
      hash ^= actives_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (MinLevel != 0L) {
        output.WriteRawTag(8);
        output.WriteInt64(MinLevel);
      }
      if (MaxLevel != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(MaxLevel);
      }
      times_.WriteTo(output, _repeated_times_codec);
      demands_.WriteTo(output, _repeated_demands_codec);
      actives_.WriteTo(output, _repeated_actives_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (MinLevel != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(MinLevel);
      }
      if (MaxLevel != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(MaxLevel);
      }
      size += times_.CalculateSize(_repeated_times_codec);
      size += demands_.CalculateSize(_repeated_demands_codec);
      size += actives_.CalculateSize(_repeated_actives_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservoirConstraintProto other) {
      if (other == null) {
        return;
      }
      if (other.MinLevel != 0L) {
        MinLevel = other.MinLevel;
      }
      if (other.MaxLevel != 0L) {
        MaxLevel = other.MaxLevel;
      }
      times_.Add(other.times_);
      demands_.Add(other.demands_);
      actives_.Add(other.actives_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            MinLevel = input.ReadInt64();
            break;
          }
          case 16: {
            MaxLevel = input.ReadInt64();
            break;
          }
          case 26:
          case 24: {
            times_.AddEntriesFrom(input, _repeated_times_codec);
            break;
          }
          case 34:
          case 32: {
            demands_.AddEntriesFrom(input, _repeated_demands_codec);
            break;
          }
          case 42:
          case 40: {
            actives_.AddEntriesFrom(input, _repeated_actives_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class CircuitConstraintProto : pb::IMessage<CircuitConstraintProto> {
    private static readonly pb::MessageParser<CircuitConstraintProto> _parser = new pb::MessageParser<CircuitConstraintProto>(() => new CircuitConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CircuitConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[13]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CircuitConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CircuitConstraintProto(CircuitConstraintProto other) : this() {
      tails_ = other.tails_.Clone();
      heads_ = other.heads_.Clone();
      literals_ = other.literals_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CircuitConstraintProto Clone() {
      return new CircuitConstraintProto(this);
    }
 
    public const int TailsFieldNumber = 3;
    private static readonly pb::FieldCodec<int> _repeated_tails_codec
        = pb::FieldCodec.ForInt32(26);
    private readonly pbc::RepeatedField<int> tails_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Tails {
      get { return tails_; }
    }
 
    public const int HeadsFieldNumber = 4;
    private static readonly pb::FieldCodec<int> _repeated_heads_codec
        = pb::FieldCodec.ForInt32(34);
    private readonly pbc::RepeatedField<int> heads_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Heads {
      get { return heads_; }
    }
 
    public const int LiteralsFieldNumber = 5;
    private static readonly pb::FieldCodec<int> _repeated_literals_codec
        = pb::FieldCodec.ForInt32(42);
    private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Literals {
      get { return literals_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CircuitConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CircuitConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!tails_.Equals(other.tails_)) return false;
      if(!heads_.Equals(other.heads_)) return false;
      if(!literals_.Equals(other.literals_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= tails_.GetHashCode();
      hash ^= heads_.GetHashCode();
      hash ^= literals_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      tails_.WriteTo(output, _repeated_tails_codec);
      heads_.WriteTo(output, _repeated_heads_codec);
      literals_.WriteTo(output, _repeated_literals_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += tails_.CalculateSize(_repeated_tails_codec);
      size += heads_.CalculateSize(_repeated_heads_codec);
      size += literals_.CalculateSize(_repeated_literals_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CircuitConstraintProto other) {
      if (other == null) {
        return;
      }
      tails_.Add(other.tails_);
      heads_.Add(other.heads_);
      literals_.Add(other.literals_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 26:
          case 24: {
            tails_.AddEntriesFrom(input, _repeated_tails_codec);
            break;
          }
          case 34:
          case 32: {
            heads_.AddEntriesFrom(input, _repeated_heads_codec);
            break;
          }
          case 42:
          case 40: {
            literals_.AddEntriesFrom(input, _repeated_literals_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class RoutesConstraintProto : pb::IMessage<RoutesConstraintProto> {
    private static readonly pb::MessageParser<RoutesConstraintProto> _parser = new pb::MessageParser<RoutesConstraintProto>(() => new RoutesConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<RoutesConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[14]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RoutesConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RoutesConstraintProto(RoutesConstraintProto other) : this() {
      tails_ = other.tails_.Clone();
      heads_ = other.heads_.Clone();
      literals_ = other.literals_.Clone();
      demands_ = other.demands_.Clone();
      capacity_ = other.capacity_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RoutesConstraintProto Clone() {
      return new RoutesConstraintProto(this);
    }
 
    public const int TailsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_tails_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> tails_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Tails {
      get { return tails_; }
    }
 
    public const int HeadsFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_heads_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> heads_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Heads {
      get { return heads_; }
    }
 
    public const int LiteralsFieldNumber = 3;
    private static readonly pb::FieldCodec<int> _repeated_literals_codec
        = pb::FieldCodec.ForInt32(26);
    private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Literals {
      get { return literals_; }
    }
 
    public const int DemandsFieldNumber = 4;
    private static readonly pb::FieldCodec<int> _repeated_demands_codec
        = pb::FieldCodec.ForInt32(34);
    private readonly pbc::RepeatedField<int> demands_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Demands {
      get { return demands_; }
    }
 
    public const int CapacityFieldNumber = 5;
    private long capacity_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long Capacity {
      get { return capacity_; }
      set {
        capacity_ = value;
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as RoutesConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(RoutesConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!tails_.Equals(other.tails_)) return false;
      if(!heads_.Equals(other.heads_)) return false;
      if(!literals_.Equals(other.literals_)) return false;
      if(!demands_.Equals(other.demands_)) return false;
      if (Capacity != other.Capacity) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= tails_.GetHashCode();
      hash ^= heads_.GetHashCode();
      hash ^= literals_.GetHashCode();
      hash ^= demands_.GetHashCode();
      if (Capacity != 0L) hash ^= Capacity.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      tails_.WriteTo(output, _repeated_tails_codec);
      heads_.WriteTo(output, _repeated_heads_codec);
      literals_.WriteTo(output, _repeated_literals_codec);
      demands_.WriteTo(output, _repeated_demands_codec);
      if (Capacity != 0L) {
        output.WriteRawTag(40);
        output.WriteInt64(Capacity);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += tails_.CalculateSize(_repeated_tails_codec);
      size += heads_.CalculateSize(_repeated_heads_codec);
      size += literals_.CalculateSize(_repeated_literals_codec);
      size += demands_.CalculateSize(_repeated_demands_codec);
      if (Capacity != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Capacity);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(RoutesConstraintProto other) {
      if (other == null) {
        return;
      }
      tails_.Add(other.tails_);
      heads_.Add(other.heads_);
      literals_.Add(other.literals_);
      demands_.Add(other.demands_);
      if (other.Capacity != 0L) {
        Capacity = other.Capacity;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            tails_.AddEntriesFrom(input, _repeated_tails_codec);
            break;
          }
          case 18:
          case 16: {
            heads_.AddEntriesFrom(input, _repeated_heads_codec);
            break;
          }
          case 26:
          case 24: {
            literals_.AddEntriesFrom(input, _repeated_literals_codec);
            break;
          }
          case 34:
          case 32: {
            demands_.AddEntriesFrom(input, _repeated_demands_codec);
            break;
          }
          case 40: {
            Capacity = input.ReadInt64();
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class CircuitCoveringConstraintProto : pb::IMessage<CircuitCoveringConstraintProto> {
    private static readonly pb::MessageParser<CircuitCoveringConstraintProto> _parser = new pb::MessageParser<CircuitCoveringConstraintProto>(() => new CircuitCoveringConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CircuitCoveringConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[15]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CircuitCoveringConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CircuitCoveringConstraintProto(CircuitCoveringConstraintProto other) : this() {
      nexts_ = other.nexts_.Clone();
      distinguishedNodes_ = other.distinguishedNodes_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CircuitCoveringConstraintProto Clone() {
      return new CircuitCoveringConstraintProto(this);
    }
 
    public const int NextsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_nexts_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> nexts_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Nexts {
      get { return nexts_; }
    }
 
    public const int DistinguishedNodesFieldNumber = 2;
    private static readonly pb::FieldCodec<long> _repeated_distinguishedNodes_codec
        = pb::FieldCodec.ForInt64(18);
    private readonly pbc::RepeatedField<long> distinguishedNodes_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> DistinguishedNodes {
      get { return distinguishedNodes_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CircuitCoveringConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CircuitCoveringConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!nexts_.Equals(other.nexts_)) return false;
      if(!distinguishedNodes_.Equals(other.distinguishedNodes_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= nexts_.GetHashCode();
      hash ^= distinguishedNodes_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      nexts_.WriteTo(output, _repeated_nexts_codec);
      distinguishedNodes_.WriteTo(output, _repeated_distinguishedNodes_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += nexts_.CalculateSize(_repeated_nexts_codec);
      size += distinguishedNodes_.CalculateSize(_repeated_distinguishedNodes_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CircuitCoveringConstraintProto other) {
      if (other == null) {
        return;
      }
      nexts_.Add(other.nexts_);
      distinguishedNodes_.Add(other.distinguishedNodes_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            nexts_.AddEntriesFrom(input, _repeated_nexts_codec);
            break;
          }
          case 18:
          case 16: {
            distinguishedNodes_.AddEntriesFrom(input, _repeated_distinguishedNodes_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class TableConstraintProto : pb::IMessage<TableConstraintProto> {
    private static readonly pb::MessageParser<TableConstraintProto> _parser = new pb::MessageParser<TableConstraintProto>(() => new TableConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<TableConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[16]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public TableConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public TableConstraintProto(TableConstraintProto other) : this() {
      vars_ = other.vars_.Clone();
      values_ = other.values_.Clone();
      negated_ = other.negated_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public TableConstraintProto Clone() {
      return new TableConstraintProto(this);
    }
 
    public const int VarsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    public const int ValuesFieldNumber = 2;
    private static readonly pb::FieldCodec<long> _repeated_values_codec
        = pb::FieldCodec.ForInt64(18);
    private readonly pbc::RepeatedField<long> values_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Values {
      get { return values_; }
    }
 
    public const int NegatedFieldNumber = 3;
    private bool negated_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Negated {
      get { return negated_; }
      set {
        negated_ = value;
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as TableConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(TableConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!vars_.Equals(other.vars_)) return false;
      if(!values_.Equals(other.values_)) return false;
      if (Negated != other.Negated) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= vars_.GetHashCode();
      hash ^= values_.GetHashCode();
      if (Negated != false) hash ^= Negated.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      vars_.WriteTo(output, _repeated_vars_codec);
      values_.WriteTo(output, _repeated_values_codec);
      if (Negated != false) {
        output.WriteRawTag(24);
        output.WriteBool(Negated);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += vars_.CalculateSize(_repeated_vars_codec);
      size += values_.CalculateSize(_repeated_values_codec);
      if (Negated != false) {
        size += 1 + 1;
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(TableConstraintProto other) {
      if (other == null) {
        return;
      }
      vars_.Add(other.vars_);
      values_.Add(other.values_);
      if (other.Negated != false) {
        Negated = other.Negated;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
          case 18:
          case 16: {
            values_.AddEntriesFrom(input, _repeated_values_codec);
            break;
          }
          case 24: {
            Negated = input.ReadBool();
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class InverseConstraintProto : pb::IMessage<InverseConstraintProto> {
    private static readonly pb::MessageParser<InverseConstraintProto> _parser = new pb::MessageParser<InverseConstraintProto>(() => new InverseConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<InverseConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[17]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public InverseConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public InverseConstraintProto(InverseConstraintProto other) : this() {
      fDirect_ = other.fDirect_.Clone();
      fInverse_ = other.fInverse_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public InverseConstraintProto Clone() {
      return new InverseConstraintProto(this);
    }
 
    public const int FDirectFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_fDirect_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> fDirect_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> FDirect {
      get { return fDirect_; }
    }
 
    public const int FInverseFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_fInverse_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> fInverse_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> FInverse {
      get { return fInverse_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as InverseConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(InverseConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!fDirect_.Equals(other.fDirect_)) return false;
      if(!fInverse_.Equals(other.fInverse_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= fDirect_.GetHashCode();
      hash ^= fInverse_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      fDirect_.WriteTo(output, _repeated_fDirect_codec);
      fInverse_.WriteTo(output, _repeated_fInverse_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += fDirect_.CalculateSize(_repeated_fDirect_codec);
      size += fInverse_.CalculateSize(_repeated_fInverse_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(InverseConstraintProto other) {
      if (other == null) {
        return;
      }
      fDirect_.Add(other.fDirect_);
      fInverse_.Add(other.fInverse_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            fDirect_.AddEntriesFrom(input, _repeated_fDirect_codec);
            break;
          }
          case 18:
          case 16: {
            fInverse_.AddEntriesFrom(input, _repeated_fInverse_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class AutomatonConstraintProto : pb::IMessage<AutomatonConstraintProto> {
    private static readonly pb::MessageParser<AutomatonConstraintProto> _parser = new pb::MessageParser<AutomatonConstraintProto>(() => new AutomatonConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<AutomatonConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[18]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AutomatonConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AutomatonConstraintProto(AutomatonConstraintProto other) : this() {
      startingState_ = other.startingState_;
      finalStates_ = other.finalStates_.Clone();
      transitionTail_ = other.transitionTail_.Clone();
      transitionHead_ = other.transitionHead_.Clone();
      transitionLabel_ = other.transitionLabel_.Clone();
      vars_ = other.vars_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public AutomatonConstraintProto Clone() {
      return new AutomatonConstraintProto(this);
    }
 
    public const int StartingStateFieldNumber = 2;
    private long startingState_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long StartingState {
      get { return startingState_; }
      set {
        startingState_ = value;
      }
    }
 
    public const int FinalStatesFieldNumber = 3;
    private static readonly pb::FieldCodec<long> _repeated_finalStates_codec
        = pb::FieldCodec.ForInt64(26);
    private readonly pbc::RepeatedField<long> finalStates_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> FinalStates {
      get { return finalStates_; }
    }
 
    public const int TransitionTailFieldNumber = 4;
    private static readonly pb::FieldCodec<long> _repeated_transitionTail_codec
        = pb::FieldCodec.ForInt64(34);
    private readonly pbc::RepeatedField<long> transitionTail_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> TransitionTail {
      get { return transitionTail_; }
    }
 
    public const int TransitionHeadFieldNumber = 5;
    private static readonly pb::FieldCodec<long> _repeated_transitionHead_codec
        = pb::FieldCodec.ForInt64(42);
    private readonly pbc::RepeatedField<long> transitionHead_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> TransitionHead {
      get { return transitionHead_; }
    }
 
    public const int TransitionLabelFieldNumber = 6;
    private static readonly pb::FieldCodec<long> _repeated_transitionLabel_codec
        = pb::FieldCodec.ForInt64(50);
    private readonly pbc::RepeatedField<long> transitionLabel_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> TransitionLabel {
      get { return transitionLabel_; }
    }
 
    public const int VarsFieldNumber = 7;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(58);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as AutomatonConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(AutomatonConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (StartingState != other.StartingState) return false;
      if(!finalStates_.Equals(other.finalStates_)) return false;
      if(!transitionTail_.Equals(other.transitionTail_)) return false;
      if(!transitionHead_.Equals(other.transitionHead_)) return false;
      if(!transitionLabel_.Equals(other.transitionLabel_)) return false;
      if(!vars_.Equals(other.vars_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (StartingState != 0L) hash ^= StartingState.GetHashCode();
      hash ^= finalStates_.GetHashCode();
      hash ^= transitionTail_.GetHashCode();
      hash ^= transitionHead_.GetHashCode();
      hash ^= transitionLabel_.GetHashCode();
      hash ^= vars_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (StartingState != 0L) {
        output.WriteRawTag(16);
        output.WriteInt64(StartingState);
      }
      finalStates_.WriteTo(output, _repeated_finalStates_codec);
      transitionTail_.WriteTo(output, _repeated_transitionTail_codec);
      transitionHead_.WriteTo(output, _repeated_transitionHead_codec);
      transitionLabel_.WriteTo(output, _repeated_transitionLabel_codec);
      vars_.WriteTo(output, _repeated_vars_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (StartingState != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(StartingState);
      }
      size += finalStates_.CalculateSize(_repeated_finalStates_codec);
      size += transitionTail_.CalculateSize(_repeated_transitionTail_codec);
      size += transitionHead_.CalculateSize(_repeated_transitionHead_codec);
      size += transitionLabel_.CalculateSize(_repeated_transitionLabel_codec);
      size += vars_.CalculateSize(_repeated_vars_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(AutomatonConstraintProto other) {
      if (other == null) {
        return;
      }
      if (other.StartingState != 0L) {
        StartingState = other.StartingState;
      }
      finalStates_.Add(other.finalStates_);
      transitionTail_.Add(other.transitionTail_);
      transitionHead_.Add(other.transitionHead_);
      transitionLabel_.Add(other.transitionLabel_);
      vars_.Add(other.vars_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 16: {
            StartingState = input.ReadInt64();
            break;
          }
          case 26:
          case 24: {
            finalStates_.AddEntriesFrom(input, _repeated_finalStates_codec);
            break;
          }
          case 34:
          case 32: {
            transitionTail_.AddEntriesFrom(input, _repeated_transitionTail_codec);
            break;
          }
          case 42:
          case 40: {
            transitionHead_.AddEntriesFrom(input, _repeated_transitionHead_codec);
            break;
          }
          case 50:
          case 48: {
            transitionLabel_.AddEntriesFrom(input, _repeated_transitionLabel_codec);
            break;
          }
          case 58:
          case 56: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class ConstraintProto : pb::IMessage<ConstraintProto> {
    private static readonly pb::MessageParser<ConstraintProto> _parser = new pb::MessageParser<ConstraintProto>(() => new ConstraintProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ConstraintProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[19]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConstraintProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConstraintProto(ConstraintProto other) : this() {
      name_ = other.name_;
      enforcementLiteral_ = other.enforcementLiteral_.Clone();
      switch (other.ConstraintCase) {
        case ConstraintOneofCase.BoolOr:
          BoolOr = other.BoolOr.Clone();
          break;
        case ConstraintOneofCase.BoolAnd:
          BoolAnd = other.BoolAnd.Clone();
          break;
        case ConstraintOneofCase.AtMostOne:
          AtMostOne = other.AtMostOne.Clone();
          break;
        case ConstraintOneofCase.BoolXor:
          BoolXor = other.BoolXor.Clone();
          break;
        case ConstraintOneofCase.IntDiv:
          IntDiv = other.IntDiv.Clone();
          break;
        case ConstraintOneofCase.IntMod:
          IntMod = other.IntMod.Clone();
          break;
        case ConstraintOneofCase.IntMax:
          IntMax = other.IntMax.Clone();
          break;
        case ConstraintOneofCase.LinMax:
          LinMax = other.LinMax.Clone();
          break;
        case ConstraintOneofCase.IntMin:
          IntMin = other.IntMin.Clone();
          break;
        case ConstraintOneofCase.LinMin:
          LinMin = other.LinMin.Clone();
          break;
        case ConstraintOneofCase.IntProd:
          IntProd = other.IntProd.Clone();
          break;
        case ConstraintOneofCase.Linear:
          Linear = other.Linear.Clone();
          break;
        case ConstraintOneofCase.AllDiff:
          AllDiff = other.AllDiff.Clone();
          break;
        case ConstraintOneofCase.Element:
          Element = other.Element.Clone();
          break;
        case ConstraintOneofCase.Circuit:
          Circuit = other.Circuit.Clone();
          break;
        case ConstraintOneofCase.Routes:
          Routes = other.Routes.Clone();
          break;
        case ConstraintOneofCase.CircuitCovering:
          CircuitCovering = other.CircuitCovering.Clone();
          break;
        case ConstraintOneofCase.Table:
          Table = other.Table.Clone();
          break;
        case ConstraintOneofCase.Automaton:
          Automaton = other.Automaton.Clone();
          break;
        case ConstraintOneofCase.Inverse:
          Inverse = other.Inverse.Clone();
          break;
        case ConstraintOneofCase.Reservoir:
          Reservoir = other.Reservoir.Clone();
          break;
        case ConstraintOneofCase.Interval:
          Interval = other.Interval.Clone();
          break;
        case ConstraintOneofCase.NoOverlap:
          NoOverlap = other.NoOverlap.Clone();
          break;
        case ConstraintOneofCase.NoOverlap2D:
          NoOverlap2D = other.NoOverlap2D.Clone();
          break;
        case ConstraintOneofCase.Cumulative:
          Cumulative = other.Cumulative.Clone();
          break;
      }
 
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConstraintProto Clone() {
      return new ConstraintProto(this);
    }
 
    public const int NameFieldNumber = 1;
    private string name_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }
 
    public const int EnforcementLiteralFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_enforcementLiteral_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> enforcementLiteral_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> EnforcementLiteral {
      get { return enforcementLiteral_; }
    }
 
    public const int BoolOrFieldNumber = 3;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.BoolArgumentProto BoolOr {
      get { return constraintCase_ == ConstraintOneofCase.BoolOr ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolOr;
      }
    }
 
    public const int BoolAndFieldNumber = 4;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.BoolArgumentProto BoolAnd {
      get { return constraintCase_ == ConstraintOneofCase.BoolAnd ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolAnd;
      }
    }
 
    public const int AtMostOneFieldNumber = 26;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.BoolArgumentProto AtMostOne {
      get { return constraintCase_ == ConstraintOneofCase.AtMostOne ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.AtMostOne;
      }
    }
 
    public const int BoolXorFieldNumber = 5;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.BoolArgumentProto BoolXor {
      get { return constraintCase_ == ConstraintOneofCase.BoolXor ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolXor;
      }
    }
 
    public const int IntDivFieldNumber = 7;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.IntegerArgumentProto IntDiv {
      get { return constraintCase_ == ConstraintOneofCase.IntDiv ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntDiv;
      }
    }
 
    public const int IntModFieldNumber = 8;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.IntegerArgumentProto IntMod {
      get { return constraintCase_ == ConstraintOneofCase.IntMod ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMod;
      }
    }
 
    public const int IntMaxFieldNumber = 9;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.IntegerArgumentProto IntMax {
      get { return constraintCase_ == ConstraintOneofCase.IntMax ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMax;
      }
    }
 
    public const int LinMaxFieldNumber = 27;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.LinearArgumentProto LinMax {
      get { return constraintCase_ == ConstraintOneofCase.LinMax ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.LinMax;
      }
    }
 
    public const int IntMinFieldNumber = 10;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.IntegerArgumentProto IntMin {
      get { return constraintCase_ == ConstraintOneofCase.IntMin ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMin;
      }
    }
 
    public const int LinMinFieldNumber = 28;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.LinearArgumentProto LinMin {
      get { return constraintCase_ == ConstraintOneofCase.LinMin ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.LinMin;
      }
    }
 
    public const int IntProdFieldNumber = 11;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.IntegerArgumentProto IntProd {
      get { return constraintCase_ == ConstraintOneofCase.IntProd ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntProd;
      }
    }
 
    public const int LinearFieldNumber = 12;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.LinearConstraintProto Linear {
      get { return constraintCase_ == ConstraintOneofCase.Linear ? (global::Google.OrTools.Sat.LinearConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Linear;
      }
    }
 
    public const int AllDiffFieldNumber = 13;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.AllDifferentConstraintProto AllDiff {
      get { return constraintCase_ == ConstraintOneofCase.AllDiff ? (global::Google.OrTools.Sat.AllDifferentConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.AllDiff;
      }
    }
 
    public const int ElementFieldNumber = 14;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.ElementConstraintProto Element {
      get { return constraintCase_ == ConstraintOneofCase.Element ? (global::Google.OrTools.Sat.ElementConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Element;
      }
    }
 
    public const int CircuitFieldNumber = 15;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.CircuitConstraintProto Circuit {
      get { return constraintCase_ == ConstraintOneofCase.Circuit ? (global::Google.OrTools.Sat.CircuitConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Circuit;
      }
    }
 
    public const int RoutesFieldNumber = 23;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.RoutesConstraintProto Routes {
      get { return constraintCase_ == ConstraintOneofCase.Routes ? (global::Google.OrTools.Sat.RoutesConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Routes;
      }
    }
 
    public const int CircuitCoveringFieldNumber = 25;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.CircuitCoveringConstraintProto CircuitCovering {
      get { return constraintCase_ == ConstraintOneofCase.CircuitCovering ? (global::Google.OrTools.Sat.CircuitCoveringConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.CircuitCovering;
      }
    }
 
    public const int TableFieldNumber = 16;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.TableConstraintProto Table {
      get { return constraintCase_ == ConstraintOneofCase.Table ? (global::Google.OrTools.Sat.TableConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Table;
      }
    }
 
    public const int AutomatonFieldNumber = 17;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.AutomatonConstraintProto Automaton {
      get { return constraintCase_ == ConstraintOneofCase.Automaton ? (global::Google.OrTools.Sat.AutomatonConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Automaton;
      }
    }
 
    public const int InverseFieldNumber = 18;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.InverseConstraintProto Inverse {
      get { return constraintCase_ == ConstraintOneofCase.Inverse ? (global::Google.OrTools.Sat.InverseConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Inverse;
      }
    }
 
    public const int ReservoirFieldNumber = 24;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.ReservoirConstraintProto Reservoir {
      get { return constraintCase_ == ConstraintOneofCase.Reservoir ? (global::Google.OrTools.Sat.ReservoirConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Reservoir;
      }
    }
 
    public const int IntervalFieldNumber = 19;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.IntervalConstraintProto Interval {
      get { return constraintCase_ == ConstraintOneofCase.Interval ? (global::Google.OrTools.Sat.IntervalConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Interval;
      }
    }
 
    public const int NoOverlapFieldNumber = 20;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.NoOverlapConstraintProto NoOverlap {
      get { return constraintCase_ == ConstraintOneofCase.NoOverlap ? (global::Google.OrTools.Sat.NoOverlapConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.NoOverlap;
      }
    }
 
    public const int NoOverlap2DFieldNumber = 21;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.NoOverlap2DConstraintProto NoOverlap2D {
      get { return constraintCase_ == ConstraintOneofCase.NoOverlap2D ? (global::Google.OrTools.Sat.NoOverlap2DConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.NoOverlap2D;
      }
    }
 
    public const int CumulativeFieldNumber = 22;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.CumulativeConstraintProto Cumulative {
      get { return constraintCase_ == ConstraintOneofCase.Cumulative ? (global::Google.OrTools.Sat.CumulativeConstraintProto) constraint_ : null; }
      set {
        constraint_ = value;
        constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Cumulative;
      }
    }
 
    private object constraint_;
    public enum ConstraintOneofCase {
      None = 0,
      BoolOr = 3,
      BoolAnd = 4,
      AtMostOne = 26,
      BoolXor = 5,
      IntDiv = 7,
      IntMod = 8,
      IntMax = 9,
      LinMax = 27,
      IntMin = 10,
      LinMin = 28,
      IntProd = 11,
      Linear = 12,
      AllDiff = 13,
      Element = 14,
      Circuit = 15,
      Routes = 23,
      CircuitCovering = 25,
      Table = 16,
      Automaton = 17,
      Inverse = 18,
      Reservoir = 24,
      Interval = 19,
      NoOverlap = 20,
      NoOverlap2D = 21,
      Cumulative = 22,
    }
    private ConstraintOneofCase constraintCase_ = ConstraintOneofCase.None;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConstraintOneofCase ConstraintCase {
      get { return constraintCase_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearConstraint() {
      constraintCase_ = ConstraintOneofCase.None;
      constraint_ = null;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ConstraintProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ConstraintProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Name != other.Name) return false;
      if(!enforcementLiteral_.Equals(other.enforcementLiteral_)) return false;
      if (!object.Equals(BoolOr, other.BoolOr)) return false;
      if (!object.Equals(BoolAnd, other.BoolAnd)) return false;
      if (!object.Equals(AtMostOne, other.AtMostOne)) return false;
      if (!object.Equals(BoolXor, other.BoolXor)) return false;
      if (!object.Equals(IntDiv, other.IntDiv)) return false;
      if (!object.Equals(IntMod, other.IntMod)) return false;
      if (!object.Equals(IntMax, other.IntMax)) return false;
      if (!object.Equals(LinMax, other.LinMax)) return false;
      if (!object.Equals(IntMin, other.IntMin)) return false;
      if (!object.Equals(LinMin, other.LinMin)) return false;
      if (!object.Equals(IntProd, other.IntProd)) return false;
      if (!object.Equals(Linear, other.Linear)) return false;
      if (!object.Equals(AllDiff, other.AllDiff)) return false;
      if (!object.Equals(Element, other.Element)) return false;
      if (!object.Equals(Circuit, other.Circuit)) return false;
      if (!object.Equals(Routes, other.Routes)) return false;
      if (!object.Equals(CircuitCovering, other.CircuitCovering)) return false;
      if (!object.Equals(Table, other.Table)) return false;
      if (!object.Equals(Automaton, other.Automaton)) return false;
      if (!object.Equals(Inverse, other.Inverse)) return false;
      if (!object.Equals(Reservoir, other.Reservoir)) return false;
      if (!object.Equals(Interval, other.Interval)) return false;
      if (!object.Equals(NoOverlap, other.NoOverlap)) return false;
      if (!object.Equals(NoOverlap2D, other.NoOverlap2D)) return false;
      if (!object.Equals(Cumulative, other.Cumulative)) return false;
      if (ConstraintCase != other.ConstraintCase) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Name.Length != 0) hash ^= Name.GetHashCode();
      hash ^= enforcementLiteral_.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.BoolOr) hash ^= BoolOr.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.BoolAnd) hash ^= BoolAnd.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.AtMostOne) hash ^= AtMostOne.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.BoolXor) hash ^= BoolXor.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.IntDiv) hash ^= IntDiv.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.IntMod) hash ^= IntMod.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.IntMax) hash ^= IntMax.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.LinMax) hash ^= LinMax.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.IntMin) hash ^= IntMin.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.LinMin) hash ^= LinMin.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.IntProd) hash ^= IntProd.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Linear) hash ^= Linear.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.AllDiff) hash ^= AllDiff.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Element) hash ^= Element.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Circuit) hash ^= Circuit.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Routes) hash ^= Routes.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.CircuitCovering) hash ^= CircuitCovering.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Table) hash ^= Table.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Automaton) hash ^= Automaton.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Inverse) hash ^= Inverse.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Reservoir) hash ^= Reservoir.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Interval) hash ^= Interval.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.NoOverlap) hash ^= NoOverlap.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) hash ^= NoOverlap2D.GetHashCode();
      if (constraintCase_ == ConstraintOneofCase.Cumulative) hash ^= Cumulative.GetHashCode();
      hash ^= (int) constraintCase_;
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      enforcementLiteral_.WriteTo(output, _repeated_enforcementLiteral_codec);
      if (constraintCase_ == ConstraintOneofCase.BoolOr) {
        output.WriteRawTag(26);
        output.WriteMessage(BoolOr);
      }
      if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
        output.WriteRawTag(34);
        output.WriteMessage(BoolAnd);
      }
      if (constraintCase_ == ConstraintOneofCase.BoolXor) {
        output.WriteRawTag(42);
        output.WriteMessage(BoolXor);
      }
      if (constraintCase_ == ConstraintOneofCase.IntDiv) {
        output.WriteRawTag(58);
        output.WriteMessage(IntDiv);
      }
      if (constraintCase_ == ConstraintOneofCase.IntMod) {
        output.WriteRawTag(66);
        output.WriteMessage(IntMod);
      }
      if (constraintCase_ == ConstraintOneofCase.IntMax) {
        output.WriteRawTag(74);
        output.WriteMessage(IntMax);
      }
      if (constraintCase_ == ConstraintOneofCase.IntMin) {
        output.WriteRawTag(82);
        output.WriteMessage(IntMin);
      }
      if (constraintCase_ == ConstraintOneofCase.IntProd) {
        output.WriteRawTag(90);
        output.WriteMessage(IntProd);
      }
      if (constraintCase_ == ConstraintOneofCase.Linear) {
        output.WriteRawTag(98);
        output.WriteMessage(Linear);
      }
      if (constraintCase_ == ConstraintOneofCase.AllDiff) {
        output.WriteRawTag(106);
        output.WriteMessage(AllDiff);
      }
      if (constraintCase_ == ConstraintOneofCase.Element) {
        output.WriteRawTag(114);
        output.WriteMessage(Element);
      }
      if (constraintCase_ == ConstraintOneofCase.Circuit) {
        output.WriteRawTag(122);
        output.WriteMessage(Circuit);
      }
      if (constraintCase_ == ConstraintOneofCase.Table) {
        output.WriteRawTag(130, 1);
        output.WriteMessage(Table);
      }
      if (constraintCase_ == ConstraintOneofCase.Automaton) {
        output.WriteRawTag(138, 1);
        output.WriteMessage(Automaton);
      }
      if (constraintCase_ == ConstraintOneofCase.Inverse) {
        output.WriteRawTag(146, 1);
        output.WriteMessage(Inverse);
      }
      if (constraintCase_ == ConstraintOneofCase.Interval) {
        output.WriteRawTag(154, 1);
        output.WriteMessage(Interval);
      }
      if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
        output.WriteRawTag(162, 1);
        output.WriteMessage(NoOverlap);
      }
      if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
        output.WriteRawTag(170, 1);
        output.WriteMessage(NoOverlap2D);
      }
      if (constraintCase_ == ConstraintOneofCase.Cumulative) {
        output.WriteRawTag(178, 1);
        output.WriteMessage(Cumulative);
      }
      if (constraintCase_ == ConstraintOneofCase.Routes) {
        output.WriteRawTag(186, 1);
        output.WriteMessage(Routes);
      }
      if (constraintCase_ == ConstraintOneofCase.Reservoir) {
        output.WriteRawTag(194, 1);
        output.WriteMessage(Reservoir);
      }
      if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
        output.WriteRawTag(202, 1);
        output.WriteMessage(CircuitCovering);
      }
      if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
        output.WriteRawTag(210, 1);
        output.WriteMessage(AtMostOne);
      }
      if (constraintCase_ == ConstraintOneofCase.LinMax) {
        output.WriteRawTag(218, 1);
        output.WriteMessage(LinMax);
      }
      if (constraintCase_ == ConstraintOneofCase.LinMin) {
        output.WriteRawTag(226, 1);
        output.WriteMessage(LinMin);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      size += enforcementLiteral_.CalculateSize(_repeated_enforcementLiteral_codec);
      if (constraintCase_ == ConstraintOneofCase.BoolOr) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolOr);
      }
      if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolAnd);
      }
      if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(AtMostOne);
      }
      if (constraintCase_ == ConstraintOneofCase.BoolXor) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolXor);
      }
      if (constraintCase_ == ConstraintOneofCase.IntDiv) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntDiv);
      }
      if (constraintCase_ == ConstraintOneofCase.IntMod) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMod);
      }
      if (constraintCase_ == ConstraintOneofCase.IntMax) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMax);
      }
      if (constraintCase_ == ConstraintOneofCase.LinMax) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMax);
      }
      if (constraintCase_ == ConstraintOneofCase.IntMin) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMin);
      }
      if (constraintCase_ == ConstraintOneofCase.LinMin) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMin);
      }
      if (constraintCase_ == ConstraintOneofCase.IntProd) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntProd);
      }
      if (constraintCase_ == ConstraintOneofCase.Linear) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Linear);
      }
      if (constraintCase_ == ConstraintOneofCase.AllDiff) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(AllDiff);
      }
      if (constraintCase_ == ConstraintOneofCase.Element) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Element);
      }
      if (constraintCase_ == ConstraintOneofCase.Circuit) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Circuit);
      }
      if (constraintCase_ == ConstraintOneofCase.Routes) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Routes);
      }
      if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(CircuitCovering);
      }
      if (constraintCase_ == ConstraintOneofCase.Table) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Table);
      }
      if (constraintCase_ == ConstraintOneofCase.Automaton) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Automaton);
      }
      if (constraintCase_ == ConstraintOneofCase.Inverse) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Inverse);
      }
      if (constraintCase_ == ConstraintOneofCase.Reservoir) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Reservoir);
      }
      if (constraintCase_ == ConstraintOneofCase.Interval) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Interval);
      }
      if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap);
      }
      if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap2D);
      }
      if (constraintCase_ == ConstraintOneofCase.Cumulative) {
        size += 2 + pb::CodedOutputStream.ComputeMessageSize(Cumulative);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ConstraintProto other) {
      if (other == null) {
        return;
      }
      if (other.Name.Length != 0) {
        Name = other.Name;
      }
      enforcementLiteral_.Add(other.enforcementLiteral_);
      switch (other.ConstraintCase) {
        case ConstraintOneofCase.BoolOr:
          if (BoolOr == null) {
            BoolOr = new global::Google.OrTools.Sat.BoolArgumentProto();
          }
          BoolOr.MergeFrom(other.BoolOr);
          break;
        case ConstraintOneofCase.BoolAnd:
          if (BoolAnd == null) {
            BoolAnd = new global::Google.OrTools.Sat.BoolArgumentProto();
          }
          BoolAnd.MergeFrom(other.BoolAnd);
          break;
        case ConstraintOneofCase.AtMostOne:
          if (AtMostOne == null) {
            AtMostOne = new global::Google.OrTools.Sat.BoolArgumentProto();
          }
          AtMostOne.MergeFrom(other.AtMostOne);
          break;
        case ConstraintOneofCase.BoolXor:
          if (BoolXor == null) {
            BoolXor = new global::Google.OrTools.Sat.BoolArgumentProto();
          }
          BoolXor.MergeFrom(other.BoolXor);
          break;
        case ConstraintOneofCase.IntDiv:
          if (IntDiv == null) {
            IntDiv = new global::Google.OrTools.Sat.IntegerArgumentProto();
          }
          IntDiv.MergeFrom(other.IntDiv);
          break;
        case ConstraintOneofCase.IntMod:
          if (IntMod == null) {
            IntMod = new global::Google.OrTools.Sat.IntegerArgumentProto();
          }
          IntMod.MergeFrom(other.IntMod);
          break;
        case ConstraintOneofCase.IntMax:
          if (IntMax == null) {
            IntMax = new global::Google.OrTools.Sat.IntegerArgumentProto();
          }
          IntMax.MergeFrom(other.IntMax);
          break;
        case ConstraintOneofCase.LinMax:
          if (LinMax == null) {
            LinMax = new global::Google.OrTools.Sat.LinearArgumentProto();
          }
          LinMax.MergeFrom(other.LinMax);
          break;
        case ConstraintOneofCase.IntMin:
          if (IntMin == null) {
            IntMin = new global::Google.OrTools.Sat.IntegerArgumentProto();
          }
          IntMin.MergeFrom(other.IntMin);
          break;
        case ConstraintOneofCase.LinMin:
          if (LinMin == null) {
            LinMin = new global::Google.OrTools.Sat.LinearArgumentProto();
          }
          LinMin.MergeFrom(other.LinMin);
          break;
        case ConstraintOneofCase.IntProd:
          if (IntProd == null) {
            IntProd = new global::Google.OrTools.Sat.IntegerArgumentProto();
          }
          IntProd.MergeFrom(other.IntProd);
          break;
        case ConstraintOneofCase.Linear:
          if (Linear == null) {
            Linear = new global::Google.OrTools.Sat.LinearConstraintProto();
          }
          Linear.MergeFrom(other.Linear);
          break;
        case ConstraintOneofCase.AllDiff:
          if (AllDiff == null) {
            AllDiff = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
          }
          AllDiff.MergeFrom(other.AllDiff);
          break;
        case ConstraintOneofCase.Element:
          if (Element == null) {
            Element = new global::Google.OrTools.Sat.ElementConstraintProto();
          }
          Element.MergeFrom(other.Element);
          break;
        case ConstraintOneofCase.Circuit:
          if (Circuit == null) {
            Circuit = new global::Google.OrTools.Sat.CircuitConstraintProto();
          }
          Circuit.MergeFrom(other.Circuit);
          break;
        case ConstraintOneofCase.Routes:
          if (Routes == null) {
            Routes = new global::Google.OrTools.Sat.RoutesConstraintProto();
          }
          Routes.MergeFrom(other.Routes);
          break;
        case ConstraintOneofCase.CircuitCovering:
          if (CircuitCovering == null) {
            CircuitCovering = new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
          }
          CircuitCovering.MergeFrom(other.CircuitCovering);
          break;
        case ConstraintOneofCase.Table:
          if (Table == null) {
            Table = new global::Google.OrTools.Sat.TableConstraintProto();
          }
          Table.MergeFrom(other.Table);
          break;
        case ConstraintOneofCase.Automaton:
          if (Automaton == null) {
            Automaton = new global::Google.OrTools.Sat.AutomatonConstraintProto();
          }
          Automaton.MergeFrom(other.Automaton);
          break;
        case ConstraintOneofCase.Inverse:
          if (Inverse == null) {
            Inverse = new global::Google.OrTools.Sat.InverseConstraintProto();
          }
          Inverse.MergeFrom(other.Inverse);
          break;
        case ConstraintOneofCase.Reservoir:
          if (Reservoir == null) {
            Reservoir = new global::Google.OrTools.Sat.ReservoirConstraintProto();
          }
          Reservoir.MergeFrom(other.Reservoir);
          break;
        case ConstraintOneofCase.Interval:
          if (Interval == null) {
            Interval = new global::Google.OrTools.Sat.IntervalConstraintProto();
          }
          Interval.MergeFrom(other.Interval);
          break;
        case ConstraintOneofCase.NoOverlap:
          if (NoOverlap == null) {
            NoOverlap = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
          }
          NoOverlap.MergeFrom(other.NoOverlap);
          break;
        case ConstraintOneofCase.NoOverlap2D:
          if (NoOverlap2D == null) {
            NoOverlap2D = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
          }
          NoOverlap2D.MergeFrom(other.NoOverlap2D);
          break;
        case ConstraintOneofCase.Cumulative:
          if (Cumulative == null) {
            Cumulative = new global::Google.OrTools.Sat.CumulativeConstraintProto();
          }
          Cumulative.MergeFrom(other.Cumulative);
          break;
      }
 
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18:
          case 16: {
            enforcementLiteral_.AddEntriesFrom(input, _repeated_enforcementLiteral_codec);
            break;
          }
          case 26: {
            global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.BoolOr) {
              subBuilder.MergeFrom(BoolOr);
            }
            input.ReadMessage(subBuilder);
            BoolOr = subBuilder;
            break;
          }
          case 34: {
            global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
              subBuilder.MergeFrom(BoolAnd);
            }
            input.ReadMessage(subBuilder);
            BoolAnd = subBuilder;
            break;
          }
          case 42: {
            global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.BoolXor) {
              subBuilder.MergeFrom(BoolXor);
            }
            input.ReadMessage(subBuilder);
            BoolXor = subBuilder;
            break;
          }
          case 58: {
            global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.IntDiv) {
              subBuilder.MergeFrom(IntDiv);
            }
            input.ReadMessage(subBuilder);
            IntDiv = subBuilder;
            break;
          }
          case 66: {
            global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.IntMod) {
              subBuilder.MergeFrom(IntMod);
            }
            input.ReadMessage(subBuilder);
            IntMod = subBuilder;
            break;
          }
          case 74: {
            global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.IntMax) {
              subBuilder.MergeFrom(IntMax);
            }
            input.ReadMessage(subBuilder);
            IntMax = subBuilder;
            break;
          }
          case 82: {
            global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.IntMin) {
              subBuilder.MergeFrom(IntMin);
            }
            input.ReadMessage(subBuilder);
            IntMin = subBuilder;
            break;
          }
          case 90: {
            global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.IntProd) {
              subBuilder.MergeFrom(IntProd);
            }
            input.ReadMessage(subBuilder);
            IntProd = subBuilder;
            break;
          }
          case 98: {
            global::Google.OrTools.Sat.LinearConstraintProto subBuilder = new global::Google.OrTools.Sat.LinearConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Linear) {
              subBuilder.MergeFrom(Linear);
            }
            input.ReadMessage(subBuilder);
            Linear = subBuilder;
            break;
          }
          case 106: {
            global::Google.OrTools.Sat.AllDifferentConstraintProto subBuilder = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.AllDiff) {
              subBuilder.MergeFrom(AllDiff);
            }
            input.ReadMessage(subBuilder);
            AllDiff = subBuilder;
            break;
          }
          case 114: {
            global::Google.OrTools.Sat.ElementConstraintProto subBuilder = new global::Google.OrTools.Sat.ElementConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Element) {
              subBuilder.MergeFrom(Element);
            }
            input.ReadMessage(subBuilder);
            Element = subBuilder;
            break;
          }
          case 122: {
            global::Google.OrTools.Sat.CircuitConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Circuit) {
              subBuilder.MergeFrom(Circuit);
            }
            input.ReadMessage(subBuilder);
            Circuit = subBuilder;
            break;
          }
          case 130: {
            global::Google.OrTools.Sat.TableConstraintProto subBuilder = new global::Google.OrTools.Sat.TableConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Table) {
              subBuilder.MergeFrom(Table);
            }
            input.ReadMessage(subBuilder);
            Table = subBuilder;
            break;
          }
          case 138: {
            global::Google.OrTools.Sat.AutomatonConstraintProto subBuilder = new global::Google.OrTools.Sat.AutomatonConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Automaton) {
              subBuilder.MergeFrom(Automaton);
            }
            input.ReadMessage(subBuilder);
            Automaton = subBuilder;
            break;
          }
          case 146: {
            global::Google.OrTools.Sat.InverseConstraintProto subBuilder = new global::Google.OrTools.Sat.InverseConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Inverse) {
              subBuilder.MergeFrom(Inverse);
            }
            input.ReadMessage(subBuilder);
            Inverse = subBuilder;
            break;
          }
          case 154: {
            global::Google.OrTools.Sat.IntervalConstraintProto subBuilder = new global::Google.OrTools.Sat.IntervalConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Interval) {
              subBuilder.MergeFrom(Interval);
            }
            input.ReadMessage(subBuilder);
            Interval = subBuilder;
            break;
          }
          case 162: {
            global::Google.OrTools.Sat.NoOverlapConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
              subBuilder.MergeFrom(NoOverlap);
            }
            input.ReadMessage(subBuilder);
            NoOverlap = subBuilder;
            break;
          }
          case 170: {
            global::Google.OrTools.Sat.NoOverlap2DConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
              subBuilder.MergeFrom(NoOverlap2D);
            }
            input.ReadMessage(subBuilder);
            NoOverlap2D = subBuilder;
            break;
          }
          case 178: {
            global::Google.OrTools.Sat.CumulativeConstraintProto subBuilder = new global::Google.OrTools.Sat.CumulativeConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Cumulative) {
              subBuilder.MergeFrom(Cumulative);
            }
            input.ReadMessage(subBuilder);
            Cumulative = subBuilder;
            break;
          }
          case 186: {
            global::Google.OrTools.Sat.RoutesConstraintProto subBuilder = new global::Google.OrTools.Sat.RoutesConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Routes) {
              subBuilder.MergeFrom(Routes);
            }
            input.ReadMessage(subBuilder);
            Routes = subBuilder;
            break;
          }
          case 194: {
            global::Google.OrTools.Sat.ReservoirConstraintProto subBuilder = new global::Google.OrTools.Sat.ReservoirConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.Reservoir) {
              subBuilder.MergeFrom(Reservoir);
            }
            input.ReadMessage(subBuilder);
            Reservoir = subBuilder;
            break;
          }
          case 202: {
            global::Google.OrTools.Sat.CircuitCoveringConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
            if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
              subBuilder.MergeFrom(CircuitCovering);
            }
            input.ReadMessage(subBuilder);
            CircuitCovering = subBuilder;
            break;
          }
          case 210: {
            global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
              subBuilder.MergeFrom(AtMostOne);
            }
            input.ReadMessage(subBuilder);
            AtMostOne = subBuilder;
            break;
          }
          case 218: {
            global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.LinMax) {
              subBuilder.MergeFrom(LinMax);
            }
            input.ReadMessage(subBuilder);
            LinMax = subBuilder;
            break;
          }
          case 226: {
            global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
            if (constraintCase_ == ConstraintOneofCase.LinMin) {
              subBuilder.MergeFrom(LinMin);
            }
            input.ReadMessage(subBuilder);
            LinMin = subBuilder;
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class CpObjectiveProto : pb::IMessage<CpObjectiveProto> {
    private static readonly pb::MessageParser<CpObjectiveProto> _parser = new pb::MessageParser<CpObjectiveProto>(() => new CpObjectiveProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CpObjectiveProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[20]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpObjectiveProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpObjectiveProto(CpObjectiveProto other) : this() {
      vars_ = other.vars_.Clone();
      coeffs_ = other.coeffs_.Clone();
      offset_ = other.offset_;
      scalingFactor_ = other.scalingFactor_;
      domain_ = other.domain_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpObjectiveProto Clone() {
      return new CpObjectiveProto(this);
    }
 
    public const int VarsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    public const int CoeffsFieldNumber = 4;
    private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
        = pb::FieldCodec.ForInt64(34);
    private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Coeffs {
      get { return coeffs_; }
    }
 
    public const int OffsetFieldNumber = 2;
    private double offset_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double Offset {
      get { return offset_; }
      set {
        offset_ = value;
      }
    }
 
    public const int ScalingFactorFieldNumber = 3;
    private double scalingFactor_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double ScalingFactor {
      get { return scalingFactor_; }
      set {
        scalingFactor_ = value;
      }
    }
 
    public const int DomainFieldNumber = 5;
    private static readonly pb::FieldCodec<long> _repeated_domain_codec
        = pb::FieldCodec.ForInt64(42);
    private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Domain {
      get { return domain_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CpObjectiveProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CpObjectiveProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!vars_.Equals(other.vars_)) return false;
      if(!coeffs_.Equals(other.coeffs_)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Offset, other.Offset)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ScalingFactor, other.ScalingFactor)) return false;
      if(!domain_.Equals(other.domain_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= vars_.GetHashCode();
      hash ^= coeffs_.GetHashCode();
      if (Offset != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Offset);
      if (ScalingFactor != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ScalingFactor);
      hash ^= domain_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      vars_.WriteTo(output, _repeated_vars_codec);
      if (Offset != 0D) {
        output.WriteRawTag(17);
        output.WriteDouble(Offset);
      }
      if (ScalingFactor != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(ScalingFactor);
      }
      coeffs_.WriteTo(output, _repeated_coeffs_codec);
      domain_.WriteTo(output, _repeated_domain_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += vars_.CalculateSize(_repeated_vars_codec);
      size += coeffs_.CalculateSize(_repeated_coeffs_codec);
      if (Offset != 0D) {
        size += 1 + 8;
      }
      if (ScalingFactor != 0D) {
        size += 1 + 8;
      }
      size += domain_.CalculateSize(_repeated_domain_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CpObjectiveProto other) {
      if (other == null) {
        return;
      }
      vars_.Add(other.vars_);
      coeffs_.Add(other.coeffs_);
      if (other.Offset != 0D) {
        Offset = other.Offset;
      }
      if (other.ScalingFactor != 0D) {
        ScalingFactor = other.ScalingFactor;
      }
      domain_.Add(other.domain_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
          case 17: {
            Offset = input.ReadDouble();
            break;
          }
          case 25: {
            ScalingFactor = input.ReadDouble();
            break;
          }
          case 34:
          case 32: {
            coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
            break;
          }
          case 42:
          case 40: {
            domain_.AddEntriesFrom(input, _repeated_domain_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class DecisionStrategyProto : pb::IMessage<DecisionStrategyProto> {
    private static readonly pb::MessageParser<DecisionStrategyProto> _parser = new pb::MessageParser<DecisionStrategyProto>(() => new DecisionStrategyProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<DecisionStrategyProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[21]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DecisionStrategyProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DecisionStrategyProto(DecisionStrategyProto other) : this() {
      variables_ = other.variables_.Clone();
      variableSelectionStrategy_ = other.variableSelectionStrategy_;
      domainReductionStrategy_ = other.domainReductionStrategy_;
      transformations_ = other.transformations_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DecisionStrategyProto Clone() {
      return new DecisionStrategyProto(this);
    }
 
    public const int VariablesFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_variables_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> variables_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Variables {
      get { return variables_; }
    }
 
    public const int VariableSelectionStrategyFieldNumber = 2;
    private global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy variableSelectionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy VariableSelectionStrategy {
      get { return variableSelectionStrategy_; }
      set {
        variableSelectionStrategy_ = value;
      }
    }
 
    public const int DomainReductionStrategyFieldNumber = 3;
    private global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy domainReductionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy DomainReductionStrategy {
      get { return domainReductionStrategy_; }
      set {
        domainReductionStrategy_ = value;
      }
    }
 
    public const int TransformationsFieldNumber = 4;
    private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> _repeated_transformations_codec
        = pb::FieldCodec.ForMessage(34, global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser);
    private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> transformations_ = new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> Transformations {
      get { return transformations_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as DecisionStrategyProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(DecisionStrategyProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!variables_.Equals(other.variables_)) return false;
      if (VariableSelectionStrategy != other.VariableSelectionStrategy) return false;
      if (DomainReductionStrategy != other.DomainReductionStrategy) return false;
      if(!transformations_.Equals(other.transformations_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= variables_.GetHashCode();
      if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) hash ^= VariableSelectionStrategy.GetHashCode();
      if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) hash ^= DomainReductionStrategy.GetHashCode();
      hash ^= transformations_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      variables_.WriteTo(output, _repeated_variables_codec);
      if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
        output.WriteRawTag(16);
        output.WriteEnum((int) VariableSelectionStrategy);
      }
      if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
        output.WriteRawTag(24);
        output.WriteEnum((int) DomainReductionStrategy);
      }
      transformations_.WriteTo(output, _repeated_transformations_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += variables_.CalculateSize(_repeated_variables_codec);
      if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) VariableSelectionStrategy);
      }
      if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DomainReductionStrategy);
      }
      size += transformations_.CalculateSize(_repeated_transformations_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(DecisionStrategyProto other) {
      if (other == null) {
        return;
      }
      variables_.Add(other.variables_);
      if (other.VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
        VariableSelectionStrategy = other.VariableSelectionStrategy;
      }
      if (other.DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
        DomainReductionStrategy = other.DomainReductionStrategy;
      }
      transformations_.Add(other.transformations_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            variables_.AddEntriesFrom(input, _repeated_variables_codec);
            break;
          }
          case 16: {
            VariableSelectionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy) input.ReadEnum();
            break;
          }
          case 24: {
            DomainReductionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) input.ReadEnum();
            break;
          }
          case 34: {
            transformations_.AddEntriesFrom(input, _repeated_transformations_codec);
            break;
          }
        }
      }
    }
 
    #region Nested types
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      public enum VariableSelectionStrategy {
        [pbr::OriginalName("CHOOSE_FIRST")] ChooseFirst = 0,
        [pbr::OriginalName("CHOOSE_LOWEST_MIN")] ChooseLowestMin = 1,
        [pbr::OriginalName("CHOOSE_HIGHEST_MAX")] ChooseHighestMax = 2,
        [pbr::OriginalName("CHOOSE_MIN_DOMAIN_SIZE")] ChooseMinDomainSize = 3,
        [pbr::OriginalName("CHOOSE_MAX_DOMAIN_SIZE")] ChooseMaxDomainSize = 4,
      }
 
      public enum DomainReductionStrategy {
        [pbr::OriginalName("SELECT_MIN_VALUE")] SelectMinValue = 0,
        [pbr::OriginalName("SELECT_MAX_VALUE")] SelectMaxValue = 1,
        [pbr::OriginalName("SELECT_LOWER_HALF")] SelectLowerHalf = 2,
        [pbr::OriginalName("SELECT_UPPER_HALF")] SelectUpperHalf = 3,
        [pbr::OriginalName("SELECT_MEDIAN_VALUE")] SelectMedianValue = 4,
      }
 
      public sealed partial class AffineTransformation : pb::IMessage<AffineTransformation> {
        private static readonly pb::MessageParser<AffineTransformation> _parser = new pb::MessageParser<AffineTransformation>(() => new AffineTransformation());
        private pb::UnknownFieldSet _unknownFields;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<AffineTransformation> Parser { get { return _parser; } }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Google.OrTools.Sat.DecisionStrategyProto.Descriptor.NestedTypes[0]; }
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public AffineTransformation() {
          OnConstruction();
        }
 
        partial void OnConstruction();
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public AffineTransformation(AffineTransformation other) : this() {
          var_ = other.var_;
          offset_ = other.offset_;
          positiveCoeff_ = other.positiveCoeff_;
          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public AffineTransformation Clone() {
          return new AffineTransformation(this);
        }
 
        public const int VarFieldNumber = 1;
        private int var_;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Var {
          get { return var_; }
          set {
            var_ = value;
          }
        }
 
        public const int OffsetFieldNumber = 2;
        private long offset_;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Offset {
          get { return offset_; }
          set {
            offset_ = value;
          }
        }
 
        public const int PositiveCoeffFieldNumber = 3;
        private long positiveCoeff_;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long PositiveCoeff {
          get { return positiveCoeff_; }
          set {
            positiveCoeff_ = value;
          }
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as AffineTransformation);
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(AffineTransformation other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (Var != other.Var) return false;
          if (Offset != other.Offset) return false;
          if (PositiveCoeff != other.PositiveCoeff) return false;
          return Equals(_unknownFields, other._unknownFields);
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (Var != 0) hash ^= Var.GetHashCode();
          if (Offset != 0L) hash ^= Offset.GetHashCode();
          if (PositiveCoeff != 0L) hash ^= PositiveCoeff.GetHashCode();
          if (_unknownFields != null) {
            hash ^= _unknownFields.GetHashCode();
          }
          return hash;
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (Var != 0) {
            output.WriteRawTag(8);
            output.WriteInt32(Var);
          }
          if (Offset != 0L) {
            output.WriteRawTag(16);
            output.WriteInt64(Offset);
          }
          if (PositiveCoeff != 0L) {
            output.WriteRawTag(24);
            output.WriteInt64(PositiveCoeff);
          }
          if (_unknownFields != null) {
            _unknownFields.WriteTo(output);
          }
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (Var != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Var);
          }
          if (Offset != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
          }
          if (PositiveCoeff != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(PositiveCoeff);
          }
          if (_unknownFields != null) {
            size += _unknownFields.CalculateSize();
          }
          return size;
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(AffineTransformation other) {
          if (other == null) {
            return;
          }
          if (other.Var != 0) {
            Var = other.Var;
          }
          if (other.Offset != 0L) {
            Offset = other.Offset;
          }
          if (other.PositiveCoeff != 0L) {
            PositiveCoeff = other.PositiveCoeff;
          }
          _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
        }
 
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                break;
              case 8: {
                Var = input.ReadInt32();
                break;
              }
              case 16: {
                Offset = input.ReadInt64();
                break;
              }
              case 24: {
                PositiveCoeff = input.ReadInt64();
                break;
              }
            }
          }
        }
 
      }
 
    }
    #endregion
 
  }
 
  public sealed partial class PartialVariableAssignment : pb::IMessage<PartialVariableAssignment> {
    private static readonly pb::MessageParser<PartialVariableAssignment> _parser = new pb::MessageParser<PartialVariableAssignment>(() => new PartialVariableAssignment());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<PartialVariableAssignment> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[22]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public PartialVariableAssignment() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public PartialVariableAssignment(PartialVariableAssignment other) : this() {
      vars_ = other.vars_.Clone();
      values_ = other.values_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public PartialVariableAssignment Clone() {
      return new PartialVariableAssignment(this);
    }
 
    public const int VarsFieldNumber = 1;
    private static readonly pb::FieldCodec<int> _repeated_vars_codec
        = pb::FieldCodec.ForInt32(10);
    private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> Vars {
      get { return vars_; }
    }
 
    public const int ValuesFieldNumber = 2;
    private static readonly pb::FieldCodec<long> _repeated_values_codec
        = pb::FieldCodec.ForInt64(18);
    private readonly pbc::RepeatedField<long> values_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Values {
      get { return values_; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as PartialVariableAssignment);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(PartialVariableAssignment other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!vars_.Equals(other.vars_)) return false;
      if(!values_.Equals(other.values_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= vars_.GetHashCode();
      hash ^= values_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      vars_.WriteTo(output, _repeated_vars_codec);
      values_.WriteTo(output, _repeated_values_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += vars_.CalculateSize(_repeated_vars_codec);
      size += values_.CalculateSize(_repeated_values_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(PartialVariableAssignment other) {
      if (other == null) {
        return;
      }
      vars_.Add(other.vars_);
      values_.Add(other.values_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10:
          case 8: {
            vars_.AddEntriesFrom(input, _repeated_vars_codec);
            break;
          }
          case 18:
          case 16: {
            values_.AddEntriesFrom(input, _repeated_values_codec);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class CpModelProto : pb::IMessage<CpModelProto> {
    private static readonly pb::MessageParser<CpModelProto> _parser = new pb::MessageParser<CpModelProto>(() => new CpModelProto());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CpModelProto> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[23]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpModelProto() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpModelProto(CpModelProto other) : this() {
      name_ = other.name_;
      variables_ = other.variables_.Clone();
      constraints_ = other.constraints_.Clone();
      objective_ = other.objective_ != null ? other.objective_.Clone() : null;
      searchStrategy_ = other.searchStrategy_.Clone();
      solutionHint_ = other.solutionHint_ != null ? other.solutionHint_.Clone() : null;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpModelProto Clone() {
      return new CpModelProto(this);
    }
 
    public const int NameFieldNumber = 1;
    private string name_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }
 
    public const int VariablesFieldNumber = 2;
    private static readonly pb::FieldCodec<global::Google.OrTools.Sat.IntegerVariableProto> _repeated_variables_codec
        = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.IntegerVariableProto.Parser);
    private readonly pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> variables_ = new pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> Variables {
      get { return variables_; }
    }
 
    public const int ConstraintsFieldNumber = 3;
    private static readonly pb::FieldCodec<global::Google.OrTools.Sat.ConstraintProto> _repeated_constraints_codec
        = pb::FieldCodec.ForMessage(26, global::Google.OrTools.Sat.ConstraintProto.Parser);
    private readonly pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto> constraints_ = new pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto> Constraints {
      get { return constraints_; }
    }
 
    public const int ObjectiveFieldNumber = 4;
    private global::Google.OrTools.Sat.CpObjectiveProto objective_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.CpObjectiveProto Objective {
      get { return objective_; }
      set {
        objective_ = value;
      }
    }
 
    public const int SearchStrategyFieldNumber = 5;
    private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto> _repeated_searchStrategy_codec
        = pb::FieldCodec.ForMessage(42, global::Google.OrTools.Sat.DecisionStrategyProto.Parser);
    private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto> searchStrategy_ = new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto> SearchStrategy {
      get { return searchStrategy_; }
    }
 
    public const int SolutionHintFieldNumber = 6;
    private global::Google.OrTools.Sat.PartialVariableAssignment solutionHint_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.PartialVariableAssignment SolutionHint {
      get { return solutionHint_; }
      set {
        solutionHint_ = value;
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CpModelProto);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CpModelProto other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Name != other.Name) return false;
      if(!variables_.Equals(other.variables_)) return false;
      if(!constraints_.Equals(other.constraints_)) return false;
      if (!object.Equals(Objective, other.Objective)) return false;
      if(!searchStrategy_.Equals(other.searchStrategy_)) return false;
      if (!object.Equals(SolutionHint, other.SolutionHint)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Name.Length != 0) hash ^= Name.GetHashCode();
      hash ^= variables_.GetHashCode();
      hash ^= constraints_.GetHashCode();
      if (objective_ != null) hash ^= Objective.GetHashCode();
      hash ^= searchStrategy_.GetHashCode();
      if (solutionHint_ != null) hash ^= SolutionHint.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      variables_.WriteTo(output, _repeated_variables_codec);
      constraints_.WriteTo(output, _repeated_constraints_codec);
      if (objective_ != null) {
        output.WriteRawTag(34);
        output.WriteMessage(Objective);
      }
      searchStrategy_.WriteTo(output, _repeated_searchStrategy_codec);
      if (solutionHint_ != null) {
        output.WriteRawTag(50);
        output.WriteMessage(SolutionHint);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      size += variables_.CalculateSize(_repeated_variables_codec);
      size += constraints_.CalculateSize(_repeated_constraints_codec);
      if (objective_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Objective);
      }
      size += searchStrategy_.CalculateSize(_repeated_searchStrategy_codec);
      if (solutionHint_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(SolutionHint);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CpModelProto other) {
      if (other == null) {
        return;
      }
      if (other.Name.Length != 0) {
        Name = other.Name;
      }
      variables_.Add(other.variables_);
      constraints_.Add(other.constraints_);
      if (other.objective_ != null) {
        if (objective_ == null) {
          Objective = new global::Google.OrTools.Sat.CpObjectiveProto();
        }
        Objective.MergeFrom(other.Objective);
      }
      searchStrategy_.Add(other.searchStrategy_);
      if (other.solutionHint_ != null) {
        if (solutionHint_ == null) {
          SolutionHint = new global::Google.OrTools.Sat.PartialVariableAssignment();
        }
        SolutionHint.MergeFrom(other.SolutionHint);
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            variables_.AddEntriesFrom(input, _repeated_variables_codec);
            break;
          }
          case 26: {
            constraints_.AddEntriesFrom(input, _repeated_constraints_codec);
            break;
          }
          case 34: {
            if (objective_ == null) {
              Objective = new global::Google.OrTools.Sat.CpObjectiveProto();
            }
            input.ReadMessage(Objective);
            break;
          }
          case 42: {
            searchStrategy_.AddEntriesFrom(input, _repeated_searchStrategy_codec);
            break;
          }
          case 50: {
            if (solutionHint_ == null) {
              SolutionHint = new global::Google.OrTools.Sat.PartialVariableAssignment();
            }
            input.ReadMessage(SolutionHint);
            break;
          }
        }
      }
    }
 
  }
 
  public sealed partial class CpSolverResponse : pb::IMessage<CpSolverResponse> {
    private static readonly pb::MessageParser<CpSolverResponse> _parser = new pb::MessageParser<CpSolverResponse>(() => new CpSolverResponse());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CpSolverResponse> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[24]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpSolverResponse() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpSolverResponse(CpSolverResponse other) : this() {
      status_ = other.status_;
      solution_ = other.solution_.Clone();
      objectiveValue_ = other.objectiveValue_;
      bestObjectiveBound_ = other.bestObjectiveBound_;
      solutionLowerBounds_ = other.solutionLowerBounds_.Clone();
      solutionUpperBounds_ = other.solutionUpperBounds_.Clone();
      tightenedVariables_ = other.tightenedVariables_.Clone();
      allSolutionsWereFound_ = other.allSolutionsWereFound_;
      numBooleans_ = other.numBooleans_;
      numConflicts_ = other.numConflicts_;
      numBranches_ = other.numBranches_;
      numBinaryPropagations_ = other.numBinaryPropagations_;
      numIntegerPropagations_ = other.numIntegerPropagations_;
      wallTime_ = other.wallTime_;
      userTime_ = other.userTime_;
      deterministicTime_ = other.deterministicTime_;
      primalIntegral_ = other.primalIntegral_;
      solutionInfo_ = other.solutionInfo_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CpSolverResponse Clone() {
      return new CpSolverResponse(this);
    }
 
    public const int StatusFieldNumber = 1;
    private global::Google.OrTools.Sat.CpSolverStatus status_ = global::Google.OrTools.Sat.CpSolverStatus.Unknown;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Google.OrTools.Sat.CpSolverStatus Status {
      get { return status_; }
      set {
        status_ = value;
      }
    }
 
    public const int SolutionFieldNumber = 2;
    private static readonly pb::FieldCodec<long> _repeated_solution_codec
        = pb::FieldCodec.ForInt64(18);
    private readonly pbc::RepeatedField<long> solution_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> Solution {
      get { return solution_; }
    }
 
    public const int ObjectiveValueFieldNumber = 3;
    private double objectiveValue_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double ObjectiveValue {
      get { return objectiveValue_; }
      set {
        objectiveValue_ = value;
      }
    }
 
    public const int BestObjectiveBoundFieldNumber = 4;
    private double bestObjectiveBound_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double BestObjectiveBound {
      get { return bestObjectiveBound_; }
      set {
        bestObjectiveBound_ = value;
      }
    }
 
    public const int SolutionLowerBoundsFieldNumber = 18;
    private static readonly pb::FieldCodec<long> _repeated_solutionLowerBounds_codec
        = pb::FieldCodec.ForInt64(146);
    private readonly pbc::RepeatedField<long> solutionLowerBounds_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> SolutionLowerBounds {
      get { return solutionLowerBounds_; }
    }
 
    public const int SolutionUpperBoundsFieldNumber = 19;
    private static readonly pb::FieldCodec<long> _repeated_solutionUpperBounds_codec
        = pb::FieldCodec.ForInt64(154);
    private readonly pbc::RepeatedField<long> solutionUpperBounds_ = new pbc::RepeatedField<long>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<long> SolutionUpperBounds {
      get { return solutionUpperBounds_; }
    }
 
    public const int TightenedVariablesFieldNumber = 21;
    private static readonly pb::FieldCodec<global::Google.OrTools.Sat.IntegerVariableProto> _repeated_tightenedVariables_codec
        = pb::FieldCodec.ForMessage(170, global::Google.OrTools.Sat.IntegerVariableProto.Parser);
    private readonly pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> tightenedVariables_ = new pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> TightenedVariables {
      get { return tightenedVariables_; }
    }
 
    public const int AllSolutionsWereFoundFieldNumber = 5;
    private bool allSolutionsWereFound_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool AllSolutionsWereFound {
      get { return allSolutionsWereFound_; }
      set {
        allSolutionsWereFound_ = value;
      }
    }
 
    public const int NumBooleansFieldNumber = 10;
    private long numBooleans_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long NumBooleans {
      get { return numBooleans_; }
      set {
        numBooleans_ = value;
      }
    }
 
    public const int NumConflictsFieldNumber = 11;
    private long numConflicts_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long NumConflicts {
      get { return numConflicts_; }
      set {
        numConflicts_ = value;
      }
    }
 
    public const int NumBranchesFieldNumber = 12;
    private long numBranches_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long NumBranches {
      get { return numBranches_; }
      set {
        numBranches_ = value;
      }
    }
 
    public const int NumBinaryPropagationsFieldNumber = 13;
    private long numBinaryPropagations_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long NumBinaryPropagations {
      get { return numBinaryPropagations_; }
      set {
        numBinaryPropagations_ = value;
      }
    }
 
    public const int NumIntegerPropagationsFieldNumber = 14;
    private long numIntegerPropagations_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long NumIntegerPropagations {
      get { return numIntegerPropagations_; }
      set {
        numIntegerPropagations_ = value;
      }
    }
 
    public const int WallTimeFieldNumber = 15;
    private double wallTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double WallTime {
      get { return wallTime_; }
      set {
        wallTime_ = value;
      }
    }
 
    public const int UserTimeFieldNumber = 16;
    private double userTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double UserTime {
      get { return userTime_; }
      set {
        userTime_ = value;
      }
    }
 
    public const int DeterministicTimeFieldNumber = 17;
    private double deterministicTime_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DeterministicTime {
      get { return deterministicTime_; }
      set {
        deterministicTime_ = value;
      }
    }
 
    public const int PrimalIntegralFieldNumber = 22;
    private double primalIntegral_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double PrimalIntegral {
      get { return primalIntegral_; }
      set {
        primalIntegral_ = value;
      }
    }
 
    public const int SolutionInfoFieldNumber = 20;
    private string solutionInfo_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string SolutionInfo {
      get { return solutionInfo_; }
      set {
        solutionInfo_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CpSolverResponse);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CpSolverResponse other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Status != other.Status) return false;
      if(!solution_.Equals(other.solution_)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveValue, other.ObjectiveValue)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(BestObjectiveBound, other.BestObjectiveBound)) return false;
      if(!solutionLowerBounds_.Equals(other.solutionLowerBounds_)) return false;
      if(!solutionUpperBounds_.Equals(other.solutionUpperBounds_)) return false;
      if(!tightenedVariables_.Equals(other.tightenedVariables_)) return false;
      if (AllSolutionsWereFound != other.AllSolutionsWereFound) return false;
      if (NumBooleans != other.NumBooleans) return false;
      if (NumConflicts != other.NumConflicts) return false;
      if (NumBranches != other.NumBranches) return false;
      if (NumBinaryPropagations != other.NumBinaryPropagations) return false;
      if (NumIntegerPropagations != other.NumIntegerPropagations) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(WallTime, other.WallTime)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(UserTime, other.UserTime)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DeterministicTime, other.DeterministicTime)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PrimalIntegral, other.PrimalIntegral)) return false;
      if (SolutionInfo != other.SolutionInfo) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) hash ^= Status.GetHashCode();
      hash ^= solution_.GetHashCode();
      if (ObjectiveValue != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveValue);
      if (BestObjectiveBound != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BestObjectiveBound);
      hash ^= solutionLowerBounds_.GetHashCode();
      hash ^= solutionUpperBounds_.GetHashCode();
      hash ^= tightenedVariables_.GetHashCode();
      if (AllSolutionsWereFound != false) hash ^= AllSolutionsWereFound.GetHashCode();
      if (NumBooleans != 0L) hash ^= NumBooleans.GetHashCode();
      if (NumConflicts != 0L) hash ^= NumConflicts.GetHashCode();
      if (NumBranches != 0L) hash ^= NumBranches.GetHashCode();
      if (NumBinaryPropagations != 0L) hash ^= NumBinaryPropagations.GetHashCode();
      if (NumIntegerPropagations != 0L) hash ^= NumIntegerPropagations.GetHashCode();
      if (WallTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(WallTime);
      if (UserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(UserTime);
      if (DeterministicTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DeterministicTime);
      if (PrimalIntegral != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalIntegral);
      if (SolutionInfo.Length != 0) hash ^= SolutionInfo.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
        output.WriteRawTag(8);
        output.WriteEnum((int) Status);
      }
      solution_.WriteTo(output, _repeated_solution_codec);
      if (ObjectiveValue != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(ObjectiveValue);
      }
      if (BestObjectiveBound != 0D) {
        output.WriteRawTag(33);
        output.WriteDouble(BestObjectiveBound);
      }
      if (AllSolutionsWereFound != false) {
        output.WriteRawTag(40);
        output.WriteBool(AllSolutionsWereFound);
      }
      if (NumBooleans != 0L) {
        output.WriteRawTag(80);
        output.WriteInt64(NumBooleans);
      }
      if (NumConflicts != 0L) {
        output.WriteRawTag(88);
        output.WriteInt64(NumConflicts);
      }
      if (NumBranches != 0L) {
        output.WriteRawTag(96);
        output.WriteInt64(NumBranches);
      }
      if (NumBinaryPropagations != 0L) {
        output.WriteRawTag(104);
        output.WriteInt64(NumBinaryPropagations);
      }
      if (NumIntegerPropagations != 0L) {
        output.WriteRawTag(112);
        output.WriteInt64(NumIntegerPropagations);
      }
      if (WallTime != 0D) {
        output.WriteRawTag(121);
        output.WriteDouble(WallTime);
      }
      if (UserTime != 0D) {
        output.WriteRawTag(129, 1);
        output.WriteDouble(UserTime);
      }
      if (DeterministicTime != 0D) {
        output.WriteRawTag(137, 1);
        output.WriteDouble(DeterministicTime);
      }
      solutionLowerBounds_.WriteTo(output, _repeated_solutionLowerBounds_codec);
      solutionUpperBounds_.WriteTo(output, _repeated_solutionUpperBounds_codec);
      if (SolutionInfo.Length != 0) {
        output.WriteRawTag(162, 1);
        output.WriteString(SolutionInfo);
      }
      tightenedVariables_.WriteTo(output, _repeated_tightenedVariables_codec);
      if (PrimalIntegral != 0D) {
        output.WriteRawTag(177, 1);
        output.WriteDouble(PrimalIntegral);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Status);
      }
      size += solution_.CalculateSize(_repeated_solution_codec);
      if (ObjectiveValue != 0D) {
        size += 1 + 8;
      }
      if (BestObjectiveBound != 0D) {
        size += 1 + 8;
      }
      size += solutionLowerBounds_.CalculateSize(_repeated_solutionLowerBounds_codec);
      size += solutionUpperBounds_.CalculateSize(_repeated_solutionUpperBounds_codec);
      size += tightenedVariables_.CalculateSize(_repeated_tightenedVariables_codec);
      if (AllSolutionsWereFound != false) {
        size += 1 + 1;
      }
      if (NumBooleans != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBooleans);
      }
      if (NumConflicts != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumConflicts);
      }
      if (NumBranches != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBranches);
      }
      if (NumBinaryPropagations != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBinaryPropagations);
      }
      if (NumIntegerPropagations != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumIntegerPropagations);
      }
      if (WallTime != 0D) {
        size += 1 + 8;
      }
      if (UserTime != 0D) {
        size += 2 + 8;
      }
      if (DeterministicTime != 0D) {
        size += 2 + 8;
      }
      if (PrimalIntegral != 0D) {
        size += 2 + 8;
      }
      if (SolutionInfo.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(SolutionInfo);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CpSolverResponse other) {
      if (other == null) {
        return;
      }
      if (other.Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
        Status = other.Status;
      }
      solution_.Add(other.solution_);
      if (other.ObjectiveValue != 0D) {
        ObjectiveValue = other.ObjectiveValue;
      }
      if (other.BestObjectiveBound != 0D) {
        BestObjectiveBound = other.BestObjectiveBound;
      }
      solutionLowerBounds_.Add(other.solutionLowerBounds_);
      solutionUpperBounds_.Add(other.solutionUpperBounds_);
      tightenedVariables_.Add(other.tightenedVariables_);
      if (other.AllSolutionsWereFound != false) {
        AllSolutionsWereFound = other.AllSolutionsWereFound;
      }
      if (other.NumBooleans != 0L) {
        NumBooleans = other.NumBooleans;
      }
      if (other.NumConflicts != 0L) {
        NumConflicts = other.NumConflicts;
      }
      if (other.NumBranches != 0L) {
        NumBranches = other.NumBranches;
      }
      if (other.NumBinaryPropagations != 0L) {
        NumBinaryPropagations = other.NumBinaryPropagations;
      }
      if (other.NumIntegerPropagations != 0L) {
        NumIntegerPropagations = other.NumIntegerPropagations;
      }
      if (other.WallTime != 0D) {
        WallTime = other.WallTime;
      }
      if (other.UserTime != 0D) {
        UserTime = other.UserTime;
      }
      if (other.DeterministicTime != 0D) {
        DeterministicTime = other.DeterministicTime;
      }
      if (other.PrimalIntegral != 0D) {
        PrimalIntegral = other.PrimalIntegral;
      }
      if (other.SolutionInfo.Length != 0) {
        SolutionInfo = other.SolutionInfo;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Status = (global::Google.OrTools.Sat.CpSolverStatus) input.ReadEnum();
            break;
          }
          case 18:
          case 16: {
            solution_.AddEntriesFrom(input, _repeated_solution_codec);
            break;
          }
          case 25: {
            ObjectiveValue = input.ReadDouble();
            break;
          }
          case 33: {
            BestObjectiveBound = input.ReadDouble();
            break;
          }
          case 40: {
            AllSolutionsWereFound = input.ReadBool();
            break;
          }
          case 80: {
            NumBooleans = input.ReadInt64();
            break;
          }
          case 88: {
            NumConflicts = input.ReadInt64();
            break;
          }
          case 96: {
            NumBranches = input.ReadInt64();
            break;
          }
          case 104: {
            NumBinaryPropagations = input.ReadInt64();
            break;
          }
          case 112: {
            NumIntegerPropagations = input.ReadInt64();
            break;
          }
          case 121: {
            WallTime = input.ReadDouble();
            break;
          }
          case 129: {
            UserTime = input.ReadDouble();
            break;
          }
          case 137: {
            DeterministicTime = input.ReadDouble();
            break;
          }
          case 146:
          case 144: {
            solutionLowerBounds_.AddEntriesFrom(input, _repeated_solutionLowerBounds_codec);
            break;
          }
          case 154:
          case 152: {
            solutionUpperBounds_.AddEntriesFrom(input, _repeated_solutionUpperBounds_codec);
            break;
          }
          case 162: {
            SolutionInfo = input.ReadString();
            break;
          }
          case 170: {
            tightenedVariables_.AddEntriesFrom(input, _repeated_tightenedVariables_codec);
            break;
          }
          case 177: {
            PrimalIntegral = input.ReadDouble();
            break;
          }
        }
      }
    }
 
  }
 
  #endregion
 
}
 
#endregion Designer generated code