diff --git a/ortools/flatzinc/checker.cc b/ortools/flatzinc/checker.cc
index 5daee430b30..1b0d18b8482 100644
--- a/ortools/flatzinc/checker.cc
+++ b/ortools/flatzinc/checker.cc
@@ -157,6 +157,7 @@ int64_t SetSize(
 bool CheckAllDifferentInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 1) return false;
   absl::flat_hash_set<int64_t> visited;
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
     const int64_t value = EvalAt(ct.arguments[0], i, evaluator);
@@ -172,6 +173,7 @@ bool CheckAllDifferentInt(
 bool CheckAllDifferentSet(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 1) return false;
   std::vector<std::vector<int64_t>> values;
   values.reserve(Length(ct.arguments[0]));
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
@@ -190,6 +192,7 @@ bool CheckAllDifferentSet(
 bool CheckAlldifferentExcept0(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 1) return false;
   absl::flat_hash_set<int64_t> visited;
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
     const int64_t value = EvalAt(ct.arguments[0], i, evaluator);
@@ -205,6 +208,7 @@ bool CheckAlldifferentExcept0(
 bool CheckAllDisjoint(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 1) return false;
   absl::flat_hash_set<int64_t> visited;
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
     for (const int64_t value : SetEvalAt(ct.arguments[0], i, set_evaluator)) {
@@ -220,6 +224,7 @@ bool CheckAllDisjoint(
 bool CheckAmong(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t expected = Eval(ct.arguments[0], evaluator);
   int64_t count = 0;
   for (int i = 0; i < Length(ct.arguments[1]); ++i) {
@@ -233,6 +238,7 @@ bool CheckAmong(
 bool CheckArrayBoolAnd(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   int64_t result = 1;
 
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
@@ -246,6 +252,7 @@ bool CheckArrayBoolAnd(
 bool CheckArrayBoolOr(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   int64_t result = 0;
 
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
@@ -259,6 +266,7 @@ bool CheckArrayBoolOr(
 bool CheckArrayBoolXor(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 1) return false;
   int64_t result = 0;
 
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
@@ -271,6 +279,7 @@ bool CheckArrayBoolXor(
 bool CheckArrayIntElement(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   // Flatzinc arrays are 1 based.
   const int64_t shifted_index = Eval(ct.arguments[0], evaluator) - 1;
   const int64_t element = EvalAt(ct.arguments[1], shifted_index, evaluator);
@@ -281,6 +290,7 @@ bool CheckArrayIntElement(
 bool CheckArrayIntElementNonShifted(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   CHECK_EQ(ct.arguments[0].variables.size(), 1);
   const int64_t index = Eval(ct.arguments[0], evaluator);
   const int64_t element = EvalAt(ct.arguments[1], index, evaluator);
@@ -291,6 +301,7 @@ bool CheckArrayIntElementNonShifted(
 bool CheckArrayVarIntElement(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   // Flatzinc arrays are 1 based.
   const int64_t shifted_index = Eval(ct.arguments[0], evaluator) - 1;
   const int64_t element = EvalAt(ct.arguments[1], shifted_index, evaluator);
@@ -301,6 +312,7 @@ bool CheckArrayVarIntElement(
 bool CheckOrToolsArgMaxInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int rank = evaluator(ct.arguments[1].Var());
   const int min_index = ct.arguments[2].Value();
   const int multiplier = ct.arguments[3].Value();
@@ -319,6 +331,7 @@ bool CheckOrToolsArgMaxInt(
 bool CheckOrToolsArrayIntElement(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t min_index = ct.arguments[1].values[0];
   const int64_t index = Eval(ct.arguments[0], evaluator) - min_index;
   const int64_t element = EvalAt(ct.arguments[2], index, evaluator);
@@ -329,6 +342,7 @@ bool CheckOrToolsArrayIntElement(
 bool CheckAtMostInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t expected = Eval(ct.arguments[0], evaluator);
   const int64_t value = Eval(ct.arguments[2], evaluator);
 
@@ -342,6 +356,7 @@ bool CheckAtMostInt(
 bool CheckBoolAnd(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t status = Eval(ct.arguments[2], evaluator);
@@ -351,6 +366,7 @@ bool CheckBoolAnd(
 bool CheckBoolClause(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   int64_t result = 0;
 
   // Positive variables.
@@ -370,6 +386,7 @@ bool CheckBoolClause(
 bool CheckBoolNot(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left == 1 - right;
@@ -378,6 +395,7 @@ bool CheckBoolNot(
 bool CheckBoolOr(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t status = Eval(ct.arguments[2], evaluator);
@@ -387,6 +405,7 @@ bool CheckBoolOr(
 bool CheckBoolXor(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t target = Eval(ct.arguments[2], evaluator);
@@ -396,6 +415,7 @@ bool CheckBoolXor(
 bool CheckDisjoint(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   std::vector<int64_t> computed_intersection;
@@ -408,6 +428,7 @@ bool CheckDisjoint(
 bool CheckOrToolsCircuit(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int size = Length(ct.arguments[0]);
   const int base = ct.arguments[1].Value();
 
@@ -424,6 +445,7 @@ bool CheckOrToolsCircuit(
 bool CheckOrToolsBinPacking(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t capacity = ct.arguments[0].Value();
   const int num_positions = Length(ct.arguments[1]);
   const std::vector<int64_t>& weights = ct.arguments[2].values;
@@ -443,6 +465,7 @@ bool CheckOrToolsBinPacking(
 bool CheckOrToolsBinPackingCapa(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const std::vector<int64_t>& capacities = ct.arguments[0].values;
   const int num_positions = Length(ct.arguments[1]);
   const int64_t first_bin = ct.arguments[2].values[0];
@@ -464,6 +487,7 @@ bool CheckOrToolsBinPackingCapa(
 bool CheckOrToolsBinPackingLoad(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int num_positions = Length(ct.arguments[1]);
   const int64_t first_bin = ct.arguments[2].values[0];
   const int64_t last_bin = ct.arguments[2].values[1];
@@ -486,6 +510,7 @@ bool CheckOrToolsBinPackingLoad(
 bool CheckOrToolsNValue(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t card = Eval(ct.arguments[0], evaluator);
   absl::flat_hash_set<int64_t> values;
   for (int i = 0; i < Length(ct.arguments[1]); ++i) {
@@ -507,6 +532,7 @@ int64_t ComputeCount(const Constraint& ct,
 bool CheckOrToolsCountEq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   return count == expected;
@@ -515,6 +541,7 @@ bool CheckOrToolsCountEq(
 bool CheckCountGeq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   return count >= expected;
@@ -523,6 +550,7 @@ bool CheckCountGeq(
 bool CheckCountGt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   return count > expected;
@@ -531,6 +559,7 @@ bool CheckCountGt(
 bool CheckCountLeq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   return count <= expected;
@@ -539,6 +568,7 @@ bool CheckCountLeq(
 bool CheckCountLt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   return count < expected;
@@ -547,6 +577,7 @@ bool CheckCountLt(
 bool CheckCountNeq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   return count != expected;
@@ -555,6 +586,7 @@ bool CheckCountNeq(
 bool CheckCountReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t count = ComputeCount(ct, evaluator);
   const int64_t expected = Eval(ct.arguments[2], evaluator);
   const int64_t status = Eval(ct.arguments[3], evaluator);
@@ -564,6 +596,7 @@ bool CheckCountReif(
 bool CheckCumulative(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   // TODO(user): Improve complexity for large durations.
   const int64_t capacity = Eval(ct.arguments[3], evaluator);
   const int size = Length(ct.arguments[0]);
@@ -587,6 +620,7 @@ bool CheckCumulative(
 bool CheckOrToolsCumulativeOpt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 5) return false;
   // TODO: Improve complexity for large durations.
   const int64_t capacity = Eval(ct.arguments[4], evaluator);
   const int size = Length(ct.arguments[0]);
@@ -640,6 +674,7 @@ bool CheckDiffnNonStrictK(
 bool CheckDisjunctive(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int size = Length(ct.arguments[0]);
   CHECK_EQ(size, Length(ct.arguments[1]));
   std::vector<std::pair<int64_t, int64_t>> start_durations_pairs;
@@ -662,6 +697,7 @@ bool CheckDisjunctive(
 bool CheckDisjunctiveStrict(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int size = Length(ct.arguments[0]);
   CHECK_EQ(size, Length(ct.arguments[1]));
   std::vector<std::pair<int64_t, int64_t>> start_durations_pairs;
@@ -683,6 +719,7 @@ bool CheckDisjunctiveStrict(
 bool CheckOrToolsDisjunctiveStrictOpt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int size = Length(ct.arguments[0]);
   CHECK_EQ(size, Length(ct.arguments[1]));
   CHECK_EQ(size, Length(ct.arguments[2]));
@@ -706,6 +743,7 @@ bool CheckOrToolsDisjunctiveStrictOpt(
 bool CheckPartitionSet(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   absl::flat_hash_set<int64_t> visited;
   for (int i = 0; i < Length(ct.arguments[0]); ++i) {
     for (const int64_t value : SetEvalAt(ct.arguments[0], i, set_evaluator)) {
@@ -754,6 +792,7 @@ std::vector<int64_t> ComputeGlobalCardinalityCards(
 bool CheckOrToolsGlobalCardinality(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const std::vector<int64_t> cards =
       ComputeGlobalCardinalityCards(ct, evaluator);
   CHECK_EQ(cards.size(), Length(ct.arguments[2]));
@@ -778,6 +817,7 @@ bool CheckOrToolsGlobalCardinality(
 bool CheckOrToolsGlobalCardinalityLowUp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 5) return false;
   const std::vector<int64_t> cards =
       ComputeGlobalCardinalityCards(ct, evaluator);
   CHECK_EQ(cards.size(), ct.arguments[2].values.size());
@@ -803,6 +843,7 @@ bool CheckOrToolsGlobalCardinalityLowUp(
 bool CheckIntAbs(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return std::abs(left) == right;
@@ -811,6 +852,7 @@ bool CheckIntAbs(
 bool CheckIntDiv(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t target = Eval(ct.arguments[2], evaluator);
@@ -820,6 +862,7 @@ bool CheckIntDiv(
 bool CheckIntEq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left == right;
@@ -828,6 +871,7 @@ bool CheckIntEq(
 bool CheckIntEqImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -837,6 +881,7 @@ bool CheckIntEqImp(
 bool CheckIntEqReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -846,6 +891,7 @@ bool CheckIntEqReif(
 bool CheckIntGe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left >= right;
@@ -854,6 +900,7 @@ bool CheckIntGe(
 bool CheckIntGeImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -863,6 +910,7 @@ bool CheckIntGeImp(
 bool CheckIntGeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -872,6 +920,7 @@ bool CheckIntGeReif(
 bool CheckIntGt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left > right;
@@ -880,6 +929,7 @@ bool CheckIntGt(
 bool CheckIntGtImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -889,6 +939,7 @@ bool CheckIntGtImp(
 bool CheckIntGtReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -898,6 +949,7 @@ bool CheckIntGtReif(
 bool CheckIntLe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left <= right;
@@ -906,6 +958,7 @@ bool CheckIntLe(
 bool CheckIntLeImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -915,6 +968,7 @@ bool CheckIntLeImp(
 bool CheckIntLeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -924,6 +978,7 @@ bool CheckIntLeReif(
 bool CheckIntLt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left < right;
@@ -932,6 +987,7 @@ bool CheckIntLt(
 bool CheckIntLtImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -941,6 +997,7 @@ bool CheckIntLtImp(
 bool CheckIntLtReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -960,6 +1017,7 @@ int64_t ComputeIntLin(const Constraint& ct,
 bool CheckIntLinEq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   return left == right;
@@ -968,6 +1026,7 @@ bool CheckIntLinEq(
 bool CheckIntLinEqImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -977,6 +1036,7 @@ bool CheckIntLinEqImp(
 bool CheckIntLinEqReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -986,6 +1046,7 @@ bool CheckIntLinEqReif(
 bool CheckIntLinGe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   return left >= right;
@@ -994,6 +1055,7 @@ bool CheckIntLinGe(
 bool CheckIntLinGeImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -1003,6 +1065,7 @@ bool CheckIntLinGeImp(
 bool CheckIntLinGeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -1012,6 +1075,7 @@ bool CheckIntLinGeReif(
 bool CheckIntLinLe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   return left <= right;
@@ -1020,6 +1084,7 @@ bool CheckIntLinLe(
 bool CheckIntLinLeImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -1029,6 +1094,7 @@ bool CheckIntLinLeImp(
 bool CheckIntLinLeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -1038,6 +1104,7 @@ bool CheckIntLinLeReif(
 bool CheckIntLinNe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   return left != right;
@@ -1046,6 +1113,7 @@ bool CheckIntLinNe(
 bool CheckIntLinNeImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -1055,6 +1123,7 @@ bool CheckIntLinNeImp(
 bool CheckIntLinNeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t left = ComputeIntLin(ct, evaluator);
   const int64_t right = Eval(ct.arguments[2], evaluator);
   const bool status = Eval(ct.arguments[3], evaluator) != 0;
@@ -1064,6 +1133,7 @@ bool CheckIntLinNeReif(
 bool CheckIntMax(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t status = Eval(ct.arguments[2], evaluator);
@@ -1073,6 +1143,7 @@ bool CheckIntMax(
 bool CheckIntMin(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t status = Eval(ct.arguments[2], evaluator);
@@ -1082,6 +1153,7 @@ bool CheckIntMin(
 bool CheckIntMinus(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t target = Eval(ct.arguments[2], evaluator);
@@ -1091,6 +1163,7 @@ bool CheckIntMinus(
 bool CheckIntMod(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t target = Eval(ct.arguments[2], evaluator);
@@ -1100,6 +1173,7 @@ bool CheckIntMod(
 bool CheckIntNe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left != right;
@@ -1108,6 +1182,7 @@ bool CheckIntNe(
 bool CheckIntNeImp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -1117,6 +1192,7 @@ bool CheckIntNeImp(
 bool CheckIntNeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -1126,6 +1202,7 @@ bool CheckIntNeReif(
 bool CheckIntNegate(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   return left == -right;
@@ -1134,6 +1211,7 @@ bool CheckIntNegate(
 bool CheckIntPlus(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t target = Eval(ct.arguments[2], evaluator);
@@ -1143,6 +1221,7 @@ bool CheckIntPlus(
 bool CheckIntTimes(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t left = Eval(ct.arguments[0], evaluator);
   const int64_t right = Eval(ct.arguments[1], evaluator);
   const int64_t target = Eval(ct.arguments[2], evaluator);
@@ -1152,6 +1231,7 @@ bool CheckIntTimes(
 bool CheckOrToolsInverse(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   CHECK_EQ(Length(ct.arguments[0]), Length(ct.arguments[1]));
   const int size = Length(ct.arguments[0]);
   const int f_base = ct.arguments[2].Value();
@@ -1180,6 +1260,7 @@ bool CheckOrToolsInverse(
 bool CheckOrToolsLexLessInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int min_size =
       std::min(Length(ct.arguments[0]), Length(ct.arguments[1]));
   for (int i = 0; i < min_size; ++i) {
@@ -1199,6 +1280,7 @@ bool CheckOrToolsLexLessInt(
 bool CheckOrToolsLexLesseqInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int min_size =
       std::min(Length(ct.arguments[0]), Length(ct.arguments[1]));
   for (int i = 0; i < min_size; ++i) {
@@ -1218,6 +1300,7 @@ bool CheckOrToolsLexLesseqInt(
 bool CheckMaximumArgInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t max_index = Eval(ct.arguments[1], evaluator) - 1;
   const int64_t max_value = EvalAt(ct.arguments[0], max_index, evaluator);
   // Checks that all value before max_index are < max_value.
@@ -1239,6 +1322,7 @@ bool CheckMaximumArgInt(
 bool CheckMaximumInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   int64_t max_value = std::numeric_limits<int64_t>::min();
   for (int i = 0; i < Length(ct.arguments[1]); ++i) {
     max_value = std::max(max_value, EvalAt(ct.arguments[1], i, evaluator));
@@ -1249,6 +1333,7 @@ bool CheckMaximumInt(
 bool CheckMinimumArgInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t min_index = Eval(ct.arguments[1], evaluator) - 1;
   const int64_t min_value = EvalAt(ct.arguments[0], min_index, evaluator);
   // Checks that all value before min_index are > min_value.
@@ -1270,6 +1355,7 @@ bool CheckMinimumArgInt(
 bool CheckMinimumInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   int64_t min_value = std::numeric_limits<int64_t>::max();
   for (int i = 0; i < Length(ct.arguments[1]); ++i) {
     min_value = std::min(min_value, EvalAt(ct.arguments[1], i, evaluator));
@@ -1301,6 +1387,7 @@ bool CheckNetworkFlowConservation(
 bool CheckOrToolsNetworkFlow(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   return CheckNetworkFlowConservation(ct.arguments[0], ct.arguments[1],
                                       ct.arguments[2].Value(), ct.arguments[3],
                                       evaluator);
@@ -1309,6 +1396,7 @@ bool CheckOrToolsNetworkFlow(
 bool CheckOrToolsNetworkFlowCost(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 6) return false;
   if (!CheckNetworkFlowConservation(ct.arguments[0], ct.arguments[1],
                                     ct.arguments[2].Value(), ct.arguments[3],
                                     evaluator)) {
@@ -1343,6 +1431,7 @@ bool CheckRegularNfa(
 bool CheckSetCard(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t set_size = SetSize(ct.arguments[0], set_evaluator);
   const int64_t cardinality = Eval(ct.arguments[1], evaluator);
   return set_size == cardinality;
@@ -1351,6 +1440,7 @@ bool CheckSetCard(
 bool CheckArraySetElement(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t index = Eval(ct.arguments[0], evaluator);
   const int64_t min_index = ct.arguments[0].Var()->domain.Min();
   const std::vector<int64_t> element =
@@ -1362,6 +1452,7 @@ bool CheckArraySetElement(
 bool CheckSetIn(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t value = Eval(ct.arguments[0], evaluator);
   const std::vector<int64_t> set = SetEval(ct.arguments[1], set_evaluator);
   return std::find(set.begin(), set.end(), value) != set.end();
@@ -1370,6 +1461,7 @@ bool CheckSetIn(
 bool CheckSetNotIn(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const int64_t value = Eval(ct.arguments[0], evaluator);
   const std::vector<int64_t> set = SetEval(ct.arguments[1], set_evaluator);
   return std::find(set.begin(), set.end(), value) == set.end();
@@ -1378,6 +1470,7 @@ bool CheckSetNotIn(
 bool CheckSetInReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t value = Eval(ct.arguments[0], evaluator);
   const std::vector<int64_t> set = SetEval(ct.arguments[1], set_evaluator);
   const bool contain = std::find(set.begin(), set.end(), value) != set.end();
@@ -1388,6 +1481,7 @@ bool CheckSetInReif(
 bool CheckSetIntersect(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
@@ -1402,6 +1496,7 @@ bool CheckSetIntersect(
 bool CheckSetUnion(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
@@ -1416,6 +1511,7 @@ bool CheckSetUnion(
 bool CheckSetSubset(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   return std::includes(values_y.begin(), values_y.end(), values_x.begin(),
@@ -1425,6 +1521,7 @@ bool CheckSetSubset(
 bool CheckSetSubsetReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -1435,6 +1532,7 @@ bool CheckSetSubsetReif(
 bool CheckSetSuperset(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   return std::includes(values_x.begin(), values_x.end(), values_y.begin(),
@@ -1444,6 +1542,7 @@ bool CheckSetSuperset(
 bool CheckSetSupersetReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -1454,6 +1553,7 @@ bool CheckSetSupersetReif(
 bool CheckSetDiff(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
@@ -1468,6 +1568,7 @@ bool CheckSetDiff(
 bool CheckSetSymDiff(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
@@ -1482,6 +1583,7 @@ bool CheckSetSymDiff(
 bool CheckSetEq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   return values_x == values_y;
@@ -1490,6 +1592,7 @@ bool CheckSetEq(
 bool CheckSetEqReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -1499,6 +1602,7 @@ bool CheckSetEqReif(
 bool CheckSetNe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   return values_x != values_y;
@@ -1507,6 +1611,7 @@ bool CheckSetNe(
 bool CheckSetLe(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const int min_size = std::min(values_x.size(), values_y.size());
@@ -1520,6 +1625,7 @@ bool CheckSetLe(
 bool CheckSetLeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const int min_size = std::min(values_x.size(), values_y.size());
@@ -1539,6 +1645,7 @@ bool CheckSetLeReif(
 bool CheckSetLt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const int min_size = std::min(values_x.size(), values_y.size());
@@ -1552,6 +1659,7 @@ bool CheckSetLt(
 bool CheckSetLtReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const int min_size = std::min(values_x.size(), values_y.size());
@@ -1571,6 +1679,7 @@ bool CheckSetLtReif(
 bool CheckSetNeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const bool status = Eval(ct.arguments[2], evaluator) != 0;
@@ -1580,6 +1689,7 @@ bool CheckSetNeReif(
 bool CheckSlidingSum(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 4) return false;
   const int64_t low = Eval(ct.arguments[0], evaluator);
   const int64_t up = Eval(ct.arguments[1], evaluator);
   const int64_t length = Eval(ct.arguments[2], evaluator);
@@ -1604,6 +1714,7 @@ bool CheckSlidingSum(
 bool CheckSort(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   CHECK_EQ(Length(ct.arguments[0]), Length(ct.arguments[1]));
   absl::flat_hash_map<int64_t, int> init_count;
   absl::flat_hash_map<int64_t, int> sorted_count;
@@ -1626,6 +1737,7 @@ bool CheckSort(
 bool CheckOrToolsSubCircuit(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   absl::flat_hash_set<int64_t> visited;
   const int base = ct.arguments[1].Value();
   // Find inactive nodes (pointing to themselves).
@@ -1664,6 +1776,7 @@ bool CheckOrToolsTableInt(
 bool CheckSymmetricAllDifferent(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 1) return false;
   const int size = Length(ct.arguments[0]);
   for (int i = 0; i < size; ++i) {
     const int64_t value = EvalAt(ct.arguments[0], i, evaluator) - 1;
@@ -1681,6 +1794,7 @@ bool CheckSymmetricAllDifferent(
 bool CheckValuePrecedeInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 3) return false;
   const int64_t before = ct.arguments[0].Value();
   const int64_t after = ct.arguments[1].Value();
   const int64_t length = Length(ct.arguments[2]);
@@ -1696,6 +1810,7 @@ bool CheckValuePrecedeInt(
 bool CheckOrToolsPrecedeChainInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  if (ct.arguments.size() < 2) return false;
   absl::flat_hash_map<int64_t, int> value_to_index;
   if (ct.arguments[0].type == fz::Argument::INT_INTERVAL) {
     for (int64_t v = ct.arguments[0].values[0]; v <= ct.arguments[0].values[1];
diff --git a/ortools/flatzinc/cp_model_fz_solver.cc b/ortools/flatzinc/cp_model_fz_solver.cc
index 883e6cc859b..910f73870f5 100644
--- a/ortools/flatzinc/cp_model_fz_solver.cc
+++ b/ortools/flatzinc/cp_model_fz_solver.cc
@@ -1278,6 +1278,7 @@ void CpModelProtoWithMapping::AlwaysFalseConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::BoolClauseConstraint(const fz::Constraint& fz_ct,
                                                    ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_bool_or();
   for (const int var : LookupVars(fz_ct.arguments[0])) {
     arg->add_literals(var);
@@ -1288,6 +1289,7 @@ void CpModelProtoWithMapping::BoolClauseConstraint(const fz::Constraint& fz_ct,
 }
 void CpModelProtoWithMapping::BoolXorConstraint(const fz::Constraint& fz_ct,
                                                 ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   // This is not the same semantics as the array_bool_xor as this constraint
   // is actually a fully reified xor(a, b) <==> x.
   const int a = LookupVar(fz_ct.arguments[0]);
@@ -1306,6 +1308,7 @@ void CpModelProtoWithMapping::BoolXorConstraint(const fz::Constraint& fz_ct,
 }
 void CpModelProtoWithMapping::ArrayBoolXorConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 1);
   auto* arg = ct->mutable_bool_xor();
   for (const int var : LookupVars(fz_ct.arguments[0])) {
     arg->add_literals(var);
@@ -1339,6 +1342,7 @@ void CpModelProtoWithMapping::BoolEqConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::BoolNeConstraint(const fz::Constraint& fz_ct,
                                                ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_linear();
   FillDomainInProto(1, arg);
   AddTermToLinearConstraint(LookupVar(fz_ct.arguments[0]), 1, arg);
@@ -1354,6 +1358,7 @@ void CpModelProtoWithMapping::IntNeConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntLinEqConstraint(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   // Special case for the index of element 2D and element 3D constraints.
   if (fz_ct.strong_propagation && fz_ct.arguments[0].Size() >= 3 &&
       fz_ct.arguments[0].Size() <= 4 &&
@@ -1367,6 +1372,7 @@ void CpModelProtoWithMapping::IntLinEqConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::BoolLinEqConstraint(const fz::Constraint& fz_ct,
                                                   ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_linear();
   const std::vector<int> vars = LookupVars(fz_ct.arguments[1]);
   if (fz_ct.arguments[2].IsVariable()) {
@@ -1383,6 +1389,7 @@ void CpModelProtoWithMapping::BoolLinEqConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::BoolOrIntLinLeConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int64_t rhs = fz_ct.arguments[2].values[0];
   FillLinearConstraintWithGivenDomain(
       {std::numeric_limits<int64_t>::min(), rhs}, fz_ct, ct);
@@ -1390,6 +1397,7 @@ void CpModelProtoWithMapping::BoolOrIntLinLeConstraint(
 
 void CpModelProtoWithMapping::IntLinLtConstraint(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int64_t rhs = fz_ct.arguments[2].values[0];
   FillLinearConstraintWithGivenDomain(
       {std::numeric_limits<int64_t>::min(), rhs - 1}, fz_ct, ct);
@@ -1397,6 +1405,7 @@ void CpModelProtoWithMapping::IntLinLtConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntLinGeConstraint(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int64_t rhs = fz_ct.arguments[2].values[0];
   FillLinearConstraintWithGivenDomain(
       {rhs, std::numeric_limits<int64_t>::max()}, fz_ct, ct);
@@ -1404,6 +1413,7 @@ void CpModelProtoWithMapping::IntLinGeConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntLinGtConstraint(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int64_t rhs = fz_ct.arguments[2].values[0];
   FillLinearConstraintWithGivenDomain(
       {rhs + 1, std::numeric_limits<int64_t>::max()}, fz_ct, ct);
@@ -1411,6 +1421,7 @@ void CpModelProtoWithMapping::IntLinGtConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntLinNeConstraint(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int64_t rhs = fz_ct.arguments[2].values[0];
   FillLinearConstraintWithGivenDomain(
       {std::numeric_limits<int64_t>::min(), rhs - 1, rhs + 1,
@@ -1420,6 +1431,7 @@ void CpModelProtoWithMapping::IntLinNeConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::SetCardConstraint(const fz::Constraint& fz_ct,
                                                 ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   int64_t set_size = 0;
   if (fz_ct.arguments[0].type == fz::Argument::INT_LIST) {
     set_size = fz_ct.arguments[0].values.size();
@@ -1436,6 +1448,7 @@ void CpModelProtoWithMapping::SetCardConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::SetInConstraint(const fz::Constraint& fz_ct,
                                               ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_linear();
   arg->add_vars(LookupVar(fz_ct.arguments[0]));
   arg->add_coeffs(1);
@@ -1454,6 +1467,7 @@ void CpModelProtoWithMapping::SetInConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::SetInNegatedConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_linear();
   if (fz_ct.arguments[1].type == fz::Argument::INT_LIST) {
     FillDomainInProto(Domain::FromValues(std::vector<int64_t>{
@@ -1474,6 +1488,7 @@ void CpModelProtoWithMapping::SetInNegatedConstraint(
 
 void CpModelProtoWithMapping::IntMinConstraint(const fz::Constraint& fz_ct,
                                                ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_lin_max();
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0], /*negate=*/true);
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[1], /*negate=*/true);
@@ -1482,6 +1497,7 @@ void CpModelProtoWithMapping::IntMinConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::ArrayIntMinConstraint(const fz::Constraint& fz_ct,
                                                     ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_lin_max();
   *arg->mutable_target() = LookupExpr(fz_ct.arguments[0], /*negate=*/true);
   for (int i = 0; i < fz_ct.arguments[1].Size(); ++i) {
@@ -1491,6 +1507,7 @@ void CpModelProtoWithMapping::ArrayIntMinConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntMaxConstraint(const fz::Constraint& fz_ct,
                                                ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_lin_max();
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0]);
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[1]);
@@ -1499,6 +1516,7 @@ void CpModelProtoWithMapping::IntMaxConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::ArrayIntMaxConstraint(const fz::Constraint& fz_ct,
                                                     ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_lin_max();
   *arg->mutable_target() = LookupExpr(fz_ct.arguments[0]);
   for (int i = 0; i < fz_ct.arguments[1].Size(); ++i) {
@@ -1508,6 +1526,7 @@ void CpModelProtoWithMapping::ArrayIntMaxConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntTimesConstraint(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_int_prod();
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0]);
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[1]);
@@ -1516,6 +1535,7 @@ void CpModelProtoWithMapping::IntTimesConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntAbsConstraint(const fz::Constraint& fz_ct,
                                                ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_lin_max();
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0]);
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0], /*negate=*/true);
@@ -1524,6 +1544,7 @@ void CpModelProtoWithMapping::IntAbsConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntPlusConstraint(const fz::Constraint& fz_ct,
                                                 ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_linear();
   FillDomainInProto(0, arg);
   AddTermToLinearConstraint(LookupVar(fz_ct.arguments[0]), 1, arg);
@@ -1533,6 +1554,7 @@ void CpModelProtoWithMapping::IntPlusConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntDivConstraint(const fz::Constraint& fz_ct,
                                                ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_int_div();
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0]);
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[1]);
@@ -1541,6 +1563,7 @@ void CpModelProtoWithMapping::IntDivConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::IntModConstraint(const fz::Constraint& fz_ct,
                                                ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_int_mod();
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[0]);
   *arg->add_exprs() = LookupExpr(fz_ct.arguments[1]);
@@ -1549,6 +1572,7 @@ void CpModelProtoWithMapping::IntModConstraint(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::ArrayElementConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   auto* arg = ct->mutable_element();
   *arg->mutable_linear_index() = LookupExpr(fz_ct.arguments[0]);
   if (!absl::EndsWith(fz_ct.type, "_nonshifted")) {
@@ -1569,6 +1593,7 @@ void CpModelProtoWithMapping::ArrayElementConstraint(
 
 void CpModelProtoWithMapping::OrToolsConstantElementConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   auto* arg = ct->mutable_element();
 
   // Index.
@@ -1588,6 +1613,7 @@ void CpModelProtoWithMapping::OrToolsConstantElementConstraint(
 
 void CpModelProtoWithMapping::OrToolsVariableElementConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   auto* arg = ct->mutable_element();
 
   // Index.
@@ -1613,6 +1639,7 @@ void CpModelProtoWithMapping::OrToolsVariableElementConstraint(
 
 void CpModelProtoWithMapping::OrToolsTableIntConstraint(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   auto* arg = ct->mutable_table();
   for (const VarOrValue v : LookupVarsOrValues(fz_ct.arguments[0])) {
     LinearExpressionProto* expr = arg->add_exprs();
@@ -1628,6 +1655,7 @@ void CpModelProtoWithMapping::OrToolsTableIntConstraint(
 
 void CpModelProtoWithMapping::OrToolsRegular(const fz::Constraint& fz_ct,
                                              ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 6);
   auto* arg = ct->mutable_automaton();
   for (const VarOrValue v : LookupVarsOrValues(fz_ct.arguments[0])) {
     LinearExpressionProto* expr = arg->add_exprs();
@@ -1680,6 +1708,7 @@ void CpModelProtoWithMapping::OrToolsRegular(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsArgMax(const fz::Constraint& fz_ct,
                                             ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
   const int num_vars = x.size();
   const int z = LookupVar(fz_ct.arguments[1]);
@@ -1729,6 +1758,7 @@ void CpModelProtoWithMapping::OrToolsArgMax(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::FznAllDifferentInt(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 1);
   auto* arg = ct->mutable_all_diff();
   for (int i = 0; i < fz_ct.arguments[0].Size(); ++i) {
     *arg->add_exprs() = LookupExprAt(fz_ct.arguments[0], i);
@@ -1737,6 +1767,7 @@ void CpModelProtoWithMapping::FznAllDifferentInt(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::FznValuePrecedeInt(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int64_t before = fz_ct.arguments[0].Value();
   const int64_t after = fz_ct.arguments[1].Value();
   const std::vector<int> x = LookupVars(fz_ct.arguments[2]);
@@ -1774,6 +1805,7 @@ void CpModelProtoWithMapping::FznValuePrecedeInt(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsCountEqCst(const fz::Constraint& fz_ct,
                                                 ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const std::vector<VarOrValue> counts = LookupVarsOrValues(fz_ct.arguments[0]);
   const int64_t value = fz_ct.arguments[1].Value();
   const VarOrValue target = LookupVarOrValue(fz_ct.arguments[2]);
@@ -1802,6 +1834,7 @@ void CpModelProtoWithMapping::OrToolsCountEqCst(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsCountEq(const fz::Constraint& fz_ct,
                                              ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const std::vector<VarOrValue> counts = LookupVarsOrValues(fz_ct.arguments[0]);
   const int var = LookupVar(fz_ct.arguments[1]);
   const VarOrValue target = LookupVarOrValue(fz_ct.arguments[2]);
@@ -1822,6 +1855,7 @@ void CpModelProtoWithMapping::OrToolsCountEq(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsCircuit(const fz::Constraint& fz_ct,
                                              ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const int64_t min_index = fz_ct.arguments[1].Value();
   const int size = std::max(fz_ct.arguments[0].values.size(),
                             fz_ct.arguments[0].variables.size());
@@ -1873,6 +1907,7 @@ void CpModelProtoWithMapping::OrToolsCircuit(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsInverse(const fz::Constraint& fz_ct,
                                              ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   auto* arg = ct->mutable_inverse();
 
   const auto direct_variables = LookupVars(fz_ct.arguments[0]);
@@ -1937,6 +1972,7 @@ void CpModelProtoWithMapping::OrToolsInverse(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsLexOrdering(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
   const std::vector<int> y = LookupVars(fz_ct.arguments[1]);
   const bool accepts_equals = fz_ct.type == "ortools_lex_lesseq_bool" ||
@@ -1947,6 +1983,7 @@ void CpModelProtoWithMapping::OrToolsLexOrdering(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsPrecedeChainInt(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   std::vector<int64_t> values;
   if (fz_ct.arguments[0].type == fz::Argument::INT_INTERVAL) {
     values.reserve(fz_ct.arguments[0].values[1] - fz_ct.arguments[0].values[0] +
@@ -1991,6 +2028,7 @@ void CpModelProtoWithMapping::OrToolsPrecedeChainInt(
 
 void CpModelProtoWithMapping::FznDisjunctive(const fz::Constraint& fz_ct,
                                              ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const std::vector<VarOrValue> starts = LookupVarsOrValues(fz_ct.arguments[0]);
   const std::vector<VarOrValue> sizes = LookupVarsOrValues(fz_ct.arguments[1]);
 
@@ -2005,6 +2043,7 @@ void CpModelProtoWithMapping::FznDisjunctive(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::FznDisjunctiveStrict(const fz::Constraint& fz_ct,
                                                    ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const std::vector<VarOrValue> starts = LookupVarsOrValues(fz_ct.arguments[0]);
   const std::vector<VarOrValue> sizes = LookupVarsOrValues(fz_ct.arguments[1]);
 
@@ -2017,6 +2056,7 @@ void CpModelProtoWithMapping::FznDisjunctiveStrict(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::FznCumulative(const fz::Constraint& fz_ct,
                                             ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   const std::vector<VarOrValue> starts = LookupVarsOrValues(fz_ct.arguments[0]);
   const std::vector<VarOrValue> sizes = LookupVarsOrValues(fz_ct.arguments[1]);
   const std::vector<VarOrValue> demands =
@@ -2056,6 +2096,7 @@ void CpModelProtoWithMapping::FznCumulative(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsCumulativeOpt(const fz::Constraint& fz_ct,
                                                    ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 5);
   const std::vector<int> occurs = LookupVars(fz_ct.arguments[0]);
   const std::vector<VarOrValue> starts = LookupVarsOrValues(fz_ct.arguments[1]);
   const std::vector<VarOrValue> durations =
@@ -2085,6 +2126,7 @@ void CpModelProtoWithMapping::OrToolsCumulativeOpt(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsDisjunctiveStrictOpt(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const std::vector<int> occurs = LookupVars(fz_ct.arguments[0]);
   const std::vector<VarOrValue> starts = LookupVarsOrValues(fz_ct.arguments[1]);
   const std::vector<VarOrValue> durations =
@@ -2099,6 +2141,7 @@ void CpModelProtoWithMapping::OrToolsDisjunctiveStrictOpt(
 
 void CpModelProtoWithMapping::FznDiffn(const fz::Constraint& fz_ct,
                                        ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   const bool is_strict = fz_ct.type == "fzn_diffn";
   const std::vector<VarOrValue> x = LookupVarsOrValues(fz_ct.arguments[0]);
   const std::vector<VarOrValue> y = LookupVarsOrValues(fz_ct.arguments[1]);
@@ -2119,6 +2162,7 @@ void CpModelProtoWithMapping::FznDiffn(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsNetworkFlow(const fz::Constraint& fz_ct,
                                                  ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 6);
   // Note that we leave ct empty here (with just the name set).
   // We simply do a linear encoding of this constraint.
   const bool has_cost = fz_ct.type == "ortools_network_flow_cost";
@@ -2161,6 +2205,7 @@ void CpModelProtoWithMapping::OrToolsNetworkFlow(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsBinPacking(const fz::Constraint& fz_ct,
                                                 ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int capacity = fz_ct.arguments[0].Value();
   const std::vector<int> positions = LookupVars(fz_ct.arguments[1]);
   CHECK_EQ(fz_ct.arguments[2].type, fz::Argument::INT_LIST);
@@ -2190,6 +2235,7 @@ void CpModelProtoWithMapping::OrToolsBinPacking(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsBinPackingCapa(const fz::Constraint& fz_ct,
                                                     ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   const std::vector<int64_t>& capacities = fz_ct.arguments[0].values;
   const std::vector<int> bins = LookupVars(fz_ct.arguments[1]);
   CHECK_EQ(fz_ct.arguments[2].type, fz::Argument::INT_INTERVAL);
@@ -2224,6 +2270,7 @@ void CpModelProtoWithMapping::OrToolsBinPackingCapa(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsBinPackingLoad(const fz::Constraint& fz_ct,
                                                     ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   const std::vector<int>& loads = LookupVars(fz_ct.arguments[0]);
   const std::vector<int> positions = LookupVars(fz_ct.arguments[1]);
   if (fz_ct.arguments[3].values.empty()) {  // No items.
@@ -2276,6 +2323,7 @@ void CpModelProtoWithMapping::OrToolsBinPackingLoad(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsNvalue(const fz::Constraint& fz_ct,
                                             ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const int card = LookupVar(fz_ct.arguments[0]);
   const std::vector<int>& x = LookupVars(fz_ct.arguments[1]);
 
@@ -2311,6 +2359,7 @@ void CpModelProtoWithMapping::OrToolsNvalue(const fz::Constraint& fz_ct,
 
 void CpModelProtoWithMapping::OrToolsGlobalCardinality(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 4);
   const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
   CHECK_EQ(fz_ct.arguments[1].type, fz::Argument::INT_LIST);
   const std::vector<int64_t>& values = fz_ct.arguments[1].values;
@@ -2354,6 +2403,7 @@ void CpModelProtoWithMapping::OrToolsGlobalCardinality(
 
 void CpModelProtoWithMapping::OrToolsGlobalCardinalityLowUp(
     const fz::Constraint& fz_ct, ConstraintProto* ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 5);
   const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
   CHECK(fz_ct.arguments[1].type == fz::Argument::INT_LIST ||
         fz_ct.arguments[1].type == fz::Argument::VOID_ARGUMENT);
@@ -2546,6 +2596,7 @@ void CpModelProtoWithMapping::FirstPass(const fz::Constraint& fz_ct) {
 
 void CpModelProtoWithMapping::ArraySetElementConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int index = LookupVar(fz_ct.arguments[0]);
   const Domain index_domain = ReadDomainFromProto(proto.variables(index));
   const std::shared_ptr<SetVariable> target_var =
@@ -2605,6 +2656,7 @@ void CpModelProtoWithMapping::ArraySetElementConstraint(
 
 void CpModelProtoWithMapping::ArrayVarSetElementConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   const int index = LookupVar(fz_ct.arguments[0]);
   const Domain index_domain = ReadDomainFromProto(proto.variables(index));
   const int64_t min_index = index_domain.Min();
@@ -2654,6 +2706,7 @@ void CpModelProtoWithMapping::ArrayVarSetElementConstraint(
 
 void CpModelProtoWithMapping::FznAllDifferentSetConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 1);
   const int num_vars = fz_ct.arguments[0].Size();
   if (num_vars == 0) return;
 
@@ -2677,6 +2730,7 @@ void CpModelProtoWithMapping::FznAllDifferentSetConstraint(
 
 void CpModelProtoWithMapping::FznAllDisjointConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 1);
   const int num_vars = fz_ct.arguments[0].Size();
   if (num_vars == 0) return;
 
@@ -2700,6 +2754,7 @@ void CpModelProtoWithMapping::FznAllDisjointConstraint(
 
 void CpModelProtoWithMapping::FznDisjointConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   std::vector<int> x_literals, y_literals;
   PutSetBooleansInCommonDomain(
       {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1])},
@@ -2714,6 +2769,7 @@ void CpModelProtoWithMapping::FznDisjointConstraint(
 
 void CpModelProtoWithMapping::FznPartitionSetConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const int num_vars = fz_ct.arguments[0].Size();
   if (num_vars == 0) return;
 
@@ -2752,6 +2808,7 @@ void CpModelProtoWithMapping::FznPartitionSetConstraint(
 }
 
 void CpModelProtoWithMapping::SetCardConstraint(const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   std::shared_ptr<SetVariable> set_var = LookupSetVar(fz_ct.arguments[0]);
   VarOrValue var_or_value = LookupVarOrValue(fz_ct.arguments[1]);
   if (set_var->card_var_index == kNoVar) {
@@ -2780,6 +2837,7 @@ void CpModelProtoWithMapping::SetCardConstraint(const fz::Constraint& fz_ct) {
 }
 
 void CpModelProtoWithMapping::SetInConstraint(const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   const VarOrValue var_or_value = LookupVarOrValue(fz_ct.arguments[0]);
   std::shared_ptr<SetVariable> set_var = LookupSetVar(fz_ct.arguments[1]);
   if (var_or_value.var == kNoVar) {
@@ -2838,6 +2896,7 @@ void CpModelProtoWithMapping::SetInConstraint(const fz::Constraint& fz_ct) {
 }
 
 void CpModelProtoWithMapping::SetInReifConstraint(const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   VarOrValue var_or_value = LookupVarOrValue(fz_ct.arguments[0]);
   std::shared_ptr<const SetVariable> set_var = LookupSetVar(fz_ct.arguments[1]);
   const int enforcement_literal = LookupVar(fz_ct.arguments[2]);
@@ -2875,6 +2934,7 @@ void CpModelProtoWithMapping::SetInReifConstraint(const fz::Constraint& fz_ct) {
 }
 
 void CpModelProtoWithMapping::SetOpConstraint(const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   std::vector<int> x_literals, y_literals, r_literals;
   PutSetBooleansInCommonDomain(
       {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1]),
@@ -2902,6 +2962,7 @@ void CpModelProtoWithMapping::SetOpConstraint(const fz::Constraint& fz_ct) {
 
 void CpModelProtoWithMapping::SetSubSupersetEqConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   std::vector<int> x_literals, y_literals;
   PutSetBooleansInCommonDomain(
       {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1])},
@@ -2925,6 +2986,7 @@ void CpModelProtoWithMapping::SetSubSupersetEqConstraint(
 }
 
 void CpModelProtoWithMapping::SetNeConstraint(const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 2);
   std::vector<int> x_literals, y_literals;
   PutSetBooleansInCommonDomain(
       {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1])},
@@ -2934,6 +2996,7 @@ void CpModelProtoWithMapping::SetNeConstraint(const fz::Constraint& fz_ct) {
 
 void CpModelProtoWithMapping::SetSubSupersetEqReifConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   std::vector<int> x_literals, y_literals;
   PutSetBooleansInCommonDomain(
       {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1])},
@@ -2965,6 +3028,7 @@ void CpModelProtoWithMapping::SetSubSupersetEqReifConstraint(
 
 void CpModelProtoWithMapping::SetLexOrderingConstraint(
     const fz::Constraint& fz_ct) {
+  DCHECK_GE(fz_ct.arguments.size(), 3);
   // set_le is tricky. Let's see all possible sets of size four in their
   // lexicographical order and their bit representation:
   // {}        0000