diff --git a/Makefile.dep b/Makefile.dep
index 1ea49eac45..e6c20d7d10 100644
--- a/Makefile.dep
+++ b/Makefile.dep
@@ -35244,3 +35244,139 @@ test/int/min-distance$(OBJSUFFIX) test/int/min-distance$(SBJSUFFIX): \
 	./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \
 	./gecode/support/timer.hpp ./test/int.hh ./test/int.hpp \
 	./test/test.hh ./test/test.hpp
+gecode/int/inter-distance$(OBJSUFFIX) gecode/int/inter-distance$(SBJSUFFIX): \
+	./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \
+	./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \
+	./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \
+	./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \
+	./gecode/int/distinct.hh ./gecode/int/distinct/bnd.hpp ./gecode/int/distinct/cbs.hpp \
+	./gecode/int/distinct/dom-ctrl.hpp ./gecode/int/distinct/dom.hpp ./gecode/int/distinct/eqite.hpp \
+	./gecode/int/distinct/graph.hpp ./gecode/int/distinct/ter-dom.hpp ./gecode/int/distinct/val.hpp \
+	./gecode/int/div.hh ./gecode/int/div.hpp ./gecode/int/exception.hpp \
+	./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/tuple-set.hpp \
+	./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp ./gecode/int/inter-distance.hh \
+	./gecode/int/ipl.hpp ./gecode/int/irt.hpp ./gecode/int/limits.hpp \
+	./gecode/int/propagator.hpp ./gecode/int/reify.hpp ./gecode/int/rel.hh \
+	./gecode/int/rel/eq.hpp ./gecode/int/rel/lex.hpp ./gecode/int/rel/lq-le.hpp \
+	./gecode/int/rel/nq.hpp ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp \
+	./gecode/int/trace/bool-trace-view.hpp ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp \
+	./gecode/int/trace/traits.hpp ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp \
+	./gecode/int/var-imp/delta.hpp ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp \
+	./gecode/int/var/int.hpp ./gecode/int/var/print.hpp ./gecode/int/view-val-graph.hh \
+	./gecode/int/view-val-graph/bi-link.hpp ./gecode/int/view-val-graph/comb-ptr-flag.hpp ./gecode/int/view-val-graph/edge.hpp \
+	./gecode/int/view-val-graph/graph.hpp ./gecode/int/view-val-graph/iter-prune-val.hpp ./gecode/int/view-val-graph/node.hpp \
+	./gecode/int/view.hpp ./gecode/int/view/bool-test.hpp ./gecode/int/view/bool.hpp \
+	./gecode/int/view/cached.hpp ./gecode/int/view/constint.hpp ./gecode/int/view/int.hpp \
+	./gecode/int/view/iter.hpp ./gecode/int/view/minus.hpp ./gecode/int/view/neg-bool.hpp \
+	./gecode/int/view/offset.hpp ./gecode/int/view/print.hpp ./gecode/int/view/rel-test.hpp \
+	./gecode/int/view/scale.hpp ./gecode/int/view/zero.hpp ./gecode/iter.hh \
+	./gecode/iter/ranges-add.hpp ./gecode/iter/ranges-append.hpp ./gecode/iter/ranges-array.hpp \
+	./gecode/iter/ranges-cache.hpp ./gecode/iter/ranges-compl.hpp ./gecode/iter/ranges-diff.hpp \
+	./gecode/iter/ranges-empty.hpp ./gecode/iter/ranges-inter.hpp ./gecode/iter/ranges-list.hpp \
+	./gecode/iter/ranges-map.hpp ./gecode/iter/ranges-minmax.hpp ./gecode/iter/ranges-minus.hpp \
+	./gecode/iter/ranges-negative.hpp ./gecode/iter/ranges-offset.hpp ./gecode/iter/ranges-operations.hpp \
+	./gecode/iter/ranges-positive.hpp ./gecode/iter/ranges-rangelist.hpp ./gecode/iter/ranges-scale.hpp \
+	./gecode/iter/ranges-singleton-append.hpp ./gecode/iter/ranges-singleton.hpp ./gecode/iter/ranges-size.hpp \
+	./gecode/iter/ranges-union.hpp ./gecode/iter/ranges-values.hpp ./gecode/iter/values-array.hpp \
+	./gecode/iter/values-bitset.hpp ./gecode/iter/values-bitsetoffset.hpp ./gecode/iter/values-inter.hpp \
+	./gecode/iter/values-list.hpp ./gecode/iter/values-map.hpp ./gecode/iter/values-minus.hpp \
+	./gecode/iter/values-negative.hpp ./gecode/iter/values-offset.hpp ./gecode/iter/values-positive.hpp \
+	./gecode/iter/values-ranges.hpp ./gecode/iter/values-singleton.hpp ./gecode/iter/values-union.hpp \
+	./gecode/iter/values-unique.hpp ./gecode/kernel.hh ./gecode/kernel/archive.hpp \
+	./gecode/kernel/branch/action.hpp ./gecode/kernel/branch/afc.hpp ./gecode/kernel/branch/chb.hpp \
+	./gecode/kernel/branch/filter.hpp ./gecode/kernel/branch/merit.hpp ./gecode/kernel/branch/print.hpp \
+	./gecode/kernel/branch/tiebreak.hpp ./gecode/kernel/branch/traits.hpp ./gecode/kernel/branch/val-commit.hpp \
+	./gecode/kernel/branch/val-sel-commit.hpp ./gecode/kernel/branch/val-sel.hpp ./gecode/kernel/branch/val.hpp \
+	./gecode/kernel/branch/var.hpp ./gecode/kernel/branch/view-sel.hpp ./gecode/kernel/branch/view-val.hpp \
+	./gecode/kernel/branch/view.hpp ./gecode/kernel/core.hpp ./gecode/kernel/data/array.hpp \
+	./gecode/kernel/data/rnd.hpp ./gecode/kernel/data/shared-array.hpp ./gecode/kernel/data/shared-data.hpp \
+	./gecode/kernel/exception.hpp ./gecode/kernel/gpi.hpp ./gecode/kernel/macros.hpp \
+	./gecode/kernel/memory/allocators.hpp ./gecode/kernel/memory/config.hpp ./gecode/kernel/memory/manager.hpp \
+	./gecode/kernel/memory/region.hpp ./gecode/kernel/modevent.hpp ./gecode/kernel/propagator/advisor.hpp \
+	./gecode/kernel/propagator/pattern.hpp ./gecode/kernel/propagator/subscribed.hpp ./gecode/kernel/propagator/wait.hpp \
+	./gecode/kernel/range-list.hpp ./gecode/kernel/shared-object.hpp ./gecode/kernel/shared-space-data.hpp \
+	./gecode/kernel/trace/filter.hpp ./gecode/kernel/trace/general.hpp ./gecode/kernel/trace/print.hpp \
+	./gecode/kernel/trace/recorder.hpp ./gecode/kernel/trace/tracer.hpp ./gecode/kernel/trace/traits.hpp \
+	./gecode/kernel/var-imp.hpp ./gecode/kernel/var-type.hpp ./gecode/kernel/var.hpp \
+	./gecode/kernel/view.hpp ./gecode/search.hh ./gecode/search/bab.hpp \
+	./gecode/search/base.hpp ./gecode/search/build.hpp ./gecode/search/cutoff.hpp \
+	./gecode/search/dfs.hpp ./gecode/search/engine.hpp ./gecode/search/exception.hpp \
+	./gecode/search/lds.hpp ./gecode/search/options.hpp ./gecode/search/pbs.hpp \
+	./gecode/search/rbs.hpp ./gecode/search/sebs.hpp ./gecode/search/seq/dead.hh \
+	./gecode/search/statistics.hpp ./gecode/search/stop.hpp ./gecode/search/support.hh \
+	./gecode/search/trace-recorder.hpp ./gecode/search/tracer.hpp ./gecode/search/traits.hpp \
+	./gecode/support.hh ./gecode/support/allocator.hpp ./gecode/support/auto-link.hpp \
+	./gecode/support/bitset-base.hpp ./gecode/support/bitset-offset.hpp ./gecode/support/bitset.hpp \
+	./gecode/support/block-allocator.hpp ./gecode/support/cast.hpp gecode/support/config.hpp \
+	./gecode/support/dynamic-array.hpp ./gecode/support/dynamic-queue.hpp ./gecode/support/dynamic-stack.hpp \
+	./gecode/support/exception.hpp ./gecode/support/failpoint.hpp ./gecode/support/hash.hpp \
+	./gecode/support/heap.hpp ./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp \
+	./gecode/support/macros.hpp ./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp \
+	./gecode/support/ref-count.hpp ./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp \
+	./gecode/support/static-stack.hpp ./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp \
+	./gecode/support/timer.hpp
+test/int/inter-distance$(OBJSUFFIX) test/int/inter-distance$(SBJSUFFIX): \
+	./gecode/int.hh ./gecode/int/array-traits.hpp ./gecode/int/array.hpp \
+	./gecode/int/branch.hpp ./gecode/int/branch/action.hpp ./gecode/int/branch/afc.hpp \
+	./gecode/int/branch/assign.hpp ./gecode/int/branch/chb.hpp ./gecode/int/branch/traits.hpp \
+	./gecode/int/branch/val.hpp ./gecode/int/branch/var.hpp ./gecode/int/channel.hpp \
+	./gecode/int/div.hh ./gecode/int/div.hpp ./gecode/int/exception.hpp \
+	./gecode/int/extensional.hpp ./gecode/int/extensional/dfa.hpp ./gecode/int/extensional/tuple-set.hpp \
+	./gecode/int/int-set-1.hpp ./gecode/int/int-set-2.hpp ./gecode/int/ipl.hpp \
+	./gecode/int/irt.hpp ./gecode/int/limits.hpp ./gecode/int/propagator.hpp \
+	./gecode/int/reify.hpp ./gecode/int/trace.hpp ./gecode/int/trace/bool-delta.hpp \
+	./gecode/int/trace/bool-trace-view.hpp ./gecode/int/trace/int-delta.hpp ./gecode/int/trace/int-trace-view.hpp \
+	./gecode/int/trace/traits.hpp ./gecode/int/var-imp.hpp ./gecode/int/var-imp/bool.hpp \
+	./gecode/int/var-imp/delta.hpp ./gecode/int/var-imp/int.hpp ./gecode/int/var/bool.hpp \
+	./gecode/int/var/int.hpp ./gecode/int/var/print.hpp ./gecode/int/view.hpp \
+	./gecode/int/view/bool-test.hpp ./gecode/int/view/bool.hpp ./gecode/int/view/cached.hpp \
+	./gecode/int/view/constint.hpp ./gecode/int/view/int.hpp ./gecode/int/view/iter.hpp \
+	./gecode/int/view/minus.hpp ./gecode/int/view/neg-bool.hpp ./gecode/int/view/offset.hpp \
+	./gecode/int/view/print.hpp ./gecode/int/view/rel-test.hpp ./gecode/int/view/scale.hpp \
+	./gecode/int/view/zero.hpp ./gecode/iter.hh ./gecode/iter/ranges-add.hpp \
+	./gecode/iter/ranges-append.hpp ./gecode/iter/ranges-array.hpp ./gecode/iter/ranges-cache.hpp \
+	./gecode/iter/ranges-compl.hpp ./gecode/iter/ranges-diff.hpp ./gecode/iter/ranges-empty.hpp \
+	./gecode/iter/ranges-inter.hpp ./gecode/iter/ranges-list.hpp ./gecode/iter/ranges-map.hpp \
+	./gecode/iter/ranges-minmax.hpp ./gecode/iter/ranges-minus.hpp ./gecode/iter/ranges-negative.hpp \
+	./gecode/iter/ranges-offset.hpp ./gecode/iter/ranges-operations.hpp ./gecode/iter/ranges-positive.hpp \
+	./gecode/iter/ranges-rangelist.hpp ./gecode/iter/ranges-scale.hpp ./gecode/iter/ranges-singleton-append.hpp \
+	./gecode/iter/ranges-singleton.hpp ./gecode/iter/ranges-size.hpp ./gecode/iter/ranges-union.hpp \
+	./gecode/iter/ranges-values.hpp ./gecode/iter/values-array.hpp ./gecode/iter/values-bitset.hpp \
+	./gecode/iter/values-bitsetoffset.hpp ./gecode/iter/values-inter.hpp ./gecode/iter/values-list.hpp \
+	./gecode/iter/values-map.hpp ./gecode/iter/values-minus.hpp ./gecode/iter/values-negative.hpp \
+	./gecode/iter/values-offset.hpp ./gecode/iter/values-positive.hpp ./gecode/iter/values-ranges.hpp \
+	./gecode/iter/values-singleton.hpp ./gecode/iter/values-union.hpp ./gecode/iter/values-unique.hpp \
+	./gecode/kernel.hh ./gecode/kernel/archive.hpp ./gecode/kernel/branch/action.hpp \
+	./gecode/kernel/branch/afc.hpp ./gecode/kernel/branch/chb.hpp ./gecode/kernel/branch/filter.hpp \
+	./gecode/kernel/branch/merit.hpp ./gecode/kernel/branch/print.hpp ./gecode/kernel/branch/tiebreak.hpp \
+	./gecode/kernel/branch/traits.hpp ./gecode/kernel/branch/val-commit.hpp ./gecode/kernel/branch/val-sel-commit.hpp \
+	./gecode/kernel/branch/val-sel.hpp ./gecode/kernel/branch/val.hpp ./gecode/kernel/branch/var.hpp \
+	./gecode/kernel/branch/view-sel.hpp ./gecode/kernel/branch/view-val.hpp ./gecode/kernel/branch/view.hpp \
+	./gecode/kernel/core.hpp ./gecode/kernel/data/array.hpp ./gecode/kernel/data/rnd.hpp \
+	./gecode/kernel/data/shared-array.hpp ./gecode/kernel/data/shared-data.hpp ./gecode/kernel/exception.hpp \
+	./gecode/kernel/gpi.hpp ./gecode/kernel/macros.hpp ./gecode/kernel/memory/allocators.hpp \
+	./gecode/kernel/memory/config.hpp ./gecode/kernel/memory/manager.hpp ./gecode/kernel/memory/region.hpp \
+	./gecode/kernel/modevent.hpp ./gecode/kernel/propagator/advisor.hpp ./gecode/kernel/propagator/pattern.hpp \
+	./gecode/kernel/propagator/subscribed.hpp ./gecode/kernel/propagator/wait.hpp ./gecode/kernel/range-list.hpp \
+	./gecode/kernel/shared-object.hpp ./gecode/kernel/shared-space-data.hpp ./gecode/kernel/trace/filter.hpp \
+	./gecode/kernel/trace/general.hpp ./gecode/kernel/trace/print.hpp ./gecode/kernel/trace/recorder.hpp \
+	./gecode/kernel/trace/tracer.hpp ./gecode/kernel/trace/traits.hpp ./gecode/kernel/var-imp.hpp \
+	./gecode/kernel/var-type.hpp ./gecode/kernel/var.hpp ./gecode/kernel/view.hpp \
+	./gecode/search.hh ./gecode/search/bab.hpp ./gecode/search/base.hpp \
+	./gecode/search/build.hpp ./gecode/search/cutoff.hpp ./gecode/search/dfs.hpp \
+	./gecode/search/engine.hpp ./gecode/search/exception.hpp ./gecode/search/lds.hpp \
+	./gecode/search/options.hpp ./gecode/search/pbs.hpp ./gecode/search/rbs.hpp \
+	./gecode/search/sebs.hpp ./gecode/search/seq/dead.hh ./gecode/search/statistics.hpp \
+	./gecode/search/stop.hpp ./gecode/search/support.hh ./gecode/search/trace-recorder.hpp \
+	./gecode/search/tracer.hpp ./gecode/search/traits.hpp ./gecode/support.hh \
+	./gecode/support/allocator.hpp ./gecode/support/auto-link.hpp ./gecode/support/bitset-base.hpp \
+	./gecode/support/bitset-offset.hpp ./gecode/support/bitset.hpp ./gecode/support/block-allocator.hpp \
+	./gecode/support/cast.hpp gecode/support/config.hpp ./gecode/support/dynamic-array.hpp \
+	./gecode/support/dynamic-queue.hpp ./gecode/support/dynamic-stack.hpp ./gecode/support/exception.hpp \
+	./gecode/support/failpoint.hpp ./gecode/support/hash.hpp ./gecode/support/heap.hpp \
+	./gecode/support/hw-rnd.hpp ./gecode/support/int-type.hpp ./gecode/support/macros.hpp \
+	./gecode/support/marked-pointer.hpp ./gecode/support/random.hpp ./gecode/support/ref-count.hpp \
+	./gecode/support/run-jobs.hpp ./gecode/support/sort.hpp ./gecode/support/static-stack.hpp \
+	./gecode/support/thread.hpp ./gecode/support/thread/thread.hpp ./gecode/support/timer.hpp \
+	./test/int.hh ./test/int.hpp ./test/test.hh \
+	./test/test.hpp
diff --git a/Makefile.in b/Makefile.in
index 26d8c94e77..8e5d2c625d 100755
--- a/Makefile.in
+++ b/Makefile.in
@@ -337,7 +337,7 @@ INTSRC0 = \
 	bin-packing/conflict-graph.cpp \
 	order.cpp order/propagate.cpp \
 	unary.cpp cumulative.cpp cumulatives.cpp \
-	circuit.cpp no-overlap.cpp nvalues.cpp \
+	circuit.cpp no-overlap.cpp inter-distance.cpp nvalues.cpp \
 	member.cpp min-distance.cpp branch/action.cpp branch/chb.cpp \
 	arithmetic/mult.cpp  \
 	branch/view-sel.cpp branch/val-sel-commit.cpp \
@@ -428,7 +428,7 @@ INTHDR0 = \
 	circuit.hh circuit/base.hpp circuit/val.hpp circuit/dom.hpp \
 	no-overlap.hh no-overlap/dim.hpp no-overlap/box.hpp \
 	no-overlap/base.hpp no-overlap/man.hpp no-overlap/opt.hpp \
-	nvalues.hh nvalues/range-event.hpp \
+	inter-distance.hh nvalues.hh nvalues/range-event.hpp \
 	nvalues/sym-bit-matrix.hpp nvalues/graph.hpp \
 	nvalues/bool-base.hpp nvalues/bool-eq.hpp \
 	nvalues/bool-lq.hpp nvalues/bool-gq.hpp \
@@ -1122,7 +1122,7 @@ INTTESTSRC00 = \
 	rel linear gcc sorted unshare exec sequence \
 	mm-arithmetic mm-bool mm-lin mm-count mm-rel \
 	bin-packing order unary cumulative cumulatives circuit \
-	no-overlap precede nvalues member min-distance
+	no-overlap precede inter-distance nvalues member min-distance
 INTTESTSRC0 = test/int.cpp $(INTTESTSRC00:%=test/int/%.cpp)
 INTTESTOBJ = $(INTTESTSRC0:%.cpp=%$(OBJSUFFIX))
 
diff --git a/changelog.in b/changelog.in
index 219972aeb1..394b936a5d 100755
--- a/changelog.in
+++ b/changelog.in
@@ -162,6 +162,21 @@ The propagation algorithms follow:
 M. Z. Lagerkvist, Propagation Algorithms for the Minimum-Distance Constraint
 over Selected Points, ModRef 2026.
 
+[ENTRY]
+Module: int
+What:   new
+Rank:   major
+[DESCRIPTION]
+Add the inter-distance constraint for fixed and variable separation. Basic
+propagation checks feasibility and bounds the distance; advanced propagation
+adds staged quadratic bounds filtering. The algorithms are described in:
+C.-G. Quimper, A. Lopez-Ortiz, G. Pesant, A Quadratic Propagator for the
+Inter-Distance Constraint, AAAI 2006, and Constraint Programming Letters 3
+(2008), 21-35.
+M. R. Garey, D. S. Johnson, B. B. Simons, R. E. Tarjan, Scheduling Unit-Time
+Tasks with Arbitrary Release Times and Deadlines, SIAM Journal on Computing
+10(2) (1981), 256-269.
+
 [RELEASE]
 Version: 6.4.0
 Date: 2026-07-15
diff --git a/cmake/GecodeSources.cmake b/cmake/GecodeSources.cmake
index 09b4365587..58a415eb36 100644
--- a/cmake/GecodeSources.cmake
+++ b/cmake/GecodeSources.cmake
@@ -88,6 +88,7 @@ set(GECODE_INT_SOURCES
   gecode/int/extensional/tuple-set.cpp
   gecode/int/gcc.cpp
   gecode/int/int-set.cpp
+  gecode/int/inter-distance.cpp
   gecode/int/ldsb.cpp
   gecode/int/ldsb/sym-imp.cpp
   gecode/int/ldsb/sym-obj.cpp
@@ -415,6 +416,7 @@ set(GECODE_TEST_SOURCES
   test/int/exec.cpp
   test/int/extensional.cpp
   test/int/gcc.cpp
+  test/int/inter-distance.cpp
   test/int/linear.cpp
   test/int/member.cpp
   test/int/min-distance.cpp
diff --git a/gecode/int.hh b/gecode/int.hh
index 7d0e765955..04bfb99d70 100755
--- a/gecode/int.hh
+++ b/gecode/int.hh
@@ -1748,6 +1748,75 @@ namespace Gecode {
   //@}
 
 
+  /**
+   * \defgroup TaskModelIntInterDistance Inter-distance constraint
+   * \ingroup TaskModelInt
+   */
+  //@{
+  /** \brief Post bounds-consistent propagator for \f$|x_i-x_j|\geq p\f$ for all \f$0\leq i\neq j<|x|\f$
+   *
+   * Domains with holes are treated as intervals between their bounds.
+   *
+   * - \a IPL_BASIC checks interval feasibility in \f$O(n\log n)\f$ time
+   *   and linear temporary space, where \f$n=|x|\f$.
+   * - \a IPL_ADVANCED and \a IPL_BASIC_ADVANCED first perform
+   *   the basic check, then schedule quadratic bounds(Z) filtering at
+   *   a higher cost. This filtering uses quadratic temporary space.
+   *
+   * The default, \a IPL_DEF, uses both stages. The value/bounds/domain part
+   * of \a ipl does not affect these algorithms.
+   *
+   * A zero distance, or fewer than two variables, imposes no restriction.
+   * A distance of one is propagated as a bounds-consistent distinct constraint.
+   *
+   * The propagator uses algorithms taken from:
+   *
+   * Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+   * A Quadratic Propagator for the Inter-Distance Constraint,
+   * AAAI, pages 123-128, 2006.
+   *
+   * and
+   *
+   * M. R. Garey, D. S. Johnson, B. B. Simons, and R. E. Tarjan,
+   * Scheduling Unit-Time Tasks with Arbitrary Release Times and Deadlines,
+   * SIAM Journal on Computing 10(2), pages 256-269, 1981.
+   *
+   * Throws Int::OutOfLimits if \a p is negative or exceeds Int::Limits::max.
+   * Throws Int::ArgumentSame if \a p is positive and \a x contains the same
+   * unassigned variable multiply.
+   */
+  GECODE_INT_EXPORT void
+  inter_distance(Home home, const IntVarArgs& x, int p,
+                 IntPropLevel ipl=IPL_DEF);
+  /** \brief Post inter-distance constraint with variable separation
+   *
+   * Constrains \f$p\geq0\f$ and \f$|x_i-x_j|\geq p\f$ for all
+   * \f$0\leq i\neq j<|x|\f$.
+   *
+   * Uses the same algorithm options as the fixed-distance overload.
+   * The basic stage additionally tightens \a p's upper bound by binary
+   * search using the linear-space feasibility checker. Its time bound
+   * is \f$O(n\log n\log(1+\max(p)))\f$. The advanced stage provides
+   * bounds(Z) consistency for \a x using the minimum of \a p, giving
+   * bounds(Z) consistency for the whole constraint.
+   *
+   * The variable-distance algorithm is taken from:
+   *
+   * Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+   * A Quadratic Propagator for the Inter-Distance Constraint,
+   * Constraint Programming Letters 3, pages 21-35, 2008, Section 5.
+   *
+   * Fewer than two variables only constrain \a p to be nonnegative.
+   * With at least two variables, throws Int::ArgumentSame if \a p is the
+   * same unassigned variable as a member of \a x, or if \a p can be positive
+   * and \a x contains the same unassigned variable multiply.
+   */
+  GECODE_INT_EXPORT void
+  inter_distance(Home home, const IntVarArgs& x, IntVar p,
+                 IntPropLevel ipl=IPL_DEF);
+  //@}
+
+
   /**
    * \defgroup TaskModelIntDistinct Distinct constraints
    * \ingroup TaskModelInt
diff --git a/gecode/int/inter-distance.cpp b/gecode/int/inter-distance.cpp
new file mode 100644
index 0000000000..77b39cef20
--- /dev/null
+++ b/gecode/int/inter-distance.cpp
@@ -0,0 +1,953 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Claude-Guy Quimper <claude-guy.quimper@ift.ulaval.ca>
+ *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
+ *
+ *  Copyright:
+ *     Claude-Guy Quimper, 2006
+ *     Mikael Zayenz Lagerkvist, 2026
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.dev
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/int/inter-distance.hh>
+#include <gecode/int/distinct.hh>
+
+#include <algorithm>
+#include <limits>
+#include <tuple>
+
+namespace Gecode { namespace Int { namespace InterDistance {
+
+  namespace {
+    typedef long long int Time;
+    typedef std::ptrdiff_t RegionIndex;
+
+    /// Task bounds and ranks in their sorted orders
+    struct Task {
+      Time min;
+      Time max;
+      int minRank;
+      int maxRank;
+    };
+
+    /// Forbidden starting times (inclusive)
+    struct Forbidden {
+      Time min;
+      Time max;
+    };
+
+    /// Nonnegative remainder, including for negative deadlines
+    Time residue(Time t, Time p) {
+      Time q = t % p;
+      return (q < 0) ? q+p : q;
+    }
+
+    /**
+     * \brief Ordered residue groups with region-backed storage
+     *
+     * Group keys are drawn from the original deadline residues. A shift
+     * merges groups into an existing key, but later deadline activation can
+     * reinsert a removed key. A Fenwick tree of active-key counts supports
+     * insertion, removal, and successor queries in O(log n) time.
+     */
+    class ResidueGroups {
+      Time* keys;
+      int* groups;
+      int* counts;
+      int keyCount;
+      int activeCount;
+      int topBit;
+
+      /// Change the active-key count at rank i
+      void update(int i, int delta) {
+        for (unsigned int j=static_cast<unsigned int>(i)+1;
+             j<=static_cast<unsigned int>(keyCount); j+=j & -j)
+          counts[j] += delta;
+        activeCount += delta;
+      }
+
+      /// First active key at or after rank i, or keyCount
+      int next_active(int i) const {
+        int before = 0;
+        for (unsigned int j=static_cast<unsigned int>(i); j; j-=j & -j)
+          before += counts[j];
+        if (before == activeCount)
+          return keyCount;
+
+        int ordinal = before+1;
+        int rank = 0;
+        for (int bit=topBit; bit; bit/=2)
+          if ((bit <= keyCount-rank) && (counts[rank+bit] < ordinal)) {
+            rank += bit;
+            ordinal -= counts[rank];
+          }
+        return rank;
+      }
+    public:
+      /// Allocate once; repeated distance checks reuse these arrays
+      ResidueGroups(Region& r, int n)
+        : keys(r.alloc<Time>(n)), groups(r.alloc<int>(n)),
+          counts(r.alloc<int>(static_cast<unsigned int>(n)+1)),
+          keyCount(0), activeCount(0), topBit(0) {}
+
+      /// Prepare the key universe for distance p
+      void reset(const Time* deadlines, int n, int p) {
+        for (int i=0; i<n; i++)
+          keys[i] = residue(deadlines[i],p);
+        std::sort(keys,keys+n);
+        keyCount = static_cast<int>(std::unique(keys,keys+n)-keys);
+        std::fill(groups,groups+keyCount,-1);
+        std::fill(counts,counts+keyCount+1,0);
+        activeCount = 0;
+        topBit = 1;
+        while (topBit <= keyCount/2)
+          topBit *= 2;
+      }
+
+      /// Rank of a key in the fixed universe
+      int rank(Time key) const {
+        int i = static_cast<int>(std::lower_bound(keys,keys+keyCount,key)-keys);
+        assert((i < keyCount) && (keys[i] == key));
+        return i;
+      }
+
+      /// Key and group at rank i; -1 denotes an inactive group
+      Time key(int i) const { return keys[i]; }
+      int group(int i) const { return groups[i]; }
+
+      /// Insert a key or replace its group representative
+      void set_group(int i, int root) {
+        if (groups[i] < 0)
+          update(i,1);
+        groups[i] = root;
+      }
+
+      /// Remove an active key
+      void remove(int i) {
+        assert(groups[i] >= 0);
+        groups[i] = -1;
+        update(i,-1);
+      }
+
+      /// First active key, or the end rank
+      int first_active(void) const { return next_active(0); }
+      /// First active key greater than key, or the end rank
+      int active_after(Time key) const {
+        return next_active(static_cast<int>(
+          std::upper_bound(keys,keys+keyCount,key)-keys));
+      }
+      /// Whether a successor query returned the end rank
+      bool at_end(int i) const { return i == keyCount; }
+    };
+
+    /**
+     * \brief Linear-space feasibility checker of Garey et al. (1981)
+     *
+     * Algorithm B represents each deadline's critical time as its deadline
+     * minus its task load and pseudo-offset. A Fenwick tree maintains loads.
+     * A weighted union-find merges deadlines with the same residue modulo p;
+     * ordered region-backed arrays locate affected residues. Each
+     * deadline is inserted once and each merge removes a residue, giving
+     * O(n log n) time. Relevant deadlines are kept in deadline order, with
+     * dominated predecessors removed permanently (Lemmas 5 and 6).
+     */
+    class Feasibility {
+      const int n;
+      int dc;
+      Task* tasks;
+      Task** release;
+      /// Distinct latest start times; critical() adds p to obtain deadlines
+      Time* deadlines;
+      int* loads;
+      int* successor;
+      int* previous;
+      int* parent;
+      int* size;
+      Time* offset;
+      ResidueGroups residues;
+      /// First remaining relevant deadline at or after i
+      int find(int i) {
+        int root = i;
+        while (successor[root] != root)
+          root = successor[root];
+        while (successor[i] != i) {
+          int next = successor[i];
+          successor[i] = root;
+          i = next;
+        }
+        return root;
+      }
+      /// Number of processed tasks with a deadline at or before i
+      int load(int i) const {
+        int count = 0;
+        for (size_t j=static_cast<size_t>(i)+1; j; j-=j & -j)
+          count += loads[j];
+        return count;
+      }
+      /// Sum weighted links, including the root's shared offset
+      Time displacement(int i) const {
+        if (parent[i] == -1)
+          return 0;
+        Time d = offset[i];
+        while (parent[i] != i) {
+          i = parent[i];
+          d += offset[i];
+        }
+        return d;
+      }
+      /// Merge roots while preserving each deadline's displacement
+      int merge(int a, int b) {
+        if (size[a] < size[b])
+          std::swap(a,b);
+        parent[b] = a;
+        offset[b] -= offset[a];
+        size[a] += size[b];
+        return a;
+      }
+      /// Pseudo-critical time for deadline i
+      Time critical(int i, Time p) const {
+        return deadlines[i]+p-static_cast<Time>(load(i))*p-displacement(i);
+      }
+
+      /// Shift and merge active residues from first up to end into target
+      void merge_residue_range(int first, Time end, int target, int p) {
+        Time a = residues.key(target);
+        int root = residues.group(target);
+        int i = first;
+        while (!residues.at_end(i) && (residues.key(i) < end)) {
+          Time key = residues.key(i);
+          int group = residues.group(i);
+          offset[group] += residue(key-a,p);
+          root = merge(root,group);
+          residues.remove(i);
+          i = residues.active_after(key);
+        }
+        residues.set_group(target,root);
+      }
+
+      /// Move groups in the open residue arc (a,b) into the group at a
+      void forbid(Time a, Time b, int p) {
+        int target = residues.rank(a);
+        // The active deadline's group has residue critical(active,p) % p,
+        // so activation has already supplied the target key.
+        assert(residues.group(target) >= 0);
+
+        // At a wraparound, zero is included precisely when it is below b.
+        merge_residue_range(residues.active_after(a),(a < b) ? b : p,target,p);
+        if (a >= b)
+          merge_residue_range(residues.first_active(),b,target,p);
+      }
+    public:
+      Feasibility(Region& r, const ViewArray<IntView>& x)
+        : n(x.size()), dc(0), residues(r,x.size()) {
+        tasks = r.alloc<Task>(n);
+        release = r.alloc<Task*>(n);
+        Task** finish = r.alloc<Task*>(n);
+        deadlines = r.alloc<Time>(n);
+        for (int i=0; i<n; i++) {
+          tasks[i].min = x[i].min();
+          tasks[i].max = x[i].max();
+          release[i] = finish[i] = tasks+i;
+        }
+        std::sort(release,release+n,[](const Task* a, const Task* b) {
+          return std::tie(a->min,a->max) < std::tie(b->min,b->max);
+        });
+        std::sort(finish,finish+n,[](const Task* a, const Task* b) {
+          return a->max < b->max;
+        });
+        for (int i=0; i<n; i++) {
+          if ((i == 0) || (finish[i]->max != deadlines[dc-1]))
+            deadlines[dc++] = finish[i]->max;
+          finish[i]->maxRank = dc-1;
+        }
+        // Include the successor sentinel without overflowing signed int.
+        // Region::alloc has an unsigned-int overload on every platform.
+        const unsigned int count = static_cast<unsigned int>(dc)+1;
+        loads = r.alloc<int>(count);
+        successor = r.alloc<int>(count);
+        previous = r.alloc<int>(dc);
+        parent = r.alloc<int>(dc);
+        size = r.alloc<int>(dc);
+        offset = r.alloc<Time>(dc);
+      }
+      /// Test interval feasibility, reusing the sorted bounds and scratch
+      bool check(int p) {
+        if (p == 0)
+          return true;
+
+        std::fill(loads,loads+dc+1,0);
+        for (int i=0; i<dc; i++) {
+          successor[i] = i;
+          previous[i] = i-1;
+          parent[i] = -1;
+        }
+        successor[dc] = dc;
+        residues.reset(deadlines,dc,p);
+
+        int active = dc;
+        int pending = dc-1;
+        for (int i=n; i--;) {
+          int rank = release[i]->maxRank;
+          for (size_t j=static_cast<size_t>(rank)+1;
+               j<=static_cast<size_t>(dc); j+=j & -j)
+            loads[j]++;
+          int d = find(rank);
+          active = std::min(active,d);
+          Time c = critical(d,p);
+          while ((previous[d] >= 0) && (critical(previous[d],p) > c)) {
+            int obsolete = previous[d];
+            successor[obsolete] = d;
+            previous[d] = previous[obsolete];
+            if (active == obsolete)
+              active = d;
+          }
+
+          // Construct regions after processing all tasks at this release time.
+          if ((i > 0) && (release[i-1]->min == release[i]->min))
+            continue;
+          c = critical(active,p);
+          Time r = release[i]->min;
+          if (c < r)
+            return false;
+          if (c-p+1 >= r)
+            continue;
+
+          // Only deadlines whose back-schedule can reach this region
+          // are activated. Earlier deadlines must retain zero offsets.
+          while ((pending >= 0) && (deadlines[pending]+p >= c)) {
+            parent[pending] = pending;
+            size[pending] = 1;
+            offset[pending] = 0;
+            int key = residues.rank(residue(deadlines[pending],p));
+            int group = residues.group(key);
+            residues.set_group(key,(group < 0) ? pending : merge(group,pending));
+            pending--;
+          }
+          forbid(residue(c-p,p),residue(r,p),p);
+        }
+        return true;
+      }
+    };
+
+    /// Adjustment interval in a doubly linked list sorted by minimum
+    struct Adjustment {
+      Time min;
+      Time max;
+      RegionIndex previous;
+      RegionIndex next;
+    };
+
+    /**
+     * \brief Scratch data for one direction of bounds filtering
+     *
+     * The Garey-Johnson-Simons-Tarjan feasibility pass constructs forbidden
+     * starting regions. An earliest-completion table and a latest-start
+     * vector allow the dominance sweep to generate only quadratically many
+     * adjustment intervals. The linked list and union-find propagate changes
+     * to bounds without rescanning all variables for each interval.
+     * This implements Algorithm 2 and the adjustment data structure in
+     * Sections 4.1 and 4.2 of Quimper et al. (2008).
+     */
+    class Filter {
+    private:
+      const int n;
+      const Time p;
+      Task** minSorted;
+      Task** maxSorted;
+      Forbidden* forbidden;
+      int forbiddenCount;
+      Time* ectTable;
+      Time* lstTable;
+      Adjustment* regions;
+      RegionIndex regionCount;
+      RegionIndex* firstRegion;
+      /// Adjustment-list cursor for each live bound-group representative
+      RegionIndex* nextRegion;
+      Time* bounds;
+      // links[i] > i forwards to a merged group's representative; otherwise
+      // i is a live representative and links[i] < i is its predecessor (-1
+      // for the first group). Merging preserves this predecessor at the root.
+      int* links;
+      bool* processed;
+      int* leader;
+    public:
+      /// Bounds loaded by the propagator, then tightened by this sweep
+      Task* tasks;
+      /// Allocate scratch storage, with no persistent ownership
+      Filter(Region& r, int n0, int p0)
+        : n(n0), p(p0), forbiddenCount(0), regionCount(0) {
+        const size_t count = static_cast<size_t>(n);
+        const size_t limit = std::numeric_limits<size_t>::max();
+        // Region::alloc multiplies unchecked. Reject impossible byte sizes
+        // before allocating the quadratic tables or interval list.
+        if ((count > limit / sizeof(Time) / (count+1)) ||
+            (count > (limit / sizeof(Adjustment) - 3) / (count+3)))
+          throw MemoryExhausted();
+        tasks = r.alloc<Task>(n);
+        minSorted = r.alloc<Task*>(n);
+        maxSorted = r.alloc<Task*>(n);
+        forbidden = r.alloc<Forbidden>(n);
+        const size_t entries = count * (count+1);
+        ectTable = static_cast<Time*>(r.ralloc(entries * sizeof(Time)));
+        lstTable = r.alloc<Time>(n+2);
+        const size_t capacity = count * (count+3) / 2 + 3;
+        regions = static_cast<Adjustment*>(
+          r.ralloc(capacity * sizeof(Adjustment)));
+        firstRegion = r.alloc<RegionIndex>(n);
+        nextRegion = r.alloc<RegionIndex>(n);
+        bounds = r.alloc<Time>(n);
+        links = r.alloc<int>(n);
+        processed = r.alloc<bool>(n);
+        leader = r.alloc<int>(n);
+      }
+      /// Earliest completion time for q tasks at release time i
+      Time ect(int i, int q) const {
+        return ectTable[static_cast<size_t>(q)*n+i];
+      }
+      /// Latest start time for q tasks at the current deadline
+      Time lst(int q) const {
+        return lstTable[q];
+      }
+      /// Find the representative of a merged group of bounds
+      int find(int i) {
+        int j = i;
+        while (links[j] > j)
+          j = links[j];
+        while (links[i] > i) {
+          int k = links[i];
+          links[i] = j;
+          i = k;
+        }
+        return j;
+      }
+      /// Notify bounds of a new or expanded adjustment interval
+      int notify(RegionIndex r, int vi) {
+        assert((vi >= 0) && (links[vi] < vi));
+        while ((links[vi] >= 0) &&
+               (bounds[links[vi]] >= regions[r].min))
+          vi = links[vi];
+        while (regions[r].min <= bounds[vi]) {
+          if (bounds[vi] <= regions[r].max) {
+            while ((vi < n-1) &&
+                   (regions[r].max+1 >= minSorted[vi+1]->min)) {
+              int previous = links[vi];
+              links[vi] = vi+1;
+              vi = find(vi);
+              links[vi] = previous;
+            }
+            if (regions[r].max >= bounds[vi])
+              bounds[vi] = regions[r].max+1;
+          }
+          if (regions[r].min < regions[nextRegion[vi]].min)
+            r = nextRegion[vi];
+          else
+            nextRegion[vi] = r;
+          r = regions[r].next;
+        }
+        assert((vi >= 0) && (links[vi] < vi));
+        return vi;
+      }
+    private:
+      /// Sort task pointers and record release ranks
+      void sort_tasks(void) {
+        for (int i=0; i<n; i++)
+          minSorted[i] = maxSorted[i] = tasks+i;
+        std::sort(minSorted,minSorted+n,[](const Task* a, const Task* b) {
+          return std::tie(a->min,a->max) < std::tie(b->min,b->max);
+        });
+        std::sort(maxSorted,maxSorted+n,[](const Task* a, const Task* b) {
+          return std::tie(a->max,a->min) < std::tie(b->max,b->min);
+        });
+        for (int i=0; i<n; i++)
+          minSorted[i]->minRank = i;
+      }
+
+      /// Construct forbidden start regions, detecting interval infeasibility
+      bool compute_forbidden_regions(Region& r) {
+        Time* deadlines = r.alloc<Time>(n);
+        int dc = 0;
+        for (int i=0; i<n; i++) {
+          if ((i == 0) || (maxSorted[i]->max > deadlines[dc-1]))
+            deadlines[dc++] = maxSorted[i]->max;
+          maxSorted[i]->maxRank = dc-1;
+        }
+
+        Time* times = r.alloc<Time>(dc);
+        int* cursor = r.alloc<int>(dc);
+        Forbidden* buffer = r.alloc<Forbidden>(n);
+        // Indices keep cursor movement within the allocated forbidden-region
+        // buffer, including its empty-prefix boundary.
+        int last = n-1;
+        for (int i=0; i<dc; i++) {
+          times[i] = deadlines[i];
+          cursor[i] = last;
+        }
+
+        Time min = std::numeric_limits<Time>::max();
+        Time newMin = min;
+        forbiddenCount = 0;
+        for (int i=n; i--;) {
+          for (int j=minSorted[i]->maxRank; j<dc; j++) {
+            times[j] -= p;
+            while ((cursor[j] > last) &&
+                   (times[j] < buffer[cursor[j]].min))
+              cursor[j]--;
+            if ((cursor[j] > last) &&
+                (times[j] <= buffer[cursor[j]].max))
+              times[j] = buffer[cursor[j]--].min-1;
+            newMin = std::min(newMin,times[j]);
+          }
+          if ((i == 0) || (minSorted[i-1]->min < minSorted[i]->min))
+            min = newMin;
+          if (min < minSorted[i]->min)
+            return false;
+          if (min-p+1 < minSorted[i]->min) {
+            if ((forbiddenCount > 0) &&
+                (minSorted[i]->min >= buffer[last+1].min)) {
+              // Adjacent integer regions must also be merged: skipping one
+              // region must not land on a forbidden start in its neighbour.
+              buffer[last+1].min = min-p+1;
+            } else {
+              assert(last >= 0);
+              buffer[last--] = {min-p+1,minSorted[i]->min-1};
+              forbiddenCount++;
+            }
+          }
+        }
+        for (int i=0; i<forbiddenCount; i++)
+          forbidden[i] = buffer[last+1+i];
+        return true;
+      }
+
+      /// Tabulate earliest completions outside the forbidden start regions
+      void compute_earliest_completions(void) {
+        for (int i=0; i<n; i++) {
+          ectTable[i] = minSorted[i]->min;
+          int er = 0;
+          for (int q=1; q<=n; q++) {
+            Time start = ect(i,q-1);
+            while ((er < forbiddenCount) && (forbidden[er].max < start))
+              er++;
+            if ((er < forbiddenCount) && (forbidden[er].min <= start))
+              start = forbidden[er].max+1;
+            ectTable[static_cast<size_t>(q)*n+i] = start+p;
+          }
+        }
+      }
+
+      /// Latest starts for one deadline, including the external adjustment
+      void compute_latest_starts(Time deadline, int taskCount) {
+        // Keeping only the current deadline's vector avoids a second
+        // quadratic table without increasing the sweep's complexity.
+        lstTable[0] = deadline;
+        int region = forbiddenCount-1;
+        for (int t=1; t<=taskCount+1; t++) {
+          Time start = lst(t-1)-p;
+          while ((region >= 0) && (forbidden[region].min > start))
+            region--;
+          if ((region >= 0) && (forbidden[region].max >= start))
+            start = forbidden[region].min-1;
+          lstTable[t] = start;
+        }
+      }
+
+      /// Initialize the adjustment list and the groups of variable bounds
+      void initialize_adjustments(void) {
+        const Time infinity = std::numeric_limits<Time>::max();
+        regions[0] = {-infinity,-infinity,-1,1};
+        regions[1] = {infinity,infinity,0,-1};
+        regionCount = 2;
+        for (int i=0; i<n; i++) {
+          links[i] = i-1;
+          processed[i] = false;
+          bounds[i] = minSorted[i]->min;
+          nextRegion[i] = 0;
+        }
+      }
+
+      /// Find the predecessor for an adjustment with lower bound min
+      RegionIndex insertion_point(RegionIndex hint, Time min) const {
+        // Intervals are appended in decreasing-minimum runs. Follow previous
+        // links between runs, then next links within the ordered list.
+        while (((hint+1 == regionCount) ? min : regions[hint+1].min) >=
+               regions[hint].min) {
+          hint = regions[hint].previous;
+          if (hint < 0)
+            break;
+          if (regions[hint].min <= min) {
+            hint--;
+            break;
+          }
+        }
+        hint++;
+        while (regions[regions[hint].next].min < min)
+          hint = regions[hint].next;
+        return hint;
+      }
+
+      /// Insert an adjustment after its predecessor and return its index
+      RegionIndex insert_adjustment(RegionIndex previous, Time min, Time max) {
+        RegionIndex next = regions[previous].next;
+        assert((regions[previous].min <= min) && (min <= regions[next].min));
+        RegionIndex inserted = regionCount++;
+        regions[inserted] = {min,max,previous,next};
+        regions[previous].next = inserted;
+        regions[next].previous = inserted;
+        return inserted;
+      }
+
+      /// Build and apply internal adjustments in deadline order
+      void apply_internal_adjustments(void) {
+        const Time infinity = std::numeric_limits<Time>::max();
+        RegionIndex lastRegion = 0;
+        int minP = n;
+        int maxP = 0;
+        for (int it=0; it<n; it++) {
+          int i = maxSorted[it]->minRank;
+          processed[i] = true;
+          maxP = std::max(maxP,i);
+          minP = std::min(minP,i);
+
+          // Maintain the dominating blocks before generating their intervals.
+          // These cursors share the sweep's task counts and stay together.
+          int l = leader[i] = i;
+          int kp = 1;
+          while (++l <= maxP)
+            if (processed[l])
+              kp++;
+          l = i;
+          int k = kp;
+          if (i > minP) {
+            while (!processed[--l]) {}
+            k++;
+            while (l > leader[l]) {
+              while (!processed[--l]) {}
+              k++;
+            }
+            if (ect(i,1) > ect(l,k-kp+1)) {
+              l = i;
+              k = kp;
+            }
+          }
+          kp = k;
+          int j = l;
+          while (j < maxP) {
+            while (!processed[++j]) {}
+            if (ect(j,1) <= ect(l,k- --kp+1))
+              leader[j] = l;
+            else
+              break;
+          }
+          if ((it < n-1) && (maxSorted[it]->max == maxSorted[it+1]->max))
+            continue;
+
+          compute_latest_starts(maxSorted[it]->max,it+1);
+
+          int q = 0;
+          RegionIndex insertion = 0;
+          int vi = n-1;
+          while (true) {
+            for (int t=q; t<k; t++) {
+              Time min = lst(t+1)+1;
+              // The final empty region allows external adjustments to
+              // expand the preceding intervals by one more task.
+              Time max = (l >= 0) ? ect(l,k-t)-1 : -infinity;
+              if (t > 0) {
+                insertion = insertion_point(insertion,min);
+              } else {
+                insertion = lastRegion;
+                firstRegion[i] = lastRegion = regionCount;
+              }
+              vi = notify(insert_adjustment(insertion,min,max),vi);
+            }
+            if (l == -1)
+              break;
+            q = k++;
+            if (l > minP) {
+              while (!processed[--l]) {}
+              j = leader[l];
+              while (j < l) {
+                while (!processed[--l]) {}
+                k++;
+              }
+            } else {
+              l = -1;
+            }
+          }
+        }
+      }
+
+      /// Apply external adjustments after reading each task's tightened bound
+      void apply_external_adjustments(void) {
+        // A variable is filtered before adding external intervals for its
+        // deadline, so it is never excluded by an interval it helped create.
+        for (int it=0; it<n; it++) {
+          int i = maxSorted[it]->minRank;
+          maxSorted[it]->min = bounds[find(i)];
+          if ((it == n-1) || (maxSorted[it]->max != maxSorted[it+1]->max)) {
+            int vi = n-1;
+            Time lastMax = regions[firstRegion[i]].max;
+            for (RegionIndex r=firstRegion[i]+1;
+                 (r < regionCount) && (regions[r].min < regions[r-1].min);
+                 r++) {
+              Time oldMax = regions[r].max;
+              regions[r].max = lastMax;
+              lastMax = oldMax;
+              vi = notify(r,vi);
+            }
+          }
+        }
+      }
+    public:
+      /// Filter bounds, returning false on interval infeasibility
+      bool filter(Region& r) {
+        sort_tasks();
+        if (!compute_forbidden_regions(r))
+          return false;
+        compute_earliest_completions();
+        initialize_adjustments();
+        apply_internal_adjustments();
+        apply_external_adjustments();
+        return true;
+      }
+    };
+
+    /// Largest feasible distance in [min,max], or -1 when min is infeasible
+    int maximum_feasible_distance(Region& region,
+                                  const ViewArray<IntView>& x,
+                                  int min, int max) {
+      Feasibility feasibility(region,x);
+      if (!feasibility.check(min))
+        return -1;
+      if ((max == min) || feasibility.check(max))
+        return max;
+
+      // Quimper et al. (2008), Section 5: feasibility is monotone in p.
+      // Keep min feasible and max infeasible without enumerating distances.
+      while (max-min > 1) {
+        int middle = min+(max-min)/2;
+        if (feasibility.check(middle))
+          min = middle;
+        else
+          max = middle;
+      }
+      return min;
+    }
+
+    /// Tighten x bounds in both directions; holes may require another pass
+    ExecStatus filter_bounds(Space& home, Region& region,
+                             ViewArray<IntView>& x, int p) {
+      Filter f(region,x.size(),p);
+      bool nofix = false;
+      for (int direction=0; direction<2; direction++) {
+        for (int i=0; i<x.size(); i++) {
+          // Reverse task time: [r,d] becomes [-d,-r]. Variables denote
+          // starting times, while the algorithm's maxima are deadlines.
+          f.tasks[i].min = direction ? -static_cast<Time>(x[i].max())-p : x[i].min();
+          f.tasks[i].max = direction ? -static_cast<Time>(x[i].min()) :
+            static_cast<Time>(x[i].max())+p;
+        }
+        if (!f.filter(region))
+          return ES_FAILED;
+        for (int i=0; i<x.size(); i++) {
+          Time bound = direction ? -f.tasks[i].min-p : f.tasks[i].min;
+          if (direction ? (bound < x[i].min()) : (bound > x[i].max()))
+            return ES_FAILED;
+          ModEvent me = direction ? x[i].lq(home,static_cast<int>(bound)) :
+            x[i].gq(home,static_cast<int>(bound));
+          GECODE_ME_CHECK(me);
+          nofix |= (direction ? x[i].max() : x[i].min()) != bound;
+        }
+      }
+      return nofix ? ES_NOFIX : ES_FIX;
+    }
+
+    /// Minimum separation in an assigned tuple, without quadratic tables
+    Time assigned_distance(Region& r, const ViewArray<IntView>& x) {
+      Time* values = r.alloc<Time>(x.size());
+      for (int i=0; i<x.size(); i++)
+        values[i] = x[i].val();
+      std::sort(values,values+x.size());
+      Time gap = std::numeric_limits<Time>::max();
+      for (int i=1; i<x.size(); i++)
+        gap = std::min(gap,values[i]-values[i-1]);
+      return gap;
+    }
+  }
+
+  template<class PView>
+  Bnd<PView>::Bnd(Home home, ViewArray<IntView>& x0, PView p0, bool a)
+    : MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>(home,x0,p0),
+      advanced(a) {}
+
+  template<class PView>
+  Bnd<PView>::Bnd(Space& home, Bnd& b)
+    : MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>(home,b),
+      advanced(b.advanced) {}
+
+  template<class PView>
+  Propagator*
+  Bnd<PView>::copy(Space& home) {
+    return new (home) Bnd(home,*this);
+  }
+
+  template<class PView>
+  PropCost
+  Bnd<PView>::cost(const Space&, const ModEventDelta& med) const {
+    // ME_INT_DOM is a synthetic event: subscriptions only generate bound
+    // or assignment events. It schedules the quadratic stage separately.
+    if (IntView::me(med) == ME_INT_DOM)
+      return PropCost::quadratic(PropCost::HI,x.size());
+    return PropCost::linear(PropCost::HI,x.size());
+  }
+
+  template<class PView>
+  size_t
+  Bnd<PView>::dispose(Space& home) {
+    (void) MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::dispose(home);
+    return sizeof(*this);
+  }
+
+  template<class PView>
+  ExecStatus
+  Bnd<PView>::post(Home home, ViewArray<IntView>& x, PView p, bool advanced) {
+    if (x.size() > 1)
+      (void) new (home) Bnd(home,x,p,advanced);
+    return ES_OK;
+  }
+
+  template<class PView>
+  ExecStatus
+  Bnd<PView>::propagate(Space& home, const ModEventDelta& med) {
+    Region region;
+    bool assigned = true;
+    int min = x[0].min();
+    int max = x[0].max();
+    for (int i=0; i<x.size(); i++) {
+      min = std::min(min,x[i].min());
+      max = std::max(max,x[i].max());
+      assigned &= x[i].assigned();
+    }
+
+    if (assigned) {
+      GECODE_ME_CHECK(y.lq(home,assigned_distance(region,x)));
+      return home.ES_SUBSUMED(*this);
+    }
+    if (y.max() == 0)
+      return home.ES_SUBSUMED(*this);
+    if (y.assigned() && (y.val() == 1))
+      GECODE_REWRITE(*this,Distinct::Bnd<IntView>::post(home(*this),x));
+
+    const int p = y.min();
+    if (IntView::me(med) != ME_INT_DOM) {
+      Time limit = (static_cast<Time>(max)-min)/(x.size()-1);
+      int upper = static_cast<int>(std::min(limit,static_cast<Time>(y.max())));
+      if (upper < p)
+        return ES_FAILED;
+      upper = maximum_feasible_distance(region,x,p,upper);
+      if (upper < 0)
+        return ES_FAILED;
+      GECODE_ME_CHECK(y.lq(home,upper));
+      if (y.max() == 0)
+        return home.ES_SUBSUMED(*this);
+      if (y.assigned() && (y.val() == 1))
+        GECODE_REWRITE(*this,Distinct::Bnd<IntView>::post(home(*this),x));
+      if (!advanced || (p == 0))
+        return ES_FIX;
+      return home.ES_FIX_PARTIAL(*this,IntView::med(ME_INT_DOM));
+    }
+
+    // A zero minimum gives every x bound a support; only the basic stage
+    // needs to filter the distance. A later increase wakes that stage again.
+    if (p == 0)
+      return ES_FIX;
+    ExecStatus filtered = filter_bounds(home,region,x,p);
+    if (filtered == ES_FAILED)
+      return ES_FAILED;
+
+    assigned = true;
+    for (int i=0; i<x.size(); i++)
+      assigned &= x[i].assigned();
+    if (assigned) {
+      GECODE_ME_CHECK(y.lq(home,assigned_distance(region,x)));
+      return home.ES_SUBSUMED(*this);
+    }
+
+    // Holes can move actual bounds beyond the computed bounds, invalidating
+    // an interval support for x or the distance. Restart the basic stage.
+    return filtered;
+  }
+
+  // Export the compiled view specializations for propagator reuse.
+  template class Bnd<IntView>;
+  template class Bnd<ConstIntView>;
+
+}}}
+
+namespace Gecode {
+
+  void
+  inter_distance(Home home, const IntVarArgs& x, int p, IntPropLevel ipl) {
+    using namespace Int;
+    Limits::nonnegative(p,"Int::inter_distance");
+    if ((p > 0) && same(x))
+      throw ArgumentSame("Int::inter_distance");
+    GECODE_POST;
+    if ((p == 0) || (x.size() < 2))
+      return;
+    ViewArray<IntView> xv(home,x);
+    if (p == 1) {
+      GECODE_ES_FAIL(Distinct::Bnd<IntView>::post(home,xv));
+    } else {
+      GECODE_ES_FAIL(InterDistance::Bnd<ConstIntView>::post(
+        home,xv,ConstIntView(p),ba(ipl) != IPL_BASIC));
+    }
+  }
+
+  void
+  inter_distance(Home home, const IntVarArgs& x, IntVar p, IntPropLevel ipl) {
+    using namespace Int;
+    if ((x.size() > 1) &&
+        (same(x,p) || ((p.max() > 0) && same(x))))
+      throw ArgumentSame("Int::inter_distance");
+    GECODE_POST;
+    IntView pv(p);
+    GECODE_ME_FAIL(pv.gq(home,0));
+    if ((pv.max() == 0) || (x.size() < 2))
+      return;
+    if (pv.assigned()) {
+      inter_distance(home,x,pv.val(),ipl);
+      return;
+    }
+    ViewArray<IntView> xv(home,x);
+    GECODE_ES_FAIL(InterDistance::Bnd<IntView>::post(
+      home,xv,pv,ba(ipl) != IPL_BASIC));
+  }
+
+}
+
+// STATISTICS: int-post
diff --git a/gecode/int/inter-distance.hh b/gecode/int/inter-distance.hh
new file mode 100644
index 0000000000..760ddd7cfd
--- /dev/null
+++ b/gecode/int/inter-distance.hh
@@ -0,0 +1,100 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Claude-Guy Quimper <claude-guy.quimper@ift.ulaval.ca>
+ *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
+ *
+ *  Copyright:
+ *     Claude-Guy Quimper, 2006
+ *     Mikael Zayenz Lagerkvist, 2026
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.dev
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef GECODE_INT_INTER_DISTANCE_HH
+#define GECODE_INT_INTER_DISTANCE_HH
+
+#include <gecode/int.hh>
+
+/**
+ * \namespace Gecode::Int::InterDistance
+ *
+ * The feasibility and bounds-filtering algorithms follow:
+ *   M. R. Garey, D. S. Johnson, B. B. Simons, and R. E. Tarjan,
+ *   Scheduling Unit-Time Tasks with Arbitrary Release Times and Deadlines,
+ *   SIAM Journal on Computing 10(2), pages 256-269, 1981.
+ *   Claude-Guy Quimper, Alejandro Lopez-Ortiz, and Gilles Pesant,
+ *   A Quadratic Propagator for the Inter-Distance Constraint,
+ *   AAAI, pages 123-128, 2006, and Constraint Programming Letters 3,
+ *   pages 21-35, 2008.
+ *
+ * \brief Inter-distance propagator
+ */
+namespace Gecode { namespace Int { namespace InterDistance {
+
+  /**
+   * \brief Bounds-consistent inter-distance propagator
+   *
+   * The basic stage uses Garey et al.'s O(n log n) feasibility algorithm.
+   * With a variable distance it also finds the largest feasible distance
+   * by binary search (Quimper et al., 2008, Section 5).
+   * The advanced stage performs quadratic bounds filtering.
+   * Only views and the algorithm flag are copied on cloning.
+   * The compiled distance views are IntView and ConstIntView.
+   *
+   * Requires \code #include <gecode/int/inter-distance.hh> \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class PView>
+  class GECODE_INT_EXPORT Bnd
+    : public MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND> {
+  protected:
+    using MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::x;
+    using MixNaryOnePropagator<IntView,PC_INT_BND,PView,PC_INT_BND>::y;
+    /// Whether to run quadratic filtering after the basic stage
+    bool advanced;
+    /// Constructor for posting
+    Bnd(Home home, ViewArray<IntView>& x, PView p, bool advanced);
+    /// Constructor for cloning
+    Bnd(Space& home, Bnd& b);
+  public:
+    /// Copy during cloning
+    virtual Propagator* copy(Space& home);
+    /// Cost of the current stage
+    virtual PropCost cost(const Space&, const ModEventDelta&) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta&);
+    /// Cancel subscriptions and dispose
+    virtual size_t dispose(Space& home);
+    /// Post propagator
+    static ExecStatus post(Home home, ViewArray<IntView>& x, PView p,
+                           bool advanced);
+  };
+
+}}}
+
+#endif
+
+// STATISTICS: int-prop
diff --git a/test/int/inter-distance.cpp b/test/int/inter-distance.cpp
new file mode 100644
index 0000000000..362a76b513
--- /dev/null
+++ b/test/int/inter-distance.cpp
@@ -0,0 +1,395 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
+ *
+ *  Copyright:
+ *     Mikael Zayenz Lagerkvist, 2026
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.dev
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+#include <algorithm>
+#include <limits>
+
+namespace Test { namespace Int { namespace InterDistance {
+
+  /// Exercise assignment, cloning, search, and bounds(Z) consistency
+  class Distance : public Test {
+  protected:
+    int p;
+  public:
+    Distance(int n, int p0, int min, int max,
+             Gecode::IntPropLevel ipl0=Gecode::IPL_DEF)
+      : Test((n == 3 && p0 == 2 && min == -3)
+             ? TestTags::check() : TestTags::standard(),
+             "InterDistance::"+str(n)+"::"+str(p0)+"::"+str(min)+
+             "::"+str(ipl0),n,min,max,false,ipl0), p(p0) {
+      contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
+    }
+    Distance(int n, int p0, const Gecode::IntSet& domain)
+      : Test(TestTags::standard(),"InterDistance::Holes::"+str(n)+"::"+str(p0),
+             n,domain,false,Gecode::IPL_DEF), p(p0) {
+      contest = CTL_BOUNDS_Z;
+    }
+    virtual bool solution(const Assignment& x) const {
+      for (int i=0; i<x.size(); i++)
+        for (int j=0; j<i; j++) {
+          long long int d = static_cast<long long int>(x[i])-x[j];
+          if ((-p < d) && (d < p))
+            return false;
+        }
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      Gecode::inter_distance(home,x,p,ipl);
+    }
+  };
+
+  /// Variable distance, including propagation after distance assignments
+  class Variable : public Test {
+  public:
+    Variable(int n, Gecode::IntPropLevel ipl0)
+      : Test(n == 3 ? TestTags::check() : TestTags::standard(),
+             "InterDistance::Variable::"+str(n)+"::"+str(ipl0),
+             n+1,-2,3,false,ipl0) {
+      contest = Gecode::ba(ipl) == Gecode::IPL_BASIC ? CTL_NONE : CTL_BOUNDS_Z;
+    }
+    virtual bool solution(const Assignment& x) const {
+      int p = x[x.size()-1];
+      if (p < 0)
+        return false;
+      for (int i=0; i<x.size()-1; i++)
+        for (int j=0; j<i; j++)
+          if (std::abs(x[i]-x[j]) < p)
+            return false;
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      Gecode::IntVarArgs a(x.size()-1);
+      for (int i=0; i<a.size(); i++)
+        a[i] = x[i];
+      Gecode::inter_distance(home,a,x[x.size()-1],ipl);
+    }
+  };
+
+  /// Mix arbitrary assignments with sorted, separated values and shuffle them
+  class DistanceAssignment : public RandomAssignment {
+  protected:
+    int p;
+    bool variable;
+  public:
+    DistanceAssignment(int n, const Gecode::IntSet& d, int p0, bool v,
+                       Gecode::Support::RandomGenerator& rand)
+      : RandomAssignment(n,d,100,rand), p(p0), variable(v) {}
+    virtual void next(Gecode::Support::RandomGenerator& rand) {
+      RandomAssignment::next(rand);
+      if (a % 2 == 0) {
+        int m = n - static_cast<int>(variable);
+        int distance = variable ? static_cast<int>(rand(p+1)) : p;
+        int slack = d.max()-d.min()-(m-1)*distance;
+        int value = d.min();
+        for (int i=0; i<m; i++) {
+          int extra = static_cast<int>(rand(slack+1));
+          slack -= extra;
+          value += extra;
+          vals[i] = value;
+          if (i+1 < m)
+            value += distance;
+        }
+        for (int i=m-1; i>0; i--) {
+          int j = static_cast<int>(rand(i+1));
+          std::swap(vals[i],vals[j]);
+        }
+        if (variable)
+          vals[m] = distance;
+      }
+    }
+  };
+
+  /// Larger instances with a bounded total slack
+  class Random : public Test {
+  protected:
+    int p;
+    bool variable;
+  public:
+    Random(int n, int p0, int slack, bool v, Gecode::IntPropLevel level)
+      : Test("InterDistance::Random::"+str(n)+"::"+str(p0)+"::"+
+             str(slack)+"::"+str(v)+"::"+str(level),
+             n+static_cast<int>(v),0,(n-1)*p0+slack,false,level),
+        p(p0), variable(v) {
+      testsearch = false;
+    }
+    virtual Assignment* assignment(void) const {
+      return new DistanceAssignment(arity,dom,p,variable,_rand);
+    }
+    virtual bool solution(const Assignment& x) const {
+      int n = x.size()-static_cast<int>(variable);
+      int distance = variable ? x[n] : p;
+      for (int i=0; i<n; i++)
+        for (int j=0; j<i; j++)
+          if (std::abs(x[i]-x[j]) < distance)
+            return false;
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      Gecode::IntVarArgs y(x.size()-static_cast<int>(variable));
+      for (int i=0; i<y.size(); i++)
+        y[i] = x[i];
+      if (variable)
+        Gecode::inter_distance(home,y,x[y.size()],ipl);
+      else
+        Gecode::inter_distance(home,y,p,ipl);
+    }
+  };
+
+  /// Enumerate assignments within each example's individual variable domains
+  class ExampleAssignment : public Assignment {
+    Gecode::IntSet domains[6];
+    Gecode::IntSetValues values[6];
+  public:
+    ExampleAssignment(int n, const Gecode::IntSet* d)
+      : Assignment(n,Gecode::IntSet()) {
+      for (int i=0; i<n; i++) {
+        domains[i] = d[i];
+        values[i].init(domains[i]);
+      }
+    }
+    virtual bool has_more(void) const {
+      return values[0]();
+    }
+    virtual void next(Gecode::Support::RandomGenerator&) {
+      int i = n-1;
+      while (true) {
+        ++values[i];
+        if (values[i]() || (i == 0))
+          return;
+        values[i--].init(domains[i]);
+      }
+    }
+    virtual int operator[](int i) const {
+      return values[i].val();
+    }
+  };
+
+  /// Hole-jump and residue examples use the same assignment checks
+  class Examples : public Test {
+  protected:
+    Gecode::IntSet domains[6];
+  public:
+    Examples(const std::string& name, int n, const Gecode::IntSet& domain,
+             const Gecode::IntSet* d, Gecode::IntPropLevel level)
+      : Test(TestTags::check(),"InterDistance::"+name+"::"+str(level),
+             n,domain,false,level) {
+      for (int i=0; i<n; i++)
+        domains[i] = d[i];
+      testsearch = false;
+    }
+    virtual Assignment* assignment(void) const {
+      return new ExampleAssignment(arity,domains);
+    }
+    virtual bool solution(const Assignment& x) const {
+      for (int i=0; i<x.size(); i++)
+        if (!domains[i].in(x[i]))
+          return false;
+      int p = x[x.size()-1];
+      for (int i=0; i<x.size()-1; i++)
+        for (int j=0; j<i; j++) {
+          long long int d = static_cast<long long int>(x[i])-x[j];
+          if ((-p < d) && (d < p))
+            return false;
+        }
+      return true;
+    }
+    virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+      for (int i=0; i<x.size(); i++)
+        Gecode::dom(home,x[i],domains[i]);
+      Gecode::IntVarArgs y(x.size()-1);
+      for (int i=0; i<y.size(); i++)
+        y[i] = x[i];
+      Gecode::inter_distance(home,y,x[x.size()-1],ipl);
+    }
+  };
+
+  /// Posting contracts, vacuous constraints, and shared variables
+  class Posting : public Base {
+    static bool constant_contracts(void) {
+      using namespace Gecode;
+      IntSet domain(-2,2);
+      TestSpace s(0,domain,nullptr);
+      IntVar v(s,-2,2);
+      IntVarArgs duplicate(2);
+      duplicate[0] = duplicate[1] = v;
+      inter_distance(s,duplicate,0);
+      bool same = false;
+      bool negative = false;
+      bool tooLarge = false;
+      try {
+        inter_distance(s,duplicate,2);
+      } catch (const Gecode::Int::ArgumentSame&) {
+        same = true;
+      }
+      try {
+        inter_distance(s,IntVarArgs(),-1);
+      } catch (const Gecode::Int::OutOfLimits&) {
+        negative = true;
+      }
+      try {
+        inter_distance(s,IntVarArgs(),std::numeric_limits<int>::max());
+      } catch (const Gecode::Int::OutOfLimits&) {
+        tooLarge = true;
+      }
+
+      inter_distance(s,IntVarArgs(),2);
+      IntVarArgs singleton(1);
+      singleton[0] = v;
+      inter_distance(s,singleton,2);
+      if (!same || !negative || !tooLarge || (s.status() == SS_FAILED))
+        return false;
+
+      TestSpace t(0,domain,nullptr);
+      IntVar assigned(t,3,3);
+      duplicate[0] = duplicate[1] = assigned;
+      inter_distance(t,duplicate,2);
+      if (t.status() != SS_FAILED)
+        return false;
+      return true;
+    }
+
+    static bool variable_contracts(void) {
+      using namespace Gecode;
+      IntSet domain(-3,9);
+      TestSpace empty(0,domain,nullptr);
+      IntVar distance(empty,-3,9);
+      inter_distance(empty,IntVarArgs(),distance);
+      if ((empty.status() == SS_FAILED) || (distance.min() != 0))
+        return false;
+
+      TestSpace negativeDistance(0,domain,nullptr);
+      IntVar negativeVar(negativeDistance,-3,-1);
+      inter_distance(negativeDistance,IntVarArgs(),negativeVar);
+      if (negativeDistance.status() != SS_FAILED)
+        return false;
+
+      TestSpace shared(0,domain,nullptr);
+      IntVar a(shared,0,9);
+      IntVar b(shared,0,9);
+      IntVar p(shared,0,9);
+      IntVarArgs pair(2);
+      pair[0] = a;
+      pair[1] = b;
+      bool alias = false;
+      bool repeated = false;
+      try {
+        inter_distance(shared,pair,a);
+      } catch (const Gecode::Int::ArgumentSame&) {
+        alias = true;
+      }
+      pair[1] = a;
+      try {
+        inter_distance(shared,pair,p);
+      } catch (const Gecode::Int::ArgumentSame&) {
+        repeated = true;
+      }
+      if (!alias || !repeated)
+        return false;
+      return true;
+    }
+
+  public:
+    Posting(void) : Base("Int::InterDistance::Posting",TestTags::check()) {}
+    virtual bool run(void) {
+      if (!constant_contracts()) {
+        olog << "Constant posting contracts failed" << std::endl;
+        return false;
+      }
+      if (!variable_contracts()) {
+        olog << "Variable posting contracts failed" << std::endl;
+        return false;
+      }
+      return true;
+    }
+  };
+
+  class Create {
+  public:
+    Create(void) {
+      using namespace Gecode;
+      for (IntPropLevel level : {IPL_BASIC,IPL_ADVANCED,IPL_BASIC_ADVANCED}) {
+        for (int n : {8,24})
+          for (int slack : {0,8})
+            for (bool variable : {false,true})
+              (void) new Random(n,3,slack,variable,level);
+        const IntSet paper[] = {IntSet(2,6),IntSet(10,14),
+                                IntSet(4,15),IntSet(0,8)};
+        (void) new Examples("Paper",4,IntSet(0,15),paper,level);
+        const IntSet adjacent[] = {IntSet(1,17),IntSet(5,8),
+                                   IntSet(2,14),IntSet(0,8)};
+        (void) new Examples("Adjacent",4,IntSet(0,17),adjacent,level);
+        const IntSet holes[] = {IntSet({0,2,6,7}),IntSet({-3,2}),
+          IntSet({10,11,14}),IntSet({1,2,3,6}),IntSet({-1,0,3,5,9}),
+          IntSet(4,4)};
+        (void) new Examples("HoleJump",6,IntSet(-3,14),holes,level);
+        const IntSet residue[] = {IntSet(2,11),IntSet(-10,-2),
+                                  IntSet(16,17),IntSet(13,14)};
+        (void) new Examples("Residue",4,IntSet(-10,17),residue,level);
+      }
+      const int limit = Gecode::Int::Limits::max;
+      const IntSet extremes[] = {IntSet(-limit,-limit+1),IntSet(0,1),
+                                 IntSet(limit-1,limit),IntSet(limit-1,limit)};
+      (void) new Examples("Limits",4,
+                         IntSet({-limit,-limit+1,0,1,limit-1,limit}),
+                         extremes,IPL_BASIC);
+      (void) new Distance(3,limit,IntSet({-limit,-limit+1,0,1,
+                                        limit-1,limit}));
+      for (int n=1; n<=4; n++)
+        for (int p=0; p<=4; p++)
+          (void) new Distance(n,p,-3,3);
+      (void) new Distance(3,2,Gecode::IntSet({-3,-1,0,2,3}));
+      (void) new Distance(3,2,Gecode::Int::Limits::min,
+                             Gecode::Int::Limits::min+5);
+      (void) new Distance(3,2,Gecode::Int::Limits::max-5,
+                             Gecode::Int::Limits::max);
+      for (Gecode::IntPropLevel ipl : {Gecode::IPL_DEF,Gecode::IPL_BASIC,
+                                      Gecode::IPL_ADVANCED}) {
+        (void) new Variable(2,ipl);
+        (void) new Variable(3,ipl);
+      }
+      (void) new Variable(0,Gecode::IPL_DEF);
+      (void) new Variable(1,Gecode::IPL_DEF);
+      for (Gecode::IntPropLevel ipl : {Gecode::IPL_BASIC,Gecode::IPL_ADVANCED,
+                                      Gecode::IPL_BASIC_ADVANCED})
+        (void) new Distance(3,2,-3,3,ipl);
+      (void) new Distance(3,2,-3,3,static_cast<Gecode::IntPropLevel>(
+        Gecode::IPL_BND | Gecode::IPL_BASIC));
+    }
+  } create;
+  Posting posting;
+
+}}}
+
+// STATISTICS: test-int