diff --git a/examples/tests/ac4r_table_test.cc b/examples/tests/ac4r_table_test.cc
index 80895e9733..be5c38f0a9 100644
--- a/examples/tests/ac4r_table_test.cc
+++ b/examples/tests/ac4r_table_test.cc
@@ -24,12 +24,12 @@ DEFINE_int32(upper, 10, "Upper bound of variables, lower is always 0");
 DEFINE_int32(tuples, 1000, "Number of tuples");
 DEFINE_int32(bucket, 64, "Size of buckets");
 DEFINE_bool(ac4, false, "Use AC4 Table only");
+DECLARE_bool(cp_use_ac4r_table);
 
 namespace operations_research {
 extern Constraint* BuildAc4TableConstraint(Solver* const solver,
                                            const IntTupleSet& tuples,
-                                           const std::vector<IntVar*>& vars,
-                                           int size_bucket);
+                                           const std::vector<IntVar*>& vars);
 
 void RandomFillTable(int num_tuples,
                      int64 lower,
@@ -47,10 +47,10 @@ void RandomFillTable(int num_tuples,
   }
 }
 
-void TestTable(int arity, int num_tuples, int upper, int size_bucket) {
-  if (size_bucket > 0) {
-    LOG(INFO) <<  "Creation of a Bucketed tuple Table ("
-              << size_bucket << ") with :";
+void TestTable(int arity, int num_tuples, int upper, bool use_ac4r_table) {
+  FLAGS_cp_use_ac4r_table = use_ac4r_table;
+  if (use_ac4r_table) {
+    LOG(INFO) <<  "Creation of a AC4-Regin tuple Table with :";
   } else {
     LOG(INFO) << "Creation of a Allowed Assignment Table with :";
   }
@@ -66,8 +66,8 @@ void TestTable(int arity, int num_tuples, int upper, int size_bucket) {
   RandomFillTable(num_tuples, 0, upper, &table);
   LOG(INFO) << "Table is created";
 
-  Constraint* const ct = size_bucket > 0 ?
-      BuildAc4TableConstraint(&solver, table, vars, size_bucket) :
+  Constraint* const ct = use_ac4r_table ?
+      BuildAc4TableConstraint(&solver, table, vars) :
       solver.MakeAllowedAssignments(vars, table);
   solver.AddConstraint(ct);
 
@@ -95,12 +95,15 @@ void TestTable(int arity, int num_tuples, int upper, int size_bucket) {
 int main(int argc, char** argv) {
   google::ParseCommandLineFlags(&argc, &argv, true);
   if (!FLAGS_ac4) {
-    operations_research::TestTable(FLAGS_arity, FLAGS_tuples, FLAGS_upper, 0);
+    operations_research::TestTable(FLAGS_arity,
+                                   FLAGS_tuples,
+                                   FLAGS_upper,
+                                   false);
   }
   operations_research::TestTable(FLAGS_arity,
                                  FLAGS_tuples,
                                  FLAGS_upper,
-                                 FLAGS_bucket);
+                                 true);
   return 0;
 }
 
diff --git a/src/constraint_solver/ac4r_table.cc b/src/constraint_solver/ac4r_table.cc
index 7dcf0b3ea4..1a0f78b37a 100644
--- a/src/constraint_solver/ac4r_table.cc
+++ b/src/constraint_solver/ac4r_table.cc
@@ -418,16 +418,14 @@ class Ac4TableConstraint : public Constraint {
 // External API.
 Constraint* BuildAc4TableConstraint(Solver* const solver,
                                     const IntTupleSet& tuples,
-                                    const std::vector<IntVar*>& vars,
-                                    int size_bucket) {
+                                    const std::vector<IntVar*>& vars) {
   return solver->RevAlloc(
       new Ac4TableConstraint(solver, new IndexedTable(tuples), true, vars));
 }
 
 Constraint* BuildAc4TableConstraint(Solver* const solver,
                                     IndexedTable* const table,
-                                    const std::vector<IntVar*>& vars,
-                                    int size_bucket) {
+                                    const std::vector<IntVar*>& vars) {
   return solver->RevAlloc(new Ac4TableConstraint(solver, table, true, vars));
 }
 
diff --git a/src/constraint_solver/table.cc b/src/constraint_solver/table.cc
index b916ae01e8..711c5ec499 100644
--- a/src/constraint_solver/table.cc
+++ b/src/constraint_solver/table.cc
@@ -35,6 +35,7 @@ DEFINE_bool(cp_use_compact_table, true,
             "Use compact table constraint when possible.");
 DEFINE_bool(cp_use_small_table, true,
             "Use small compact table constraint when possible.");
+DEFINE_bool(cp_use_ac4r_table, true, "Use ac4r table");
 
 namespace operations_research {
 namespace {
@@ -819,24 +820,7 @@ bool HasCompactDomains(const IntVar* const * vars, int arity) {
   }
   return sum_of_spans < 4 * sum_of_sizes;
 }
-}  // namespace
 
-Constraint* Solver::MakeAllowedAssignments(
-    const std::vector<IntVar*>& vars,
-    const IntTupleSet& tuples) {
-  if (FLAGS_cp_use_compact_table
-      && HasCompactDomains(vars.data(), vars.size())) {
-    if (tuples.NumTuples() < kBitsInUint64 && FLAGS_cp_use_small_table) {
-      return RevAlloc(
-          new SmallCompactPositiveTableConstraint(this, vars, tuples));
-    } else {
-      return RevAlloc(new CompactPositiveTableConstraint(this, vars, tuples));
-    }
-  }
-  return RevAlloc(new PositiveTableConstraint(this, vars, tuples));
-}
-
-namespace {
 // ---------- Deterministic Finite Automaton ----------
 
 // This constraint implements a finite automaton when transitions are
@@ -948,6 +932,30 @@ const int TransitionConstraint::kNextStatePosition = 2;
 const int TransitionConstraint::kTransitionTupleSize = 3;
 }  // namespace
 
+// --------- API ----------
+
+Constraint* BuildAc4TableConstraint(Solver* const solver,
+                                    const IntTupleSet& tuples,
+                                    const std::vector<IntVar*>& vars);
+
+Constraint* Solver::MakeAllowedAssignments(
+    const std::vector<IntVar*>& vars,
+    const IntTupleSet& tuples) {
+  if (tuples.NumTuples() > 512 && FLAGS_cp_use_ac4r_table) {
+    return BuildAc4TableConstraint(this, tuples, vars);
+  }
+  if (FLAGS_cp_use_compact_table
+      && HasCompactDomains(vars.data(), vars.size())) {
+    if (tuples.NumTuples() < kBitsInUint64 && FLAGS_cp_use_small_table) {
+      return RevAlloc(
+          new SmallCompactPositiveTableConstraint(this, vars, tuples));
+    } else {
+      return RevAlloc(new CompactPositiveTableConstraint(this, vars, tuples));
+    }
+  }
+  return RevAlloc(new PositiveTableConstraint(this, vars, tuples));
+}
+
 Constraint* Solver::MakeTransitionConstraint(
     const std::vector<IntVar*>& vars,
     const IntTupleSet& transition_table,