diff --git a/examples/cpp/jobshop_sat.cc b/examples/cpp/jobshop_sat.cc
index 6263304534..40736ded95 100644
--- a/examples/cpp/jobshop_sat.cc
+++ b/examples/cpp/jobshop_sat.cc
@@ -53,13 +53,14 @@ int64 ComputeHorizon(const JsspInputProblem& problem) {
   int64 max_earliest_start = 0;
   for (const Job& job : problem.jobs()) {
     if (job.has_latest_end()) {
-      max_latest_end = std::max(max_latest_end, job.latest_end().value());
+      max_latest_end =
+          std::max<int64>(max_latest_end, job.latest_end().value());
     } else {
       max_latest_end = kint64max;
     }
     if (job.has_earliest_start()) {
       max_earliest_start =
-          std::max(max_earliest_start, job.earliest_start().value());
+          std::max<int64>(max_earliest_start, job.earliest_start().value());
     }
     for (const Task& task : job.tasks()) {
       int64 max_duration = 0;
@@ -78,14 +79,14 @@ int64 ComputeHorizon(const JsspInputProblem& problem) {
     for (int i = 0; i < num_jobs; ++i) {
       int64 max_transition = 0;
       for (int j = 0; j < num_jobs; ++j) {
-        max_transition =
-            std::max(max_transition, matrix.transition_time(i * num_jobs + j));
+        max_transition = std::max<int64>(
+            max_transition, matrix.transition_time(i * num_jobs + j));
       }
       sum_of_transitions += max_transition;
     }
   }
-  return std::min(max_latest_end, sum_of_durations + sum_of_transitions +
-                  max_earliest_start);
+  return std::min<int64>(max_latest_end, sum_of_durations + sum_of_transitions +
+                                             max_earliest_start);
   // TODO(user): Uses transitions.
 }
 
@@ -138,8 +139,8 @@ void Solve(const JsspInputProblem& problem) {
       int64 min_duration = task.duration(0);
       int64 max_duration = task.duration(0);
       for (int i = 1; i < num_alternatives; ++i) {
-        min_duration = std::min(min_duration, task.duration(i));
-        max_duration = std::max(max_duration, task.duration(i));
+        min_duration = std::min<int64>(min_duration, task.duration(i));
+        max_duration = std::max<int64>(max_duration, task.duration(i));
       }
       const IntVar start = cp_model.NewIntVar(Domain(hard_start, hard_end));
       const IntVar duration =
diff --git a/ortools/bop/bop_base.cc b/ortools/bop/bop_base.cc
index 6678ee2ff9..abed0a2277 100644
--- a/ortools/bop/bop_base.cc
+++ b/ortools/bop/bop_base.cc
@@ -78,7 +78,8 @@ ProblemState::ProblemState(const LinearBooleanProblem& problem)
   const LinearObjective& objective = problem.objective();
   lower_bound_ = 0;
   for (int i = 0; i < objective.coefficients_size(); ++i) {
-    lower_bound_ += std::min(0LL, objective.coefficients(i));
+    // Fix template version for or-tools.
+    lower_bound_ += std::min<int64>(0LL, objective.coefficients(i));
   }
   upper_bound_ = solution_.IsFeasible() ? solution_.GetCost() : kint64max;
 }
diff --git a/ortools/flatzinc/presolve.cc b/ortools/flatzinc/presolve.cc
index 2300bd06a3..95c692fb90 100644
--- a/ortools/flatzinc/presolve.cc
+++ b/ortools/flatzinc/presolve.cc
@@ -1962,14 +1962,14 @@ Presolver::RuleStatus Presolver::PresolveSimplifyElement(Constraint* ct,
   if (ct->arguments[0].IsVariable()) {
     absl::flat_hash_set<int64> all_values = GetValueSet(ct->arguments[2]);
     const std::vector<int64>& array = ct->arguments[1].values;
-    const int64 array_size = array.size();
+    const int array_size = array.size();
     if (!all_values.empty()) {
       const Domain& domain = ct->arguments[0].Var()->domain;
       std::vector<int64> to_keep;
       bool remove_some = false;
       if (domain.is_interval) {
-        for (int64 v = std::max(1LL, domain.values[0]);
-             v <= std::min(array_size, domain.values[1]); ++v) {
+        for (int64 v = std::max<int64>(1, domain.values[0]);
+             v <= std::min<int64>(array_size, domain.values[1]); ++v) {
           const int64 value = array[v - 1];
           if (gtl::ContainsKey(all_values, value)) {
             to_keep.push_back(v);
@@ -2106,11 +2106,11 @@ Presolver::RuleStatus Presolver::PresolveSimplifyExprElement(Constraint* ct,
   if (ct->arguments[0].IsVariable()) {
     const Domain& domain = ct->arguments[0].Var()->domain;
     std::vector<int64> to_keep;
-    const int64 array_size = ct->arguments[1].variables.size();
+    const int array_size = ct->arguments[1].variables.size();
     bool remove_some = false;
     if (domain.is_interval) {
       for (int64 v = std::max<int64>(1, domain.values[0]);
-           v <= std::min(array_size, domain.values[1]); ++v) {
+           v <= std::min<int64>(array_size, domain.values[1]); ++v) {
         if (OverlapsAt(ct->arguments[1], v - 1, ct->arguments[2])) {
           to_keep.push_back(v);
         } else {