DotNet Reference

.Net Reference

CpModel.pb.cs
Go to the documentation of this file.
1 // <auto-generated>
2 // Generated by the protocol buffer compiler. DO NOT EDIT!
3 // source: ortools/sat/cp_model.proto
4 // </auto-generated>
5 #pragma warning disable 1591, 0612, 3021
6 #region Designer generated code
7 
8 using pb = global::Google.Protobuf;
9 using pbc = global::Google.Protobuf.Collections;
10 using pbr = global::Google.Protobuf.Reflection;
11 using scg = global::System.Collections.Generic;
12 namespace Google.OrTools.Sat {
13 
15  public static partial class CpModelReflection {
16 
17  #region Descriptor
19  public static pbr::FileDescriptor Descriptor {
20  get { return descriptor; }
21  }
22  private static pbr::FileDescriptor descriptor;
23 
24  static CpModelReflection() {
25  byte[] descriptorData = global::System.Convert.FromBase64String(
26  string.Concat(
27  "ChpvcnRvb2xzL3NhdC9jcF9tb2RlbC5wcm90bxIXb3BlcmF0aW9uc19yZXNl",
28  "YXJjaC5zYXQiNAoUSW50ZWdlclZhcmlhYmxlUHJvdG8SDAoEbmFtZRgBIAEo",
29  "CRIOCgZkb21haW4YAiADKAMiJQoRQm9vbEFyZ3VtZW50UHJvdG8SEAoIbGl0",
30  "ZXJhbHMYASADKAUiNAoUSW50ZWdlckFyZ3VtZW50UHJvdG8SDgoGdGFyZ2V0",
31  "GAEgASgFEgwKBHZhcnMYAiADKAUiRQoVTGluZWFyRXhwcmVzc2lvblByb3Rv",
32  "EgwKBHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygDEg4KBm9mZnNldBgDIAEo",
33  "AyKUAQoTTGluZWFyQXJndW1lbnRQcm90bxI+CgZ0YXJnZXQYASABKAsyLi5v",
34  "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5lYXJFeHByZXNzaW9uUHJvdG8S",
35  "PQoFZXhwcnMYAiADKAsyLi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5l",
36  "YXJFeHByZXNzaW9uUHJvdG8iKwobQWxsRGlmZmVyZW50Q29uc3RyYWludFBy",
37  "b3RvEgwKBHZhcnMYASADKAUiRQoVTGluZWFyQ29uc3RyYWludFByb3RvEgwK",
38  "BHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygDEg4KBmRvbWFpbhgDIAMoAyJF",
39  "ChZFbGVtZW50Q29uc3RyYWludFByb3RvEg0KBWluZGV4GAEgASgFEg4KBnRh",
40  "cmdldBgCIAEoBRIMCgR2YXJzGAMgAygFIowCChdJbnRlcnZhbENvbnN0cmFp",
41  "bnRQcm90bxINCgVzdGFydBgBIAEoBRILCgNlbmQYAiABKAUSDAoEc2l6ZRgD",
42  "IAEoBRJCCgpzdGFydF92aWV3GAQgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJj",
43  "aC5zYXQuTGluZWFyRXhwcmVzc2lvblByb3RvEkAKCGVuZF92aWV3GAUgASgL",
44  "Mi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuTGluZWFyRXhwcmVzc2lvblBy",
45  "b3RvEkEKCXNpemVfdmlldxgGIAEoCzIuLm9wZXJhdGlvbnNfcmVzZWFyY2gu",
46  "c2F0LkxpbmVhckV4cHJlc3Npb25Qcm90byItChhOb092ZXJsYXBDb25zdHJh",
47  "aW50UHJvdG8SEQoJaW50ZXJ2YWxzGAEgAygFInAKGk5vT3ZlcmxhcDJEQ29u",
48  "c3RyYWludFByb3RvEhMKC3hfaW50ZXJ2YWxzGAEgAygFEhMKC3lfaW50ZXJ2",
49  "YWxzGAIgAygFEigKIGJveGVzX3dpdGhfbnVsbF9hcmVhX2Nhbl9vdmVybGFw",
50  "GAMgASgIIlEKGUN1bXVsYXRpdmVDb25zdHJhaW50UHJvdG8SEAoIY2FwYWNp",
51  "dHkYASABKAUSEQoJaW50ZXJ2YWxzGAIgAygFEg8KB2RlbWFuZHMYAyADKAUi",
52  "cQoYUmVzZXJ2b2lyQ29uc3RyYWludFByb3RvEhEKCW1pbl9sZXZlbBgBIAEo",
53  "AxIRCgltYXhfbGV2ZWwYAiABKAMSDQoFdGltZXMYAyADKAUSDwoHZGVtYW5k",
54  "cxgEIAMoAxIPCgdhY3RpdmVzGAUgAygFIkgKFkNpcmN1aXRDb25zdHJhaW50",
55  "UHJvdG8SDQoFdGFpbHMYAyADKAUSDQoFaGVhZHMYBCADKAUSEAoIbGl0ZXJh",
56  "bHMYBSADKAUiagoVUm91dGVzQ29uc3RyYWludFByb3RvEg0KBXRhaWxzGAEg",
57  "AygFEg0KBWhlYWRzGAIgAygFEhAKCGxpdGVyYWxzGAMgAygFEg8KB2RlbWFu",
58  "ZHMYBCADKAUSEAoIY2FwYWNpdHkYBSABKAMiRQoUVGFibGVDb25zdHJhaW50",
59  "UHJvdG8SDAoEdmFycxgBIAMoBRIOCgZ2YWx1ZXMYAiADKAMSDwoHbmVnYXRl",
60  "ZBgDIAEoCCI9ChZJbnZlcnNlQ29uc3RyYWludFByb3RvEhAKCGZfZGlyZWN0",
61  "GAEgAygFEhEKCWZfaW52ZXJzZRgCIAMoBSKiAQoYQXV0b21hdG9uQ29uc3Ry",
62  "YWludFByb3RvEhYKDnN0YXJ0aW5nX3N0YXRlGAIgASgDEhQKDGZpbmFsX3N0",
63  "YXRlcxgDIAMoAxIXCg90cmFuc2l0aW9uX3RhaWwYBCADKAMSFwoPdHJhbnNp",
64  "dGlvbl9oZWFkGAUgAygDEhgKEHRyYW5zaXRpb25fbGFiZWwYBiADKAMSDAoE",
65  "dmFycxgHIAMoBSLtDQoPQ29uc3RyYWludFByb3RvEgwKBG5hbWUYASABKAkS",
66  "GwoTZW5mb3JjZW1lbnRfbGl0ZXJhbBgCIAMoBRI9Cgdib29sX29yGAMgASgL",
67  "Mioub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuQm9vbEFyZ3VtZW50UHJvdG9I",
68  "ABI+Cghib29sX2FuZBgEIAEoCzIqLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0",
69  "LkJvb2xBcmd1bWVudFByb3RvSAASQQoLYXRfbW9zdF9vbmUYGiABKAsyKi5v",
70  "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5Cb29sQXJndW1lbnRQcm90b0gAEkEK",
71  "C2V4YWN0bHlfb25lGB0gASgLMioub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQu",
72  "Qm9vbEFyZ3VtZW50UHJvdG9IABI+Cghib29sX3hvchgFIAEoCzIqLm9wZXJh",
73  "dGlvbnNfcmVzZWFyY2guc2F0LkJvb2xBcmd1bWVudFByb3RvSAASQAoHaW50",
74  "X2RpdhgHIAEoCzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVnZXJB",
75  "cmd1bWVudFByb3RvSAASQAoHaW50X21vZBgIIAEoCzItLm9wZXJhdGlvbnNf",
76  "cmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASQAoHaW50X21h",
77  "eBgJIAEoCzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1",
78  "bWVudFByb3RvSAASPwoHbGluX21heBgbIAEoCzIsLm9wZXJhdGlvbnNfcmVz",
79  "ZWFyY2guc2F0LkxpbmVhckFyZ3VtZW50UHJvdG9IABJACgdpbnRfbWluGAog",
80  "ASgLMi0ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuSW50ZWdlckFyZ3VtZW50",
81  "UHJvdG9IABI/CgdsaW5fbWluGBwgASgLMiwub3BlcmF0aW9uc19yZXNlYXJj",
82  "aC5zYXQuTGluZWFyQXJndW1lbnRQcm90b0gAEkEKCGludF9wcm9kGAsgASgL",
83  "Mi0ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuSW50ZWdlckFyZ3VtZW50UHJv",
84  "dG9IABJACgZsaW5lYXIYDCABKAsyLi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNh",
85  "dC5MaW5lYXJDb25zdHJhaW50UHJvdG9IABJICghhbGxfZGlmZhgNIAEoCzI0",
86  "Lm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkFsbERpZmZlcmVudENvbnN0cmFp",
87  "bnRQcm90b0gAEkIKB2VsZW1lbnQYDiABKAsyLy5vcGVyYXRpb25zX3Jlc2Vh",
88  "cmNoLnNhdC5FbGVtZW50Q29uc3RyYWludFByb3RvSAASQgoHY2lyY3VpdBgP",
89  "IAEoCzIvLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNpcmN1aXRDb25zdHJh",
90  "aW50UHJvdG9IABJACgZyb3V0ZXMYFyABKAsyLi5vcGVyYXRpb25zX3Jlc2Vh",
91  "cmNoLnNhdC5Sb3V0ZXNDb25zdHJhaW50UHJvdG9IABI+CgV0YWJsZRgQIAEo",
92  "CzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LlRhYmxlQ29uc3RyYWludFBy",
93  "b3RvSAASRgoJYXV0b21hdG9uGBEgASgLMjEub3BlcmF0aW9uc19yZXNlYXJj",
94  "aC5zYXQuQXV0b21hdG9uQ29uc3RyYWludFByb3RvSAASQgoHaW52ZXJzZRgS",
95  "IAEoCzIvLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludmVyc2VDb25zdHJh",
96  "aW50UHJvdG9IABJGCglyZXNlcnZvaXIYGCABKAsyMS5vcGVyYXRpb25zX3Jl",
97  "c2VhcmNoLnNhdC5SZXNlcnZvaXJDb25zdHJhaW50UHJvdG9IABJECghpbnRl",
98  "cnZhbBgTIAEoCzIwLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVydmFs",
99  "Q29uc3RyYWludFByb3RvSAASRwoKbm9fb3ZlcmxhcBgUIAEoCzIxLm9wZXJh",
100  "dGlvbnNfcmVzZWFyY2guc2F0Lk5vT3ZlcmxhcENvbnN0cmFpbnRQcm90b0gA",
101  "EkwKDW5vX292ZXJsYXBfMmQYFSABKAsyMy5vcGVyYXRpb25zX3Jlc2VhcmNo",
102  "LnNhdC5Ob092ZXJsYXAyRENvbnN0cmFpbnRQcm90b0gAEkgKCmN1bXVsYXRp",
103  "dmUYFiABKAsyMi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5DdW11bGF0aXZl",
104  "Q29uc3RyYWludFByb3RvSABCDAoKY29uc3RyYWludCJoChBDcE9iamVjdGl2",
105  "ZVByb3RvEgwKBHZhcnMYASADKAUSDgoGY29lZmZzGAQgAygDEg4KBm9mZnNl",
106  "dBgCIAEoARIWCg5zY2FsaW5nX2ZhY3RvchgDIAEoARIOCgZkb21haW4YBSAD",
107  "KAMi1wUKFURlY2lzaW9uU3RyYXRlZ3lQcm90bxIRCgl2YXJpYWJsZXMYASAD",
108  "KAUSbQobdmFyaWFibGVfc2VsZWN0aW9uX3N0cmF0ZWd5GAIgASgOMkgub3Bl",
109  "cmF0aW9uc19yZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3RvLlZh",
110  "cmlhYmxlU2VsZWN0aW9uU3RyYXRlZ3kSaQoZZG9tYWluX3JlZHVjdGlvbl9z",
111  "dHJhdGVneRgDIAEoDjJGLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkRlY2lz",
112  "aW9uU3RyYXRlZ3lQcm90by5Eb21haW5SZWR1Y3Rpb25TdHJhdGVneRJcCg90",
113  "cmFuc2Zvcm1hdGlvbnMYBCADKAsyQy5vcGVyYXRpb25zX3Jlc2VhcmNoLnNh",
114  "dC5EZWNpc2lvblN0cmF0ZWd5UHJvdG8uQWZmaW5lVHJhbnNmb3JtYXRpb24a",
115  "TQoUQWZmaW5lVHJhbnNmb3JtYXRpb24SDQoFaW5kZXgYASABKAUSDgoGb2Zm",
116  "c2V0GAIgASgDEhYKDnBvc2l0aXZlX2NvZWZmGAMgASgDIpQBChlWYXJpYWJs",
117  "ZVNlbGVjdGlvblN0cmF0ZWd5EhAKDENIT09TRV9GSVJTVBAAEhUKEUNIT09T",
118  "RV9MT1dFU1RfTUlOEAESFgoSQ0hPT1NFX0hJR0hFU1RfTUFYEAISGgoWQ0hP",
119  "T1NFX01JTl9ET01BSU5fU0laRRADEhoKFkNIT09TRV9NQVhfRE9NQUlOX1NJ",
120  "WkUQBCKMAQoXRG9tYWluUmVkdWN0aW9uU3RyYXRlZ3kSFAoQU0VMRUNUX01J",
121  "Tl9WQUxVRRAAEhQKEFNFTEVDVF9NQVhfVkFMVUUQARIVChFTRUxFQ1RfTE9X",
122  "RVJfSEFMRhACEhUKEVNFTEVDVF9VUFBFUl9IQUxGEAMSFwoTU0VMRUNUX01F",
123  "RElBTl9WQUxVRRAEIjkKGVBhcnRpYWxWYXJpYWJsZUFzc2lnbm1lbnQSDAoE",
124  "dmFycxgBIAMoBRIOCgZ2YWx1ZXMYAiADKAMiPgoWU3BhcnNlUGVybXV0YXRp",
125  "b25Qcm90bxIPCgdzdXBwb3J0GAEgAygFEhMKC2N5Y2xlX3NpemVzGAIgAygF",
126  "IkcKEERlbnNlTWF0cml4UHJvdG8SEAoIbnVtX3Jvd3MYASABKAUSEAoIbnVt",
127  "X2NvbHMYAiABKAUSDwoHZW50cmllcxgDIAMoBSKUAQoNU3ltbWV0cnlQcm90",
128  "bxJFCgxwZXJtdXRhdGlvbnMYASADKAsyLy5vcGVyYXRpb25zX3Jlc2VhcmNo",
129  "LnNhdC5TcGFyc2VQZXJtdXRhdGlvblByb3RvEjwKCW9yYml0b3BlcxgCIAMo",
130  "CzIpLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkRlbnNlTWF0cml4UHJvdG8i",
131  "vgMKDENwTW9kZWxQcm90bxIMCgRuYW1lGAEgASgJEkAKCXZhcmlhYmxlcxgC",
132  "IAMoCzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVnZXJWYXJpYWJs",
133  "ZVByb3RvEj0KC2NvbnN0cmFpbnRzGAMgAygLMigub3BlcmF0aW9uc19yZXNl",
134  "YXJjaC5zYXQuQ29uc3RyYWludFByb3RvEjwKCW9iamVjdGl2ZRgEIAEoCzIp",
135  "Lm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNwT2JqZWN0aXZlUHJvdG8SRwoP",
136  "c2VhcmNoX3N0cmF0ZWd5GAUgAygLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5z",
137  "YXQuRGVjaXNpb25TdHJhdGVneVByb3RvEkkKDXNvbHV0aW9uX2hpbnQYBiAB",
138  "KAsyMi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5QYXJ0aWFsVmFyaWFibGVB",
139  "c3NpZ25tZW50EhMKC2Fzc3VtcHRpb25zGAcgAygFEjgKCHN5bW1ldHJ5GAgg",
140  "ASgLMiYub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuU3ltbWV0cnlQcm90byKu",
141  "BQoQQ3BTb2x2ZXJSZXNwb25zZRI3CgZzdGF0dXMYASABKA4yJy5vcGVyYXRp",
142  "b25zX3Jlc2VhcmNoLnNhdC5DcFNvbHZlclN0YXR1cxIQCghzb2x1dGlvbhgC",
143  "IAMoAxIXCg9vYmplY3RpdmVfdmFsdWUYAyABKAESHAoUYmVzdF9vYmplY3Rp",
144  "dmVfYm91bmQYBCABKAESHQoVc29sdXRpb25fbG93ZXJfYm91bmRzGBIgAygD",
145  "Eh0KFXNvbHV0aW9uX3VwcGVyX2JvdW5kcxgTIAMoAxJKChN0aWdodGVuZWRf",
146  "dmFyaWFibGVzGBUgAygLMi0ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuSW50",
147  "ZWdlclZhcmlhYmxlUHJvdG8SMAooc3VmZmljaWVudF9hc3N1bXB0aW9uc19m",
148  "b3JfaW5mZWFzaWJpbGl0eRgXIAMoBRIgChhhbGxfc29sdXRpb25zX3dlcmVf",
149  "Zm91bmQYBSABKAgSFAoMbnVtX2Jvb2xlYW5zGAogASgDEhUKDW51bV9jb25m",
150  "bGljdHMYCyABKAMSFAoMbnVtX2JyYW5jaGVzGAwgASgDEh8KF251bV9iaW5h",
151  "cnlfcHJvcGFnYXRpb25zGA0gASgDEiAKGG51bV9pbnRlZ2VyX3Byb3BhZ2F0",
152  "aW9ucxgOIAEoAxIUCgxudW1fcmVzdGFydHMYGCABKAMSGQoRbnVtX2xwX2l0",
153  "ZXJhdGlvbnMYGSABKAMSEQoJd2FsbF90aW1lGA8gASgBEhEKCXVzZXJfdGlt",
154  "ZRgQIAEoARIaChJkZXRlcm1pbmlzdGljX3RpbWUYESABKAESFwoPcHJpbWFs",
155  "X2ludGVncmFsGBYgASgBEhUKDXNvbHV0aW9uX2luZm8YFCABKAkSEQoJc29s",
156  "dmVfbG9nGBogASgJKlsKDkNwU29sdmVyU3RhdHVzEgsKB1VOS05PV04QABIR",
157  "Cg1NT0RFTF9JTlZBTElEEAESDAoIRkVBU0lCTEUQAhIOCgpJTkZFQVNJQkxF",
158  "EAMSCwoHT1BUSU1BTBAEQkAKFmNvbS5nb29nbGUub3J0b29scy5zYXRCD0Nw",
159  "TW9kZWxQcm90b2J1ZlABqgISR29vZ2xlLk9yVG9vbHMuU2F0YgZwcm90bzM="));
160  descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
161  new pbr::FileDescriptor[] { },
162  new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.OrTools.Sat.CpSolverStatus), }, null, new pbr::GeneratedClrTypeInfo[] {
163  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerVariableProto), global::Google.OrTools.Sat.IntegerVariableProto.Parser, new[]{ "Name", "Domain" }, null, null, null, null),
164  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.BoolArgumentProto), global::Google.OrTools.Sat.BoolArgumentProto.Parser, new[]{ "Literals" }, null, null, null, null),
165  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerArgumentProto), global::Google.OrTools.Sat.IntegerArgumentProto.Parser, new[]{ "Target", "Vars" }, null, null, null, null),
166  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearExpressionProto), global::Google.OrTools.Sat.LinearExpressionProto.Parser, new[]{ "Vars", "Coeffs", "Offset" }, null, null, null, null),
167  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearArgumentProto), global::Google.OrTools.Sat.LinearArgumentProto.Parser, new[]{ "Target", "Exprs" }, null, null, null, null),
168  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AllDifferentConstraintProto), global::Google.OrTools.Sat.AllDifferentConstraintProto.Parser, new[]{ "Vars" }, null, null, null, null),
169  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearConstraintProto), global::Google.OrTools.Sat.LinearConstraintProto.Parser, new[]{ "Vars", "Coeffs", "Domain" }, null, null, null, null),
170  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ElementConstraintProto), global::Google.OrTools.Sat.ElementConstraintProto.Parser, new[]{ "Index", "Target", "Vars" }, null, null, null, null),
171  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntervalConstraintProto), global::Google.OrTools.Sat.IntervalConstraintProto.Parser, new[]{ "Start", "End", "Size", "StartView", "EndView", "SizeView" }, null, null, null, null),
172  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlapConstraintProto), global::Google.OrTools.Sat.NoOverlapConstraintProto.Parser, new[]{ "Intervals" }, null, null, null, null),
173  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlap2DConstraintProto), global::Google.OrTools.Sat.NoOverlap2DConstraintProto.Parser, new[]{ "XIntervals", "YIntervals", "BoxesWithNullAreaCanOverlap" }, null, null, null, null),
174  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CumulativeConstraintProto), global::Google.OrTools.Sat.CumulativeConstraintProto.Parser, new[]{ "Capacity", "Intervals", "Demands" }, null, null, null, null),
175  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),
176  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitConstraintProto), global::Google.OrTools.Sat.CircuitConstraintProto.Parser, new[]{ "Tails", "Heads", "Literals" }, null, null, null, null),
177  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),
178  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.TableConstraintProto), global::Google.OrTools.Sat.TableConstraintProto.Parser, new[]{ "Vars", "Values", "Negated" }, null, null, null, null),
179  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.InverseConstraintProto), global::Google.OrTools.Sat.InverseConstraintProto.Parser, new[]{ "FDirect", "FInverse" }, null, null, null, null),
180  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),
181  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ConstraintProto), global::Google.OrTools.Sat.ConstraintProto.Parser, new[]{ "Name", "EnforcementLiteral", "BoolOr", "BoolAnd", "AtMostOne", "ExactlyOne", "BoolXor", "IntDiv", "IntMod", "IntMax", "LinMax", "IntMin", "LinMin", "IntProd", "Linear", "AllDiff", "Element", "Circuit", "Routes", "Table", "Automaton", "Inverse", "Reservoir", "Interval", "NoOverlap", "NoOverlap2D", "Cumulative" }, new[]{ "Constraint" }, null, null, null),
182  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),
183  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[]{ "Index", "Offset", "PositiveCoeff" }, null, null, null, null)}),
184  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.PartialVariableAssignment), global::Google.OrTools.Sat.PartialVariableAssignment.Parser, new[]{ "Vars", "Values" }, null, null, null, null),
185  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.SparsePermutationProto), global::Google.OrTools.Sat.SparsePermutationProto.Parser, new[]{ "Support", "CycleSizes" }, null, null, null, null),
186  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DenseMatrixProto), global::Google.OrTools.Sat.DenseMatrixProto.Parser, new[]{ "NumRows", "NumCols", "Entries" }, null, null, null, null),
187  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.SymmetryProto), global::Google.OrTools.Sat.SymmetryProto.Parser, new[]{ "Permutations", "Orbitopes" }, null, null, null, null),
188  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpModelProto), global::Google.OrTools.Sat.CpModelProto.Parser, new[]{ "Name", "Variables", "Constraints", "Objective", "SearchStrategy", "SolutionHint", "Assumptions", "Symmetry" }, null, null, null, null),
189  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpSolverResponse), global::Google.OrTools.Sat.CpSolverResponse.Parser, new[]{ "Status", "Solution", "ObjectiveValue", "BestObjectiveBound", "SolutionLowerBounds", "SolutionUpperBounds", "TightenedVariables", "SufficientAssumptionsForInfeasibility", "AllSolutionsWereFound", "NumBooleans", "NumConflicts", "NumBranches", "NumBinaryPropagations", "NumIntegerPropagations", "NumRestarts", "NumLpIterations", "WallTime", "UserTime", "DeterministicTime", "PrimalIntegral", "SolutionInfo", "SolveLog" }, null, null, null, null)
190  }));
191  }
192  #endregion
193 
194  }
195  #region Enums
199  public enum CpSolverStatus {
204  [pbr::OriginalName("UNKNOWN")] Unknown = 0,
209  [pbr::OriginalName("MODEL_INVALID")] ModelInvalid = 1,
215  [pbr::OriginalName("FEASIBLE")] Feasible = 2,
219  [pbr::OriginalName("INFEASIBLE")] Infeasible = 3,
230  [pbr::OriginalName("OPTIMAL")] Optimal = 4,
231  }
232 
233  #endregion
234 
235  #region Messages
257  public sealed partial class IntegerVariableProto : pb::IMessage<IntegerVariableProto>
258  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
259  , pb::IBufferMessage
260  #endif
261  {
262  private static readonly pb::MessageParser<IntegerVariableProto> _parser = new pb::MessageParser<IntegerVariableProto>(() => new IntegerVariableProto());
263  private pb::UnknownFieldSet _unknownFields;
264  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
265  public static pb::MessageParser<IntegerVariableProto> Parser { get { return _parser; } }
266 
267  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
268  public static pbr::MessageDescriptor Descriptor {
269  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[0]; }
270  }
271 
272  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
273  pbr::MessageDescriptor pb::IMessage.Descriptor {
274  get { return Descriptor; }
275  }
276 
277  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
279  OnConstruction();
280  }
281 
282  partial void OnConstruction();
283 
284  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
286  name_ = other.name_;
287  domain_ = other.domain_.Clone();
288  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
289  }
290 
291  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
293  return new IntegerVariableProto(this);
294  }
295 
297  public const int NameFieldNumber = 1;
298  private string name_ = "";
302  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
303  public string Name {
304  get { return name_; }
305  set {
306  name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
307  }
308  }
309 
311  public const int DomainFieldNumber = 2;
312  private static readonly pb::FieldCodec<long> _repeated_domain_codec
313  = pb::FieldCodec.ForInt64(18);
314  private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
334  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
335  public pbc::RepeatedField<long> Domain {
336  get { return domain_; }
337  }
338 
339  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
340  public override bool Equals(object other) {
341  return Equals(other as IntegerVariableProto);
342  }
343 
344  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
345  public bool Equals(IntegerVariableProto other) {
346  if (ReferenceEquals(other, null)) {
347  return false;
348  }
349  if (ReferenceEquals(other, this)) {
350  return true;
351  }
352  if (Name != other.Name) return false;
353  if(!domain_.Equals(other.domain_)) return false;
354  return Equals(_unknownFields, other._unknownFields);
355  }
356 
357  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
358  public override int GetHashCode() {
359  int hash = 1;
360  if (Name.Length != 0) hash ^= Name.GetHashCode();
361  hash ^= domain_.GetHashCode();
362  if (_unknownFields != null) {
363  hash ^= _unknownFields.GetHashCode();
364  }
365  return hash;
366  }
367 
368  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
369  public override string ToString() {
370  return pb::JsonFormatter.ToDiagnosticString(this);
371  }
372 
373  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
374  public void WriteTo(pb::CodedOutputStream output) {
375  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
376  output.WriteRawMessage(this);
377  #else
378  if (Name.Length != 0) {
379  output.WriteRawTag(10);
380  output.WriteString(Name);
381  }
382  domain_.WriteTo(output, _repeated_domain_codec);
383  if (_unknownFields != null) {
384  _unknownFields.WriteTo(output);
385  }
386  #endif
387  }
388 
389  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
390  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
391  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
392  if (Name.Length != 0) {
393  output.WriteRawTag(10);
394  output.WriteString(Name);
395  }
396  domain_.WriteTo(ref output, _repeated_domain_codec);
397  if (_unknownFields != null) {
398  _unknownFields.WriteTo(ref output);
399  }
400  }
401  #endif
402 
403  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
404  public int CalculateSize() {
405  int size = 0;
406  if (Name.Length != 0) {
407  size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
408  }
409  size += domain_.CalculateSize(_repeated_domain_codec);
410  if (_unknownFields != null) {
411  size += _unknownFields.CalculateSize();
412  }
413  return size;
414  }
415 
416  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
417  public void MergeFrom(IntegerVariableProto other) {
418  if (other == null) {
419  return;
420  }
421  if (other.Name.Length != 0) {
422  Name = other.Name;
423  }
424  domain_.Add(other.domain_);
425  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
426  }
427 
428  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
429  public void MergeFrom(pb::CodedInputStream input) {
430  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
431  input.ReadRawMessage(this);
432  #else
433  uint tag;
434  while ((tag = input.ReadTag()) != 0) {
435  switch(tag) {
436  default:
437  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
438  break;
439  case 10: {
440  Name = input.ReadString();
441  break;
442  }
443  case 18:
444  case 16: {
445  domain_.AddEntriesFrom(input, _repeated_domain_codec);
446  break;
447  }
448  }
449  }
450  #endif
451  }
452 
453  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
454  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
455  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
456  uint tag;
457  while ((tag = input.ReadTag()) != 0) {
458  switch(tag) {
459  default:
460  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
461  break;
462  case 10: {
463  Name = input.ReadString();
464  break;
465  }
466  case 18:
467  case 16: {
468  domain_.AddEntriesFrom(ref input, _repeated_domain_codec);
469  break;
470  }
471  }
472  }
473  }
474  #endif
475 
476  }
477 
481  public sealed partial class BoolArgumentProto : pb::IMessage<BoolArgumentProto>
482  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
483  , pb::IBufferMessage
484  #endif
485  {
486  private static readonly pb::MessageParser<BoolArgumentProto> _parser = new pb::MessageParser<BoolArgumentProto>(() => new BoolArgumentProto());
487  private pb::UnknownFieldSet _unknownFields;
488  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
489  public static pb::MessageParser<BoolArgumentProto> Parser { get { return _parser; } }
490 
491  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
492  public static pbr::MessageDescriptor Descriptor {
493  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[1]; }
494  }
495 
496  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
497  pbr::MessageDescriptor pb::IMessage.Descriptor {
498  get { return Descriptor; }
499  }
500 
501  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
502  public BoolArgumentProto() {
503  OnConstruction();
504  }
505 
506  partial void OnConstruction();
507 
508  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
509  public BoolArgumentProto(BoolArgumentProto other) : this() {
510  literals_ = other.literals_.Clone();
511  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
512  }
513 
514  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
516  return new BoolArgumentProto(this);
517  }
518 
520  public const int LiteralsFieldNumber = 1;
521  private static readonly pb::FieldCodec<int> _repeated_literals_codec
522  = pb::FieldCodec.ForInt32(10);
523  private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
524  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
525  public pbc::RepeatedField<int> Literals {
526  get { return literals_; }
527  }
528 
529  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
530  public override bool Equals(object other) {
531  return Equals(other as BoolArgumentProto);
532  }
533 
534  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
535  public bool Equals(BoolArgumentProto other) {
536  if (ReferenceEquals(other, null)) {
537  return false;
538  }
539  if (ReferenceEquals(other, this)) {
540  return true;
541  }
542  if(!literals_.Equals(other.literals_)) return false;
543  return Equals(_unknownFields, other._unknownFields);
544  }
545 
546  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
547  public override int GetHashCode() {
548  int hash = 1;
549  hash ^= literals_.GetHashCode();
550  if (_unknownFields != null) {
551  hash ^= _unknownFields.GetHashCode();
552  }
553  return hash;
554  }
555 
556  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
557  public override string ToString() {
558  return pb::JsonFormatter.ToDiagnosticString(this);
559  }
560 
561  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
562  public void WriteTo(pb::CodedOutputStream output) {
563  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
564  output.WriteRawMessage(this);
565  #else
566  literals_.WriteTo(output, _repeated_literals_codec);
567  if (_unknownFields != null) {
568  _unknownFields.WriteTo(output);
569  }
570  #endif
571  }
572 
573  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
574  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
575  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
576  literals_.WriteTo(ref output, _repeated_literals_codec);
577  if (_unknownFields != null) {
578  _unknownFields.WriteTo(ref output);
579  }
580  }
581  #endif
582 
583  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
584  public int CalculateSize() {
585  int size = 0;
586  size += literals_.CalculateSize(_repeated_literals_codec);
587  if (_unknownFields != null) {
588  size += _unknownFields.CalculateSize();
589  }
590  return size;
591  }
592 
593  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
594  public void MergeFrom(BoolArgumentProto other) {
595  if (other == null) {
596  return;
597  }
598  literals_.Add(other.literals_);
599  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
600  }
601 
602  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
603  public void MergeFrom(pb::CodedInputStream input) {
604  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
605  input.ReadRawMessage(this);
606  #else
607  uint tag;
608  while ((tag = input.ReadTag()) != 0) {
609  switch(tag) {
610  default:
611  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
612  break;
613  case 10:
614  case 8: {
615  literals_.AddEntriesFrom(input, _repeated_literals_codec);
616  break;
617  }
618  }
619  }
620  #endif
621  }
622 
623  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
624  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
625  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
626  uint tag;
627  while ((tag = input.ReadTag()) != 0) {
628  switch(tag) {
629  default:
630  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
631  break;
632  case 10:
633  case 8: {
634  literals_.AddEntriesFrom(ref input, _repeated_literals_codec);
635  break;
636  }
637  }
638  }
639  }
640  #endif
641 
642  }
643 
647  public sealed partial class IntegerArgumentProto : pb::IMessage<IntegerArgumentProto>
648  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
649  , pb::IBufferMessage
650  #endif
651  {
652  private static readonly pb::MessageParser<IntegerArgumentProto> _parser = new pb::MessageParser<IntegerArgumentProto>(() => new IntegerArgumentProto());
653  private pb::UnknownFieldSet _unknownFields;
654  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
655  public static pb::MessageParser<IntegerArgumentProto> Parser { get { return _parser; } }
656 
657  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
658  public static pbr::MessageDescriptor Descriptor {
659  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[2]; }
660  }
661 
662  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
663  pbr::MessageDescriptor pb::IMessage.Descriptor {
664  get { return Descriptor; }
665  }
666 
667  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
669  OnConstruction();
670  }
671 
672  partial void OnConstruction();
673 
674  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
676  target_ = other.target_;
677  vars_ = other.vars_.Clone();
678  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
679  }
680 
681  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
683  return new IntegerArgumentProto(this);
684  }
685 
687  public const int TargetFieldNumber = 1;
688  private int target_;
689  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
690  public int Target {
691  get { return target_; }
692  set {
693  target_ = value;
694  }
695  }
696 
698  public const int VarsFieldNumber = 2;
699  private static readonly pb::FieldCodec<int> _repeated_vars_codec
700  = pb::FieldCodec.ForInt32(18);
701  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
702  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
703  public pbc::RepeatedField<int> Vars {
704  get { return vars_; }
705  }
706 
707  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
708  public override bool Equals(object other) {
709  return Equals(other as IntegerArgumentProto);
710  }
711 
712  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
713  public bool Equals(IntegerArgumentProto other) {
714  if (ReferenceEquals(other, null)) {
715  return false;
716  }
717  if (ReferenceEquals(other, this)) {
718  return true;
719  }
720  if (Target != other.Target) return false;
721  if(!vars_.Equals(other.vars_)) return false;
722  return Equals(_unknownFields, other._unknownFields);
723  }
724 
725  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
726  public override int GetHashCode() {
727  int hash = 1;
728  if (Target != 0) hash ^= Target.GetHashCode();
729  hash ^= vars_.GetHashCode();
730  if (_unknownFields != null) {
731  hash ^= _unknownFields.GetHashCode();
732  }
733  return hash;
734  }
735 
736  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
737  public override string ToString() {
738  return pb::JsonFormatter.ToDiagnosticString(this);
739  }
740 
741  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
742  public void WriteTo(pb::CodedOutputStream output) {
743  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
744  output.WriteRawMessage(this);
745  #else
746  if (Target != 0) {
747  output.WriteRawTag(8);
748  output.WriteInt32(Target);
749  }
750  vars_.WriteTo(output, _repeated_vars_codec);
751  if (_unknownFields != null) {
752  _unknownFields.WriteTo(output);
753  }
754  #endif
755  }
756 
757  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
758  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
759  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
760  if (Target != 0) {
761  output.WriteRawTag(8);
762  output.WriteInt32(Target);
763  }
764  vars_.WriteTo(ref output, _repeated_vars_codec);
765  if (_unknownFields != null) {
766  _unknownFields.WriteTo(ref output);
767  }
768  }
769  #endif
770 
771  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
772  public int CalculateSize() {
773  int size = 0;
774  if (Target != 0) {
775  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
776  }
777  size += vars_.CalculateSize(_repeated_vars_codec);
778  if (_unknownFields != null) {
779  size += _unknownFields.CalculateSize();
780  }
781  return size;
782  }
783 
784  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
785  public void MergeFrom(IntegerArgumentProto other) {
786  if (other == null) {
787  return;
788  }
789  if (other.Target != 0) {
790  Target = other.Target;
791  }
792  vars_.Add(other.vars_);
793  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
794  }
795 
796  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
797  public void MergeFrom(pb::CodedInputStream input) {
798  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
799  input.ReadRawMessage(this);
800  #else
801  uint tag;
802  while ((tag = input.ReadTag()) != 0) {
803  switch(tag) {
804  default:
805  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
806  break;
807  case 8: {
808  Target = input.ReadInt32();
809  break;
810  }
811  case 18:
812  case 16: {
813  vars_.AddEntriesFrom(input, _repeated_vars_codec);
814  break;
815  }
816  }
817  }
818  #endif
819  }
820 
821  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
822  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
823  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
824  uint tag;
825  while ((tag = input.ReadTag()) != 0) {
826  switch(tag) {
827  default:
828  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
829  break;
830  case 8: {
831  Target = input.ReadInt32();
832  break;
833  }
834  case 18:
835  case 16: {
836  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
837  break;
838  }
839  }
840  }
841  }
842  #endif
843 
844  }
845 
851  public sealed partial class LinearExpressionProto : pb::IMessage<LinearExpressionProto>
852  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
853  , pb::IBufferMessage
854  #endif
855  {
856  private static readonly pb::MessageParser<LinearExpressionProto> _parser = new pb::MessageParser<LinearExpressionProto>(() => new LinearExpressionProto());
857  private pb::UnknownFieldSet _unknownFields;
858  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
859  public static pb::MessageParser<LinearExpressionProto> Parser { get { return _parser; } }
860 
861  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
862  public static pbr::MessageDescriptor Descriptor {
863  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[3]; }
864  }
865 
866  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
867  pbr::MessageDescriptor pb::IMessage.Descriptor {
868  get { return Descriptor; }
869  }
870 
871  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
873  OnConstruction();
874  }
875 
876  partial void OnConstruction();
877 
878  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
880  vars_ = other.vars_.Clone();
881  coeffs_ = other.coeffs_.Clone();
882  offset_ = other.offset_;
883  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
884  }
885 
886  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
888  return new LinearExpressionProto(this);
889  }
890 
892  public const int VarsFieldNumber = 1;
893  private static readonly pb::FieldCodec<int> _repeated_vars_codec
894  = pb::FieldCodec.ForInt32(10);
895  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
896  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
897  public pbc::RepeatedField<int> Vars {
898  get { return vars_; }
899  }
900 
902  public const int CoeffsFieldNumber = 2;
903  private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
904  = pb::FieldCodec.ForInt64(18);
905  private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
906  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
907  public pbc::RepeatedField<long> Coeffs {
908  get { return coeffs_; }
909  }
910 
912  public const int OffsetFieldNumber = 3;
913  private long offset_;
914  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
915  public long Offset {
916  get { return offset_; }
917  set {
918  offset_ = value;
919  }
920  }
921 
922  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
923  public override bool Equals(object other) {
924  return Equals(other as LinearExpressionProto);
925  }
926 
927  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
928  public bool Equals(LinearExpressionProto other) {
929  if (ReferenceEquals(other, null)) {
930  return false;
931  }
932  if (ReferenceEquals(other, this)) {
933  return true;
934  }
935  if(!vars_.Equals(other.vars_)) return false;
936  if(!coeffs_.Equals(other.coeffs_)) return false;
937  if (Offset != other.Offset) return false;
938  return Equals(_unknownFields, other._unknownFields);
939  }
940 
941  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
942  public override int GetHashCode() {
943  int hash = 1;
944  hash ^= vars_.GetHashCode();
945  hash ^= coeffs_.GetHashCode();
946  if (Offset != 0L) hash ^= Offset.GetHashCode();
947  if (_unknownFields != null) {
948  hash ^= _unknownFields.GetHashCode();
949  }
950  return hash;
951  }
952 
953  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
954  public override string ToString() {
955  return pb::JsonFormatter.ToDiagnosticString(this);
956  }
957 
958  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
959  public void WriteTo(pb::CodedOutputStream output) {
960  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
961  output.WriteRawMessage(this);
962  #else
963  vars_.WriteTo(output, _repeated_vars_codec);
964  coeffs_.WriteTo(output, _repeated_coeffs_codec);
965  if (Offset != 0L) {
966  output.WriteRawTag(24);
967  output.WriteInt64(Offset);
968  }
969  if (_unknownFields != null) {
970  _unknownFields.WriteTo(output);
971  }
972  #endif
973  }
974 
975  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
976  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
977  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
978  vars_.WriteTo(ref output, _repeated_vars_codec);
979  coeffs_.WriteTo(ref output, _repeated_coeffs_codec);
980  if (Offset != 0L) {
981  output.WriteRawTag(24);
982  output.WriteInt64(Offset);
983  }
984  if (_unknownFields != null) {
985  _unknownFields.WriteTo(ref output);
986  }
987  }
988  #endif
989 
990  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
991  public int CalculateSize() {
992  int size = 0;
993  size += vars_.CalculateSize(_repeated_vars_codec);
994  size += coeffs_.CalculateSize(_repeated_coeffs_codec);
995  if (Offset != 0L) {
996  size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
997  }
998  if (_unknownFields != null) {
999  size += _unknownFields.CalculateSize();
1000  }
1001  return size;
1002  }
1003 
1004  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1005  public void MergeFrom(LinearExpressionProto other) {
1006  if (other == null) {
1007  return;
1008  }
1009  vars_.Add(other.vars_);
1010  coeffs_.Add(other.coeffs_);
1011  if (other.Offset != 0L) {
1012  Offset = other.Offset;
1013  }
1014  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1015  }
1016 
1017  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1018  public void MergeFrom(pb::CodedInputStream input) {
1019  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1020  input.ReadRawMessage(this);
1021  #else
1022  uint tag;
1023  while ((tag = input.ReadTag()) != 0) {
1024  switch(tag) {
1025  default:
1026  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1027  break;
1028  case 10:
1029  case 8: {
1030  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1031  break;
1032  }
1033  case 18:
1034  case 16: {
1035  coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
1036  break;
1037  }
1038  case 24: {
1039  Offset = input.ReadInt64();
1040  break;
1041  }
1042  }
1043  }
1044  #endif
1045  }
1046 
1047  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1048  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1049  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1050  uint tag;
1051  while ((tag = input.ReadTag()) != 0) {
1052  switch(tag) {
1053  default:
1054  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1055  break;
1056  case 10:
1057  case 8: {
1058  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1059  break;
1060  }
1061  case 18:
1062  case 16: {
1063  coeffs_.AddEntriesFrom(ref input, _repeated_coeffs_codec);
1064  break;
1065  }
1066  case 24: {
1067  Offset = input.ReadInt64();
1068  break;
1069  }
1070  }
1071  }
1072  }
1073  #endif
1074 
1075  }
1076 
1077  public sealed partial class LinearArgumentProto : pb::IMessage<LinearArgumentProto>
1078  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1079  , pb::IBufferMessage
1080  #endif
1081  {
1082  private static readonly pb::MessageParser<LinearArgumentProto> _parser = new pb::MessageParser<LinearArgumentProto>(() => new LinearArgumentProto());
1083  private pb::UnknownFieldSet _unknownFields;
1084  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1085  public static pb::MessageParser<LinearArgumentProto> Parser { get { return _parser; } }
1086 
1087  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1088  public static pbr::MessageDescriptor Descriptor {
1089  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[4]; }
1090  }
1091 
1092  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1093  pbr::MessageDescriptor pb::IMessage.Descriptor {
1094  get { return Descriptor; }
1095  }
1096 
1097  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1099  OnConstruction();
1100  }
1101 
1102  partial void OnConstruction();
1103 
1104  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1105  public LinearArgumentProto(LinearArgumentProto other) : this() {
1106  target_ = other.target_ != null ? other.target_.Clone() : null;
1107  exprs_ = other.exprs_.Clone();
1108  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1109  }
1110 
1111  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1113  return new LinearArgumentProto(this);
1114  }
1115 
1117  public const int TargetFieldNumber = 1;
1118  private global::Google.OrTools.Sat.LinearExpressionProto target_;
1119  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1120  public global::Google.OrTools.Sat.LinearExpressionProto Target {
1121  get { return target_; }
1122  set {
1123  target_ = value;
1124  }
1125  }
1126 
1128  public const int ExprsFieldNumber = 2;
1129  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.LinearExpressionProto> _repeated_exprs_codec
1130  = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.LinearExpressionProto.Parser);
1131  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> exprs_ = new pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto>();
1132  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1133  public pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> Exprs {
1134  get { return exprs_; }
1135  }
1136 
1137  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1138  public override bool Equals(object other) {
1139  return Equals(other as LinearArgumentProto);
1140  }
1141 
1142  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1143  public bool Equals(LinearArgumentProto other) {
1144  if (ReferenceEquals(other, null)) {
1145  return false;
1146  }
1147  if (ReferenceEquals(other, this)) {
1148  return true;
1149  }
1150  if (!object.Equals(Target, other.Target)) return false;
1151  if(!exprs_.Equals(other.exprs_)) return false;
1152  return Equals(_unknownFields, other._unknownFields);
1153  }
1154 
1155  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1156  public override int GetHashCode() {
1157  int hash = 1;
1158  if (target_ != null) hash ^= Target.GetHashCode();
1159  hash ^= exprs_.GetHashCode();
1160  if (_unknownFields != null) {
1161  hash ^= _unknownFields.GetHashCode();
1162  }
1163  return hash;
1164  }
1165 
1166  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1167  public override string ToString() {
1168  return pb::JsonFormatter.ToDiagnosticString(this);
1169  }
1170 
1171  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1172  public void WriteTo(pb::CodedOutputStream output) {
1173  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1174  output.WriteRawMessage(this);
1175  #else
1176  if (target_ != null) {
1177  output.WriteRawTag(10);
1178  output.WriteMessage(Target);
1179  }
1180  exprs_.WriteTo(output, _repeated_exprs_codec);
1181  if (_unknownFields != null) {
1182  _unknownFields.WriteTo(output);
1183  }
1184  #endif
1185  }
1186 
1187  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1188  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1189  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1190  if (target_ != null) {
1191  output.WriteRawTag(10);
1192  output.WriteMessage(Target);
1193  }
1194  exprs_.WriteTo(ref output, _repeated_exprs_codec);
1195  if (_unknownFields != null) {
1196  _unknownFields.WriteTo(ref output);
1197  }
1198  }
1199  #endif
1200 
1201  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1202  public int CalculateSize() {
1203  int size = 0;
1204  if (target_ != null) {
1205  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Target);
1206  }
1207  size += exprs_.CalculateSize(_repeated_exprs_codec);
1208  if (_unknownFields != null) {
1209  size += _unknownFields.CalculateSize();
1210  }
1211  return size;
1212  }
1213 
1214  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1215  public void MergeFrom(LinearArgumentProto other) {
1216  if (other == null) {
1217  return;
1218  }
1219  if (other.target_ != null) {
1220  if (target_ == null) {
1221  Target = new global::Google.OrTools.Sat.LinearExpressionProto();
1222  }
1223  Target.MergeFrom(other.Target);
1224  }
1225  exprs_.Add(other.exprs_);
1226  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1227  }
1228 
1229  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1230  public void MergeFrom(pb::CodedInputStream input) {
1231  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1232  input.ReadRawMessage(this);
1233  #else
1234  uint tag;
1235  while ((tag = input.ReadTag()) != 0) {
1236  switch(tag) {
1237  default:
1238  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1239  break;
1240  case 10: {
1241  if (target_ == null) {
1242  Target = new global::Google.OrTools.Sat.LinearExpressionProto();
1243  }
1244  input.ReadMessage(Target);
1245  break;
1246  }
1247  case 18: {
1248  exprs_.AddEntriesFrom(input, _repeated_exprs_codec);
1249  break;
1250  }
1251  }
1252  }
1253  #endif
1254  }
1255 
1256  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1257  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1258  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1259  uint tag;
1260  while ((tag = input.ReadTag()) != 0) {
1261  switch(tag) {
1262  default:
1263  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1264  break;
1265  case 10: {
1266  if (target_ == null) {
1267  Target = new global::Google.OrTools.Sat.LinearExpressionProto();
1268  }
1269  input.ReadMessage(Target);
1270  break;
1271  }
1272  case 18: {
1273  exprs_.AddEntriesFrom(ref input, _repeated_exprs_codec);
1274  break;
1275  }
1276  }
1277  }
1278  }
1279  #endif
1280 
1281  }
1282 
1286  public sealed partial class AllDifferentConstraintProto : pb::IMessage<AllDifferentConstraintProto>
1287  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1288  , pb::IBufferMessage
1289  #endif
1290  {
1291  private static readonly pb::MessageParser<AllDifferentConstraintProto> _parser = new pb::MessageParser<AllDifferentConstraintProto>(() => new AllDifferentConstraintProto());
1292  private pb::UnknownFieldSet _unknownFields;
1293  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1294  public static pb::MessageParser<AllDifferentConstraintProto> Parser { get { return _parser; } }
1295 
1296  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1297  public static pbr::MessageDescriptor Descriptor {
1298  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[5]; }
1299  }
1300 
1301  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1302  pbr::MessageDescriptor pb::IMessage.Descriptor {
1303  get { return Descriptor; }
1304  }
1305 
1306  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1308  OnConstruction();
1309  }
1310 
1311  partial void OnConstruction();
1312 
1313  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1315  vars_ = other.vars_.Clone();
1316  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1317  }
1318 
1319  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1321  return new AllDifferentConstraintProto(this);
1322  }
1323 
1325  public const int VarsFieldNumber = 1;
1326  private static readonly pb::FieldCodec<int> _repeated_vars_codec
1327  = pb::FieldCodec.ForInt32(10);
1328  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
1329  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1330  public pbc::RepeatedField<int> Vars {
1331  get { return vars_; }
1332  }
1333 
1334  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1335  public override bool Equals(object other) {
1336  return Equals(other as AllDifferentConstraintProto);
1337  }
1338 
1339  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1341  if (ReferenceEquals(other, null)) {
1342  return false;
1343  }
1344  if (ReferenceEquals(other, this)) {
1345  return true;
1346  }
1347  if(!vars_.Equals(other.vars_)) return false;
1348  return Equals(_unknownFields, other._unknownFields);
1349  }
1350 
1351  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1352  public override int GetHashCode() {
1353  int hash = 1;
1354  hash ^= vars_.GetHashCode();
1355  if (_unknownFields != null) {
1356  hash ^= _unknownFields.GetHashCode();
1357  }
1358  return hash;
1359  }
1360 
1361  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1362  public override string ToString() {
1363  return pb::JsonFormatter.ToDiagnosticString(this);
1364  }
1365 
1366  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1367  public void WriteTo(pb::CodedOutputStream output) {
1368  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1369  output.WriteRawMessage(this);
1370  #else
1371  vars_.WriteTo(output, _repeated_vars_codec);
1372  if (_unknownFields != null) {
1373  _unknownFields.WriteTo(output);
1374  }
1375  #endif
1376  }
1377 
1378  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1379  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1380  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1381  vars_.WriteTo(ref output, _repeated_vars_codec);
1382  if (_unknownFields != null) {
1383  _unknownFields.WriteTo(ref output);
1384  }
1385  }
1386  #endif
1387 
1388  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1389  public int CalculateSize() {
1390  int size = 0;
1391  size += vars_.CalculateSize(_repeated_vars_codec);
1392  if (_unknownFields != null) {
1393  size += _unknownFields.CalculateSize();
1394  }
1395  return size;
1396  }
1397 
1398  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1400  if (other == null) {
1401  return;
1402  }
1403  vars_.Add(other.vars_);
1404  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1405  }
1406 
1407  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1408  public void MergeFrom(pb::CodedInputStream input) {
1409  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1410  input.ReadRawMessage(this);
1411  #else
1412  uint tag;
1413  while ((tag = input.ReadTag()) != 0) {
1414  switch(tag) {
1415  default:
1416  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1417  break;
1418  case 10:
1419  case 8: {
1420  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1421  break;
1422  }
1423  }
1424  }
1425  #endif
1426  }
1427 
1428  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1429  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1430  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1431  uint tag;
1432  while ((tag = input.ReadTag()) != 0) {
1433  switch(tag) {
1434  default:
1435  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1436  break;
1437  case 10:
1438  case 8: {
1439  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1440  break;
1441  }
1442  }
1443  }
1444  }
1445  #endif
1446 
1447  }
1448 
1457  public sealed partial class LinearConstraintProto : pb::IMessage<LinearConstraintProto>
1458  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1459  , pb::IBufferMessage
1460  #endif
1461  {
1462  private static readonly pb::MessageParser<LinearConstraintProto> _parser = new pb::MessageParser<LinearConstraintProto>(() => new LinearConstraintProto());
1463  private pb::UnknownFieldSet _unknownFields;
1464  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1465  public static pb::MessageParser<LinearConstraintProto> Parser { get { return _parser; } }
1466 
1467  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1468  public static pbr::MessageDescriptor Descriptor {
1469  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[6]; }
1470  }
1471 
1472  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1473  pbr::MessageDescriptor pb::IMessage.Descriptor {
1474  get { return Descriptor; }
1475  }
1476 
1477  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1479  OnConstruction();
1480  }
1481 
1482  partial void OnConstruction();
1483 
1484  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1486  vars_ = other.vars_.Clone();
1487  coeffs_ = other.coeffs_.Clone();
1488  domain_ = other.domain_.Clone();
1489  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1490  }
1491 
1492  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1494  return new LinearConstraintProto(this);
1495  }
1496 
1498  public const int VarsFieldNumber = 1;
1499  private static readonly pb::FieldCodec<int> _repeated_vars_codec
1500  = pb::FieldCodec.ForInt32(10);
1501  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
1502  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1503  public pbc::RepeatedField<int> Vars {
1504  get { return vars_; }
1505  }
1506 
1508  public const int CoeffsFieldNumber = 2;
1509  private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
1510  = pb::FieldCodec.ForInt64(18);
1511  private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
1515  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1516  public pbc::RepeatedField<long> Coeffs {
1517  get { return coeffs_; }
1518  }
1519 
1521  public const int DomainFieldNumber = 3;
1522  private static readonly pb::FieldCodec<long> _repeated_domain_codec
1523  = pb::FieldCodec.ForInt64(26);
1524  private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
1525  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1526  public pbc::RepeatedField<long> Domain {
1527  get { return domain_; }
1528  }
1529 
1530  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1531  public override bool Equals(object other) {
1532  return Equals(other as LinearConstraintProto);
1533  }
1534 
1535  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1536  public bool Equals(LinearConstraintProto other) {
1537  if (ReferenceEquals(other, null)) {
1538  return false;
1539  }
1540  if (ReferenceEquals(other, this)) {
1541  return true;
1542  }
1543  if(!vars_.Equals(other.vars_)) return false;
1544  if(!coeffs_.Equals(other.coeffs_)) return false;
1545  if(!domain_.Equals(other.domain_)) return false;
1546  return Equals(_unknownFields, other._unknownFields);
1547  }
1548 
1549  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1550  public override int GetHashCode() {
1551  int hash = 1;
1552  hash ^= vars_.GetHashCode();
1553  hash ^= coeffs_.GetHashCode();
1554  hash ^= domain_.GetHashCode();
1555  if (_unknownFields != null) {
1556  hash ^= _unknownFields.GetHashCode();
1557  }
1558  return hash;
1559  }
1560 
1561  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1562  public override string ToString() {
1563  return pb::JsonFormatter.ToDiagnosticString(this);
1564  }
1565 
1566  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1567  public void WriteTo(pb::CodedOutputStream output) {
1568  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1569  output.WriteRawMessage(this);
1570  #else
1571  vars_.WriteTo(output, _repeated_vars_codec);
1572  coeffs_.WriteTo(output, _repeated_coeffs_codec);
1573  domain_.WriteTo(output, _repeated_domain_codec);
1574  if (_unknownFields != null) {
1575  _unknownFields.WriteTo(output);
1576  }
1577  #endif
1578  }
1579 
1580  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1581  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1582  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1583  vars_.WriteTo(ref output, _repeated_vars_codec);
1584  coeffs_.WriteTo(ref output, _repeated_coeffs_codec);
1585  domain_.WriteTo(ref output, _repeated_domain_codec);
1586  if (_unknownFields != null) {
1587  _unknownFields.WriteTo(ref output);
1588  }
1589  }
1590  #endif
1591 
1592  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1593  public int CalculateSize() {
1594  int size = 0;
1595  size += vars_.CalculateSize(_repeated_vars_codec);
1596  size += coeffs_.CalculateSize(_repeated_coeffs_codec);
1597  size += domain_.CalculateSize(_repeated_domain_codec);
1598  if (_unknownFields != null) {
1599  size += _unknownFields.CalculateSize();
1600  }
1601  return size;
1602  }
1603 
1604  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1605  public void MergeFrom(LinearConstraintProto other) {
1606  if (other == null) {
1607  return;
1608  }
1609  vars_.Add(other.vars_);
1610  coeffs_.Add(other.coeffs_);
1611  domain_.Add(other.domain_);
1612  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1613  }
1614 
1615  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1616  public void MergeFrom(pb::CodedInputStream input) {
1617  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1618  input.ReadRawMessage(this);
1619  #else
1620  uint tag;
1621  while ((tag = input.ReadTag()) != 0) {
1622  switch(tag) {
1623  default:
1624  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1625  break;
1626  case 10:
1627  case 8: {
1628  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1629  break;
1630  }
1631  case 18:
1632  case 16: {
1633  coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
1634  break;
1635  }
1636  case 26:
1637  case 24: {
1638  domain_.AddEntriesFrom(input, _repeated_domain_codec);
1639  break;
1640  }
1641  }
1642  }
1643  #endif
1644  }
1645 
1646  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1647  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1648  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1649  uint tag;
1650  while ((tag = input.ReadTag()) != 0) {
1651  switch(tag) {
1652  default:
1653  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1654  break;
1655  case 10:
1656  case 8: {
1657  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1658  break;
1659  }
1660  case 18:
1661  case 16: {
1662  coeffs_.AddEntriesFrom(ref input, _repeated_coeffs_codec);
1663  break;
1664  }
1665  case 26:
1666  case 24: {
1667  domain_.AddEntriesFrom(ref input, _repeated_domain_codec);
1668  break;
1669  }
1670  }
1671  }
1672  }
1673  #endif
1674 
1675  }
1676 
1681  public sealed partial class ElementConstraintProto : pb::IMessage<ElementConstraintProto>
1682  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1683  , pb::IBufferMessage
1684  #endif
1685  {
1686  private static readonly pb::MessageParser<ElementConstraintProto> _parser = new pb::MessageParser<ElementConstraintProto>(() => new ElementConstraintProto());
1687  private pb::UnknownFieldSet _unknownFields;
1688  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1689  public static pb::MessageParser<ElementConstraintProto> Parser { get { return _parser; } }
1690 
1691  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1692  public static pbr::MessageDescriptor Descriptor {
1693  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[7]; }
1694  }
1695 
1696  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1697  pbr::MessageDescriptor pb::IMessage.Descriptor {
1698  get { return Descriptor; }
1699  }
1700 
1701  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1703  OnConstruction();
1704  }
1705 
1706  partial void OnConstruction();
1707 
1708  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1710  index_ = other.index_;
1711  target_ = other.target_;
1712  vars_ = other.vars_.Clone();
1713  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1714  }
1715 
1716  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1718  return new ElementConstraintProto(this);
1719  }
1720 
1722  public const int IndexFieldNumber = 1;
1723  private int index_;
1724  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1725  public int Index {
1726  get { return index_; }
1727  set {
1728  index_ = value;
1729  }
1730  }
1731 
1733  public const int TargetFieldNumber = 2;
1734  private int target_;
1735  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1736  public int Target {
1737  get { return target_; }
1738  set {
1739  target_ = value;
1740  }
1741  }
1742 
1744  public const int VarsFieldNumber = 3;
1745  private static readonly pb::FieldCodec<int> _repeated_vars_codec
1746  = pb::FieldCodec.ForInt32(26);
1747  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
1748  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1749  public pbc::RepeatedField<int> Vars {
1750  get { return vars_; }
1751  }
1752 
1753  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1754  public override bool Equals(object other) {
1755  return Equals(other as ElementConstraintProto);
1756  }
1757 
1758  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1759  public bool Equals(ElementConstraintProto other) {
1760  if (ReferenceEquals(other, null)) {
1761  return false;
1762  }
1763  if (ReferenceEquals(other, this)) {
1764  return true;
1765  }
1766  if (Index != other.Index) return false;
1767  if (Target != other.Target) return false;
1768  if(!vars_.Equals(other.vars_)) return false;
1769  return Equals(_unknownFields, other._unknownFields);
1770  }
1771 
1772  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1773  public override int GetHashCode() {
1774  int hash = 1;
1775  if (Index != 0) hash ^= Index.GetHashCode();
1776  if (Target != 0) hash ^= Target.GetHashCode();
1777  hash ^= vars_.GetHashCode();
1778  if (_unknownFields != null) {
1779  hash ^= _unknownFields.GetHashCode();
1780  }
1781  return hash;
1782  }
1783 
1784  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1785  public override string ToString() {
1786  return pb::JsonFormatter.ToDiagnosticString(this);
1787  }
1788 
1789  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1790  public void WriteTo(pb::CodedOutputStream output) {
1791  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1792  output.WriteRawMessage(this);
1793  #else
1794  if (Index != 0) {
1795  output.WriteRawTag(8);
1796  output.WriteInt32(Index);
1797  }
1798  if (Target != 0) {
1799  output.WriteRawTag(16);
1800  output.WriteInt32(Target);
1801  }
1802  vars_.WriteTo(output, _repeated_vars_codec);
1803  if (_unknownFields != null) {
1804  _unknownFields.WriteTo(output);
1805  }
1806  #endif
1807  }
1808 
1809  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1810  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1811  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1812  if (Index != 0) {
1813  output.WriteRawTag(8);
1814  output.WriteInt32(Index);
1815  }
1816  if (Target != 0) {
1817  output.WriteRawTag(16);
1818  output.WriteInt32(Target);
1819  }
1820  vars_.WriteTo(ref output, _repeated_vars_codec);
1821  if (_unknownFields != null) {
1822  _unknownFields.WriteTo(ref output);
1823  }
1824  }
1825  #endif
1826 
1827  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1828  public int CalculateSize() {
1829  int size = 0;
1830  if (Index != 0) {
1831  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Index);
1832  }
1833  if (Target != 0) {
1834  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
1835  }
1836  size += vars_.CalculateSize(_repeated_vars_codec);
1837  if (_unknownFields != null) {
1838  size += _unknownFields.CalculateSize();
1839  }
1840  return size;
1841  }
1842 
1843  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1844  public void MergeFrom(ElementConstraintProto other) {
1845  if (other == null) {
1846  return;
1847  }
1848  if (other.Index != 0) {
1849  Index = other.Index;
1850  }
1851  if (other.Target != 0) {
1852  Target = other.Target;
1853  }
1854  vars_.Add(other.vars_);
1855  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1856  }
1857 
1858  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1859  public void MergeFrom(pb::CodedInputStream input) {
1860  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1861  input.ReadRawMessage(this);
1862  #else
1863  uint tag;
1864  while ((tag = input.ReadTag()) != 0) {
1865  switch(tag) {
1866  default:
1867  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1868  break;
1869  case 8: {
1870  Index = input.ReadInt32();
1871  break;
1872  }
1873  case 16: {
1874  Target = input.ReadInt32();
1875  break;
1876  }
1877  case 26:
1878  case 24: {
1879  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1880  break;
1881  }
1882  }
1883  }
1884  #endif
1885  }
1886 
1887  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1888  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1889  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1890  uint tag;
1891  while ((tag = input.ReadTag()) != 0) {
1892  switch(tag) {
1893  default:
1894  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1895  break;
1896  case 8: {
1897  Index = input.ReadInt32();
1898  break;
1899  }
1900  case 16: {
1901  Target = input.ReadInt32();
1902  break;
1903  }
1904  case 26:
1905  case 24: {
1906  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1907  break;
1908  }
1909  }
1910  }
1911  }
1912  #endif
1913 
1914  }
1915 
1921  public sealed partial class IntervalConstraintProto : pb::IMessage<IntervalConstraintProto>
1922  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1923  , pb::IBufferMessage
1924  #endif
1925  {
1926  private static readonly pb::MessageParser<IntervalConstraintProto> _parser = new pb::MessageParser<IntervalConstraintProto>(() => new IntervalConstraintProto());
1927  private pb::UnknownFieldSet _unknownFields;
1928  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1929  public static pb::MessageParser<IntervalConstraintProto> Parser { get { return _parser; } }
1930 
1931  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1932  public static pbr::MessageDescriptor Descriptor {
1933  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[8]; }
1934  }
1935 
1936  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1937  pbr::MessageDescriptor pb::IMessage.Descriptor {
1938  get { return Descriptor; }
1939  }
1940 
1941  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1943  OnConstruction();
1944  }
1945 
1946  partial void OnConstruction();
1947 
1948  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1950  start_ = other.start_;
1951  end_ = other.end_;
1952  size_ = other.size_;
1953  startView_ = other.startView_ != null ? other.startView_.Clone() : null;
1954  endView_ = other.endView_ != null ? other.endView_.Clone() : null;
1955  sizeView_ = other.sizeView_ != null ? other.sizeView_.Clone() : null;
1956  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1957  }
1958 
1959  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1961  return new IntervalConstraintProto(this);
1962  }
1963 
1965  public const int StartFieldNumber = 1;
1966  private int start_;
1967  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1968  public int Start {
1969  get { return start_; }
1970  set {
1971  start_ = value;
1972  }
1973  }
1974 
1976  public const int EndFieldNumber = 2;
1977  private int end_;
1978  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1979  public int End {
1980  get { return end_; }
1981  set {
1982  end_ = value;
1983  }
1984  }
1985 
1987  public const int SizeFieldNumber = 3;
1988  private int size_;
1989  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1990  public int Size {
1991  get { return size_; }
1992  set {
1993  size_ = value;
1994  }
1995  }
1996 
1998  public const int StartViewFieldNumber = 4;
1999  private global::Google.OrTools.Sat.LinearExpressionProto startView_;
2018  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2019  public global::Google.OrTools.Sat.LinearExpressionProto StartView {
2020  get { return startView_; }
2021  set {
2022  startView_ = value;
2023  }
2024  }
2025 
2027  public const int EndViewFieldNumber = 5;
2028  private global::Google.OrTools.Sat.LinearExpressionProto endView_;
2029  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2030  public global::Google.OrTools.Sat.LinearExpressionProto EndView {
2031  get { return endView_; }
2032  set {
2033  endView_ = value;
2034  }
2035  }
2036 
2038  public const int SizeViewFieldNumber = 6;
2039  private global::Google.OrTools.Sat.LinearExpressionProto sizeView_;
2040  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2041  public global::Google.OrTools.Sat.LinearExpressionProto SizeView {
2042  get { return sizeView_; }
2043  set {
2044  sizeView_ = value;
2045  }
2046  }
2047 
2048  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2049  public override bool Equals(object other) {
2050  return Equals(other as IntervalConstraintProto);
2051  }
2052 
2053  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2054  public bool Equals(IntervalConstraintProto other) {
2055  if (ReferenceEquals(other, null)) {
2056  return false;
2057  }
2058  if (ReferenceEquals(other, this)) {
2059  return true;
2060  }
2061  if (Start != other.Start) return false;
2062  if (End != other.End) return false;
2063  if (Size != other.Size) return false;
2064  if (!object.Equals(StartView, other.StartView)) return false;
2065  if (!object.Equals(EndView, other.EndView)) return false;
2066  if (!object.Equals(SizeView, other.SizeView)) return false;
2067  return Equals(_unknownFields, other._unknownFields);
2068  }
2069 
2070  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2071  public override int GetHashCode() {
2072  int hash = 1;
2073  if (Start != 0) hash ^= Start.GetHashCode();
2074  if (End != 0) hash ^= End.GetHashCode();
2075  if (Size != 0) hash ^= Size.GetHashCode();
2076  if (startView_ != null) hash ^= StartView.GetHashCode();
2077  if (endView_ != null) hash ^= EndView.GetHashCode();
2078  if (sizeView_ != null) hash ^= SizeView.GetHashCode();
2079  if (_unknownFields != null) {
2080  hash ^= _unknownFields.GetHashCode();
2081  }
2082  return hash;
2083  }
2084 
2085  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2086  public override string ToString() {
2087  return pb::JsonFormatter.ToDiagnosticString(this);
2088  }
2089 
2090  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2091  public void WriteTo(pb::CodedOutputStream output) {
2092  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2093  output.WriteRawMessage(this);
2094  #else
2095  if (Start != 0) {
2096  output.WriteRawTag(8);
2097  output.WriteInt32(Start);
2098  }
2099  if (End != 0) {
2100  output.WriteRawTag(16);
2101  output.WriteInt32(End);
2102  }
2103  if (Size != 0) {
2104  output.WriteRawTag(24);
2105  output.WriteInt32(Size);
2106  }
2107  if (startView_ != null) {
2108  output.WriteRawTag(34);
2109  output.WriteMessage(StartView);
2110  }
2111  if (endView_ != null) {
2112  output.WriteRawTag(42);
2113  output.WriteMessage(EndView);
2114  }
2115  if (sizeView_ != null) {
2116  output.WriteRawTag(50);
2117  output.WriteMessage(SizeView);
2118  }
2119  if (_unknownFields != null) {
2120  _unknownFields.WriteTo(output);
2121  }
2122  #endif
2123  }
2124 
2125  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2126  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2127  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2128  if (Start != 0) {
2129  output.WriteRawTag(8);
2130  output.WriteInt32(Start);
2131  }
2132  if (End != 0) {
2133  output.WriteRawTag(16);
2134  output.WriteInt32(End);
2135  }
2136  if (Size != 0) {
2137  output.WriteRawTag(24);
2138  output.WriteInt32(Size);
2139  }
2140  if (startView_ != null) {
2141  output.WriteRawTag(34);
2142  output.WriteMessage(StartView);
2143  }
2144  if (endView_ != null) {
2145  output.WriteRawTag(42);
2146  output.WriteMessage(EndView);
2147  }
2148  if (sizeView_ != null) {
2149  output.WriteRawTag(50);
2150  output.WriteMessage(SizeView);
2151  }
2152  if (_unknownFields != null) {
2153  _unknownFields.WriteTo(ref output);
2154  }
2155  }
2156  #endif
2157 
2158  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2159  public int CalculateSize() {
2160  int size = 0;
2161  if (Start != 0) {
2162  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
2163  }
2164  if (End != 0) {
2165  size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
2166  }
2167  if (Size != 0) {
2168  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Size);
2169  }
2170  if (startView_ != null) {
2171  size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartView);
2172  }
2173  if (endView_ != null) {
2174  size += 1 + pb::CodedOutputStream.ComputeMessageSize(EndView);
2175  }
2176  if (sizeView_ != null) {
2177  size += 1 + pb::CodedOutputStream.ComputeMessageSize(SizeView);
2178  }
2179  if (_unknownFields != null) {
2180  size += _unknownFields.CalculateSize();
2181  }
2182  return size;
2183  }
2184 
2185  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2186  public void MergeFrom(IntervalConstraintProto other) {
2187  if (other == null) {
2188  return;
2189  }
2190  if (other.Start != 0) {
2191  Start = other.Start;
2192  }
2193  if (other.End != 0) {
2194  End = other.End;
2195  }
2196  if (other.Size != 0) {
2197  Size = other.Size;
2198  }
2199  if (other.startView_ != null) {
2200  if (startView_ == null) {
2201  StartView = new global::Google.OrTools.Sat.LinearExpressionProto();
2202  }
2203  StartView.MergeFrom(other.StartView);
2204  }
2205  if (other.endView_ != null) {
2206  if (endView_ == null) {
2207  EndView = new global::Google.OrTools.Sat.LinearExpressionProto();
2208  }
2209  EndView.MergeFrom(other.EndView);
2210  }
2211  if (other.sizeView_ != null) {
2212  if (sizeView_ == null) {
2213  SizeView = new global::Google.OrTools.Sat.LinearExpressionProto();
2214  }
2215  SizeView.MergeFrom(other.SizeView);
2216  }
2217  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2218  }
2219 
2220  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2221  public void MergeFrom(pb::CodedInputStream input) {
2222  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2223  input.ReadRawMessage(this);
2224  #else
2225  uint tag;
2226  while ((tag = input.ReadTag()) != 0) {
2227  switch(tag) {
2228  default:
2229  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2230  break;
2231  case 8: {
2232  Start = input.ReadInt32();
2233  break;
2234  }
2235  case 16: {
2236  End = input.ReadInt32();
2237  break;
2238  }
2239  case 24: {
2240  Size = input.ReadInt32();
2241  break;
2242  }
2243  case 34: {
2244  if (startView_ == null) {
2245  StartView = new global::Google.OrTools.Sat.LinearExpressionProto();
2246  }
2247  input.ReadMessage(StartView);
2248  break;
2249  }
2250  case 42: {
2251  if (endView_ == null) {
2252  EndView = new global::Google.OrTools.Sat.LinearExpressionProto();
2253  }
2254  input.ReadMessage(EndView);
2255  break;
2256  }
2257  case 50: {
2258  if (sizeView_ == null) {
2259  SizeView = new global::Google.OrTools.Sat.LinearExpressionProto();
2260  }
2261  input.ReadMessage(SizeView);
2262  break;
2263  }
2264  }
2265  }
2266  #endif
2267  }
2268 
2269  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2270  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2271  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2272  uint tag;
2273  while ((tag = input.ReadTag()) != 0) {
2274  switch(tag) {
2275  default:
2276  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2277  break;
2278  case 8: {
2279  Start = input.ReadInt32();
2280  break;
2281  }
2282  case 16: {
2283  End = input.ReadInt32();
2284  break;
2285  }
2286  case 24: {
2287  Size = input.ReadInt32();
2288  break;
2289  }
2290  case 34: {
2291  if (startView_ == null) {
2292  StartView = new global::Google.OrTools.Sat.LinearExpressionProto();
2293  }
2294  input.ReadMessage(StartView);
2295  break;
2296  }
2297  case 42: {
2298  if (endView_ == null) {
2299  EndView = new global::Google.OrTools.Sat.LinearExpressionProto();
2300  }
2301  input.ReadMessage(EndView);
2302  break;
2303  }
2304  case 50: {
2305  if (sizeView_ == null) {
2306  SizeView = new global::Google.OrTools.Sat.LinearExpressionProto();
2307  }
2308  input.ReadMessage(SizeView);
2309  break;
2310  }
2311  }
2312  }
2313  }
2314  #endif
2315 
2316  }
2317 
2325  public sealed partial class NoOverlapConstraintProto : pb::IMessage<NoOverlapConstraintProto>
2326  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2327  , pb::IBufferMessage
2328  #endif
2329  {
2330  private static readonly pb::MessageParser<NoOverlapConstraintProto> _parser = new pb::MessageParser<NoOverlapConstraintProto>(() => new NoOverlapConstraintProto());
2331  private pb::UnknownFieldSet _unknownFields;
2332  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2333  public static pb::MessageParser<NoOverlapConstraintProto> Parser { get { return _parser; } }
2334 
2335  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2336  public static pbr::MessageDescriptor Descriptor {
2337  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[9]; }
2338  }
2339 
2340  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2341  pbr::MessageDescriptor pb::IMessage.Descriptor {
2342  get { return Descriptor; }
2343  }
2344 
2345  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2347  OnConstruction();
2348  }
2349 
2350  partial void OnConstruction();
2351 
2352  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2354  intervals_ = other.intervals_.Clone();
2355  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2356  }
2357 
2358  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2360  return new NoOverlapConstraintProto(this);
2361  }
2362 
2364  public const int IntervalsFieldNumber = 1;
2365  private static readonly pb::FieldCodec<int> _repeated_intervals_codec
2366  = pb::FieldCodec.ForInt32(10);
2367  private readonly pbc::RepeatedField<int> intervals_ = new pbc::RepeatedField<int>();
2368  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2369  public pbc::RepeatedField<int> Intervals {
2370  get { return intervals_; }
2371  }
2372 
2373  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2374  public override bool Equals(object other) {
2375  return Equals(other as NoOverlapConstraintProto);
2376  }
2377 
2378  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2379  public bool Equals(NoOverlapConstraintProto other) {
2380  if (ReferenceEquals(other, null)) {
2381  return false;
2382  }
2383  if (ReferenceEquals(other, this)) {
2384  return true;
2385  }
2386  if(!intervals_.Equals(other.intervals_)) return false;
2387  return Equals(_unknownFields, other._unknownFields);
2388  }
2389 
2390  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2391  public override int GetHashCode() {
2392  int hash = 1;
2393  hash ^= intervals_.GetHashCode();
2394  if (_unknownFields != null) {
2395  hash ^= _unknownFields.GetHashCode();
2396  }
2397  return hash;
2398  }
2399 
2400  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2401  public override string ToString() {
2402  return pb::JsonFormatter.ToDiagnosticString(this);
2403  }
2404 
2405  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2406  public void WriteTo(pb::CodedOutputStream output) {
2407  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2408  output.WriteRawMessage(this);
2409  #else
2410  intervals_.WriteTo(output, _repeated_intervals_codec);
2411  if (_unknownFields != null) {
2412  _unknownFields.WriteTo(output);
2413  }
2414  #endif
2415  }
2416 
2417  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2418  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2419  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2420  intervals_.WriteTo(ref output, _repeated_intervals_codec);
2421  if (_unknownFields != null) {
2422  _unknownFields.WriteTo(ref output);
2423  }
2424  }
2425  #endif
2426 
2427  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2428  public int CalculateSize() {
2429  int size = 0;
2430  size += intervals_.CalculateSize(_repeated_intervals_codec);
2431  if (_unknownFields != null) {
2432  size += _unknownFields.CalculateSize();
2433  }
2434  return size;
2435  }
2436 
2437  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2439  if (other == null) {
2440  return;
2441  }
2442  intervals_.Add(other.intervals_);
2443  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2444  }
2445 
2446  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2447  public void MergeFrom(pb::CodedInputStream input) {
2448  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2449  input.ReadRawMessage(this);
2450  #else
2451  uint tag;
2452  while ((tag = input.ReadTag()) != 0) {
2453  switch(tag) {
2454  default:
2455  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2456  break;
2457  case 10:
2458  case 8: {
2459  intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
2460  break;
2461  }
2462  }
2463  }
2464  #endif
2465  }
2466 
2467  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2468  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2469  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2470  uint tag;
2471  while ((tag = input.ReadTag()) != 0) {
2472  switch(tag) {
2473  default:
2474  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2475  break;
2476  case 10:
2477  case 8: {
2478  intervals_.AddEntriesFrom(ref input, _repeated_intervals_codec);
2479  break;
2480  }
2481  }
2482  }
2483  }
2484  #endif
2485 
2486  }
2487 
2491  public sealed partial class NoOverlap2DConstraintProto : pb::IMessage<NoOverlap2DConstraintProto>
2492  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2493  , pb::IBufferMessage
2494  #endif
2495  {
2496  private static readonly pb::MessageParser<NoOverlap2DConstraintProto> _parser = new pb::MessageParser<NoOverlap2DConstraintProto>(() => new NoOverlap2DConstraintProto());
2497  private pb::UnknownFieldSet _unknownFields;
2498  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2499  public static pb::MessageParser<NoOverlap2DConstraintProto> Parser { get { return _parser; } }
2500 
2501  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2502  public static pbr::MessageDescriptor Descriptor {
2503  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[10]; }
2504  }
2505 
2506  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2507  pbr::MessageDescriptor pb::IMessage.Descriptor {
2508  get { return Descriptor; }
2509  }
2510 
2511  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2513  OnConstruction();
2514  }
2515 
2516  partial void OnConstruction();
2517 
2518  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2520  xIntervals_ = other.xIntervals_.Clone();
2521  yIntervals_ = other.yIntervals_.Clone();
2522  boxesWithNullAreaCanOverlap_ = other.boxesWithNullAreaCanOverlap_;
2523  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2524  }
2525 
2526  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2528  return new NoOverlap2DConstraintProto(this);
2529  }
2530 
2532  public const int XIntervalsFieldNumber = 1;
2533  private static readonly pb::FieldCodec<int> _repeated_xIntervals_codec
2534  = pb::FieldCodec.ForInt32(10);
2535  private readonly pbc::RepeatedField<int> xIntervals_ = new pbc::RepeatedField<int>();
2536  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2537  public pbc::RepeatedField<int> XIntervals {
2538  get { return xIntervals_; }
2539  }
2540 
2542  public const int YIntervalsFieldNumber = 2;
2543  private static readonly pb::FieldCodec<int> _repeated_yIntervals_codec
2544  = pb::FieldCodec.ForInt32(18);
2545  private readonly pbc::RepeatedField<int> yIntervals_ = new pbc::RepeatedField<int>();
2549  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2550  public pbc::RepeatedField<int> YIntervals {
2551  get { return yIntervals_; }
2552  }
2553 
2555  public const int BoxesWithNullAreaCanOverlapFieldNumber = 3;
2556  private bool boxesWithNullAreaCanOverlap_;
2557  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2558  public bool BoxesWithNullAreaCanOverlap {
2559  get { return boxesWithNullAreaCanOverlap_; }
2560  set {
2561  boxesWithNullAreaCanOverlap_ = value;
2562  }
2563  }
2564 
2565  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2566  public override bool Equals(object other) {
2567  return Equals(other as NoOverlap2DConstraintProto);
2568  }
2569 
2570  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2571  public bool Equals(NoOverlap2DConstraintProto other) {
2572  if (ReferenceEquals(other, null)) {
2573  return false;
2574  }
2575  if (ReferenceEquals(other, this)) {
2576  return true;
2577  }
2578  if(!xIntervals_.Equals(other.xIntervals_)) return false;
2579  if(!yIntervals_.Equals(other.yIntervals_)) return false;
2580  if (BoxesWithNullAreaCanOverlap != other.BoxesWithNullAreaCanOverlap) return false;
2581  return Equals(_unknownFields, other._unknownFields);
2582  }
2583 
2584  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2585  public override int GetHashCode() {
2586  int hash = 1;
2587  hash ^= xIntervals_.GetHashCode();
2588  hash ^= yIntervals_.GetHashCode();
2589  if (BoxesWithNullAreaCanOverlap != false) hash ^= BoxesWithNullAreaCanOverlap.GetHashCode();
2590  if (_unknownFields != null) {
2591  hash ^= _unknownFields.GetHashCode();
2592  }
2593  return hash;
2594  }
2595 
2596  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2597  public override string ToString() {
2598  return pb::JsonFormatter.ToDiagnosticString(this);
2599  }
2600 
2601  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2602  public void WriteTo(pb::CodedOutputStream output) {
2603  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2604  output.WriteRawMessage(this);
2605  #else
2606  xIntervals_.WriteTo(output, _repeated_xIntervals_codec);
2607  yIntervals_.WriteTo(output, _repeated_yIntervals_codec);
2608  if (BoxesWithNullAreaCanOverlap != false) {
2609  output.WriteRawTag(24);
2610  output.WriteBool(BoxesWithNullAreaCanOverlap);
2611  }
2612  if (_unknownFields != null) {
2613  _unknownFields.WriteTo(output);
2614  }
2615  #endif
2616  }
2617 
2618  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2619  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2620  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2621  xIntervals_.WriteTo(ref output, _repeated_xIntervals_codec);
2622  yIntervals_.WriteTo(ref output, _repeated_yIntervals_codec);
2623  if (BoxesWithNullAreaCanOverlap != false) {
2624  output.WriteRawTag(24);
2625  output.WriteBool(BoxesWithNullAreaCanOverlap);
2626  }
2627  if (_unknownFields != null) {
2628  _unknownFields.WriteTo(ref output);
2629  }
2630  }
2631  #endif
2632 
2633  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2634  public int CalculateSize() {
2635  int size = 0;
2636  size += xIntervals_.CalculateSize(_repeated_xIntervals_codec);
2637  size += yIntervals_.CalculateSize(_repeated_yIntervals_codec);
2638  if (BoxesWithNullAreaCanOverlap != false) {
2639  size += 1 + 1;
2640  }
2641  if (_unknownFields != null) {
2642  size += _unknownFields.CalculateSize();
2643  }
2644  return size;
2645  }
2646 
2647  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2649  if (other == null) {
2650  return;
2651  }
2652  xIntervals_.Add(other.xIntervals_);
2653  yIntervals_.Add(other.yIntervals_);
2654  if (other.BoxesWithNullAreaCanOverlap != false) {
2655  BoxesWithNullAreaCanOverlap = other.BoxesWithNullAreaCanOverlap;
2656  }
2657  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2658  }
2659 
2660  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2661  public void MergeFrom(pb::CodedInputStream input) {
2662  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2663  input.ReadRawMessage(this);
2664  #else
2665  uint tag;
2666  while ((tag = input.ReadTag()) != 0) {
2667  switch(tag) {
2668  default:
2669  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2670  break;
2671  case 10:
2672  case 8: {
2673  xIntervals_.AddEntriesFrom(input, _repeated_xIntervals_codec);
2674  break;
2675  }
2676  case 18:
2677  case 16: {
2678  yIntervals_.AddEntriesFrom(input, _repeated_yIntervals_codec);
2679  break;
2680  }
2681  case 24: {
2682  BoxesWithNullAreaCanOverlap = input.ReadBool();
2683  break;
2684  }
2685  }
2686  }
2687  #endif
2688  }
2689 
2690  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2691  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2692  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2693  uint tag;
2694  while ((tag = input.ReadTag()) != 0) {
2695  switch(tag) {
2696  default:
2697  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2698  break;
2699  case 10:
2700  case 8: {
2701  xIntervals_.AddEntriesFrom(ref input, _repeated_xIntervals_codec);
2702  break;
2703  }
2704  case 18:
2705  case 16: {
2706  yIntervals_.AddEntriesFrom(ref input, _repeated_yIntervals_codec);
2707  break;
2708  }
2709  case 24: {
2710  BoxesWithNullAreaCanOverlap = input.ReadBool();
2711  break;
2712  }
2713  }
2714  }
2715  }
2716  #endif
2717 
2718  }
2719 
2726  public sealed partial class CumulativeConstraintProto : pb::IMessage<CumulativeConstraintProto>
2727  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2728  , pb::IBufferMessage
2729  #endif
2730  {
2731  private static readonly pb::MessageParser<CumulativeConstraintProto> _parser = new pb::MessageParser<CumulativeConstraintProto>(() => new CumulativeConstraintProto());
2732  private pb::UnknownFieldSet _unknownFields;
2733  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2734  public static pb::MessageParser<CumulativeConstraintProto> Parser { get { return _parser; } }
2735 
2736  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2737  public static pbr::MessageDescriptor Descriptor {
2738  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[11]; }
2739  }
2740 
2741  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2742  pbr::MessageDescriptor pb::IMessage.Descriptor {
2743  get { return Descriptor; }
2744  }
2745 
2746  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2748  OnConstruction();
2749  }
2750 
2751  partial void OnConstruction();
2752 
2753  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2755  capacity_ = other.capacity_;
2756  intervals_ = other.intervals_.Clone();
2757  demands_ = other.demands_.Clone();
2758  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2759  }
2760 
2761  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2763  return new CumulativeConstraintProto(this);
2764  }
2765 
2767  public const int CapacityFieldNumber = 1;
2768  private int capacity_;
2769  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2770  public int Capacity {
2771  get { return capacity_; }
2772  set {
2773  capacity_ = value;
2774  }
2775  }
2776 
2778  public const int IntervalsFieldNumber = 2;
2779  private static readonly pb::FieldCodec<int> _repeated_intervals_codec
2780  = pb::FieldCodec.ForInt32(18);
2781  private readonly pbc::RepeatedField<int> intervals_ = new pbc::RepeatedField<int>();
2782  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2783  public pbc::RepeatedField<int> Intervals {
2784  get { return intervals_; }
2785  }
2786 
2788  public const int DemandsFieldNumber = 3;
2789  private static readonly pb::FieldCodec<int> _repeated_demands_codec
2790  = pb::FieldCodec.ForInt32(26);
2791  private readonly pbc::RepeatedField<int> demands_ = new pbc::RepeatedField<int>();
2795  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2796  public pbc::RepeatedField<int> Demands {
2797  get { return demands_; }
2798  }
2799 
2800  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2801  public override bool Equals(object other) {
2802  return Equals(other as CumulativeConstraintProto);
2803  }
2804 
2805  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2806  public bool Equals(CumulativeConstraintProto other) {
2807  if (ReferenceEquals(other, null)) {
2808  return false;
2809  }
2810  if (ReferenceEquals(other, this)) {
2811  return true;
2812  }
2813  if (Capacity != other.Capacity) return false;
2814  if(!intervals_.Equals(other.intervals_)) return false;
2815  if(!demands_.Equals(other.demands_)) return false;
2816  return Equals(_unknownFields, other._unknownFields);
2817  }
2818 
2819  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2820  public override int GetHashCode() {
2821  int hash = 1;
2822  if (Capacity != 0) hash ^= Capacity.GetHashCode();
2823  hash ^= intervals_.GetHashCode();
2824  hash ^= demands_.GetHashCode();
2825  if (_unknownFields != null) {
2826  hash ^= _unknownFields.GetHashCode();
2827  }
2828  return hash;
2829  }
2830 
2831  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2832  public override string ToString() {
2833  return pb::JsonFormatter.ToDiagnosticString(this);
2834  }
2835 
2836  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2837  public void WriteTo(pb::CodedOutputStream output) {
2838  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2839  output.WriteRawMessage(this);
2840  #else
2841  if (Capacity != 0) {
2842  output.WriteRawTag(8);
2843  output.WriteInt32(Capacity);
2844  }
2845  intervals_.WriteTo(output, _repeated_intervals_codec);
2846  demands_.WriteTo(output, _repeated_demands_codec);
2847  if (_unknownFields != null) {
2848  _unknownFields.WriteTo(output);
2849  }
2850  #endif
2851  }
2852 
2853  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2854  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2855  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2856  if (Capacity != 0) {
2857  output.WriteRawTag(8);
2858  output.WriteInt32(Capacity);
2859  }
2860  intervals_.WriteTo(ref output, _repeated_intervals_codec);
2861  demands_.WriteTo(ref output, _repeated_demands_codec);
2862  if (_unknownFields != null) {
2863  _unknownFields.WriteTo(ref output);
2864  }
2865  }
2866  #endif
2867 
2868  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2869  public int CalculateSize() {
2870  int size = 0;
2871  if (Capacity != 0) {
2872  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Capacity);
2873  }
2874  size += intervals_.CalculateSize(_repeated_intervals_codec);
2875  size += demands_.CalculateSize(_repeated_demands_codec);
2876  if (_unknownFields != null) {
2877  size += _unknownFields.CalculateSize();
2878  }
2879  return size;
2880  }
2881 
2882  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2884  if (other == null) {
2885  return;
2886  }
2887  if (other.Capacity != 0) {
2888  Capacity = other.Capacity;
2889  }
2890  intervals_.Add(other.intervals_);
2891  demands_.Add(other.demands_);
2892  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2893  }
2894 
2895  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2896  public void MergeFrom(pb::CodedInputStream input) {
2897  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2898  input.ReadRawMessage(this);
2899  #else
2900  uint tag;
2901  while ((tag = input.ReadTag()) != 0) {
2902  switch(tag) {
2903  default:
2904  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2905  break;
2906  case 8: {
2907  Capacity = input.ReadInt32();
2908  break;
2909  }
2910  case 18:
2911  case 16: {
2912  intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
2913  break;
2914  }
2915  case 26:
2916  case 24: {
2917  demands_.AddEntriesFrom(input, _repeated_demands_codec);
2918  break;
2919  }
2920  }
2921  }
2922  #endif
2923  }
2924 
2925  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2926  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2927  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2928  uint tag;
2929  while ((tag = input.ReadTag()) != 0) {
2930  switch(tag) {
2931  default:
2932  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2933  break;
2934  case 8: {
2935  Capacity = input.ReadInt32();
2936  break;
2937  }
2938  case 18:
2939  case 16: {
2940  intervals_.AddEntriesFrom(ref input, _repeated_intervals_codec);
2941  break;
2942  }
2943  case 26:
2944  case 24: {
2945  demands_.AddEntriesFrom(ref input, _repeated_demands_codec);
2946  break;
2947  }
2948  }
2949  }
2950  }
2951  #endif
2952 
2953  }
2954 
2971  public sealed partial class ReservoirConstraintProto : pb::IMessage<ReservoirConstraintProto>
2972  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2973  , pb::IBufferMessage
2974  #endif
2975  {
2976  private static readonly pb::MessageParser<ReservoirConstraintProto> _parser = new pb::MessageParser<ReservoirConstraintProto>(() => new ReservoirConstraintProto());
2977  private pb::UnknownFieldSet _unknownFields;
2978  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2979  public static pb::MessageParser<ReservoirConstraintProto> Parser { get { return _parser; } }
2980 
2981  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2982  public static pbr::MessageDescriptor Descriptor {
2983  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[12]; }
2984  }
2985 
2986  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2987  pbr::MessageDescriptor pb::IMessage.Descriptor {
2988  get { return Descriptor; }
2989  }
2990 
2991  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2993  OnConstruction();
2994  }
2995 
2996  partial void OnConstruction();
2997 
2998  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3000  minLevel_ = other.minLevel_;
3001  maxLevel_ = other.maxLevel_;
3002  times_ = other.times_.Clone();
3003  demands_ = other.demands_.Clone();
3004  actives_ = other.actives_.Clone();
3005  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3006  }
3007 
3008  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3010  return new ReservoirConstraintProto(this);
3011  }
3012 
3014  public const int MinLevelFieldNumber = 1;
3015  private long minLevel_;
3016  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3017  public long MinLevel {
3018  get { return minLevel_; }
3019  set {
3020  minLevel_ = value;
3021  }
3022  }
3023 
3025  public const int MaxLevelFieldNumber = 2;
3026  private long maxLevel_;
3027  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3028  public long MaxLevel {
3029  get { return maxLevel_; }
3030  set {
3031  maxLevel_ = value;
3032  }
3033  }
3034 
3036  public const int TimesFieldNumber = 3;
3037  private static readonly pb::FieldCodec<int> _repeated_times_codec
3038  = pb::FieldCodec.ForInt32(26);
3039  private readonly pbc::RepeatedField<int> times_ = new pbc::RepeatedField<int>();
3043  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3044  public pbc::RepeatedField<int> Times {
3045  get { return times_; }
3046  }
3047 
3049  public const int DemandsFieldNumber = 4;
3050  private static readonly pb::FieldCodec<long> _repeated_demands_codec
3051  = pb::FieldCodec.ForInt64(34);
3052  private readonly pbc::RepeatedField<long> demands_ = new pbc::RepeatedField<long>();
3056  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3057  public pbc::RepeatedField<long> Demands {
3058  get { return demands_; }
3059  }
3060 
3062  public const int ActivesFieldNumber = 5;
3063  private static readonly pb::FieldCodec<int> _repeated_actives_codec
3064  = pb::FieldCodec.ForInt32(42);
3065  private readonly pbc::RepeatedField<int> actives_ = new pbc::RepeatedField<int>();
3069  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3070  public pbc::RepeatedField<int> Actives {
3071  get { return actives_; }
3072  }
3073 
3074  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3075  public override bool Equals(object other) {
3076  return Equals(other as ReservoirConstraintProto);
3077  }
3078 
3079  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3080  public bool Equals(ReservoirConstraintProto other) {
3081  if (ReferenceEquals(other, null)) {
3082  return false;
3083  }
3084  if (ReferenceEquals(other, this)) {
3085  return true;
3086  }
3087  if (MinLevel != other.MinLevel) return false;
3088  if (MaxLevel != other.MaxLevel) return false;
3089  if(!times_.Equals(other.times_)) return false;
3090  if(!demands_.Equals(other.demands_)) return false;
3091  if(!actives_.Equals(other.actives_)) return false;
3092  return Equals(_unknownFields, other._unknownFields);
3093  }
3094 
3095  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3096  public override int GetHashCode() {
3097  int hash = 1;
3098  if (MinLevel != 0L) hash ^= MinLevel.GetHashCode();
3099  if (MaxLevel != 0L) hash ^= MaxLevel.GetHashCode();
3100  hash ^= times_.GetHashCode();
3101  hash ^= demands_.GetHashCode();
3102  hash ^= actives_.GetHashCode();
3103  if (_unknownFields != null) {
3104  hash ^= _unknownFields.GetHashCode();
3105  }
3106  return hash;
3107  }
3108 
3109  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3110  public override string ToString() {
3111  return pb::JsonFormatter.ToDiagnosticString(this);
3112  }
3113 
3114  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3115  public void WriteTo(pb::CodedOutputStream output) {
3116  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3117  output.WriteRawMessage(this);
3118  #else
3119  if (MinLevel != 0L) {
3120  output.WriteRawTag(8);
3121  output.WriteInt64(MinLevel);
3122  }
3123  if (MaxLevel != 0L) {
3124  output.WriteRawTag(16);
3125  output.WriteInt64(MaxLevel);
3126  }
3127  times_.WriteTo(output, _repeated_times_codec);
3128  demands_.WriteTo(output, _repeated_demands_codec);
3129  actives_.WriteTo(output, _repeated_actives_codec);
3130  if (_unknownFields != null) {
3131  _unknownFields.WriteTo(output);
3132  }
3133  #endif
3134  }
3135 
3136  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3137  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3138  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3139  if (MinLevel != 0L) {
3140  output.WriteRawTag(8);
3141  output.WriteInt64(MinLevel);
3142  }
3143  if (MaxLevel != 0L) {
3144  output.WriteRawTag(16);
3145  output.WriteInt64(MaxLevel);
3146  }
3147  times_.WriteTo(ref output, _repeated_times_codec);
3148  demands_.WriteTo(ref output, _repeated_demands_codec);
3149  actives_.WriteTo(ref output, _repeated_actives_codec);
3150  if (_unknownFields != null) {
3151  _unknownFields.WriteTo(ref output);
3152  }
3153  }
3154  #endif
3155 
3156  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3157  public int CalculateSize() {
3158  int size = 0;
3159  if (MinLevel != 0L) {
3160  size += 1 + pb::CodedOutputStream.ComputeInt64Size(MinLevel);
3161  }
3162  if (MaxLevel != 0L) {
3163  size += 1 + pb::CodedOutputStream.ComputeInt64Size(MaxLevel);
3164  }
3165  size += times_.CalculateSize(_repeated_times_codec);
3166  size += demands_.CalculateSize(_repeated_demands_codec);
3167  size += actives_.CalculateSize(_repeated_actives_codec);
3168  if (_unknownFields != null) {
3169  size += _unknownFields.CalculateSize();
3170  }
3171  return size;
3172  }
3173 
3174  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3176  if (other == null) {
3177  return;
3178  }
3179  if (other.MinLevel != 0L) {
3180  MinLevel = other.MinLevel;
3181  }
3182  if (other.MaxLevel != 0L) {
3183  MaxLevel = other.MaxLevel;
3184  }
3185  times_.Add(other.times_);
3186  demands_.Add(other.demands_);
3187  actives_.Add(other.actives_);
3188  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3189  }
3190 
3191  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3192  public void MergeFrom(pb::CodedInputStream input) {
3193  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3194  input.ReadRawMessage(this);
3195  #else
3196  uint tag;
3197  while ((tag = input.ReadTag()) != 0) {
3198  switch(tag) {
3199  default:
3200  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3201  break;
3202  case 8: {
3203  MinLevel = input.ReadInt64();
3204  break;
3205  }
3206  case 16: {
3207  MaxLevel = input.ReadInt64();
3208  break;
3209  }
3210  case 26:
3211  case 24: {
3212  times_.AddEntriesFrom(input, _repeated_times_codec);
3213  break;
3214  }
3215  case 34:
3216  case 32: {
3217  demands_.AddEntriesFrom(input, _repeated_demands_codec);
3218  break;
3219  }
3220  case 42:
3221  case 40: {
3222  actives_.AddEntriesFrom(input, _repeated_actives_codec);
3223  break;
3224  }
3225  }
3226  }
3227  #endif
3228  }
3229 
3230  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3231  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3232  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3233  uint tag;
3234  while ((tag = input.ReadTag()) != 0) {
3235  switch(tag) {
3236  default:
3237  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3238  break;
3239  case 8: {
3240  MinLevel = input.ReadInt64();
3241  break;
3242  }
3243  case 16: {
3244  MaxLevel = input.ReadInt64();
3245  break;
3246  }
3247  case 26:
3248  case 24: {
3249  times_.AddEntriesFrom(ref input, _repeated_times_codec);
3250  break;
3251  }
3252  case 34:
3253  case 32: {
3254  demands_.AddEntriesFrom(ref input, _repeated_demands_codec);
3255  break;
3256  }
3257  case 42:
3258  case 40: {
3259  actives_.AddEntriesFrom(ref input, _repeated_actives_codec);
3260  break;
3261  }
3262  }
3263  }
3264  }
3265  #endif
3266 
3267  }
3268 
3280  public sealed partial class CircuitConstraintProto : pb::IMessage<CircuitConstraintProto>
3281  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3282  , pb::IBufferMessage
3283  #endif
3284  {
3285  private static readonly pb::MessageParser<CircuitConstraintProto> _parser = new pb::MessageParser<CircuitConstraintProto>(() => new CircuitConstraintProto());
3286  private pb::UnknownFieldSet _unknownFields;
3287  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3288  public static pb::MessageParser<CircuitConstraintProto> Parser { get { return _parser; } }
3289 
3290  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3291  public static pbr::MessageDescriptor Descriptor {
3292  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[13]; }
3293  }
3294 
3295  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3296  pbr::MessageDescriptor pb::IMessage.Descriptor {
3297  get { return Descriptor; }
3298  }
3299 
3300  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3302  OnConstruction();
3303  }
3304 
3305  partial void OnConstruction();
3306 
3307  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3309  tails_ = other.tails_.Clone();
3310  heads_ = other.heads_.Clone();
3311  literals_ = other.literals_.Clone();
3312  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3313  }
3314 
3315  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3317  return new CircuitConstraintProto(this);
3318  }
3319 
3321  public const int TailsFieldNumber = 3;
3322  private static readonly pb::FieldCodec<int> _repeated_tails_codec
3323  = pb::FieldCodec.ForInt32(26);
3324  private readonly pbc::RepeatedField<int> tails_ = new pbc::RepeatedField<int>();
3325  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3326  public pbc::RepeatedField<int> Tails {
3327  get { return tails_; }
3328  }
3329 
3331  public const int HeadsFieldNumber = 4;
3332  private static readonly pb::FieldCodec<int> _repeated_heads_codec
3333  = pb::FieldCodec.ForInt32(34);
3334  private readonly pbc::RepeatedField<int> heads_ = new pbc::RepeatedField<int>();
3335  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3336  public pbc::RepeatedField<int> Heads {
3337  get { return heads_; }
3338  }
3339 
3341  public const int LiteralsFieldNumber = 5;
3342  private static readonly pb::FieldCodec<int> _repeated_literals_codec
3343  = pb::FieldCodec.ForInt32(42);
3344  private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
3345  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3346  public pbc::RepeatedField<int> Literals {
3347  get { return literals_; }
3348  }
3349 
3350  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3351  public override bool Equals(object other) {
3352  return Equals(other as CircuitConstraintProto);
3353  }
3354 
3355  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3356  public bool Equals(CircuitConstraintProto other) {
3357  if (ReferenceEquals(other, null)) {
3358  return false;
3359  }
3360  if (ReferenceEquals(other, this)) {
3361  return true;
3362  }
3363  if(!tails_.Equals(other.tails_)) return false;
3364  if(!heads_.Equals(other.heads_)) return false;
3365  if(!literals_.Equals(other.literals_)) return false;
3366  return Equals(_unknownFields, other._unknownFields);
3367  }
3368 
3369  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3370  public override int GetHashCode() {
3371  int hash = 1;
3372  hash ^= tails_.GetHashCode();
3373  hash ^= heads_.GetHashCode();
3374  hash ^= literals_.GetHashCode();
3375  if (_unknownFields != null) {
3376  hash ^= _unknownFields.GetHashCode();
3377  }
3378  return hash;
3379  }
3380 
3381  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3382  public override string ToString() {
3383  return pb::JsonFormatter.ToDiagnosticString(this);
3384  }
3385 
3386  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3387  public void WriteTo(pb::CodedOutputStream output) {
3388  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3389  output.WriteRawMessage(this);
3390  #else
3391  tails_.WriteTo(output, _repeated_tails_codec);
3392  heads_.WriteTo(output, _repeated_heads_codec);
3393  literals_.WriteTo(output, _repeated_literals_codec);
3394  if (_unknownFields != null) {
3395  _unknownFields.WriteTo(output);
3396  }
3397  #endif
3398  }
3399 
3400  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3401  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3402  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3403  tails_.WriteTo(ref output, _repeated_tails_codec);
3404  heads_.WriteTo(ref output, _repeated_heads_codec);
3405  literals_.WriteTo(ref output, _repeated_literals_codec);
3406  if (_unknownFields != null) {
3407  _unknownFields.WriteTo(ref output);
3408  }
3409  }
3410  #endif
3411 
3412  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3413  public int CalculateSize() {
3414  int size = 0;
3415  size += tails_.CalculateSize(_repeated_tails_codec);
3416  size += heads_.CalculateSize(_repeated_heads_codec);
3417  size += literals_.CalculateSize(_repeated_literals_codec);
3418  if (_unknownFields != null) {
3419  size += _unknownFields.CalculateSize();
3420  }
3421  return size;
3422  }
3423 
3424  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3425  public void MergeFrom(CircuitConstraintProto other) {
3426  if (other == null) {
3427  return;
3428  }
3429  tails_.Add(other.tails_);
3430  heads_.Add(other.heads_);
3431  literals_.Add(other.literals_);
3432  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3433  }
3434 
3435  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3436  public void MergeFrom(pb::CodedInputStream input) {
3437  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3438  input.ReadRawMessage(this);
3439  #else
3440  uint tag;
3441  while ((tag = input.ReadTag()) != 0) {
3442  switch(tag) {
3443  default:
3444  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3445  break;
3446  case 26:
3447  case 24: {
3448  tails_.AddEntriesFrom(input, _repeated_tails_codec);
3449  break;
3450  }
3451  case 34:
3452  case 32: {
3453  heads_.AddEntriesFrom(input, _repeated_heads_codec);
3454  break;
3455  }
3456  case 42:
3457  case 40: {
3458  literals_.AddEntriesFrom(input, _repeated_literals_codec);
3459  break;
3460  }
3461  }
3462  }
3463  #endif
3464  }
3465 
3466  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3467  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3468  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3469  uint tag;
3470  while ((tag = input.ReadTag()) != 0) {
3471  switch(tag) {
3472  default:
3473  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3474  break;
3475  case 26:
3476  case 24: {
3477  tails_.AddEntriesFrom(ref input, _repeated_tails_codec);
3478  break;
3479  }
3480  case 34:
3481  case 32: {
3482  heads_.AddEntriesFrom(ref input, _repeated_heads_codec);
3483  break;
3484  }
3485  case 42:
3486  case 40: {
3487  literals_.AddEntriesFrom(ref input, _repeated_literals_codec);
3488  break;
3489  }
3490  }
3491  }
3492  }
3493  #endif
3494 
3495  }
3496 
3514  public sealed partial class RoutesConstraintProto : pb::IMessage<RoutesConstraintProto>
3515  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3516  , pb::IBufferMessage
3517  #endif
3518  {
3519  private static readonly pb::MessageParser<RoutesConstraintProto> _parser = new pb::MessageParser<RoutesConstraintProto>(() => new RoutesConstraintProto());
3520  private pb::UnknownFieldSet _unknownFields;
3521  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3522  public static pb::MessageParser<RoutesConstraintProto> Parser { get { return _parser; } }
3523 
3524  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3525  public static pbr::MessageDescriptor Descriptor {
3526  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[14]; }
3527  }
3528 
3529  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3530  pbr::MessageDescriptor pb::IMessage.Descriptor {
3531  get { return Descriptor; }
3532  }
3533 
3534  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3536  OnConstruction();
3537  }
3538 
3539  partial void OnConstruction();
3540 
3541  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3543  tails_ = other.tails_.Clone();
3544  heads_ = other.heads_.Clone();
3545  literals_ = other.literals_.Clone();
3546  demands_ = other.demands_.Clone();
3547  capacity_ = other.capacity_;
3548  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3549  }
3550 
3551  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3553  return new RoutesConstraintProto(this);
3554  }
3555 
3557  public const int TailsFieldNumber = 1;
3558  private static readonly pb::FieldCodec<int> _repeated_tails_codec
3559  = pb::FieldCodec.ForInt32(10);
3560  private readonly pbc::RepeatedField<int> tails_ = new pbc::RepeatedField<int>();
3561  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3562  public pbc::RepeatedField<int> Tails {
3563  get { return tails_; }
3564  }
3565 
3567  public const int HeadsFieldNumber = 2;
3568  private static readonly pb::FieldCodec<int> _repeated_heads_codec
3569  = pb::FieldCodec.ForInt32(18);
3570  private readonly pbc::RepeatedField<int> heads_ = new pbc::RepeatedField<int>();
3571  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3572  public pbc::RepeatedField<int> Heads {
3573  get { return heads_; }
3574  }
3575 
3577  public const int LiteralsFieldNumber = 3;
3578  private static readonly pb::FieldCodec<int> _repeated_literals_codec
3579  = pb::FieldCodec.ForInt32(26);
3580  private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
3581  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3582  public pbc::RepeatedField<int> Literals {
3583  get { return literals_; }
3584  }
3585 
3587  public const int DemandsFieldNumber = 4;
3588  private static readonly pb::FieldCodec<int> _repeated_demands_codec
3589  = pb::FieldCodec.ForInt32(34);
3590  private readonly pbc::RepeatedField<int> demands_ = new pbc::RepeatedField<int>();
3602  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3603  public pbc::RepeatedField<int> Demands {
3604  get { return demands_; }
3605  }
3606 
3608  public const int CapacityFieldNumber = 5;
3609  private long capacity_;
3610  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3611  public long Capacity {
3612  get { return capacity_; }
3613  set {
3614  capacity_ = value;
3615  }
3616  }
3617 
3618  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3619  public override bool Equals(object other) {
3620  return Equals(other as RoutesConstraintProto);
3621  }
3622 
3623  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3624  public bool Equals(RoutesConstraintProto other) {
3625  if (ReferenceEquals(other, null)) {
3626  return false;
3627  }
3628  if (ReferenceEquals(other, this)) {
3629  return true;
3630  }
3631  if(!tails_.Equals(other.tails_)) return false;
3632  if(!heads_.Equals(other.heads_)) return false;
3633  if(!literals_.Equals(other.literals_)) return false;
3634  if(!demands_.Equals(other.demands_)) return false;
3635  if (Capacity != other.Capacity) return false;
3636  return Equals(_unknownFields, other._unknownFields);
3637  }
3638 
3639  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3640  public override int GetHashCode() {
3641  int hash = 1;
3642  hash ^= tails_.GetHashCode();
3643  hash ^= heads_.GetHashCode();
3644  hash ^= literals_.GetHashCode();
3645  hash ^= demands_.GetHashCode();
3646  if (Capacity != 0L) hash ^= Capacity.GetHashCode();
3647  if (_unknownFields != null) {
3648  hash ^= _unknownFields.GetHashCode();
3649  }
3650  return hash;
3651  }
3652 
3653  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3654  public override string ToString() {
3655  return pb::JsonFormatter.ToDiagnosticString(this);
3656  }
3657 
3658  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3659  public void WriteTo(pb::CodedOutputStream output) {
3660  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3661  output.WriteRawMessage(this);
3662  #else
3663  tails_.WriteTo(output, _repeated_tails_codec);
3664  heads_.WriteTo(output, _repeated_heads_codec);
3665  literals_.WriteTo(output, _repeated_literals_codec);
3666  demands_.WriteTo(output, _repeated_demands_codec);
3667  if (Capacity != 0L) {
3668  output.WriteRawTag(40);
3669  output.WriteInt64(Capacity);
3670  }
3671  if (_unknownFields != null) {
3672  _unknownFields.WriteTo(output);
3673  }
3674  #endif
3675  }
3676 
3677  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3678  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3679  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3680  tails_.WriteTo(ref output, _repeated_tails_codec);
3681  heads_.WriteTo(ref output, _repeated_heads_codec);
3682  literals_.WriteTo(ref output, _repeated_literals_codec);
3683  demands_.WriteTo(ref output, _repeated_demands_codec);
3684  if (Capacity != 0L) {
3685  output.WriteRawTag(40);
3686  output.WriteInt64(Capacity);
3687  }
3688  if (_unknownFields != null) {
3689  _unknownFields.WriteTo(ref output);
3690  }
3691  }
3692  #endif
3693 
3694  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3695  public int CalculateSize() {
3696  int size = 0;
3697  size += tails_.CalculateSize(_repeated_tails_codec);
3698  size += heads_.CalculateSize(_repeated_heads_codec);
3699  size += literals_.CalculateSize(_repeated_literals_codec);
3700  size += demands_.CalculateSize(_repeated_demands_codec);
3701  if (Capacity != 0L) {
3702  size += 1 + pb::CodedOutputStream.ComputeInt64Size(Capacity);
3703  }
3704  if (_unknownFields != null) {
3705  size += _unknownFields.CalculateSize();
3706  }
3707  return size;
3708  }
3709 
3710  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3711  public void MergeFrom(RoutesConstraintProto other) {
3712  if (other == null) {
3713  return;
3714  }
3715  tails_.Add(other.tails_);
3716  heads_.Add(other.heads_);
3717  literals_.Add(other.literals_);
3718  demands_.Add(other.demands_);
3719  if (other.Capacity != 0L) {
3720  Capacity = other.Capacity;
3721  }
3722  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3723  }
3724 
3725  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3726  public void MergeFrom(pb::CodedInputStream input) {
3727  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3728  input.ReadRawMessage(this);
3729  #else
3730  uint tag;
3731  while ((tag = input.ReadTag()) != 0) {
3732  switch(tag) {
3733  default:
3734  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3735  break;
3736  case 10:
3737  case 8: {
3738  tails_.AddEntriesFrom(input, _repeated_tails_codec);
3739  break;
3740  }
3741  case 18:
3742  case 16: {
3743  heads_.AddEntriesFrom(input, _repeated_heads_codec);
3744  break;
3745  }
3746  case 26:
3747  case 24: {
3748  literals_.AddEntriesFrom(input, _repeated_literals_codec);
3749  break;
3750  }
3751  case 34:
3752  case 32: {
3753  demands_.AddEntriesFrom(input, _repeated_demands_codec);
3754  break;
3755  }
3756  case 40: {
3757  Capacity = input.ReadInt64();
3758  break;
3759  }
3760  }
3761  }
3762  #endif
3763  }
3764 
3765  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3766  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3767  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3768  uint tag;
3769  while ((tag = input.ReadTag()) != 0) {
3770  switch(tag) {
3771  default:
3772  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3773  break;
3774  case 10:
3775  case 8: {
3776  tails_.AddEntriesFrom(ref input, _repeated_tails_codec);
3777  break;
3778  }
3779  case 18:
3780  case 16: {
3781  heads_.AddEntriesFrom(ref input, _repeated_heads_codec);
3782  break;
3783  }
3784  case 26:
3785  case 24: {
3786  literals_.AddEntriesFrom(ref input, _repeated_literals_codec);
3787  break;
3788  }
3789  case 34:
3790  case 32: {
3791  demands_.AddEntriesFrom(ref input, _repeated_demands_codec);
3792  break;
3793  }
3794  case 40: {
3795  Capacity = input.ReadInt64();
3796  break;
3797  }
3798  }
3799  }
3800  }
3801  #endif
3802 
3803  }
3804 
3810  public sealed partial class TableConstraintProto : pb::IMessage<TableConstraintProto>
3811  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3812  , pb::IBufferMessage
3813  #endif
3814  {
3815  private static readonly pb::MessageParser<TableConstraintProto> _parser = new pb::MessageParser<TableConstraintProto>(() => new TableConstraintProto());
3816  private pb::UnknownFieldSet _unknownFields;
3817  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3818  public static pb::MessageParser<TableConstraintProto> Parser { get { return _parser; } }
3819 
3820  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3821  public static pbr::MessageDescriptor Descriptor {
3822  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[15]; }
3823  }
3824 
3825  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3826  pbr::MessageDescriptor pb::IMessage.Descriptor {
3827  get { return Descriptor; }
3828  }
3829 
3830  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3832  OnConstruction();
3833  }
3834 
3835  partial void OnConstruction();
3836 
3837  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3839  vars_ = other.vars_.Clone();
3840  values_ = other.values_.Clone();
3841  negated_ = other.negated_;
3842  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3843  }
3844 
3845  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3847  return new TableConstraintProto(this);
3848  }
3849 
3851  public const int VarsFieldNumber = 1;
3852  private static readonly pb::FieldCodec<int> _repeated_vars_codec
3853  = pb::FieldCodec.ForInt32(10);
3854  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
3855  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3856  public pbc::RepeatedField<int> Vars {
3857  get { return vars_; }
3858  }
3859 
3861  public const int ValuesFieldNumber = 2;
3862  private static readonly pb::FieldCodec<long> _repeated_values_codec
3863  = pb::FieldCodec.ForInt64(18);
3864  private readonly pbc::RepeatedField<long> values_ = new pbc::RepeatedField<long>();
3865  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3866  public pbc::RepeatedField<long> Values {
3867  get { return values_; }
3868  }
3869 
3871  public const int NegatedFieldNumber = 3;
3872  private bool negated_;
3877  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3878  public bool Negated {
3879  get { return negated_; }
3880  set {
3881  negated_ = value;
3882  }
3883  }
3884 
3885  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3886  public override bool Equals(object other) {
3887  return Equals(other as TableConstraintProto);
3888  }
3889 
3890  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3891  public bool Equals(TableConstraintProto other) {
3892  if (ReferenceEquals(other, null)) {
3893  return false;
3894  }
3895  if (ReferenceEquals(other, this)) {
3896  return true;
3897  }
3898  if(!vars_.Equals(other.vars_)) return false;
3899  if(!values_.Equals(other.values_)) return false;
3900  if (Negated != other.Negated) return false;
3901  return Equals(_unknownFields, other._unknownFields);
3902  }
3903 
3904  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3905  public override int GetHashCode() {
3906  int hash = 1;
3907  hash ^= vars_.GetHashCode();
3908  hash ^= values_.GetHashCode();
3909  if (Negated != false) hash ^= Negated.GetHashCode();
3910  if (_unknownFields != null) {
3911  hash ^= _unknownFields.GetHashCode();
3912  }
3913  return hash;
3914  }
3915 
3916  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3917  public override string ToString() {
3918  return pb::JsonFormatter.ToDiagnosticString(this);
3919  }
3920 
3921  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3922  public void WriteTo(pb::CodedOutputStream output) {
3923  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3924  output.WriteRawMessage(this);
3925  #else
3926  vars_.WriteTo(output, _repeated_vars_codec);
3927  values_.WriteTo(output, _repeated_values_codec);
3928  if (Negated != false) {
3929  output.WriteRawTag(24);
3930  output.WriteBool(Negated);
3931  }
3932  if (_unknownFields != null) {
3933  _unknownFields.WriteTo(output);
3934  }
3935  #endif
3936  }
3937 
3938  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3939  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3940  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3941  vars_.WriteTo(ref output, _repeated_vars_codec);
3942  values_.WriteTo(ref output, _repeated_values_codec);
3943  if (Negated != false) {
3944  output.WriteRawTag(24);
3945  output.WriteBool(Negated);
3946  }
3947  if (_unknownFields != null) {
3948  _unknownFields.WriteTo(ref output);
3949  }
3950  }
3951  #endif
3952 
3953  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3954  public int CalculateSize() {
3955  int size = 0;
3956  size += vars_.CalculateSize(_repeated_vars_codec);
3957  size += values_.CalculateSize(_repeated_values_codec);
3958  if (Negated != false) {
3959  size += 1 + 1;
3960  }
3961  if (_unknownFields != null) {
3962  size += _unknownFields.CalculateSize();
3963  }
3964  return size;
3965  }
3966 
3967  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3968  public void MergeFrom(TableConstraintProto other) {
3969  if (other == null) {
3970  return;
3971  }
3972  vars_.Add(other.vars_);
3973  values_.Add(other.values_);
3974  if (other.Negated != false) {
3975  Negated = other.Negated;
3976  }
3977  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3978  }
3979 
3980  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3981  public void MergeFrom(pb::CodedInputStream input) {
3982  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3983  input.ReadRawMessage(this);
3984  #else
3985  uint tag;
3986  while ((tag = input.ReadTag()) != 0) {
3987  switch(tag) {
3988  default:
3989  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3990  break;
3991  case 10:
3992  case 8: {
3993  vars_.AddEntriesFrom(input, _repeated_vars_codec);
3994  break;
3995  }
3996  case 18:
3997  case 16: {
3998  values_.AddEntriesFrom(input, _repeated_values_codec);
3999  break;
4000  }
4001  case 24: {
4002  Negated = input.ReadBool();
4003  break;
4004  }
4005  }
4006  }
4007  #endif
4008  }
4009 
4010  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4011  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4012  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
4013  uint tag;
4014  while ((tag = input.ReadTag()) != 0) {
4015  switch(tag) {
4016  default:
4017  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
4018  break;
4019  case 10:
4020  case 8: {
4021  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
4022  break;
4023  }
4024  case 18:
4025  case 16: {
4026  values_.AddEntriesFrom(ref input, _repeated_values_codec);
4027  break;
4028  }
4029  case 24: {
4030  Negated = input.ReadBool();
4031  break;
4032  }
4033  }
4034  }
4035  }
4036  #endif
4037 
4038  }
4039 
4044  public sealed partial class InverseConstraintProto : pb::IMessage<InverseConstraintProto>
4045  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4046  , pb::IBufferMessage
4047  #endif
4048  {
4049  private static readonly pb::MessageParser<InverseConstraintProto> _parser = new pb::MessageParser<InverseConstraintProto>(() => new InverseConstraintProto());
4050  private pb::UnknownFieldSet _unknownFields;
4051  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4052  public static pb::MessageParser<InverseConstraintProto> Parser { get { return _parser; } }
4053 
4054  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4055  public static pbr::MessageDescriptor Descriptor {
4056  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[16]; }
4057  }
4058 
4059  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4060  pbr::MessageDescriptor pb::IMessage.Descriptor {
4061  get { return Descriptor; }
4062  }
4063 
4064  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4066  OnConstruction();
4067  }
4068 
4069  partial void OnConstruction();
4070 
4071  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4073  fDirect_ = other.fDirect_.Clone();
4074  fInverse_ = other.fInverse_.Clone();
4075  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4076  }
4077 
4078  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4080  return new InverseConstraintProto(this);
4081  }
4082 
4084  public const int FDirectFieldNumber = 1;
4085  private static readonly pb::FieldCodec<int> _repeated_fDirect_codec
4086  = pb::FieldCodec.ForInt32(10);
4087  private readonly pbc::RepeatedField<int> fDirect_ = new pbc::RepeatedField<int>();
4088  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4089  public pbc::RepeatedField<int> FDirect {
4090  get { return fDirect_; }
4091  }
4092 
4094  public const int FInverseFieldNumber = 2;
4095  private static readonly pb::FieldCodec<int> _repeated_fInverse_codec
4096  = pb::FieldCodec.ForInt32(18);
4097  private readonly pbc::RepeatedField<int> fInverse_ = new pbc::RepeatedField<int>();
4098  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4099  public pbc::RepeatedField<int> FInverse {
4100  get { return fInverse_; }
4101  }
4102 
4103  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4104  public override bool Equals(object other) {
4105  return Equals(other as InverseConstraintProto);
4106  }
4107 
4108  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4109  public bool Equals(InverseConstraintProto other) {
4110  if (ReferenceEquals(other, null)) {
4111  return false;
4112  }
4113  if (ReferenceEquals(other, this)) {
4114  return true;
4115  }
4116  if(!fDirect_.Equals(other.fDirect_)) return false;
4117  if(!fInverse_.Equals(other.fInverse_)) return false;
4118  return Equals(_unknownFields, other._unknownFields);
4119  }
4120 
4121  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4122  public override int GetHashCode() {
4123  int hash = 1;
4124  hash ^= fDirect_.GetHashCode();
4125  hash ^= fInverse_.GetHashCode();
4126  if (_unknownFields != null) {
4127  hash ^= _unknownFields.GetHashCode();
4128  }
4129  return hash;
4130  }
4131 
4132  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4133  public override string ToString() {
4134  return pb::JsonFormatter.ToDiagnosticString(this);
4135  }
4136 
4137  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4138  public void WriteTo(pb::CodedOutputStream output) {
4139  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4140  output.WriteRawMessage(this);
4141  #else
4142  fDirect_.WriteTo(output, _repeated_fDirect_codec);
4143  fInverse_.WriteTo(output, _repeated_fInverse_codec);
4144  if (_unknownFields != null) {
4145  _unknownFields.WriteTo(output);
4146  }
4147  #endif
4148  }
4149 
4150  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4151  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4152  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
4153  fDirect_.WriteTo(ref output, _repeated_fDirect_codec);
4154  fInverse_.WriteTo(ref output, _repeated_fInverse_codec);
4155  if (_unknownFields != null) {
4156  _unknownFields.WriteTo(ref output);
4157  }
4158  }
4159  #endif
4160 
4161  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4162  public int CalculateSize() {
4163  int size = 0;
4164  size += fDirect_.CalculateSize(_repeated_fDirect_codec);
4165  size += fInverse_.CalculateSize(_repeated_fInverse_codec);
4166  if (_unknownFields != null) {
4167  size += _unknownFields.CalculateSize();
4168  }
4169  return size;
4170  }
4171 
4172  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4173  public void MergeFrom(InverseConstraintProto other) {
4174  if (other == null) {
4175  return;
4176  }
4177  fDirect_.Add(other.fDirect_);
4178  fInverse_.Add(other.fInverse_);
4179  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
4180  }
4181 
4182  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4183  public void MergeFrom(pb::CodedInputStream input) {
4184  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4185  input.ReadRawMessage(this);
4186  #else
4187  uint tag;
4188  while ((tag = input.ReadTag()) != 0) {
4189  switch(tag) {
4190  default:
4191  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
4192  break;
4193  case 10:
4194  case 8: {
4195  fDirect_.AddEntriesFrom(input, _repeated_fDirect_codec);
4196  break;
4197  }
4198  case 18:
4199  case 16: {
4200  fInverse_.AddEntriesFrom(input, _repeated_fInverse_codec);
4201  break;
4202  }
4203  }
4204  }
4205  #endif
4206  }
4207 
4208  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4209  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4210  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
4211  uint tag;
4212  while ((tag = input.ReadTag()) != 0) {
4213  switch(tag) {
4214  default:
4215  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
4216  break;
4217  case 10:
4218  case 8: {
4219  fDirect_.AddEntriesFrom(ref input, _repeated_fDirect_codec);
4220  break;
4221  }
4222  case 18:
4223  case 16: {
4224  fInverse_.AddEntriesFrom(ref input, _repeated_fInverse_codec);
4225  break;
4226  }
4227  }
4228  }
4229  }
4230  #endif
4231 
4232  }
4233 
4238  public sealed partial class AutomatonConstraintProto : pb::IMessage<AutomatonConstraintProto>
4239  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4240  , pb::IBufferMessage
4241  #endif
4242  {
4243  private static readonly pb::MessageParser<AutomatonConstraintProto> _parser = new pb::MessageParser<AutomatonConstraintProto>(() => new AutomatonConstraintProto());
4244  private pb::UnknownFieldSet _unknownFields;
4245  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4246  public static pb::MessageParser<AutomatonConstraintProto> Parser { get { return _parser; } }
4247 
4248  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4249  public static pbr::MessageDescriptor Descriptor {
4250  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[17]; }
4251  }
4252 
4253  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4254  pbr::MessageDescriptor pb::IMessage.Descriptor {
4255  get { return Descriptor; }
4256  }
4257 
4258  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4260  OnConstruction();
4261  }
4262 
4263  partial void OnConstruction();
4264 
4265  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4267  startingState_ = other.startingState_;
4268  finalStates_ = other.finalStates_.Clone();
4269  transitionTail_ = other.transitionTail_.Clone();
4270  transitionHead_ = other.transitionHead_.Clone();
4271  transitionLabel_ = other.transitionLabel_.Clone();
4272  vars_ = other.vars_.Clone();
4273  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4274  }
4275 
4276  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4278  return new AutomatonConstraintProto(this);
4279  }
4280 
4282  public const int StartingStateFieldNumber = 2;
4283  private long startingState_;
4289  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4290  public long StartingState {
4291  get { return startingState_; }
4292  set {
4293  startingState_ = value;
4294  }
4295  }
4296 
4298  public const int FinalStatesFieldNumber = 3;
4299  private static readonly pb::FieldCodec<long> _repeated_finalStates_codec
4300  = pb::FieldCodec.ForInt64(26);
4301  private readonly pbc::RepeatedField<long> finalStates_ = new pbc::RepeatedField<long>();
4302  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4303  public pbc::RepeatedField<long> FinalStates {
4304  get { return finalStates_; }
4305  }
4306 
4308  public const int TransitionTailFieldNumber = 4;
4309  private static readonly pb::FieldCodec<long> _repeated_transitionTail_codec
4310  = pb::FieldCodec.ForInt64(34);
4311  private readonly pbc::RepeatedField<long> transitionTail_ = new pbc::RepeatedField<long>();
4317  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4318  public pbc::RepeatedField<long> TransitionTail {
4319  get { return transitionTail_; }
4320  }
4321 
4323  public const int TransitionHeadFieldNumber = 5;
4324  private static readonly pb::FieldCodec<long> _repeated_transitionHead_codec
4325  = pb::FieldCodec.ForInt64(42);
4326  private readonly pbc::RepeatedField<long> transitionHead_ = new pbc::RepeatedField<long>();
4327  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4328  public pbc::RepeatedField<long> TransitionHead {
4329  get { return transitionHead_; }
4330  }
4331 
4333  public const int TransitionLabelFieldNumber = 6;
4334  private static readonly pb::FieldCodec<long> _repeated_transitionLabel_codec
4335  = pb::FieldCodec.ForInt64(50);
4336  private readonly pbc::RepeatedField<long> transitionLabel_ = new pbc::RepeatedField<long>();
4337  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4338  public pbc::RepeatedField<long> TransitionLabel {
4339  get { return transitionLabel_; }
4340  }
4341 
4343  public const int VarsFieldNumber = 7;
4344  private static readonly pb::FieldCodec<int> _repeated_vars_codec
4345  = pb::FieldCodec.ForInt32(58);
4346  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
4351  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4352  public pbc::RepeatedField<int> Vars {
4353  get { return vars_; }
4354  }
4355 
4356  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4357  public override bool Equals(object other) {
4358  return Equals(other as AutomatonConstraintProto);
4359  }
4360 
4361  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4362  public bool Equals(AutomatonConstraintProto other) {
4363  if (ReferenceEquals(other, null)) {
4364  return false;
4365  }
4366  if (ReferenceEquals(other, this)) {
4367  return true;
4368  }
4369  if (StartingState != other.StartingState) return false;
4370  if(!finalStates_.Equals(other.finalStates_)) return false;
4371  if(!transitionTail_.Equals(other.transitionTail_)) return false;
4372  if(!transitionHead_.Equals(other.transitionHead_)) return false;
4373  if(!transitionLabel_.Equals(other.transitionLabel_)) return false;
4374  if(!vars_.Equals(other.vars_)) return false;
4375  return Equals(_unknownFields, other._unknownFields);
4376  }
4377 
4378  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4379  public override int GetHashCode() {
4380  int hash = 1;
4381  if (StartingState != 0L) hash ^= StartingState.GetHashCode();
4382  hash ^= finalStates_.GetHashCode();
4383  hash ^= transitionTail_.GetHashCode();
4384  hash ^= transitionHead_.GetHashCode();
4385  hash ^= transitionLabel_.GetHashCode();
4386  hash ^= vars_.GetHashCode();
4387  if (_unknownFields != null) {
4388  hash ^= _unknownFields.GetHashCode();
4389  }
4390  return hash;
4391  }
4392 
4393  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4394  public override string ToString() {
4395  return pb::JsonFormatter.ToDiagnosticString(this);
4396  }
4397 
4398  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4399  public void WriteTo(pb::CodedOutputStream output) {
4400  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4401  output.WriteRawMessage(this);
4402  #else
4403  if (StartingState != 0L) {
4404  output.WriteRawTag(16);
4405  output.WriteInt64(StartingState);
4406  }
4407  finalStates_.WriteTo(output, _repeated_finalStates_codec);
4408  transitionTail_.WriteTo(output, _repeated_transitionTail_codec);
4409  transitionHead_.WriteTo(output, _repeated_transitionHead_codec);
4410  transitionLabel_.WriteTo(output, _repeated_transitionLabel_codec);
4411  vars_.WriteTo(output, _repeated_vars_codec);
4412  if (_unknownFields != null) {
4413  _unknownFields.WriteTo(output);
4414  }
4415  #endif
4416  }
4417 
4418  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4419  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4420  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
4421  if (StartingState != 0L) {
4422  output.WriteRawTag(16);
4423  output.WriteInt64(StartingState);
4424  }
4425  finalStates_.WriteTo(ref output, _repeated_finalStates_codec);
4426  transitionTail_.WriteTo(ref output, _repeated_transitionTail_codec);
4427  transitionHead_.WriteTo(ref output, _repeated_transitionHead_codec);
4428  transitionLabel_.WriteTo(ref output, _repeated_transitionLabel_codec);
4429  vars_.WriteTo(ref output, _repeated_vars_codec);
4430  if (_unknownFields != null) {
4431  _unknownFields.WriteTo(ref output);
4432  }
4433  }
4434  #endif
4435 
4436  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4437  public int CalculateSize() {
4438  int size = 0;
4439  if (StartingState != 0L) {
4440  size += 1 + pb::CodedOutputStream.ComputeInt64Size(StartingState);
4441  }
4442  size += finalStates_.CalculateSize(_repeated_finalStates_codec);
4443  size += transitionTail_.CalculateSize(_repeated_transitionTail_codec);
4444  size += transitionHead_.CalculateSize(_repeated_transitionHead_codec);
4445  size += transitionLabel_.CalculateSize(_repeated_transitionLabel_codec);
4446  size += vars_.CalculateSize(_repeated_vars_codec);
4447  if (_unknownFields != null) {
4448  size += _unknownFields.CalculateSize();
4449  }
4450  return size;
4451  }
4452 
4453  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4455  if (other == null) {
4456  return;
4457  }
4458  if (other.StartingState != 0L) {
4459  StartingState = other.StartingState;
4460  }
4461  finalStates_.Add(other.finalStates_);
4462  transitionTail_.Add(other.transitionTail_);
4463  transitionHead_.Add(other.transitionHead_);
4464  transitionLabel_.Add(other.transitionLabel_);
4465  vars_.Add(other.vars_);
4466  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
4467  }
4468 
4469  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4470  public void MergeFrom(pb::CodedInputStream input) {
4471  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4472  input.ReadRawMessage(this);
4473  #else
4474  uint tag;
4475  while ((tag = input.ReadTag()) != 0) {
4476  switch(tag) {
4477  default:
4478  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
4479  break;
4480  case 16: {
4481  StartingState = input.ReadInt64();
4482  break;
4483  }
4484  case 26:
4485  case 24: {
4486  finalStates_.AddEntriesFrom(input, _repeated_finalStates_codec);
4487  break;
4488  }
4489  case 34:
4490  case 32: {
4491  transitionTail_.AddEntriesFrom(input, _repeated_transitionTail_codec);
4492  break;
4493  }
4494  case 42:
4495  case 40: {
4496  transitionHead_.AddEntriesFrom(input, _repeated_transitionHead_codec);
4497  break;
4498  }
4499  case 50:
4500  case 48: {
4501  transitionLabel_.AddEntriesFrom(input, _repeated_transitionLabel_codec);
4502  break;
4503  }
4504  case 58:
4505  case 56: {
4506  vars_.AddEntriesFrom(input, _repeated_vars_codec);
4507  break;
4508  }
4509  }
4510  }
4511  #endif
4512  }
4513 
4514  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4515  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4516  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
4517  uint tag;
4518  while ((tag = input.ReadTag()) != 0) {
4519  switch(tag) {
4520  default:
4521  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
4522  break;
4523  case 16: {
4524  StartingState = input.ReadInt64();
4525  break;
4526  }
4527  case 26:
4528  case 24: {
4529  finalStates_.AddEntriesFrom(ref input, _repeated_finalStates_codec);
4530  break;
4531  }
4532  case 34:
4533  case 32: {
4534  transitionTail_.AddEntriesFrom(ref input, _repeated_transitionTail_codec);
4535  break;
4536  }
4537  case 42:
4538  case 40: {
4539  transitionHead_.AddEntriesFrom(ref input, _repeated_transitionHead_codec);
4540  break;
4541  }
4542  case 50:
4543  case 48: {
4544  transitionLabel_.AddEntriesFrom(ref input, _repeated_transitionLabel_codec);
4545  break;
4546  }
4547  case 58:
4548  case 56: {
4549  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
4550  break;
4551  }
4552  }
4553  }
4554  }
4555  #endif
4556 
4557  }
4558 
4562  public sealed partial class ConstraintProto : pb::IMessage<ConstraintProto>
4563  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4564  , pb::IBufferMessage
4565  #endif
4566  {
4567  private static readonly pb::MessageParser<ConstraintProto> _parser = new pb::MessageParser<ConstraintProto>(() => new ConstraintProto());
4568  private pb::UnknownFieldSet _unknownFields;
4569  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4570  public static pb::MessageParser<ConstraintProto> Parser { get { return _parser; } }
4571 
4572  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4573  public static pbr::MessageDescriptor Descriptor {
4574  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[18]; }
4575  }
4576 
4577  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4578  pbr::MessageDescriptor pb::IMessage.Descriptor {
4579  get { return Descriptor; }
4580  }
4581 
4582  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4583  public ConstraintProto() {
4584  OnConstruction();
4585  }
4586 
4587  partial void OnConstruction();
4588 
4589  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4590  public ConstraintProto(ConstraintProto other) : this() {
4591  name_ = other.name_;
4592  enforcementLiteral_ = other.enforcementLiteral_.Clone();
4593  switch (other.ConstraintCase) {
4594  case ConstraintOneofCase.BoolOr:
4595  BoolOr = other.BoolOr.Clone();
4596  break;
4597  case ConstraintOneofCase.BoolAnd:
4598  BoolAnd = other.BoolAnd.Clone();
4599  break;
4600  case ConstraintOneofCase.AtMostOne:
4601  AtMostOne = other.AtMostOne.Clone();
4602  break;
4603  case ConstraintOneofCase.ExactlyOne:
4604  ExactlyOne = other.ExactlyOne.Clone();
4605  break;
4606  case ConstraintOneofCase.BoolXor:
4607  BoolXor = other.BoolXor.Clone();
4608  break;
4609  case ConstraintOneofCase.IntDiv:
4610  IntDiv = other.IntDiv.Clone();
4611  break;
4612  case ConstraintOneofCase.IntMod:
4613  IntMod = other.IntMod.Clone();
4614  break;
4615  case ConstraintOneofCase.IntMax:
4616  IntMax = other.IntMax.Clone();
4617  break;
4618  case ConstraintOneofCase.LinMax:
4619  LinMax = other.LinMax.Clone();
4620  break;
4621  case ConstraintOneofCase.IntMin:
4622  IntMin = other.IntMin.Clone();
4623  break;
4624  case ConstraintOneofCase.LinMin:
4625  LinMin = other.LinMin.Clone();
4626  break;
4627  case ConstraintOneofCase.IntProd:
4628  IntProd = other.IntProd.Clone();
4629  break;
4630  case ConstraintOneofCase.Linear:
4631  Linear = other.Linear.Clone();
4632  break;
4633  case ConstraintOneofCase.AllDiff:
4634  AllDiff = other.AllDiff.Clone();
4635  break;
4636  case ConstraintOneofCase.Element:
4637  Element = other.Element.Clone();
4638  break;
4639  case ConstraintOneofCase.Circuit:
4640  Circuit = other.Circuit.Clone();
4641  break;
4642  case ConstraintOneofCase.Routes:
4643  Routes = other.Routes.Clone();
4644  break;
4645  case ConstraintOneofCase.Table:
4646  Table = other.Table.Clone();
4647  break;
4648  case ConstraintOneofCase.Automaton:
4649  Automaton = other.Automaton.Clone();
4650  break;
4651  case ConstraintOneofCase.Inverse:
4652  Inverse = other.Inverse.Clone();
4653  break;
4654  case ConstraintOneofCase.Reservoir:
4655  Reservoir = other.Reservoir.Clone();
4656  break;
4657  case ConstraintOneofCase.Interval:
4658  Interval = other.Interval.Clone();
4659  break;
4660  case ConstraintOneofCase.NoOverlap:
4661  NoOverlap = other.NoOverlap.Clone();
4662  break;
4663  case ConstraintOneofCase.NoOverlap2D:
4664  NoOverlap2D = other.NoOverlap2D.Clone();
4665  break;
4666  case ConstraintOneofCase.Cumulative:
4667  Cumulative = other.Cumulative.Clone();
4668  break;
4669  }
4670 
4671  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4672  }
4673 
4674  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4676  return new ConstraintProto(this);
4677  }
4678 
4680  public const int NameFieldNumber = 1;
4681  private string name_ = "";
4685  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4686  public string Name {
4687  get { return name_; }
4688  set {
4689  name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
4690  }
4691  }
4692 
4694  public const int EnforcementLiteralFieldNumber = 2;
4695  private static readonly pb::FieldCodec<int> _repeated_enforcementLiteral_codec
4696  = pb::FieldCodec.ForInt32(18);
4697  private readonly pbc::RepeatedField<int> enforcementLiteral_ = new pbc::RepeatedField<int>();
4714  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4715  public pbc::RepeatedField<int> EnforcementLiteral {
4716  get { return enforcementLiteral_; }
4717  }
4718 
4720  public const int BoolOrFieldNumber = 3;
4724  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4725  public global::Google.OrTools.Sat.BoolArgumentProto BoolOr {
4726  get { return constraintCase_ == ConstraintOneofCase.BoolOr ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4727  set {
4728  constraint_ = value;
4729  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolOr;
4730  }
4731  }
4732 
4734  public const int BoolAndFieldNumber = 4;
4742  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4743  public global::Google.OrTools.Sat.BoolArgumentProto BoolAnd {
4744  get { return constraintCase_ == ConstraintOneofCase.BoolAnd ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4745  set {
4746  constraint_ = value;
4747  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolAnd;
4748  }
4749  }
4750 
4752  public const int AtMostOneFieldNumber = 26;
4766  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4767  public global::Google.OrTools.Sat.BoolArgumentProto AtMostOne {
4768  get { return constraintCase_ == ConstraintOneofCase.AtMostOne ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4769  set {
4770  constraint_ = value;
4771  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.AtMostOne;
4772  }
4773  }
4774 
4776  public const int ExactlyOneFieldNumber = 29;
4791  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4792  public global::Google.OrTools.Sat.BoolArgumentProto ExactlyOne {
4793  get { return constraintCase_ == ConstraintOneofCase.ExactlyOne ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4794  set {
4795  constraint_ = value;
4796  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.ExactlyOne;
4797  }
4798  }
4799 
4801  public const int BoolXorFieldNumber = 5;
4805  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4806  public global::Google.OrTools.Sat.BoolArgumentProto BoolXor {
4807  get { return constraintCase_ == ConstraintOneofCase.BoolXor ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4808  set {
4809  constraint_ = value;
4810  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolXor;
4811  }
4812  }
4813 
4815  public const int IntDivFieldNumber = 7;
4820  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4821  public global::Google.OrTools.Sat.IntegerArgumentProto IntDiv {
4822  get { return constraintCase_ == ConstraintOneofCase.IntDiv ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4823  set {
4824  constraint_ = value;
4825  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntDiv;
4826  }
4827  }
4828 
4830  public const int IntModFieldNumber = 8;
4835  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4836  public global::Google.OrTools.Sat.IntegerArgumentProto IntMod {
4837  get { return constraintCase_ == ConstraintOneofCase.IntMod ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4838  set {
4839  constraint_ = value;
4840  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMod;
4841  }
4842  }
4843 
4845  public const int IntMaxFieldNumber = 9;
4855  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4856  public global::Google.OrTools.Sat.IntegerArgumentProto IntMax {
4857  get { return constraintCase_ == ConstraintOneofCase.IntMax ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4858  set {
4859  constraint_ = value;
4860  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMax;
4861  }
4862  }
4863 
4865  public const int LinMaxFieldNumber = 27;
4866  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4867  public global::Google.OrTools.Sat.LinearArgumentProto LinMax {
4868  get { return constraintCase_ == ConstraintOneofCase.LinMax ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ : null; }
4869  set {
4870  constraint_ = value;
4871  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.LinMax;
4872  }
4873  }
4874 
4876  public const int IntMinFieldNumber = 10;
4886  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4887  public global::Google.OrTools.Sat.IntegerArgumentProto IntMin {
4888  get { return constraintCase_ == ConstraintOneofCase.IntMin ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4889  set {
4890  constraint_ = value;
4891  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMin;
4892  }
4893  }
4894 
4896  public const int LinMinFieldNumber = 28;
4897  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4898  public global::Google.OrTools.Sat.LinearArgumentProto LinMin {
4899  get { return constraintCase_ == ConstraintOneofCase.LinMin ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ : null; }
4900  set {
4901  constraint_ = value;
4902  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.LinMin;
4903  }
4904  }
4905 
4907  public const int IntProdFieldNumber = 11;
4915  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4916  public global::Google.OrTools.Sat.IntegerArgumentProto IntProd {
4917  get { return constraintCase_ == ConstraintOneofCase.IntProd ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4918  set {
4919  constraint_ = value;
4920  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntProd;
4921  }
4922  }
4923 
4925  public const int LinearFieldNumber = 12;
4930  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4931  public global::Google.OrTools.Sat.LinearConstraintProto Linear {
4932  get { return constraintCase_ == ConstraintOneofCase.Linear ? (global::Google.OrTools.Sat.LinearConstraintProto) constraint_ : null; }
4933  set {
4934  constraint_ = value;
4935  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Linear;
4936  }
4937  }
4938 
4940  public const int AllDiffFieldNumber = 13;
4944  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4945  public global::Google.OrTools.Sat.AllDifferentConstraintProto AllDiff {
4946  get { return constraintCase_ == ConstraintOneofCase.AllDiff ? (global::Google.OrTools.Sat.AllDifferentConstraintProto) constraint_ : null; }
4947  set {
4948  constraint_ = value;
4949  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.AllDiff;
4950  }
4951  }
4952 
4954  public const int ElementFieldNumber = 14;
4959  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4960  public global::Google.OrTools.Sat.ElementConstraintProto Element {
4961  get { return constraintCase_ == ConstraintOneofCase.Element ? (global::Google.OrTools.Sat.ElementConstraintProto) constraint_ : null; }
4962  set {
4963  constraint_ = value;
4964  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Element;
4965  }
4966  }
4967 
4969  public const int CircuitFieldNumber = 15;
4974  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4975  public global::Google.OrTools.Sat.CircuitConstraintProto Circuit {
4976  get { return constraintCase_ == ConstraintOneofCase.Circuit ? (global::Google.OrTools.Sat.CircuitConstraintProto) constraint_ : null; }
4977  set {
4978  constraint_ = value;
4979  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Circuit;
4980  }
4981  }
4982 
4984  public const int RoutesFieldNumber = 23;
4988  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4989  public global::Google.OrTools.Sat.RoutesConstraintProto Routes {
4990  get { return constraintCase_ == ConstraintOneofCase.Routes ? (global::Google.OrTools.Sat.RoutesConstraintProto) constraint_ : null; }
4991  set {
4992  constraint_ = value;
4993  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Routes;
4994  }
4995  }
4996 
4998  public const int TableFieldNumber = 16;
5003  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5004  public global::Google.OrTools.Sat.TableConstraintProto Table {
5005  get { return constraintCase_ == ConstraintOneofCase.Table ? (global::Google.OrTools.Sat.TableConstraintProto) constraint_ : null; }
5006  set {
5007  constraint_ = value;
5008  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Table;
5009  }
5010  }
5011 
5013  public const int AutomatonFieldNumber = 17;
5018  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5019  public global::Google.OrTools.Sat.AutomatonConstraintProto Automaton {
5020  get { return constraintCase_ == ConstraintOneofCase.Automaton ? (global::Google.OrTools.Sat.AutomatonConstraintProto) constraint_ : null; }
5021  set {
5022  constraint_ = value;
5023  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Automaton;
5024  }
5025  }
5026 
5028  public const int InverseFieldNumber = 18;
5033  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5034  public global::Google.OrTools.Sat.InverseConstraintProto Inverse {
5035  get { return constraintCase_ == ConstraintOneofCase.Inverse ? (global::Google.OrTools.Sat.InverseConstraintProto) constraint_ : null; }
5036  set {
5037  constraint_ = value;
5038  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Inverse;
5039  }
5040  }
5041 
5043  public const int ReservoirFieldNumber = 24;
5049  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5050  public global::Google.OrTools.Sat.ReservoirConstraintProto Reservoir {
5051  get { return constraintCase_ == ConstraintOneofCase.Reservoir ? (global::Google.OrTools.Sat.ReservoirConstraintProto) constraint_ : null; }
5052  set {
5053  constraint_ = value;
5054  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Reservoir;
5055  }
5056  }
5057 
5059  public const int IntervalFieldNumber = 19;
5064  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5065  public global::Google.OrTools.Sat.IntervalConstraintProto Interval {
5066  get { return constraintCase_ == ConstraintOneofCase.Interval ? (global::Google.OrTools.Sat.IntervalConstraintProto) constraint_ : null; }
5067  set {
5068  constraint_ = value;
5069  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Interval;
5070  }
5071  }
5072 
5074  public const int NoOverlapFieldNumber = 20;
5080  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5081  public global::Google.OrTools.Sat.NoOverlapConstraintProto NoOverlap {
5082  get { return constraintCase_ == ConstraintOneofCase.NoOverlap ? (global::Google.OrTools.Sat.NoOverlapConstraintProto) constraint_ : null; }
5083  set {
5084  constraint_ = value;
5085  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.NoOverlap;
5086  }
5087  }
5088 
5090  public const int NoOverlap2DFieldNumber = 21;
5094  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5095  public global::Google.OrTools.Sat.NoOverlap2DConstraintProto NoOverlap2D {
5096  get { return constraintCase_ == ConstraintOneofCase.NoOverlap2D ? (global::Google.OrTools.Sat.NoOverlap2DConstraintProto) constraint_ : null; }
5097  set {
5098  constraint_ = value;
5099  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.NoOverlap2D;
5100  }
5101  }
5102 
5104  public const int CumulativeFieldNumber = 22;
5110  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5111  public global::Google.OrTools.Sat.CumulativeConstraintProto Cumulative {
5112  get { return constraintCase_ == ConstraintOneofCase.Cumulative ? (global::Google.OrTools.Sat.CumulativeConstraintProto) constraint_ : null; }
5113  set {
5114  constraint_ = value;
5115  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Cumulative;
5116  }
5117  }
5118 
5119  private object constraint_;
5121  public enum ConstraintOneofCase {
5122  None = 0,
5123  BoolOr = 3,
5124  BoolAnd = 4,
5125  AtMostOne = 26,
5126  ExactlyOne = 29,
5127  BoolXor = 5,
5128  IntDiv = 7,
5129  IntMod = 8,
5130  IntMax = 9,
5131  LinMax = 27,
5132  IntMin = 10,
5133  LinMin = 28,
5134  IntProd = 11,
5135  Linear = 12,
5136  AllDiff = 13,
5137  Element = 14,
5138  Circuit = 15,
5139  Routes = 23,
5140  Table = 16,
5141  Automaton = 17,
5142  Inverse = 18,
5143  Reservoir = 24,
5144  Interval = 19,
5145  NoOverlap = 20,
5146  NoOverlap2D = 21,
5147  Cumulative = 22,
5148  }
5149  private ConstraintOneofCase constraintCase_ = ConstraintOneofCase.None;
5150  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5151  public ConstraintOneofCase ConstraintCase {
5152  get { return constraintCase_; }
5153  }
5154 
5155  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5156  public void ClearConstraint() {
5157  constraintCase_ = ConstraintOneofCase.None;
5158  constraint_ = null;
5159  }
5160 
5161  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5162  public override bool Equals(object other) {
5163  return Equals(other as ConstraintProto);
5164  }
5165 
5166  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5167  public bool Equals(ConstraintProto other) {
5168  if (ReferenceEquals(other, null)) {
5169  return false;
5170  }
5171  if (ReferenceEquals(other, this)) {
5172  return true;
5173  }
5174  if (Name != other.Name) return false;
5175  if(!enforcementLiteral_.Equals(other.enforcementLiteral_)) return false;
5176  if (!object.Equals(BoolOr, other.BoolOr)) return false;
5177  if (!object.Equals(BoolAnd, other.BoolAnd)) return false;
5178  if (!object.Equals(AtMostOne, other.AtMostOne)) return false;
5179  if (!object.Equals(ExactlyOne, other.ExactlyOne)) return false;
5180  if (!object.Equals(BoolXor, other.BoolXor)) return false;
5181  if (!object.Equals(IntDiv, other.IntDiv)) return false;
5182  if (!object.Equals(IntMod, other.IntMod)) return false;
5183  if (!object.Equals(IntMax, other.IntMax)) return false;
5184  if (!object.Equals(LinMax, other.LinMax)) return false;
5185  if (!object.Equals(IntMin, other.IntMin)) return false;
5186  if (!object.Equals(LinMin, other.LinMin)) return false;
5187  if (!object.Equals(IntProd, other.IntProd)) return false;
5188  if (!object.Equals(Linear, other.Linear)) return false;
5189  if (!object.Equals(AllDiff, other.AllDiff)) return false;
5190  if (!object.Equals(Element, other.Element)) return false;
5191  if (!object.Equals(Circuit, other.Circuit)) return false;
5192  if (!object.Equals(Routes, other.Routes)) return false;
5193  if (!object.Equals(Table, other.Table)) return false;
5194  if (!object.Equals(Automaton, other.Automaton)) return false;
5195  if (!object.Equals(Inverse, other.Inverse)) return false;
5196  if (!object.Equals(Reservoir, other.Reservoir)) return false;
5197  if (!object.Equals(Interval, other.Interval)) return false;
5198  if (!object.Equals(NoOverlap, other.NoOverlap)) return false;
5199  if (!object.Equals(NoOverlap2D, other.NoOverlap2D)) return false;
5200  if (!object.Equals(Cumulative, other.Cumulative)) return false;
5201  if (ConstraintCase != other.ConstraintCase) return false;
5202  return Equals(_unknownFields, other._unknownFields);
5203  }
5204 
5205  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5206  public override int GetHashCode() {
5207  int hash = 1;
5208  if (Name.Length != 0) hash ^= Name.GetHashCode();
5209  hash ^= enforcementLiteral_.GetHashCode();
5210  if (constraintCase_ == ConstraintOneofCase.BoolOr) hash ^= BoolOr.GetHashCode();
5211  if (constraintCase_ == ConstraintOneofCase.BoolAnd) hash ^= BoolAnd.GetHashCode();
5212  if (constraintCase_ == ConstraintOneofCase.AtMostOne) hash ^= AtMostOne.GetHashCode();
5213  if (constraintCase_ == ConstraintOneofCase.ExactlyOne) hash ^= ExactlyOne.GetHashCode();
5214  if (constraintCase_ == ConstraintOneofCase.BoolXor) hash ^= BoolXor.GetHashCode();
5215  if (constraintCase_ == ConstraintOneofCase.IntDiv) hash ^= IntDiv.GetHashCode();
5216  if (constraintCase_ == ConstraintOneofCase.IntMod) hash ^= IntMod.GetHashCode();
5217  if (constraintCase_ == ConstraintOneofCase.IntMax) hash ^= IntMax.GetHashCode();
5218  if (constraintCase_ == ConstraintOneofCase.LinMax) hash ^= LinMax.GetHashCode();
5219  if (constraintCase_ == ConstraintOneofCase.IntMin) hash ^= IntMin.GetHashCode();
5220  if (constraintCase_ == ConstraintOneofCase.LinMin) hash ^= LinMin.GetHashCode();
5221  if (constraintCase_ == ConstraintOneofCase.IntProd) hash ^= IntProd.GetHashCode();
5222  if (constraintCase_ == ConstraintOneofCase.Linear) hash ^= Linear.GetHashCode();
5223  if (constraintCase_ == ConstraintOneofCase.AllDiff) hash ^= AllDiff.GetHashCode();
5224  if (constraintCase_ == ConstraintOneofCase.Element) hash ^= Element.GetHashCode();
5225  if (constraintCase_ == ConstraintOneofCase.Circuit) hash ^= Circuit.GetHashCode();
5226  if (constraintCase_ == ConstraintOneofCase.Routes) hash ^= Routes.GetHashCode();
5227  if (constraintCase_ == ConstraintOneofCase.Table) hash ^= Table.GetHashCode();
5228  if (constraintCase_ == ConstraintOneofCase.Automaton) hash ^= Automaton.GetHashCode();
5229  if (constraintCase_ == ConstraintOneofCase.Inverse) hash ^= Inverse.GetHashCode();
5230  if (constraintCase_ == ConstraintOneofCase.Reservoir) hash ^= Reservoir.GetHashCode();
5231  if (constraintCase_ == ConstraintOneofCase.Interval) hash ^= Interval.GetHashCode();
5232  if (constraintCase_ == ConstraintOneofCase.NoOverlap) hash ^= NoOverlap.GetHashCode();
5233  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) hash ^= NoOverlap2D.GetHashCode();
5234  if (constraintCase_ == ConstraintOneofCase.Cumulative) hash ^= Cumulative.GetHashCode();
5235  hash ^= (int) constraintCase_;
5236  if (_unknownFields != null) {
5237  hash ^= _unknownFields.GetHashCode();
5238  }
5239  return hash;
5240  }
5241 
5242  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5243  public override string ToString() {
5244  return pb::JsonFormatter.ToDiagnosticString(this);
5245  }
5246 
5247  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5248  public void WriteTo(pb::CodedOutputStream output) {
5249  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5250  output.WriteRawMessage(this);
5251  #else
5252  if (Name.Length != 0) {
5253  output.WriteRawTag(10);
5254  output.WriteString(Name);
5255  }
5256  enforcementLiteral_.WriteTo(output, _repeated_enforcementLiteral_codec);
5257  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5258  output.WriteRawTag(26);
5259  output.WriteMessage(BoolOr);
5260  }
5261  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5262  output.WriteRawTag(34);
5263  output.WriteMessage(BoolAnd);
5264  }
5265  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5266  output.WriteRawTag(42);
5267  output.WriteMessage(BoolXor);
5268  }
5269  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5270  output.WriteRawTag(58);
5271  output.WriteMessage(IntDiv);
5272  }
5273  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5274  output.WriteRawTag(66);
5275  output.WriteMessage(IntMod);
5276  }
5277  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5278  output.WriteRawTag(74);
5279  output.WriteMessage(IntMax);
5280  }
5281  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5282  output.WriteRawTag(82);
5283  output.WriteMessage(IntMin);
5284  }
5285  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5286  output.WriteRawTag(90);
5287  output.WriteMessage(IntProd);
5288  }
5289  if (constraintCase_ == ConstraintOneofCase.Linear) {
5290  output.WriteRawTag(98);
5291  output.WriteMessage(Linear);
5292  }
5293  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5294  output.WriteRawTag(106);
5295  output.WriteMessage(AllDiff);
5296  }
5297  if (constraintCase_ == ConstraintOneofCase.Element) {
5298  output.WriteRawTag(114);
5299  output.WriteMessage(Element);
5300  }
5301  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5302  output.WriteRawTag(122);
5303  output.WriteMessage(Circuit);
5304  }
5305  if (constraintCase_ == ConstraintOneofCase.Table) {
5306  output.WriteRawTag(130, 1);
5307  output.WriteMessage(Table);
5308  }
5309  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5310  output.WriteRawTag(138, 1);
5311  output.WriteMessage(Automaton);
5312  }
5313  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5314  output.WriteRawTag(146, 1);
5315  output.WriteMessage(Inverse);
5316  }
5317  if (constraintCase_ == ConstraintOneofCase.Interval) {
5318  output.WriteRawTag(154, 1);
5319  output.WriteMessage(Interval);
5320  }
5321  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5322  output.WriteRawTag(162, 1);
5323  output.WriteMessage(NoOverlap);
5324  }
5325  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5326  output.WriteRawTag(170, 1);
5327  output.WriteMessage(NoOverlap2D);
5328  }
5329  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5330  output.WriteRawTag(178, 1);
5331  output.WriteMessage(Cumulative);
5332  }
5333  if (constraintCase_ == ConstraintOneofCase.Routes) {
5334  output.WriteRawTag(186, 1);
5335  output.WriteMessage(Routes);
5336  }
5337  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5338  output.WriteRawTag(194, 1);
5339  output.WriteMessage(Reservoir);
5340  }
5341  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5342  output.WriteRawTag(210, 1);
5343  output.WriteMessage(AtMostOne);
5344  }
5345  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5346  output.WriteRawTag(218, 1);
5347  output.WriteMessage(LinMax);
5348  }
5349  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5350  output.WriteRawTag(226, 1);
5351  output.WriteMessage(LinMin);
5352  }
5353  if (constraintCase_ == ConstraintOneofCase.ExactlyOne) {
5354  output.WriteRawTag(234, 1);
5355  output.WriteMessage(ExactlyOne);
5356  }
5357  if (_unknownFields != null) {
5358  _unknownFields.WriteTo(output);
5359  }
5360  #endif
5361  }
5362 
5363  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5364  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5365  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
5366  if (Name.Length != 0) {
5367  output.WriteRawTag(10);
5368  output.WriteString(Name);
5369  }
5370  enforcementLiteral_.WriteTo(ref output, _repeated_enforcementLiteral_codec);
5371  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5372  output.WriteRawTag(26);
5373  output.WriteMessage(BoolOr);
5374  }
5375  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5376  output.WriteRawTag(34);
5377  output.WriteMessage(BoolAnd);
5378  }
5379  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5380  output.WriteRawTag(42);
5381  output.WriteMessage(BoolXor);
5382  }
5383  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5384  output.WriteRawTag(58);
5385  output.WriteMessage(IntDiv);
5386  }
5387  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5388  output.WriteRawTag(66);
5389  output.WriteMessage(IntMod);
5390  }
5391  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5392  output.WriteRawTag(74);
5393  output.WriteMessage(IntMax);
5394  }
5395  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5396  output.WriteRawTag(82);
5397  output.WriteMessage(IntMin);
5398  }
5399  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5400  output.WriteRawTag(90);
5401  output.WriteMessage(IntProd);
5402  }
5403  if (constraintCase_ == ConstraintOneofCase.Linear) {
5404  output.WriteRawTag(98);
5405  output.WriteMessage(Linear);
5406  }
5407  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5408  output.WriteRawTag(106);
5409  output.WriteMessage(AllDiff);
5410  }
5411  if (constraintCase_ == ConstraintOneofCase.Element) {
5412  output.WriteRawTag(114);
5413  output.WriteMessage(Element);
5414  }
5415  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5416  output.WriteRawTag(122);
5417  output.WriteMessage(Circuit);
5418  }
5419  if (constraintCase_ == ConstraintOneofCase.Table) {
5420  output.WriteRawTag(130, 1);
5421  output.WriteMessage(Table);
5422  }
5423  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5424  output.WriteRawTag(138, 1);
5425  output.WriteMessage(Automaton);
5426  }
5427  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5428  output.WriteRawTag(146, 1);
5429  output.WriteMessage(Inverse);
5430  }
5431  if (constraintCase_ == ConstraintOneofCase.Interval) {
5432  output.WriteRawTag(154, 1);
5433  output.WriteMessage(Interval);
5434  }
5435  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5436  output.WriteRawTag(162, 1);
5437  output.WriteMessage(NoOverlap);
5438  }
5439  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5440  output.WriteRawTag(170, 1);
5441  output.WriteMessage(NoOverlap2D);
5442  }
5443  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5444  output.WriteRawTag(178, 1);
5445  output.WriteMessage(Cumulative);
5446  }
5447  if (constraintCase_ == ConstraintOneofCase.Routes) {
5448  output.WriteRawTag(186, 1);
5449  output.WriteMessage(Routes);
5450  }
5451  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5452  output.WriteRawTag(194, 1);
5453  output.WriteMessage(Reservoir);
5454  }
5455  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5456  output.WriteRawTag(210, 1);
5457  output.WriteMessage(AtMostOne);
5458  }
5459  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5460  output.WriteRawTag(218, 1);
5461  output.WriteMessage(LinMax);
5462  }
5463  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5464  output.WriteRawTag(226, 1);
5465  output.WriteMessage(LinMin);
5466  }
5467  if (constraintCase_ == ConstraintOneofCase.ExactlyOne) {
5468  output.WriteRawTag(234, 1);
5469  output.WriteMessage(ExactlyOne);
5470  }
5471  if (_unknownFields != null) {
5472  _unknownFields.WriteTo(ref output);
5473  }
5474  }
5475  #endif
5476 
5477  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5478  public int CalculateSize() {
5479  int size = 0;
5480  if (Name.Length != 0) {
5481  size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
5482  }
5483  size += enforcementLiteral_.CalculateSize(_repeated_enforcementLiteral_codec);
5484  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5485  size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolOr);
5486  }
5487  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5488  size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolAnd);
5489  }
5490  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5491  size += 2 + pb::CodedOutputStream.ComputeMessageSize(AtMostOne);
5492  }
5493  if (constraintCase_ == ConstraintOneofCase.ExactlyOne) {
5494  size += 2 + pb::CodedOutputStream.ComputeMessageSize(ExactlyOne);
5495  }
5496  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5497  size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolXor);
5498  }
5499  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5500  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntDiv);
5501  }
5502  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5503  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMod);
5504  }
5505  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5506  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMax);
5507  }
5508  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5509  size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMax);
5510  }
5511  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5512  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMin);
5513  }
5514  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5515  size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMin);
5516  }
5517  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5518  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntProd);
5519  }
5520  if (constraintCase_ == ConstraintOneofCase.Linear) {
5521  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Linear);
5522  }
5523  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5524  size += 1 + pb::CodedOutputStream.ComputeMessageSize(AllDiff);
5525  }
5526  if (constraintCase_ == ConstraintOneofCase.Element) {
5527  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Element);
5528  }
5529  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5530  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Circuit);
5531  }
5532  if (constraintCase_ == ConstraintOneofCase.Routes) {
5533  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Routes);
5534  }
5535  if (constraintCase_ == ConstraintOneofCase.Table) {
5536  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Table);
5537  }
5538  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5539  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Automaton);
5540  }
5541  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5542  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Inverse);
5543  }
5544  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5545  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Reservoir);
5546  }
5547  if (constraintCase_ == ConstraintOneofCase.Interval) {
5548  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Interval);
5549  }
5550  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5551  size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap);
5552  }
5553  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5554  size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap2D);
5555  }
5556  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5557  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Cumulative);
5558  }
5559  if (_unknownFields != null) {
5560  size += _unknownFields.CalculateSize();
5561  }
5562  return size;
5563  }
5564 
5565  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5566  public void MergeFrom(ConstraintProto other) {
5567  if (other == null) {
5568  return;
5569  }
5570  if (other.Name.Length != 0) {
5571  Name = other.Name;
5572  }
5573  enforcementLiteral_.Add(other.enforcementLiteral_);
5574  switch (other.ConstraintCase) {
5575  case ConstraintOneofCase.BoolOr:
5576  if (BoolOr == null) {
5577  BoolOr = new global::Google.OrTools.Sat.BoolArgumentProto();
5578  }
5579  BoolOr.MergeFrom(other.BoolOr);
5580  break;
5581  case ConstraintOneofCase.BoolAnd:
5582  if (BoolAnd == null) {
5583  BoolAnd = new global::Google.OrTools.Sat.BoolArgumentProto();
5584  }
5585  BoolAnd.MergeFrom(other.BoolAnd);
5586  break;
5587  case ConstraintOneofCase.AtMostOne:
5588  if (AtMostOne == null) {
5589  AtMostOne = new global::Google.OrTools.Sat.BoolArgumentProto();
5590  }
5591  AtMostOne.MergeFrom(other.AtMostOne);
5592  break;
5593  case ConstraintOneofCase.ExactlyOne:
5594  if (ExactlyOne == null) {
5595  ExactlyOne = new global::Google.OrTools.Sat.BoolArgumentProto();
5596  }
5597  ExactlyOne.MergeFrom(other.ExactlyOne);
5598  break;
5599  case ConstraintOneofCase.BoolXor:
5600  if (BoolXor == null) {
5601  BoolXor = new global::Google.OrTools.Sat.BoolArgumentProto();
5602  }
5603  BoolXor.MergeFrom(other.BoolXor);
5604  break;
5605  case ConstraintOneofCase.IntDiv:
5606  if (IntDiv == null) {
5607  IntDiv = new global::Google.OrTools.Sat.IntegerArgumentProto();
5608  }
5609  IntDiv.MergeFrom(other.IntDiv);
5610  break;
5611  case ConstraintOneofCase.IntMod:
5612  if (IntMod == null) {
5613  IntMod = new global::Google.OrTools.Sat.IntegerArgumentProto();
5614  }
5615  IntMod.MergeFrom(other.IntMod);
5616  break;
5617  case ConstraintOneofCase.IntMax:
5618  if (IntMax == null) {
5619  IntMax = new global::Google.OrTools.Sat.IntegerArgumentProto();
5620  }
5621  IntMax.MergeFrom(other.IntMax);
5622  break;
5623  case ConstraintOneofCase.LinMax:
5624  if (LinMax == null) {
5625  LinMax = new global::Google.OrTools.Sat.LinearArgumentProto();
5626  }
5627  LinMax.MergeFrom(other.LinMax);
5628  break;
5629  case ConstraintOneofCase.IntMin:
5630  if (IntMin == null) {
5631  IntMin = new global::Google.OrTools.Sat.IntegerArgumentProto();
5632  }
5633  IntMin.MergeFrom(other.IntMin);
5634  break;
5635  case ConstraintOneofCase.LinMin:
5636  if (LinMin == null) {
5637  LinMin = new global::Google.OrTools.Sat.LinearArgumentProto();
5638  }
5639  LinMin.MergeFrom(other.LinMin);
5640  break;
5641  case ConstraintOneofCase.IntProd:
5642  if (IntProd == null) {
5643  IntProd = new global::Google.OrTools.Sat.IntegerArgumentProto();
5644  }
5645  IntProd.MergeFrom(other.IntProd);
5646  break;
5647  case ConstraintOneofCase.Linear:
5648  if (Linear == null) {
5649  Linear = new global::Google.OrTools.Sat.LinearConstraintProto();
5650  }
5651  Linear.MergeFrom(other.Linear);
5652  break;
5653  case ConstraintOneofCase.AllDiff:
5654  if (AllDiff == null) {
5655  AllDiff = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
5656  }
5657  AllDiff.MergeFrom(other.AllDiff);
5658  break;
5659  case ConstraintOneofCase.Element:
5660  if (Element == null) {
5661  Element = new global::Google.OrTools.Sat.ElementConstraintProto();
5662  }
5663  Element.MergeFrom(other.Element);
5664  break;
5665  case ConstraintOneofCase.Circuit:
5666  if (Circuit == null) {
5667  Circuit = new global::Google.OrTools.Sat.CircuitConstraintProto();
5668  }
5669  Circuit.MergeFrom(other.Circuit);
5670  break;
5671  case ConstraintOneofCase.Routes:
5672  if (Routes == null) {
5673  Routes = new global::Google.OrTools.Sat.RoutesConstraintProto();
5674  }
5675  Routes.MergeFrom(other.Routes);
5676  break;
5677  case ConstraintOneofCase.Table:
5678  if (Table == null) {
5679  Table = new global::Google.OrTools.Sat.TableConstraintProto();
5680  }
5681  Table.MergeFrom(other.Table);
5682  break;
5683  case ConstraintOneofCase.Automaton:
5684  if (Automaton == null) {
5685  Automaton = new global::Google.OrTools.Sat.AutomatonConstraintProto();
5686  }
5687  Automaton.MergeFrom(other.Automaton);
5688  break;
5689  case ConstraintOneofCase.Inverse:
5690  if (Inverse == null) {
5691  Inverse = new global::Google.OrTools.Sat.InverseConstraintProto();
5692  }
5693  Inverse.MergeFrom(other.Inverse);
5694  break;
5695  case ConstraintOneofCase.Reservoir:
5696  if (Reservoir == null) {
5697  Reservoir = new global::Google.OrTools.Sat.ReservoirConstraintProto();
5698  }
5699  Reservoir.MergeFrom(other.Reservoir);
5700  break;
5701  case ConstraintOneofCase.Interval:
5702  if (Interval == null) {
5703  Interval = new global::Google.OrTools.Sat.IntervalConstraintProto();
5704  }
5705  Interval.MergeFrom(other.Interval);
5706  break;
5707  case ConstraintOneofCase.NoOverlap:
5708  if (NoOverlap == null) {
5709  NoOverlap = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
5710  }
5711  NoOverlap.MergeFrom(other.NoOverlap);
5712  break;
5713  case ConstraintOneofCase.NoOverlap2D:
5714  if (NoOverlap2D == null) {
5715  NoOverlap2D = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
5716  }
5717  NoOverlap2D.MergeFrom(other.NoOverlap2D);
5718  break;
5719  case ConstraintOneofCase.Cumulative:
5720  if (Cumulative == null) {
5721  Cumulative = new global::Google.OrTools.Sat.CumulativeConstraintProto();
5722  }
5723  Cumulative.MergeFrom(other.Cumulative);
5724  break;
5725  }
5726 
5727  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
5728  }
5729 
5730  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5731  public void MergeFrom(pb::CodedInputStream input) {
5732  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5733  input.ReadRawMessage(this);
5734  #else
5735  uint tag;
5736  while ((tag = input.ReadTag()) != 0) {
5737  switch(tag) {
5738  default:
5739  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5740  break;
5741  case 10: {
5742  Name = input.ReadString();
5743  break;
5744  }
5745  case 18:
5746  case 16: {
5747  enforcementLiteral_.AddEntriesFrom(input, _repeated_enforcementLiteral_codec);
5748  break;
5749  }
5750  case 26: {
5751  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5752  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5753  subBuilder.MergeFrom(BoolOr);
5754  }
5755  input.ReadMessage(subBuilder);
5756  BoolOr = subBuilder;
5757  break;
5758  }
5759  case 34: {
5760  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5761  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5762  subBuilder.MergeFrom(BoolAnd);
5763  }
5764  input.ReadMessage(subBuilder);
5765  BoolAnd = subBuilder;
5766  break;
5767  }
5768  case 42: {
5769  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5770  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5771  subBuilder.MergeFrom(BoolXor);
5772  }
5773  input.ReadMessage(subBuilder);
5774  BoolXor = subBuilder;
5775  break;
5776  }
5777  case 58: {
5778  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5779  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5780  subBuilder.MergeFrom(IntDiv);
5781  }
5782  input.ReadMessage(subBuilder);
5783  IntDiv = subBuilder;
5784  break;
5785  }
5786  case 66: {
5787  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5788  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5789  subBuilder.MergeFrom(IntMod);
5790  }
5791  input.ReadMessage(subBuilder);
5792  IntMod = subBuilder;
5793  break;
5794  }
5795  case 74: {
5796  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5797  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5798  subBuilder.MergeFrom(IntMax);
5799  }
5800  input.ReadMessage(subBuilder);
5801  IntMax = subBuilder;
5802  break;
5803  }
5804  case 82: {
5805  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5806  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5807  subBuilder.MergeFrom(IntMin);
5808  }
5809  input.ReadMessage(subBuilder);
5810  IntMin = subBuilder;
5811  break;
5812  }
5813  case 90: {
5814  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5815  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5816  subBuilder.MergeFrom(IntProd);
5817  }
5818  input.ReadMessage(subBuilder);
5819  IntProd = subBuilder;
5820  break;
5821  }
5822  case 98: {
5823  global::Google.OrTools.Sat.LinearConstraintProto subBuilder = new global::Google.OrTools.Sat.LinearConstraintProto();
5824  if (constraintCase_ == ConstraintOneofCase.Linear) {
5825  subBuilder.MergeFrom(Linear);
5826  }
5827  input.ReadMessage(subBuilder);
5828  Linear = subBuilder;
5829  break;
5830  }
5831  case 106: {
5832  global::Google.OrTools.Sat.AllDifferentConstraintProto subBuilder = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
5833  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5834  subBuilder.MergeFrom(AllDiff);
5835  }
5836  input.ReadMessage(subBuilder);
5837  AllDiff = subBuilder;
5838  break;
5839  }
5840  case 114: {
5841  global::Google.OrTools.Sat.ElementConstraintProto subBuilder = new global::Google.OrTools.Sat.ElementConstraintProto();
5842  if (constraintCase_ == ConstraintOneofCase.Element) {
5843  subBuilder.MergeFrom(Element);
5844  }
5845  input.ReadMessage(subBuilder);
5846  Element = subBuilder;
5847  break;
5848  }
5849  case 122: {
5850  global::Google.OrTools.Sat.CircuitConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitConstraintProto();
5851  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5852  subBuilder.MergeFrom(Circuit);
5853  }
5854  input.ReadMessage(subBuilder);
5855  Circuit = subBuilder;
5856  break;
5857  }
5858  case 130: {
5859  global::Google.OrTools.Sat.TableConstraintProto subBuilder = new global::Google.OrTools.Sat.TableConstraintProto();
5860  if (constraintCase_ == ConstraintOneofCase.Table) {
5861  subBuilder.MergeFrom(Table);
5862  }
5863  input.ReadMessage(subBuilder);
5864  Table = subBuilder;
5865  break;
5866  }
5867  case 138: {
5868  global::Google.OrTools.Sat.AutomatonConstraintProto subBuilder = new global::Google.OrTools.Sat.AutomatonConstraintProto();
5869  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5870  subBuilder.MergeFrom(Automaton);
5871  }
5872  input.ReadMessage(subBuilder);
5873  Automaton = subBuilder;
5874  break;
5875  }
5876  case 146: {
5877  global::Google.OrTools.Sat.InverseConstraintProto subBuilder = new global::Google.OrTools.Sat.InverseConstraintProto();
5878  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5879  subBuilder.MergeFrom(Inverse);
5880  }
5881  input.ReadMessage(subBuilder);
5882  Inverse = subBuilder;
5883  break;
5884  }
5885  case 154: {
5886  global::Google.OrTools.Sat.IntervalConstraintProto subBuilder = new global::Google.OrTools.Sat.IntervalConstraintProto();
5887  if (constraintCase_ == ConstraintOneofCase.Interval) {
5888  subBuilder.MergeFrom(Interval);
5889  }
5890  input.ReadMessage(subBuilder);
5891  Interval = subBuilder;
5892  break;
5893  }
5894  case 162: {
5895  global::Google.OrTools.Sat.NoOverlapConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
5896  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5897  subBuilder.MergeFrom(NoOverlap);
5898  }
5899  input.ReadMessage(subBuilder);
5900  NoOverlap = subBuilder;
5901  break;
5902  }
5903  case 170: {
5904  global::Google.OrTools.Sat.NoOverlap2DConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
5905  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5906  subBuilder.MergeFrom(NoOverlap2D);
5907  }
5908  input.ReadMessage(subBuilder);
5909  NoOverlap2D = subBuilder;
5910  break;
5911  }
5912  case 178: {
5913  global::Google.OrTools.Sat.CumulativeConstraintProto subBuilder = new global::Google.OrTools.Sat.CumulativeConstraintProto();
5914  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5915  subBuilder.MergeFrom(Cumulative);
5916  }
5917  input.ReadMessage(subBuilder);
5918  Cumulative = subBuilder;
5919  break;
5920  }
5921  case 186: {
5922  global::Google.OrTools.Sat.RoutesConstraintProto subBuilder = new global::Google.OrTools.Sat.RoutesConstraintProto();
5923  if (constraintCase_ == ConstraintOneofCase.Routes) {
5924  subBuilder.MergeFrom(Routes);
5925  }
5926  input.ReadMessage(subBuilder);
5927  Routes = subBuilder;
5928  break;
5929  }
5930  case 194: {
5931  global::Google.OrTools.Sat.ReservoirConstraintProto subBuilder = new global::Google.OrTools.Sat.ReservoirConstraintProto();
5932  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5933  subBuilder.MergeFrom(Reservoir);
5934  }
5935  input.ReadMessage(subBuilder);
5936  Reservoir = subBuilder;
5937  break;
5938  }
5939  case 210: {
5940  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5941  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5942  subBuilder.MergeFrom(AtMostOne);
5943  }
5944  input.ReadMessage(subBuilder);
5945  AtMostOne = subBuilder;
5946  break;
5947  }
5948  case 218: {
5949  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
5950  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5951  subBuilder.MergeFrom(LinMax);
5952  }
5953  input.ReadMessage(subBuilder);
5954  LinMax = subBuilder;
5955  break;
5956  }
5957  case 226: {
5958  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
5959  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5960  subBuilder.MergeFrom(LinMin);
5961  }
5962  input.ReadMessage(subBuilder);
5963  LinMin = subBuilder;
5964  break;
5965  }
5966  case 234: {
5967  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5968  if (constraintCase_ == ConstraintOneofCase.ExactlyOne) {
5969  subBuilder.MergeFrom(ExactlyOne);
5970  }
5971  input.ReadMessage(subBuilder);
5972  ExactlyOne = subBuilder;
5973  break;
5974  }
5975  }
5976  }
5977  #endif
5978  }
5979 
5980  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5981  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5982  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
5983  uint tag;
5984  while ((tag = input.ReadTag()) != 0) {
5985  switch(tag) {
5986  default:
5987  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
5988  break;
5989  case 10: {
5990  Name = input.ReadString();
5991  break;
5992  }
5993  case 18:
5994  case 16: {
5995  enforcementLiteral_.AddEntriesFrom(ref input, _repeated_enforcementLiteral_codec);
5996  break;
5997  }
5998  case 26: {
5999  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6000  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
6001  subBuilder.MergeFrom(BoolOr);
6002  }
6003  input.ReadMessage(subBuilder);
6004  BoolOr = subBuilder;
6005  break;
6006  }
6007  case 34: {
6008  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6009  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
6010  subBuilder.MergeFrom(BoolAnd);
6011  }
6012  input.ReadMessage(subBuilder);
6013  BoolAnd = subBuilder;
6014  break;
6015  }
6016  case 42: {
6017  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6018  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
6019  subBuilder.MergeFrom(BoolXor);
6020  }
6021  input.ReadMessage(subBuilder);
6022  BoolXor = subBuilder;
6023  break;
6024  }
6025  case 58: {
6026  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6027  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
6028  subBuilder.MergeFrom(IntDiv);
6029  }
6030  input.ReadMessage(subBuilder);
6031  IntDiv = subBuilder;
6032  break;
6033  }
6034  case 66: {
6035  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6036  if (constraintCase_ == ConstraintOneofCase.IntMod) {
6037  subBuilder.MergeFrom(IntMod);
6038  }
6039  input.ReadMessage(subBuilder);
6040  IntMod = subBuilder;
6041  break;
6042  }
6043  case 74: {
6044  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6045  if (constraintCase_ == ConstraintOneofCase.IntMax) {
6046  subBuilder.MergeFrom(IntMax);
6047  }
6048  input.ReadMessage(subBuilder);
6049  IntMax = subBuilder;
6050  break;
6051  }
6052  case 82: {
6053  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6054  if (constraintCase_ == ConstraintOneofCase.IntMin) {
6055  subBuilder.MergeFrom(IntMin);
6056  }
6057  input.ReadMessage(subBuilder);
6058  IntMin = subBuilder;
6059  break;
6060  }
6061  case 90: {
6062  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6063  if (constraintCase_ == ConstraintOneofCase.IntProd) {
6064  subBuilder.MergeFrom(IntProd);
6065  }
6066  input.ReadMessage(subBuilder);
6067  IntProd = subBuilder;
6068  break;
6069  }
6070  case 98: {
6071  global::Google.OrTools.Sat.LinearConstraintProto subBuilder = new global::Google.OrTools.Sat.LinearConstraintProto();
6072  if (constraintCase_ == ConstraintOneofCase.Linear) {
6073  subBuilder.MergeFrom(Linear);
6074  }
6075  input.ReadMessage(subBuilder);
6076  Linear = subBuilder;
6077  break;
6078  }
6079  case 106: {
6080  global::Google.OrTools.Sat.AllDifferentConstraintProto subBuilder = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
6081  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
6082  subBuilder.MergeFrom(AllDiff);
6083  }
6084  input.ReadMessage(subBuilder);
6085  AllDiff = subBuilder;
6086  break;
6087  }
6088  case 114: {
6089  global::Google.OrTools.Sat.ElementConstraintProto subBuilder = new global::Google.OrTools.Sat.ElementConstraintProto();
6090  if (constraintCase_ == ConstraintOneofCase.Element) {
6091  subBuilder.MergeFrom(Element);
6092  }
6093  input.ReadMessage(subBuilder);
6094  Element = subBuilder;
6095  break;
6096  }
6097  case 122: {
6098  global::Google.OrTools.Sat.CircuitConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitConstraintProto();
6099  if (constraintCase_ == ConstraintOneofCase.Circuit) {
6100  subBuilder.MergeFrom(Circuit);
6101  }
6102  input.ReadMessage(subBuilder);
6103  Circuit = subBuilder;
6104  break;
6105  }
6106  case 130: {
6107  global::Google.OrTools.Sat.TableConstraintProto subBuilder = new global::Google.OrTools.Sat.TableConstraintProto();
6108  if (constraintCase_ == ConstraintOneofCase.Table) {
6109  subBuilder.MergeFrom(Table);
6110  }
6111  input.ReadMessage(subBuilder);
6112  Table = subBuilder;
6113  break;
6114  }
6115  case 138: {
6116  global::Google.OrTools.Sat.AutomatonConstraintProto subBuilder = new global::Google.OrTools.Sat.AutomatonConstraintProto();
6117  if (constraintCase_ == ConstraintOneofCase.Automaton) {
6118  subBuilder.MergeFrom(Automaton);
6119  }
6120  input.ReadMessage(subBuilder);
6121  Automaton = subBuilder;
6122  break;
6123  }
6124  case 146: {
6125  global::Google.OrTools.Sat.InverseConstraintProto subBuilder = new global::Google.OrTools.Sat.InverseConstraintProto();
6126  if (constraintCase_ == ConstraintOneofCase.Inverse) {
6127  subBuilder.MergeFrom(Inverse);
6128  }
6129  input.ReadMessage(subBuilder);
6130  Inverse = subBuilder;
6131  break;
6132  }
6133  case 154: {
6134  global::Google.OrTools.Sat.IntervalConstraintProto subBuilder = new global::Google.OrTools.Sat.IntervalConstraintProto();
6135  if (constraintCase_ == ConstraintOneofCase.Interval) {
6136  subBuilder.MergeFrom(Interval);
6137  }
6138  input.ReadMessage(subBuilder);
6139  Interval = subBuilder;
6140  break;
6141  }
6142  case 162: {
6143  global::Google.OrTools.Sat.NoOverlapConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
6144  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
6145  subBuilder.MergeFrom(NoOverlap);
6146  }
6147  input.ReadMessage(subBuilder);
6148  NoOverlap = subBuilder;
6149  break;
6150  }
6151  case 170: {
6152  global::Google.OrTools.Sat.NoOverlap2DConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
6153  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
6154  subBuilder.MergeFrom(NoOverlap2D);
6155  }
6156  input.ReadMessage(subBuilder);
6157  NoOverlap2D = subBuilder;
6158  break;
6159  }
6160  case 178: {
6161  global::Google.OrTools.Sat.CumulativeConstraintProto subBuilder = new global::Google.OrTools.Sat.CumulativeConstraintProto();
6162  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
6163  subBuilder.MergeFrom(Cumulative);
6164  }
6165  input.ReadMessage(subBuilder);
6166  Cumulative = subBuilder;
6167  break;
6168  }
6169  case 186: {
6170  global::Google.OrTools.Sat.RoutesConstraintProto subBuilder = new global::Google.OrTools.Sat.RoutesConstraintProto();
6171  if (constraintCase_ == ConstraintOneofCase.Routes) {
6172  subBuilder.MergeFrom(Routes);
6173  }
6174  input.ReadMessage(subBuilder);
6175  Routes = subBuilder;
6176  break;
6177  }
6178  case 194: {
6179  global::Google.OrTools.Sat.ReservoirConstraintProto subBuilder = new global::Google.OrTools.Sat.ReservoirConstraintProto();
6180  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
6181  subBuilder.MergeFrom(Reservoir);
6182  }
6183  input.ReadMessage(subBuilder);
6184  Reservoir = subBuilder;
6185  break;
6186  }
6187  case 210: {
6188  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6189  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
6190  subBuilder.MergeFrom(AtMostOne);
6191  }
6192  input.ReadMessage(subBuilder);
6193  AtMostOne = subBuilder;
6194  break;
6195  }
6196  case 218: {
6197  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
6198  if (constraintCase_ == ConstraintOneofCase.LinMax) {
6199  subBuilder.MergeFrom(LinMax);
6200  }
6201  input.ReadMessage(subBuilder);
6202  LinMax = subBuilder;
6203  break;
6204  }
6205  case 226: {
6206  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
6207  if (constraintCase_ == ConstraintOneofCase.LinMin) {
6208  subBuilder.MergeFrom(LinMin);
6209  }
6210  input.ReadMessage(subBuilder);
6211  LinMin = subBuilder;
6212  break;
6213  }
6214  case 234: {
6215  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6216  if (constraintCase_ == ConstraintOneofCase.ExactlyOne) {
6217  subBuilder.MergeFrom(ExactlyOne);
6218  }
6219  input.ReadMessage(subBuilder);
6220  ExactlyOne = subBuilder;
6221  break;
6222  }
6223  }
6224  }
6225  }
6226  #endif
6227 
6228  }
6229 
6235  public sealed partial class CpObjectiveProto : pb::IMessage<CpObjectiveProto>
6236  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6237  , pb::IBufferMessage
6238  #endif
6239  {
6240  private static readonly pb::MessageParser<CpObjectiveProto> _parser = new pb::MessageParser<CpObjectiveProto>(() => new CpObjectiveProto());
6241  private pb::UnknownFieldSet _unknownFields;
6242  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6243  public static pb::MessageParser<CpObjectiveProto> Parser { get { return _parser; } }
6244 
6245  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6246  public static pbr::MessageDescriptor Descriptor {
6247  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[19]; }
6248  }
6249 
6250  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6251  pbr::MessageDescriptor pb::IMessage.Descriptor {
6252  get { return Descriptor; }
6253  }
6254 
6255  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6256  public CpObjectiveProto() {
6257  OnConstruction();
6258  }
6259 
6260  partial void OnConstruction();
6261 
6262  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6263  public CpObjectiveProto(CpObjectiveProto other) : this() {
6264  vars_ = other.vars_.Clone();
6265  coeffs_ = other.coeffs_.Clone();
6266  offset_ = other.offset_;
6267  scalingFactor_ = other.scalingFactor_;
6268  domain_ = other.domain_.Clone();
6269  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
6270  }
6271 
6272  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6274  return new CpObjectiveProto(this);
6275  }
6276 
6278  public const int VarsFieldNumber = 1;
6279  private static readonly pb::FieldCodec<int> _repeated_vars_codec
6280  = pb::FieldCodec.ForInt32(10);
6281  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
6287  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6288  public pbc::RepeatedField<int> Vars {
6289  get { return vars_; }
6290  }
6291 
6293  public const int CoeffsFieldNumber = 4;
6294  private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
6295  = pb::FieldCodec.ForInt64(34);
6296  private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
6297  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6298  public pbc::RepeatedField<long> Coeffs {
6299  get { return coeffs_; }
6300  }
6301 
6303  public const int OffsetFieldNumber = 2;
6304  private double offset_;
6314  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6315  public double Offset {
6316  get { return offset_; }
6317  set {
6318  offset_ = value;
6319  }
6320  }
6321 
6323  public const int ScalingFactorFieldNumber = 3;
6324  private double scalingFactor_;
6325  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6326  public double ScalingFactor {
6327  get { return scalingFactor_; }
6328  set {
6329  scalingFactor_ = value;
6330  }
6331  }
6332 
6334  public const int DomainFieldNumber = 5;
6335  private static readonly pb::FieldCodec<long> _repeated_domain_codec
6336  = pb::FieldCodec.ForInt64(42);
6337  private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
6343  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6344  public pbc::RepeatedField<long> Domain {
6345  get { return domain_; }
6346  }
6347 
6348  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6349  public override bool Equals(object other) {
6350  return Equals(other as CpObjectiveProto);
6351  }
6352 
6353  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6354  public bool Equals(CpObjectiveProto other) {
6355  if (ReferenceEquals(other, null)) {
6356  return false;
6357  }
6358  if (ReferenceEquals(other, this)) {
6359  return true;
6360  }
6361  if(!vars_.Equals(other.vars_)) return false;
6362  if(!coeffs_.Equals(other.coeffs_)) return false;
6363  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Offset, other.Offset)) return false;
6364  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ScalingFactor, other.ScalingFactor)) return false;
6365  if(!domain_.Equals(other.domain_)) return false;
6366  return Equals(_unknownFields, other._unknownFields);
6367  }
6368 
6369  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6370  public override int GetHashCode() {
6371  int hash = 1;
6372  hash ^= vars_.GetHashCode();
6373  hash ^= coeffs_.GetHashCode();
6374  if (Offset != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Offset);
6375  if (ScalingFactor != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ScalingFactor);
6376  hash ^= domain_.GetHashCode();
6377  if (_unknownFields != null) {
6378  hash ^= _unknownFields.GetHashCode();
6379  }
6380  return hash;
6381  }
6382 
6383  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6384  public override string ToString() {
6385  return pb::JsonFormatter.ToDiagnosticString(this);
6386  }
6387 
6388  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6389  public void WriteTo(pb::CodedOutputStream output) {
6390  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6391  output.WriteRawMessage(this);
6392  #else
6393  vars_.WriteTo(output, _repeated_vars_codec);
6394  if (Offset != 0D) {
6395  output.WriteRawTag(17);
6396  output.WriteDouble(Offset);
6397  }
6398  if (ScalingFactor != 0D) {
6399  output.WriteRawTag(25);
6400  output.WriteDouble(ScalingFactor);
6401  }
6402  coeffs_.WriteTo(output, _repeated_coeffs_codec);
6403  domain_.WriteTo(output, _repeated_domain_codec);
6404  if (_unknownFields != null) {
6405  _unknownFields.WriteTo(output);
6406  }
6407  #endif
6408  }
6409 
6410  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6411  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6412  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
6413  vars_.WriteTo(ref output, _repeated_vars_codec);
6414  if (Offset != 0D) {
6415  output.WriteRawTag(17);
6416  output.WriteDouble(Offset);
6417  }
6418  if (ScalingFactor != 0D) {
6419  output.WriteRawTag(25);
6420  output.WriteDouble(ScalingFactor);
6421  }
6422  coeffs_.WriteTo(ref output, _repeated_coeffs_codec);
6423  domain_.WriteTo(ref output, _repeated_domain_codec);
6424  if (_unknownFields != null) {
6425  _unknownFields.WriteTo(ref output);
6426  }
6427  }
6428  #endif
6429 
6430  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6431  public int CalculateSize() {
6432  int size = 0;
6433  size += vars_.CalculateSize(_repeated_vars_codec);
6434  size += coeffs_.CalculateSize(_repeated_coeffs_codec);
6435  if (Offset != 0D) {
6436  size += 1 + 8;
6437  }
6438  if (ScalingFactor != 0D) {
6439  size += 1 + 8;
6440  }
6441  size += domain_.CalculateSize(_repeated_domain_codec);
6442  if (_unknownFields != null) {
6443  size += _unknownFields.CalculateSize();
6444  }
6445  return size;
6446  }
6447 
6448  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6449  public void MergeFrom(CpObjectiveProto other) {
6450  if (other == null) {
6451  return;
6452  }
6453  vars_.Add(other.vars_);
6454  coeffs_.Add(other.coeffs_);
6455  if (other.Offset != 0D) {
6456  Offset = other.Offset;
6457  }
6458  if (other.ScalingFactor != 0D) {
6459  ScalingFactor = other.ScalingFactor;
6460  }
6461  domain_.Add(other.domain_);
6462  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
6463  }
6464 
6465  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6466  public void MergeFrom(pb::CodedInputStream input) {
6467  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6468  input.ReadRawMessage(this);
6469  #else
6470  uint tag;
6471  while ((tag = input.ReadTag()) != 0) {
6472  switch(tag) {
6473  default:
6474  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
6475  break;
6476  case 10:
6477  case 8: {
6478  vars_.AddEntriesFrom(input, _repeated_vars_codec);
6479  break;
6480  }
6481  case 17: {
6482  Offset = input.ReadDouble();
6483  break;
6484  }
6485  case 25: {
6486  ScalingFactor = input.ReadDouble();
6487  break;
6488  }
6489  case 34:
6490  case 32: {
6491  coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
6492  break;
6493  }
6494  case 42:
6495  case 40: {
6496  domain_.AddEntriesFrom(input, _repeated_domain_codec);
6497  break;
6498  }
6499  }
6500  }
6501  #endif
6502  }
6503 
6504  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6505  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6506  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
6507  uint tag;
6508  while ((tag = input.ReadTag()) != 0) {
6509  switch(tag) {
6510  default:
6511  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
6512  break;
6513  case 10:
6514  case 8: {
6515  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
6516  break;
6517  }
6518  case 17: {
6519  Offset = input.ReadDouble();
6520  break;
6521  }
6522  case 25: {
6523  ScalingFactor = input.ReadDouble();
6524  break;
6525  }
6526  case 34:
6527  case 32: {
6528  coeffs_.AddEntriesFrom(ref input, _repeated_coeffs_codec);
6529  break;
6530  }
6531  case 42:
6532  case 40: {
6533  domain_.AddEntriesFrom(ref input, _repeated_domain_codec);
6534  break;
6535  }
6536  }
6537  }
6538  }
6539  #endif
6540 
6541  }
6542 
6547  public sealed partial class DecisionStrategyProto : pb::IMessage<DecisionStrategyProto>
6548  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6549  , pb::IBufferMessage
6550  #endif
6551  {
6552  private static readonly pb::MessageParser<DecisionStrategyProto> _parser = new pb::MessageParser<DecisionStrategyProto>(() => new DecisionStrategyProto());
6553  private pb::UnknownFieldSet _unknownFields;
6554  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6555  public static pb::MessageParser<DecisionStrategyProto> Parser { get { return _parser; } }
6556 
6557  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6558  public static pbr::MessageDescriptor Descriptor {
6559  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[20]; }
6560  }
6561 
6562  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6563  pbr::MessageDescriptor pb::IMessage.Descriptor {
6564  get { return Descriptor; }
6565  }
6566 
6567  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6569  OnConstruction();
6570  }
6571 
6572  partial void OnConstruction();
6573 
6574  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6576  variables_ = other.variables_.Clone();
6577  variableSelectionStrategy_ = other.variableSelectionStrategy_;
6578  domainReductionStrategy_ = other.domainReductionStrategy_;
6579  transformations_ = other.transformations_.Clone();
6580  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
6581  }
6582 
6583  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6585  return new DecisionStrategyProto(this);
6586  }
6587 
6589  public const int VariablesFieldNumber = 1;
6590  private static readonly pb::FieldCodec<int> _repeated_variables_codec
6591  = pb::FieldCodec.ForInt32(10);
6592  private readonly pbc::RepeatedField<int> variables_ = new pbc::RepeatedField<int>();
6598  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6599  public pbc::RepeatedField<int> Variables {
6600  get { return variables_; }
6601  }
6602 
6604  public const int VariableSelectionStrategyFieldNumber = 2;
6605  private global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy variableSelectionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst;
6606  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6607  public global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy VariableSelectionStrategy {
6608  get { return variableSelectionStrategy_; }
6609  set {
6610  variableSelectionStrategy_ = value;
6611  }
6612  }
6613 
6615  public const int DomainReductionStrategyFieldNumber = 3;
6616  private global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy domainReductionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue;
6617  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6618  public global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy DomainReductionStrategy {
6619  get { return domainReductionStrategy_; }
6620  set {
6621  domainReductionStrategy_ = value;
6622  }
6623  }
6624 
6626  public const int TransformationsFieldNumber = 4;
6627  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> _repeated_transformations_codec
6628  = pb::FieldCodec.ForMessage(34, global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser);
6629  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> transformations_ = new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation>();
6630  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6631  public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> Transformations {
6632  get { return transformations_; }
6633  }
6634 
6635  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6636  public override bool Equals(object other) {
6637  return Equals(other as DecisionStrategyProto);
6638  }
6639 
6640  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6641  public bool Equals(DecisionStrategyProto other) {
6642  if (ReferenceEquals(other, null)) {
6643  return false;
6644  }
6645  if (ReferenceEquals(other, this)) {
6646  return true;
6647  }
6648  if(!variables_.Equals(other.variables_)) return false;
6649  if (VariableSelectionStrategy != other.VariableSelectionStrategy) return false;
6650  if (DomainReductionStrategy != other.DomainReductionStrategy) return false;
6651  if(!transformations_.Equals(other.transformations_)) return false;
6652  return Equals(_unknownFields, other._unknownFields);
6653  }
6654 
6655  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6656  public override int GetHashCode() {
6657  int hash = 1;
6658  hash ^= variables_.GetHashCode();
6659  if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) hash ^= VariableSelectionStrategy.GetHashCode();
6660  if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) hash ^= DomainReductionStrategy.GetHashCode();
6661  hash ^= transformations_.GetHashCode();
6662  if (_unknownFields != null) {
6663  hash ^= _unknownFields.GetHashCode();
6664  }
6665  return hash;
6666  }
6667 
6668  [global::System.Diagnostics.DebuggerNo