int.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.dev>
 *     Guido Tack <tack@gecode.dev>
 *
 *  Contributing authors:
 *     Stefano Gualandi <stefano.gualandi@gmail.com>
 *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
 *     David Rijsman <David.Rijsman@quintiq.com>
 *     Samuel Gagnon <samuel.gagnon92@gmail.com>
 *
 *  Copyright:
 *     Stefano Gualandi, 2013
 *     Mikael Zayenz Lagerkvist, 2006, 2026
 *     David Rijsman, 2009
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *     Samuel Gagnon, 2018
 *
 *  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_HH
#define GECODE_INT_HH
 
#include <climits>
#include <cfloat>
 
#ifdef GECODE_HAS_FAULT_INJECTION
#include <atomic>
#endif
 
#include <iostream>
#include <vector>
#include <unordered_map>
#include <functional>
#include <utility>
#include <initializer_list>
 
#include <gecode/kernel.hh>
#include <gecode/search.hh>
#include <gecode/iter.hh>
 
/*
 * Configure linking
 *
 */
#if !defined(GECODE_STATIC_LIBS) && \
    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
 
#ifdef GECODE_BUILD_INT
#define GECODE_INT_EXPORT __declspec( dllexport )
#else
#define GECODE_INT_EXPORT __declspec( dllimport )
#endif
 
#else
 
#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
#define GECODE_INT_EXPORT __attribute__ ((visibility("default")))
#else
#define GECODE_INT_EXPORT
#endif
 
#endif
 
// Configure auto-linking
#ifndef GECODE_BUILD_INT
#define GECODE_LIBRARY_NAME "Int"
#include <gecode/support/auto-link.hpp>
#endif

 
#include <gecode/int/exception.hpp>
 
namespace Gecode { namespace Int {

  namespace Limits {
    const int max = INT_MAX - 1;
    const int min = -max;
    const int infinity = max + 1;
    const long long int llmax =  LLONG_MAX - 1;
    const long long int llmin = -llmax;
    const long long int llinfinity = llmax + 1;
    bool valid(int n);
    bool valid(long long int n);
    void check(int n, const char* l);
    void check(long long int n, const char* l);
    void positive(int n, const char* l);
    void positive(long long int n, const char* l);
    void nonnegative(int n, const char* l);
    void nonnegative(long long int n, const char* l);
    bool overflow_add(int n, int m);
    bool overflow_add(long long int n, long long int m);
    bool overflow_sub(int n, int m);
    bool overflow_sub(long long int n, long long int m);
    bool overflow_mul(int n, int m);
    bool overflow_mul(long long int n, long long int m);
  }
 
}}
 
#include <gecode/int/limits.hpp>
 
namespace Gecode {
 
  class IntSetRanges;
 
  template<class I> class IntSetInit;

  class IntSet : public SharedHandle {
    friend class IntSetRanges;
    template<class I> friend class IntSetInit;
  private:
    class Range {
    public:
      int min, max;
    };
    class IntSetObject : public SharedHandle::Object {
    public:
      unsigned int size;
      int n;
      Range* r;
#ifdef GECODE_HAS_FAULT_INJECTION
      static std::atomic<int> fault_live_objects;
      static void* operator new(size_t s);
      static void operator delete(void* p);
#endif
      GECODE_INT_EXPORT static IntSetObject* allocate(int m);
      GECODE_INT_EXPORT bool in(int n) const;
      GECODE_INT_EXPORT bool equal(const IntSetObject& so) const;
      GECODE_INT_EXPORT virtual ~IntSetObject(void);
    };
    class MinInc;
    GECODE_INT_EXPORT void normalize(Range* r, int n);
    GECODE_INT_EXPORT void init(int n, int m);
    GECODE_INT_EXPORT void init(const int r[], int n);
    GECODE_INT_EXPORT void init(const int r[][2], int n);
  public:
#ifdef GECODE_HAS_FAULT_INJECTION
    GECODE_INT_EXPORT static void fault_reset_allocations(void);
    GECODE_INT_EXPORT static int fault_live_allocations(void);
#endif


    IntSet(void);
    explicit IntSet(int n, int m);
    explicit IntSet(const int r[],   int n);
    explicit IntSet(const int r[][2], int n);
    template<class I>
    explicit IntSet(I& i);
    template<class I>
    explicit IntSet(const I& i);
    GECODE_INT_EXPORT
    explicit IntSet(std::initializer_list<int> r);
    GECODE_INT_EXPORT
    explicit IntSet(std::initializer_list<std::pair<int,int>> r);



    int ranges(void) const;
    int min(int i) const;
    int max(int i) const;
    unsigned int width(int i) const;



    bool in(int n) const;
    unsigned int size(void) const;
    unsigned int width(void) const;
    int min(void) const;
    int max(void) const;



    bool operator ==(const IntSet& s) const;
    bool operator !=(const IntSet& s) const;



    GECODE_INT_EXPORT static const IntSet empty;
  };

  class IntSetRanges {
  private:
    const IntSet::Range* i;
    const IntSet::Range* e;
  public:


    IntSetRanges(void);
    IntSetRanges(const IntSet& s);
    void init(const IntSet& s);



    bool operator ()(void) const;
    void operator ++(void);



    int min(void) const;
    int max(void) const;
    unsigned int width(void) const;
  };

  class IntSetValues : public Iter::Ranges::ToValues<IntSetRanges> {
  public:


    IntSetValues(void);
    IntSetValues(const IntSet& s);
    void init(const IntSet& s);
  };

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const IntSet& s);
 
}
 
#include <gecode/int/int-set-1.hpp>
 
#include <gecode/int/var-imp.hpp>
 
namespace Gecode {
 
  namespace Int {
    class IntView;
  }

  class IntVar : public VarImpVar<Int::IntVarImp> {
    friend class IntVarArray;
    friend class IntVarArgs;
  private:
    using VarImpVar<Int::IntVarImp>::x;
    void _init(Space& home, int min, int max);
    void _init(Space& home, const IntSet& d);
  public:


    IntVar(void);
    IntVar(const IntVar& y);
    IntVar(const Int::IntView& y);
    GECODE_INT_EXPORT IntVar(Space& home, int min, int max);
    GECODE_INT_EXPORT IntVar(Space& home, const IntSet& d);



    int min(void) const;
    int max(void) const;
    int med(void) const;
    int val(void) const;

    unsigned int size(void) const;
    unsigned int width(void) const;
    unsigned int regret_min(void) const;
    unsigned int regret_max(void) const;



    bool range(void) const;
    bool in(int n) const;

    IntVar& operator =(const IntVar&) = default;
  };

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const IntVar& x);

  class IntVarRanges : public Int::IntVarImpFwd {
  public:


    IntVarRanges(void);
    IntVarRanges(const IntVar& x);
    void init(const IntVar& x);
  };

  class IntVarValues : public Iter::Ranges::ToValues<IntVarRanges> {
  public:


    IntVarValues(void);
    IntVarValues(const IntVar& x);
    void init(const IntVar& x);
  };
 
  namespace Int {
    class BoolView;
  }

  class BoolVar : public VarImpVar<Int::BoolVarImp> {
    friend class BoolVarArray;
    friend class BoolVarArgs;
  private:
    using VarImpVar<Int::BoolVarImp>::x;
    void _init(Space& home, int min, int max);
  public:


    BoolVar(void);
    BoolVar(const BoolVar& y);
    BoolVar(const Int::BoolView& y);
    GECODE_INT_EXPORT BoolVar(Space& home, int min, int max);



    int min(void) const;
    int max(void) const;
    int med(void) const;
    int val(void) const;

    unsigned int size(void) const;
    unsigned int width(void) const;
    unsigned int regret_min(void) const;
    unsigned int regret_max(void) const;



    bool range(void) const;
    bool in(int n) const;



    bool zero(void) const;
    bool one(void) const;
    bool none(void) const;

    BoolVar& operator =(const BoolVar&) = default;
  };

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const BoolVar& x);
 
}
 
 
#include <gecode/int/view.hpp>
#include <gecode/int/propagator.hpp>
 
namespace Gecode {



  typedef ArgArray<IntSet> IntSetArgs;
 
}
 
#include <gecode/int/array-traits.hpp>
 
namespace Gecode {

  class IntArgs : public ArgArray<int> {
  public:


    IntArgs(void);
    explicit IntArgs(int n);
    IntArgs(const SharedArray<int>& x);
    IntArgs(const std::vector<int>& x);
    IntArgs(std::initializer_list<int> x);
    template<class InputIterator>
    IntArgs(InputIterator first, InputIterator last);
    IntArgs(int n, const int* e);
    IntArgs(const ArgArray<int>& a);

    static IntArgs create(int n, int start, int inc=1);
  };

  class IntVarArgs : public VarArgArray<IntVar> {
  public:


    IntVarArgs(void);
    explicit IntVarArgs(int n);
    IntVarArgs(const IntVarArgs& a);
    IntVarArgs(const VarArray<IntVar>& a);
    IntVarArgs(const std::vector<IntVar>& a);
    IntVarArgs(std::initializer_list<IntVar> a);
    template<class InputIterator>
    IntVarArgs(InputIterator first, InputIterator last);
    GECODE_INT_EXPORT
    IntVarArgs(Space& home, int n, int min, int max);
    GECODE_INT_EXPORT
    IntVarArgs(Space& home, int n, const IntSet& s);
    IntVarArgs& operator =(const IntVarArgs&) = default;
  };

  class BoolVarArgs : public VarArgArray<BoolVar> {
  public:


    BoolVarArgs(void);
    explicit BoolVarArgs(int n);
    BoolVarArgs(const BoolVarArgs& a);
    BoolVarArgs(const VarArray<BoolVar>& a);
    BoolVarArgs(const std::vector<BoolVar>& a);
    BoolVarArgs(std::initializer_list<BoolVar> a);
    template<class InputIterator>
    BoolVarArgs(InputIterator first, InputIterator last);
    GECODE_INT_EXPORT
    BoolVarArgs(Space& home, int n, int min, int max);
    BoolVarArgs& operator =(const BoolVarArgs&) = default;
  };



  class IntVarArray : public VarArray<IntVar> {
  public:


    IntVarArray(void);
    IntVarArray(Space& home, int n);
    IntVarArray(const IntVarArray& a);
    IntVarArray(Space& home, const IntVarArgs& a);
    GECODE_INT_EXPORT
    IntVarArray(Space& home, int n, int min, int max);
    GECODE_INT_EXPORT
    IntVarArray(Space& home, int n, const IntSet& s);

    IntVarArray& operator =(const IntVarArray&) = default;
  };

  class BoolVarArray : public VarArray<BoolVar> {
  public:


    BoolVarArray(void);
    BoolVarArray(Space& home, int n);
    BoolVarArray(const BoolVarArray& a);
    BoolVarArray(Space& home, const BoolVarArgs& a);
    GECODE_INT_EXPORT
    BoolVarArray(Space& home, int n, int min, int max);

    BoolVarArray& operator =(const BoolVarArray&) = default;
  };
 
}
 
#include <gecode/int/int-set-2.hpp>
 
#include <gecode/int/array.hpp>
 
namespace Gecode {

  enum ReifyMode {
    RM_EQV,
    RM_IMP,
    RM_PMI
  };

  class Reify {
  protected:
    BoolVar x;
    ReifyMode rm;
  public:
    Reify(void);
    Reify(BoolVar x, ReifyMode rm=RM_EQV);
    BoolVar var(void) const;
    ReifyMode mode(void) const;
    void var(BoolVar x);
    void mode(ReifyMode rm);
  };

  Reify eqv(BoolVar x);

  Reify imp(BoolVar x);

  Reify pmi(BoolVar x);
 
}
 
#include <gecode/int/reify.hpp>
 
namespace Gecode {

  enum IntRelType {
    IRT_EQ, 
    IRT_NQ, 
    IRT_LQ, 
    IRT_LE, 
    IRT_GQ, 
    IRT_GR  
  };

  IntRelType swap(IntRelType irt);

  IntRelType neg(IntRelType irt);
 
}
 
#include <gecode/int/irt.hpp>
 
namespace Gecode {

  enum BoolOpType {
    BOT_AND, 
    BOT_OR,  
    BOT_IMP, 
    BOT_EQV, 
    BOT_XOR  
  };

  enum IntPropLevel {
    IPL_DEF = 0, 
    IPL_VAL = 1, 
    IPL_BND = 2, 
    IPL_DOM = 3, 
    IPL_BASIC = 4,    
    IPL_ADVANCED = 8, 
    IPL_BASIC_ADVANCED = IPL_BASIC | IPL_ADVANCED, 
    IPL_FULL = IPL_BASIC_ADVANCED, 
    IPL_BITS_ = 4 
  };

  IntPropLevel vbd(IntPropLevel ipl);

  IntPropLevel ba(IntPropLevel ipl);
 
}
 
#include <gecode/int/ipl.hpp>
 
namespace Gecode {

  enum TaskType {
    TT_FIXP, //< Task with fixed processing time
    TT_FIXS, //< Task with fixed start time
    TT_FIXE  //< Task with fixed end time
  };

  typedef ArgArray<TaskType> TaskTypeArgs;

  template<>
  class ArrayTraits<ArgArray<TaskType> > {
  public:
    typedef TaskTypeArgs StorageType;
    typedef TaskType     ValueType;
    typedef TaskTypeArgs ArgsType;
  };
 



  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int n,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, int n,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int l, int m,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, int l, int m,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, const IntSet& s,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, const IntSet& s,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int n, Reify r,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int l, int m, Reify r,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, const IntSet& s, Reify r,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, IntVar d,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, BoolVar x, BoolVar d,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, const IntVarArgs& d,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const BoolVarArgs& x, const BoolVarArgs& d,
      IntPropLevel ipl=IPL_DEF);
 

  GECODE_INT_EXPORT void
  rel(Home home, IntVar x0, IntRelType irt, IntVar x1,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, IntVar y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, IntVar x, IntRelType irt, int c,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, int c,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, IntVar x0, IntRelType irt, IntVar x1, Reify r,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, IntVar x, IntRelType irt, int c, Reify r,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, const IntVarArgs& y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, const IntArgs& y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntArgs& x, IntRelType irt, const IntVarArgs& y,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, BoolVar y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x, IntRelType irt, int n,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x, IntRelType irt, int n, Reify r,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, int n,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, const IntArgs& y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntArgs& x, IntRelType irt, const BoolVarArgs& y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolOpType o, const BoolVarArgs& x, BoolVar y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
         BoolVar z, IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
         int n, IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  ite(Home home, BoolVar b, IntVar x, IntVar y, IntVar z,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  ite(Home home, BoolVar b, BoolVar x, BoolVar y, BoolVar z,
      IntPropLevel ipl=IPL_DEF);
 

  GECODE_INT_EXPORT void
  precede(Home home, const IntVarArgs& x, int s, int t,
          IntPropLevel=IPL_DEF);
  GECODE_INT_EXPORT void
  precede(Home home, const IntVarArgs& x, const IntArgs& c,
          IntPropLevel=IPL_DEF);
 


  GECODE_INT_EXPORT void
  member(Home home, const IntVarArgs& x, IntVar y,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  member(Home home, const BoolVarArgs& x, BoolVar y,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  member(Home home, const IntVarArgs& x, IntVar y, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  member(Home home, const BoolVarArgs& x, BoolVar y, Reify r,
         IntPropLevel ipl=IPL_DEF);
 



  typedef SharedArray<int> IntSharedArray;
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, IntVar x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, int offset, IntVar x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, BoolVar x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, int offset, BoolVar x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, int x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, int offset, int x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& x, IntVar y0, IntVar y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& x, IntVar y0, int offset, IntVar y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& x, IntVar y0, int y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& x, IntVar y0, int offset, int y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& x, IntVar y0, BoolVar y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& x, IntVar y0, int offset, BoolVar y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& x, IntVar y0, int y1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& x, IntVar y0, int offset, int y1,
          IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray a,
          IntVar x, int w, IntVar y, int h, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray a,
          IntVar x, int xoff, int w, IntVar y, int yoff, int h, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray a,
          IntVar x, int w, IntVar y, int h, BoolVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray a,
          IntVar x, int xoff, int w, IntVar y, int yoff, int h, BoolVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& a,
          IntVar x, int w, IntVar y, int h, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& a,
          IntVar x, int xoff, int w, IntVar y, int yoff, int h, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& a,
          IntVar x, int w, IntVar y, int h, BoolVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& a,
          IntVar x, int xoff, int w, IntVar y, int yoff, int h, BoolVar z,
          IntPropLevel ipl=IPL_DEF);
 



  GECODE_INT_EXPORT void
  distinct(Home home, const IntVarArgs& x,
           IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  distinct(Home home, const IntArgs& n, const IntVarArgs& x,
           IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  distinct(Home home, const BoolVarArgs& b, const IntVarArgs& x,
           IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  distinct(Home home, const IntVarArgs& x, int c,
           IntPropLevel ipl=IPL_DEF);
 



  GECODE_INT_EXPORT void
  channel(Home home, const IntVarArgs& x, const IntVarArgs& y,
          IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  channel(Home home, const IntVarArgs& x, int xoff,
          const IntVarArgs& y, int yoff,
          IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  channel(Home home, BoolVar x0, IntVar x1,
          IntPropLevel ipl=IPL_DEF);
  void
  channel(Home home, IntVar x0, BoolVar x1,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  channel(Home home, const BoolVarArgs& x, IntVar y, int o=0,
          IntPropLevel ipl=IPL_DEF);
 
}
 
#include <gecode/int/channel.hpp>
 
namespace Gecode {


  GECODE_INT_EXPORT void
  sorted(Home home, const IntVarArgs& x, const IntVarArgs& y,
         IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  sorted(Home home, const IntVarArgs& x, const IntVarArgs& y,
         const IntVarArgs& z,
         IntPropLevel ipl=IPL_DEF);
 



  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, int n, IntRelType irt, int m,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntSet& y, IntRelType irt, int m,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, IntVar y, IntRelType irt, int m,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntArgs& y, IntRelType irt, int m,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, int n, IntRelType irt, IntVar z,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntSet& y, IntRelType irt, IntVar z,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, IntVar y, IntRelType irt, IntVar z,
        IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntArgs& y, IntRelType irt, IntVar z,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntVarArgs& c,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntSetArgs& c,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x,
        const IntVarArgs& c, const IntArgs& v,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x,
        const IntSetArgs& c, const IntArgs& v,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x,
        const IntSet& c, const IntArgs& v,
        IntPropLevel ipl=IPL_DEF);




  GECODE_INT_EXPORT void
  nvalues(Home home, const IntVarArgs& x, IntRelType irt, int y,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  nvalues(Home home, const IntVarArgs& x, IntRelType irt, IntVar y,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  nvalues(Home home, const BoolVarArgs& x, IntRelType irt, int y,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  nvalues(Home home, const BoolVarArgs& x, IntRelType irt, IntVar y,
          IntPropLevel ipl=IPL_DEF);



  GECODE_INT_EXPORT void
  sequence(Home home, const IntVarArgs& x, const IntSet& s,
           int q, int l, int u, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  sequence(Home home, const BoolVarArgs& x, const IntSet& s,
           int q, int l, int u, IntPropLevel ipl=IPL_DEF);



  class DFA : public SharedHandle {
  private:
    class DFAI;
    GECODE_INT_EXPORT
    bool equal(const DFA& d) const;
  public:
    class Transition {
    public:
      int i_state; 
      int symbol;  
      int o_state; 
      Transition(void);
      Transition(int i_state0, int symbol0, int o_state0);
    };

    class Transitions {
    private:
      const Transition* c_trans;
      const Transition* e_trans;
    public:
      Transitions(const DFA& d);
      Transitions(const DFA& d, int n);
      bool operator ()(void) const;
      void operator ++(void);
      int i_state(void) const;
      int symbol(void) const;
      int o_state(void) const;
    };

    class Symbols {
    private:
      const Transition* c_trans;
      const Transition* e_trans;
    public:
      Symbols(const DFA& d);
      bool operator ()(void) const;
      void operator ++(void);
      int val(void) const;
    };

    GECODE_INT_EXPORT
    void init(int s, Transition t[], int f[], bool minimize=true);
  public:
    friend class Transitions;
    DFA(void);
    GECODE_INT_EXPORT
    DFA(int s, Transition t[], int f[], bool minimize=true);
    GECODE_INT_EXPORT
    DFA(int s, std::initializer_list<Transition> t,
        std::initializer_list<int> f, bool minimize=true);
    DFA(const DFA& d);
    GECODE_INT_EXPORT
    bool operator ==(const DFA& d) const;
    bool operator !=(const DFA& d) const;
    int n_states(void) const;
    int n_transitions(void) const;
    unsigned int n_symbols(void) const;
    unsigned int max_degree(void) const;
    int final_fst(void) const;
    int final_lst(void) const;
    int symbol_min(void) const;
    int symbol_max(void) const;
    std::size_t hash(void) const;
  };
 
}
 
#include <gecode/int/extensional/dfa.hpp>
 
namespace Gecode { namespace Int { namespace Extensional {
 
  class TupleSetAccess;
 
}}}
 
namespace Gecode {

  enum class ExtensionalPropKind {
    EPK_AUTO,   
    EPK_DENSE,  
    EPK_SPARSE, 
    EPK_DENSE_COMPRESSED 
  };

  static constexpr ExtensionalPropKind EPK_AUTO =
    ExtensionalPropKind::EPK_AUTO;
  static constexpr ExtensionalPropKind EPK_DENSE =
    ExtensionalPropKind::EPK_DENSE;
  static constexpr ExtensionalPropKind EPK_SPARSE =
    ExtensionalPropKind::EPK_SPARSE;
  static constexpr ExtensionalPropKind EPK_DENSE_COMPRESSED =
    ExtensionalPropKind::EPK_DENSE_COMPRESSED;

  class TupleSet : public SharedHandle {
    friend class Int::Extensional::TupleSetAccess;
  public:
    typedef int* Tuple;
    typedef Gecode::Support::BitSetData BitSetData;
    class CSupportWord {
    public:
      unsigned int widx; 
      BitSetData bits;   
    };

    class Range {
    public:
      int min;
      int max;
      BitSetData* s;
      unsigned int width(void) const;
      const BitSetData* supports(unsigned int n_words, int n) const;
    };
  protected:
    class ValueData {
    public:
      unsigned int n;
      Range* r;
      unsigned int* base;
      unsigned int start(int n) const;
    };

    class GECODE_VTABLE_EXPORT Data : public SharedHandle::Object {
    protected:
      static const int n_initial_free = 1024;
    public:
      enum State {
        TS_BUILDING,
        TS_FAILED,
        TS_DENSE,
        TS_SPARSE,
        TS_DENSE_COMPRESSED
      };
    public:
      int arity;
      unsigned int n_words;
      int n_tuples;
      int n_free;
      int min;
      int max;
      std::size_t key;
      int* td;
      ValueData* vd;
      Range* range;
      unsigned int* range_base;
      BitSetData* support;
      State state;
      unsigned int sparse_n_vals;
      unsigned int* sparse_offsets;
      unsigned int* sparse_tuples;
      unsigned int* sparse_tv;
      unsigned int* compressed_offsets;
      CSupportWord* compressed_words;
      unsigned int compressed_n_entries;

      Tuple add(void);
      Tuple get(int i) const;
      static void set(BitSetData* d, unsigned int n);
      static bool get(const BitSetData* d, unsigned int n);
      unsigned int tuple2idx(Tuple t) const;
      const Range* fst(int i) const;
      const Range* lst(int i) const;
      GECODE_INT_EXPORT
      void finalize(void);
      GECODE_INT_EXPORT
      void finalize(ExtensionalPropKind epk);
      GECODE_INT_EXPORT
      void resize(void);
      void clear_support(void);
      State empty_state(ExtensionalPropKind epk) const;
      State select_state(
        ExtensionalPropKind epk, bool dense_possible,
        bool sparse_possible, bool compressed_possible,
        bool support_bits_sparse, unsigned long long dense_bytes) const;
      bool finalized(void) const;
      bool failed(void) const;
      bool terminal(void) const;

      Data(int a);
      GECODE_INT_EXPORT
      virtual ~Data(void);
    };

    Data& data(void) const;
    Data& raw(void) const;
    GECODE_INT_EXPORT
    void _add(const IntArgs& t);
    GECODE_INT_EXPORT
    bool equal(const TupleSet& t) const;
  public:


    TupleSet(void);
    GECODE_INT_EXPORT
    TupleSet(int a);
    GECODE_INT_EXPORT
    void init(int a);
    GECODE_INT_EXPORT
    TupleSet(const TupleSet& t);
    GECODE_INT_EXPORT
    TupleSet& operator =(const TupleSet& t);
    GECODE_INT_EXPORT
    TupleSet(int a, const DFA& dfa);
    GECODE_INT_EXPORT
    TupleSet(int a, const DFA& dfa, ExtensionalPropKind epk);
    operator bool(void) const;
    bool operator ==(const TupleSet& t) const;
    bool operator !=(const TupleSet& t) const;



    TupleSet& add(const IntArgs& t);
    bool finalized(void) const;
    bool failed(void) const;
    void finalize(void);

    void finalize(ExtensionalPropKind epk);



    int arity(void) const;
    int tuples(void) const;
    unsigned int words(void) const;
    Tuple operator [](int i) const;
    int min(void) const;
    int max(void) const;
    std::size_t hash(void) const;
    ExtensionalPropKind representation(void) const;
  private:
    unsigned int sparse_values(void) const;
    const unsigned int* sparse_tuple_value_ids(void) const;
    const unsigned int* sparse_support_offsets(void) const;
    bool support_id(int p, int n, unsigned int& gid) const;
    bool sparse_support(int p, int n,
                        const unsigned int*& b,
                        const unsigned int*& e,
                        unsigned int& gid) const;
    bool dense_compressed_support(int p, int n,
                                  const CSupportWord*& b,
                                  const CSupportWord*& e) const;
  public:



    const Range* fst(int i) const;
    const Range* lst(int i) const;
    class Ranges {
    protected:
      const Range* c;
      const Range* l;
    public:


      Ranges(const TupleSet& ts, int i);



      bool operator ()(void) const;
      void operator ++(void);



      int min(void) const;
      int max(void) const;
      unsigned int width(void) const;
    };

  };
 
  namespace Int { namespace Extensional {

    class TupleSetAccess {
    public:
      static unsigned int sparse_values(const TupleSet& ts);
      static const unsigned int* sparse_tuple_value_ids(const TupleSet& ts);
      static const unsigned int* sparse_support_offsets(const TupleSet& ts);
      static bool support_id(const TupleSet& ts, int p, int n,
                             unsigned int& gid);
      static bool sparse_support(const TupleSet& ts, int p, int n,
                                 const unsigned int*& b,
                                 const unsigned int*& e,
                                 unsigned int& gid);
      static bool dense_compressed_support(const TupleSet& ts, int p, int n,
                                           const TupleSet::CSupportWord*& b,
                                           const TupleSet::CSupportWord*& e);
    };
 
  }}
 
}
 
#include <gecode/int/extensional/tuple-set.hpp>
 
namespace Gecode {

  GECODE_INT_EXPORT void
  extensional(Home home, const IntVarArgs& x, DFA d,
              IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const BoolVarArgs& x, DFA d,
              IntPropLevel ipl=IPL_DEF);

  void
  extensional(Home home, const IntVarArgs& x, const TupleSet& t,
              IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const IntVarArgs& x, const TupleSet& t, bool pos,
              IntPropLevel ipl=IPL_DEF);

  void
  extensional(Home home, const IntVarArgs& x, const TupleSet& t, Reify r,
              IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const IntVarArgs& x, const TupleSet& t, bool pos,
              Reify r,
              IntPropLevel ipl=IPL_DEF);

  void
  extensional(Home home, const BoolVarArgs& x, const TupleSet& t,
              IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const BoolVarArgs& x, const TupleSet& t, bool pos,
              IntPropLevel ipl=IPL_DEF);

  void
  extensional(Home home, const BoolVarArgs& x, const TupleSet& t, Reify r,
              IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const BoolVarArgs& x, const TupleSet& t, bool pos,
              Reify r,
              IntPropLevel ipl=IPL_DEF);
 
}
 
#include <gecode/int/extensional.hpp>
 
namespace Gecode {



  GECODE_INT_EXPORT void
  min(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  min(Home home, const IntVarArgs& x, IntVar y,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  max(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  max(Home home, const IntVarArgs& x, IntVar y,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  argmin(Home home, const IntVarArgs& x, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmin(Home home, const IntVarArgs& x, int o, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmax(Home home, const IntVarArgs& x, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmax(Home home, const IntVarArgs& x, int o, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmin(Home home, const BoolVarArgs& x, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmin(Home home, const BoolVarArgs& x, int o, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmax(Home home, const BoolVarArgs& x, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  argmax(Home home, const BoolVarArgs& x, int o, IntVar y, bool tiebreak=true,
         IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  abs(Home home, IntVar x0, IntVar x1,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  mult(Home home, IntVar x0, IntVar x1, IntVar x2,
       IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  divmod(Home home, IntVar x0, IntVar x1, IntVar x2, IntVar x3,
         IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  div(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  mod(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  sqr(Home home, IntVar x0, IntVar x1,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  sqrt(Home home, IntVar x0, IntVar x1,
       IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  pow(Home home, IntVar x0, int n, IntVar x1,
      IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  nroot(Home home, IntVar x0, int n, IntVar x1,
       IntPropLevel ipl=IPL_DEF);


  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, int c,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, IntVar y,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, int c,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, IntVar y,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntPropLevel ipl=IPL_DEF);
 

  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, int c,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, IntVar y,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, int c,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, IntVar y,
         IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntPropLevel ipl=IPL_DEF);
 

  GECODE_INT_EXPORT void
  binpacking(Home home,
             const IntVarArgs& l,
             const IntVarArgs& b, const IntArgs& s,
             IntPropLevel ipl=IPL_DEF);
  /* \brief Post propagator for multi-dimensional bin packing
   *
   * In the following \a n refers to the number of items and \a m
   * refers to the number of bins.
   *
   * The multi-dimensional bin-packing constraint enforces that
   * all items are packed into bins
   * \f$b_i\in\{0,\ldots,m-1\}\f$ for \f$0\leq i<n\f$
   * and that the load of each bin corresponds to the items
   * packed into it for each dimension \f$l_{j\cdot
   * d + k} = \sum_{\{i\in\{0,\ldots,n-1\}|
   * b_{j\cdot d+k}=i}\}s_{i\cdot d+k}\f$
   * for \f$0\leq j<m\f$, \f$0\leq k<d\f$
   * Furthermore, the load variables must satisfy the capacity
   * constraints \f$l_{j\cdot d + k} \leq
   * c_k\f$ for \f$0\leq j<m\f$, \f$0\leq k<d\f$.
   *
   * The constraint is implemented by the decomposition
   * introduced in: Stefano Gualandi and Michele Lombardi. A
   * simple and effective decomposition for the multidimensional
   * binpacking constraint. CP 2013, pages 356--364.
   *
   * Posting the constraint returns a maximal set containing conflicting
   * items that require pairwise different bins.
   *
   * Note that posting the constraint has exponential complexity in the
   * number of items due to the Bron-Kerbosch algorithm used for finding
   * the maximal conflict item sets.
   *
   * The propagation level \a ipl controls the filtering performed by each
   * per-dimension bin-packing propagator:
   *  - \a IPL_BASIC performs basic load and item filtering only.
   *  - \a IPL_ADVANCED performs basic filtering, knapsack filtering using
   *    NoSum, and a small DFF portfolio (CCM1 and MT). It is the default
   *    (\a IPL_DEF).
   *  - \a IPL_FULL performs all of the above and the complete DFF portfolio.
   *
   * Throws the following exceptions:
   *  - Of type Int::ArgumentSizeMismatch if any of the following properties
   *    is violated: \f$|b|=n\f$, \f$|l|=m\cdot d\f$, \f$|s|=n\cdot d\f$,
   *    and \f$|c|=d\f$.
   *  - Of type Int::ArgumentSame if \a l and \a b share unassigned variables.
   *  - Of type Int::OutOfLimits if \a s or \a c contains a negative number.
   *
   * \ingroup TaskModelIntBinPacking
   */
  GECODE_INT_EXPORT IntSet
  binpacking(Home home, int d,
             const IntVarArgs& l, const IntVarArgs& b,
             const IntArgs& s, const IntArgs& c,
             IntPropLevel ipl=IPL_DEF);
 

  GECODE_INT_EXPORT void
  nooverlap(Home home,
            const IntVarArgs& x, const IntArgs& w,
            const IntVarArgs& y, const IntArgs& h,
            IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  nooverlap(Home home,
            const IntVarArgs& x, const IntArgs& w,
            const IntVarArgs& y, const IntArgs& h,
            const BoolVarArgs& o,
            IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  nooverlap(Home home,
            const IntVarArgs& x0, const IntVarArgs& w, const IntVarArgs& x1,
            const IntVarArgs& y0, const IntVarArgs& h, const IntVarArgs& y1,
            IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  nooverlap(Home home,
            const IntVarArgs& x0, const IntVarArgs& w, const IntVarArgs& x1,
            const IntVarArgs& y0, const IntVarArgs& h, const IntVarArgs& y1,
            const BoolVarArgs& o,
            IntPropLevel ipl=IPL_DEF);
 


  GECODE_INT_EXPORT void
  order(Home home, IntVar s0, int p0, IntVar s1, int p1, BoolVar b,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntArgs& p,
        IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntArgs& p,
        const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const TaskTypeArgs& t,
        const IntVarArgs& flex, const IntArgs& fix, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const TaskTypeArgs& t,
        const IntVarArgs& flex, const IntArgs& fix,
        const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntVarArgs& p,
        const IntVarArgs& e, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntVarArgs& p,
        const IntVarArgs& e, const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);
 
 

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             IntPropLevel ipl=IPL_DEF);
 

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntArgs& p,
             const IntArgs& u, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntArgs& p,
             const IntArgs& u, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntArgs& p,
             const IntArgs& u, const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntArgs& p,
             const IntArgs& u, const BoolVarArgs& m, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntVarArgs& p,
             const IntVarArgs& e, const IntArgs& u, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntVarArgs& p,
             const IntVarArgs& e, const IntArgs& u, IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntVarArgs& p,
             const IntVarArgs& e, const IntArgs& u, const BoolVarArgs& m,
             IntPropLevel ipl=IPL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntVarArgs& p,
             const IntVarArgs& e, const IntArgs& u, const BoolVarArgs& m,
             IntPropLevel ipl=IPL_DEF);
 


  GECODE_INT_EXPORT void
  circuit(Home home, const IntVarArgs& x,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home, int offset, const IntVarArgs& x,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home,
          const IntArgs& c,
          const IntVarArgs& x, const IntVarArgs& y, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home,
          const IntArgs& c, int offset,
          const IntVarArgs& x, const IntVarArgs& y, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home,
          const IntArgs& c,
          const IntVarArgs& x, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home,
          const IntArgs& c, int offset,
          const IntVarArgs& x, IntVar z,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, const IntVarArgs& x, IntVar s, IntVar e,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, int offset, const IntVarArgs& x, IntVar s, IntVar e,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  path(Home home,
       const IntArgs& c,
       const IntVarArgs& x, IntVar s, IntVar e, const IntVarArgs& y, IntVar z,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  path(Home home,
       const IntArgs& c, int offset,
       const IntVarArgs& x, IntVar s, IntVar e, const IntVarArgs& y, IntVar z,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  path(Home home,
       const IntArgs& c,
       const IntVarArgs& x, IntVar s, IntVar e, IntVar z,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  path(Home home,
       const IntArgs& c, int offset,
       const IntVarArgs& x, IntVar s, IntVar e, IntVar z,
       IntPropLevel ipl=IPL_DEF);
 
 


  GECODE_INT_EXPORT void
  wait(Home home, IntVar x, std::function<void(Space& home)> c,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  wait(Home home, BoolVar x, std::function<void(Space& home)> c,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  wait(Home home, const IntVarArgs& x, std::function<void(Space& home)> c,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  wait(Home home, const BoolVarArgs& x,
       std::function<void(Space& home)> c,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  when(Home home, BoolVar x,
       std::function<void(Space& home)> t,
       std::function<void(Space& home)> e,
       IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  when(Home home, BoolVar x,
       std::function<void(Space& home)> t,
       IntPropLevel ipl=IPL_DEF);
 


  GECODE_INT_EXPORT void
  unshare(Home home, IntVarArgs& x,
          IntPropLevel ipl=IPL_DEF);
  GECODE_INT_EXPORT void
  unshare(Home home, BoolVarArgs& x,
          IntPropLevel ipl=IPL_DEF);
 
}
 
namespace Gecode {


  typedef std::function<bool(const Space& home, IntVar x, int i)>
    IntBranchFilter;
  typedef std::function<bool(const Space& home, BoolVar x, int i)>
    BoolBranchFilter;

  typedef std::function<double(const Space& home, IntVar x, int i)>
    IntBranchMerit;
  typedef std::function<double(const Space& home, BoolVar x, int i)>
    BoolBranchMerit;

  typedef std::function<int(const Space& home, IntVar x, int i)>
    IntBranchVal;
  typedef std::function<int(const Space& home, BoolVar x, int i)>
    BoolBranchVal;

  typedef std::function<void(Space& home, unsigned int a,
                             IntVar x, int i, int n)>
    IntBranchCommit;
  typedef std::function<void(Space& home, unsigned int a,
                             BoolVar x, int i, int n)>
    BoolBranchCommit;
 
}
 
#include <gecode/int/branch/traits.hpp>
 
namespace Gecode {

  class IntAFC : public AFC {
  public:
    IntAFC(void);
    IntAFC(const IntAFC& a);
    IntAFC& operator =(const IntAFC& a);
    IntAFC(Home home, const IntVarArgs& x, double d=1.0, bool share=true);
    void init(Home home, const IntVarArgs& x, double d=1.0, bool share=true);
  };

  class BoolAFC : public AFC {
  public:
    BoolAFC(void);
    BoolAFC(const BoolAFC& a);
    BoolAFC& operator =(const BoolAFC& a);
    BoolAFC(Home home, const BoolVarArgs& x, double d=1.0, bool share=true);
    void init(Home home, const BoolVarArgs& x, double d=1.0, bool share=true);
  };
 
}
 
#include <gecode/int/branch/afc.hpp>
 
namespace Gecode {

  class IntAction : public Action {
  public:
    IntAction(void);
    IntAction(const IntAction& a);
    IntAction& operator =(const IntAction& a);
    GECODE_INT_EXPORT
    IntAction(Home home, const IntVarArgs& x, double d=1.0,
              bool p=true, bool f=true,
              IntBranchMerit bm=nullptr);
    GECODE_INT_EXPORT void
    init(Home home, const IntVarArgs& x, double d=1.0,
         bool p=true, bool f=true,
         IntBranchMerit bm=nullptr);
  };

  class BoolAction : public Action {
  public:
    BoolAction(void);
    BoolAction(const BoolAction& a);
    BoolAction& operator =(const BoolAction& a);
    GECODE_INT_EXPORT
    BoolAction(Home home, const BoolVarArgs& x, double d=1.0,
               bool p=true, bool f=true,
               BoolBranchMerit bm=nullptr);
    GECODE_INT_EXPORT void
    init(Home home, const BoolVarArgs& x, double d=1.0,
         bool p=true, bool f=true,
         BoolBranchMerit bm=nullptr);
  };
 
}
 
#include <gecode/int/branch/action.hpp>
 
namespace Gecode {

  class IntCHB : public CHB {
  public:
    IntCHB(void);
    IntCHB(const IntCHB& chb);
    IntCHB& operator =(const IntCHB& chb);
    GECODE_INT_EXPORT
    IntCHB(Home home, const IntVarArgs& x, IntBranchMerit bm=nullptr);
    GECODE_INT_EXPORT void
    init(Home home, const IntVarArgs& x, IntBranchMerit bm=nullptr);
  };

  class BoolCHB : public CHB {
  public:
    BoolCHB(void);
    BoolCHB(const BoolCHB& chb);
    BoolCHB& operator =(const BoolCHB& chb);
    GECODE_INT_EXPORT
    BoolCHB(Home home, const BoolVarArgs& x, BoolBranchMerit bm=nullptr);
    GECODE_INT_EXPORT void
    init(Home home, const BoolVarArgs& x, BoolBranchMerit bm=nullptr);
  };
 
}
 
#include <gecode/int/branch/chb.hpp>
 
namespace Gecode {

  typedef std::function<void(const Space &home, const Brancher& b,
                             unsigned int a,
                             IntVar x, int i, const int& n,
                             std::ostream& o)>
    IntVarValPrint;

  typedef std::function<void(const Space &home, const Brancher& b,
                             unsigned int a,
                             BoolVar x, int i, const int& n,
                             std::ostream& o)>
    BoolVarValPrint;
 
}
 
namespace Gecode {

  class IntVarBranch : public VarBranch<IntVar> {
  public:
    enum Select {
      SEL_NONE = 0,        
      SEL_RND,             
      SEL_MERIT_MIN,       
      SEL_MERIT_MAX,       
      SEL_DEGREE_MIN,      
      SEL_DEGREE_MAX,      
      SEL_AFC_MIN,         
      SEL_AFC_MAX,         
      SEL_ACTION_MIN,      
      SEL_ACTION_MAX,      
      SEL_CHB_MIN,         
      SEL_CHB_MAX,         
      SEL_MIN_MIN,         
      SEL_MIN_MAX,         
      SEL_MAX_MIN,         
      SEL_MAX_MAX,         
      SEL_SIZE_MIN,        
      SEL_SIZE_MAX,        
      SEL_DEGREE_SIZE_MIN, 
      SEL_DEGREE_SIZE_MAX, 
      SEL_AFC_SIZE_MIN,    
      SEL_AFC_SIZE_MAX,    
      SEL_ACTION_SIZE_MIN, 
      SEL_ACTION_SIZE_MAX, 
      SEL_CHB_SIZE_MIN,    
      SEL_CHB_SIZE_MAX,    
      SEL_REGRET_MIN_MIN,
      SEL_REGRET_MIN_MAX,
      SEL_REGRET_MAX_MIN,
      SEL_REGRET_MAX_MAX
    };
  protected:
    Select s;
  public:
    IntVarBranch(void);
    IntVarBranch(Rnd r);
    IntVarBranch(Select s, BranchTbl t);
    IntVarBranch(Select s, double d, BranchTbl t);
    IntVarBranch(Select s, IntAFC a, BranchTbl t);
    IntVarBranch(Select s, IntAction a, BranchTbl t);
    IntVarBranch(Select s, IntCHB c, BranchTbl t);
    IntVarBranch(Select s, IntBranchMerit mf, BranchTbl t);
    Select select(void) const;
    void expand(Home home, const IntVarArgs& x);
  };

  class BoolVarBranch : public VarBranch<BoolVar> {
  public:
    enum Select {
      SEL_NONE = 0,        
      SEL_RND,             
      SEL_MERIT_MIN,       
      SEL_MERIT_MAX,       
      SEL_DEGREE_MIN,      
      SEL_DEGREE_MAX,      
      SEL_AFC_MIN,         
      SEL_AFC_MAX,         
      SEL_ACTION_MIN,      
      SEL_ACTION_MAX,      
      SEL_CHB_MIN,         
      SEL_CHB_MAX          
    };
  protected:
    Select s;
  public:
    BoolVarBranch(void);
    BoolVarBranch(Rnd r);
    BoolVarBranch(Select s, BranchTbl t);
    BoolVarBranch(Select s, double d, BranchTbl t);
    BoolVarBranch(Select s, BoolAFC a, BranchTbl t);
    BoolVarBranch(Select s, BoolAction a, BranchTbl t);
    BoolVarBranch(Select s, BoolCHB c, BranchTbl t);
    BoolVarBranch(Select s, BoolBranchMerit mf, BranchTbl t);
    Select select(void) const;
    void expand(Home home, const BoolVarArgs& x);
  };


  IntVarBranch INT_VAR_NONE(void);
  IntVarBranch INT_VAR_RND(Rnd r);
  IntVarBranch INT_VAR_MERIT_MIN(IntBranchMerit bm, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_MERIT_MAX(IntBranchMerit bm, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_DEGREE_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_DEGREE_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_MIN(IntAFC a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_MAX(IntAFC a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_MIN(IntAction a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_MAX(IntAction a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_MIN(IntCHB c, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_MAX(IntCHB c, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_MIN_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_MIN_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_MAX_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_MAX_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_SIZE_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_SIZE_MIN(IntAFC a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_AFC_SIZE_MAX(IntAFC a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_SIZE_MIN(IntAction a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_ACTION_SIZE_MAX(IntAction a, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_SIZE_MIN(IntCHB c, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_SIZE_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_SIZE_MAX(IntCHB c, BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_CHB_SIZE_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_REGRET_MIN_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_REGRET_MIN_MAX(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_REGRET_MAX_MIN(BranchTbl tbl=nullptr);
  IntVarBranch INT_VAR_REGRET_MAX_MAX(BranchTbl tbl=nullptr);

  BoolVarBranch BOOL_VAR_NONE(void);
  BoolVarBranch BOOL_VAR_RND(Rnd r);
  BoolVarBranch BOOL_VAR_MERIT_MIN(BoolBranchMerit bm, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_MERIT_MAX(BoolBranchMerit bm, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_DEGREE_MIN(BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_DEGREE_MAX(BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_AFC_MIN(BoolAFC a, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_AFC_MAX(BoolAFC a, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_ACTION_MIN(BoolAction a, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_ACTION_MAX(BoolAction a, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_CHB_MIN(BoolCHB c, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_CHB_MIN(BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_CHB_MAX(BoolCHB c, BranchTbl tbl=nullptr);
  BoolVarBranch BOOL_VAR_CHB_MAX(BranchTbl tbl=nullptr);
 
}
 
#include <gecode/int/branch/var.hpp>
 
namespace Gecode {

  class IntValBranch : public ValBranch<IntVar> {
  public:
    enum Select {
      SEL_MIN,        
      SEL_MED,        
      SEL_MAX,        
      SEL_RND,        
      SEL_SPLIT_MIN,  
      SEL_SPLIT_MAX,  
      SEL_RANGE_MIN,  
      SEL_RANGE_MAX,  
      SEL_VAL_COMMIT, 
      SEL_VALUES_MIN, 
      SEL_VALUES_MAX  
   };
  protected:
    Select s;
  public:
    IntValBranch(Select s = SEL_MIN);
    IntValBranch(Rnd r);
    IntValBranch(IntBranchVal v, IntBranchCommit c);
    Select select(void) const;
  };

  class BoolValBranch : public ValBranch<BoolVar> {
  public:
    enum Select {
      SEL_MIN,       
      SEL_MAX,       
      SEL_RND,       
      SEL_VAL_COMMIT 
   };
  protected:
    Select s;
  public:
    BoolValBranch(Select s = SEL_MIN);
    BoolValBranch(Rnd r);
    BoolValBranch(BoolBranchVal v, BoolBranchCommit c);
    Select select(void) const;
  };


  IntValBranch INT_VAL_MIN(void);
  IntValBranch INT_VAL_MED(void);
  IntValBranch INT_VAL_MAX(void);
  IntValBranch INT_VAL_RND(Rnd r);
  IntValBranch INT_VAL_SPLIT_MIN(void);
  IntValBranch INT_VAL_SPLIT_MAX(void);
  IntValBranch INT_VAL_RANGE_MIN(void);
  IntValBranch INT_VAL_RANGE_MAX(void);
  IntValBranch INT_VAL(IntBranchVal v, IntBranchCommit c=nullptr);
  IntValBranch INT_VALUES_MIN(void);
  IntValBranch INT_VALUES_MAX(void);

  BoolValBranch BOOL_VAL_MIN(void);
  BoolValBranch BOOL_VAL_MAX(void);
  BoolValBranch BOOL_VAL_RND(Rnd r);
  BoolValBranch BOOL_VAL(BoolBranchVal v, BoolBranchCommit c=nullptr);
 
}
 
#include <gecode/int/branch/val.hpp>
 
namespace Gecode {

  class IntAssign : public ValBranch<IntVar> {
  public:
    enum Select {
      SEL_MIN,       
      SEL_MED,       
      SEL_MAX,       
      SEL_RND,       
      SEL_VAL_COMMIT 
    };
  protected:
    Select s;
  public:
    IntAssign(Select s = SEL_MIN);
    IntAssign(Rnd r);
    IntAssign(IntBranchVal v, IntBranchCommit c);
    Select select(void) const;
  };

  class BoolAssign : public ValBranch<BoolVar> {
  public:
    enum Select {
      SEL_MIN,       
      SEL_MAX,       
      SEL_RND,       
      SEL_VAL_COMMIT 
    };
  protected:
    Select s;
  public:
    BoolAssign(Select s = SEL_MIN);
    BoolAssign(Rnd r);
    BoolAssign(BoolBranchVal v, BoolBranchCommit c);
    Select select(void) const;
  };


  IntAssign INT_ASSIGN_MIN(void);
  IntAssign INT_ASSIGN_MED(void);
  IntAssign INT_ASSIGN_MAX(void);
  IntAssign INT_ASSIGN_RND(Rnd r);
  IntAssign INT_ASSIGN(IntBranchVal v, IntBranchCommit c=nullptr);

  BoolAssign BOOL_ASSIGN_MIN(void);
  BoolAssign BOOL_ASSIGN_MAX(void);
  BoolAssign BOOL_ASSIGN_RND(Rnd r);
  BoolAssign BOOL_ASSIGN(BoolBranchVal v, BoolBranchCommit c=nullptr);
 
}
 
#include <gecode/int/branch/assign.hpp>
 
namespace Gecode {

  GECODE_INT_EXPORT void
  branch(Home home, const IntVarArgs& x,
         IntVarBranch vars, IntValBranch vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, const IntVarArgs& x,
         TieBreak<IntVarBranch> vars, IntValBranch vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, IntVar x, IntValBranch vals,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, const BoolVarArgs& x,
         BoolVarBranch vars, BoolValBranch vals,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, const BoolVarArgs& x,
         TieBreak<BoolVarBranch> vars, BoolValBranch vals,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, BoolVar x, BoolValBranch vals,
         BoolVarValPrint vvp=nullptr);

  GECODE_INT_EXPORT void
  assign(Home home, const IntVarArgs& x,
         IntVarBranch vars, IntAssign vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  assign(Home home, const IntVarArgs& x,
         TieBreak<IntVarBranch> vars, IntAssign vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  assign(Home home, IntVar x, IntAssign vals,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  assign(Home home, const BoolVarArgs& x,
         BoolVarBranch vars, BoolAssign vals,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  assign(Home home, const BoolVarArgs& x,
         TieBreak<BoolVarBranch> vars, BoolAssign vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  assign(Home home, BoolVar x, BoolAssign vals,
         BoolVarValPrint vvp=nullptr);
 
}
 
namespace Gecode {

  void
  branch(Home home, const IntVarArgs& x, IntValBranch vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  void
  branch(Home home, const BoolVarArgs& x, BoolValBranch vals,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);

  void
  assign(Home home, const IntVarArgs& x, IntAssign vals,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  void
  assign(Home home, const BoolVarArgs& x, BoolAssign vals,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);
 
}
 
#include <gecode/int/branch.hpp>
 
namespace Gecode {

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const DFA& d);

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const TupleSet& ts);
 
}
 
// LDSB-related declarations.
namespace Gecode {
 
  namespace Int { namespace LDSB {
    class SymmetryObject;
  }}

  class GECODE_INT_EXPORT SymmetryHandle {
  public:
    Int::LDSB::SymmetryObject* ref;
    void increment(void);
    void decrement(void);
  public:
    SymmetryHandle(void);
    SymmetryHandle(Int::LDSB::SymmetryObject* o);
    SymmetryHandle(const SymmetryHandle& h);
    const SymmetryHandle& operator=(const SymmetryHandle& h);
    ~SymmetryHandle(void);
  };
  class Symmetries;
  template<>
  class ArrayTraits<ArgArray<SymmetryHandle> > {
  public:
    typedef Symmetries     StorageType;
    typedef SymmetryHandle ValueType;
    typedef Symmetries     ArgsType;
  };


  class Symmetries : public ArgArray<SymmetryHandle> {};
  // If this is instead a typedef, strange things happen with the
  // overloading of the "branch" function.

  GECODE_INT_EXPORT SymmetryHandle VariableSymmetry(const IntVarArgs& x);
  GECODE_INT_EXPORT SymmetryHandle VariableSymmetry(const BoolVarArgs& x);
  GECODE_INT_EXPORT SymmetryHandle VariableSymmetry(const IntVarArgs& x,
                                                    const IntArgs& indices);
  GECODE_INT_EXPORT SymmetryHandle ValueSymmetry(const IntArgs& v);
  GECODE_INT_EXPORT SymmetryHandle ValueSymmetry(const IntSet& v);
  GECODE_INT_EXPORT SymmetryHandle ValueSymmetry(IntVar vars);
  GECODE_INT_EXPORT
  SymmetryHandle VariableSequenceSymmetry(const IntVarArgs& x, int ss);
  GECODE_INT_EXPORT
  SymmetryHandle VariableSequenceSymmetry(const BoolVarArgs& x, int ss);
  GECODE_INT_EXPORT
  SymmetryHandle ValueSequenceSymmetry(const IntArgs& v, int ss);

  GECODE_INT_EXPORT SymmetryHandle values_reflect(int lower, int upper);
  GECODE_INT_EXPORT SymmetryHandle values_reflect(IntVar x);

  GECODE_INT_EXPORT void
  branch(Home home, const IntVarArgs& x,
         IntVarBranch vars, IntValBranch vals,
         const Symmetries& syms,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, const IntVarArgs& x,
         TieBreak<IntVarBranch> vars, IntValBranch vals,
         const Symmetries& syms,
         IntBranchFilter bf=nullptr,
         IntVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, const BoolVarArgs& x,
         BoolVarBranch vars, BoolValBranch vals,
         const Symmetries& syms,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);
  GECODE_INT_EXPORT void
  branch(Home home, const BoolVarArgs& x,
         TieBreak<BoolVarBranch> vars, BoolValBranch vals,
         const Symmetries& syms,
         BoolBranchFilter bf=nullptr,
         BoolVarValPrint vvp=nullptr);
 
#ifdef GECODE_HAS_CBS

  GECODE_INT_EXPORT void
  cbsbranch(Home home, const IntVarArgs& x);
 

  GECODE_INT_EXPORT void
  cbsbranch(Home home, const BoolVarArgs& x);
 
#endif
 
}
 
namespace Gecode {
 
  /*
   * \brief Relaxed assignment of variables in \a x from values in \a sx
   *
   * The variables in \a x are assigned values from the assigned variables
   * in the solution \a sx with a relaxation probability \a p. That is,
   * if \f$p=0.1\f$ approximately 10% of the variables in \a x will be
   * assigned a value from \a sx.
   *
   * The random numbers are generated from the generator \a r. At least
   * one variable will not be assigned: in case the relaxation attempt
   * would suggest that all variables should be assigned, a single
   * variable will be selected randomly to remain unassigned.
   *
   * Throws an exception of type Int::ArgumentSizeMismatch, if \a x and
   * \a sx are of different size.
   *
   * Throws an exception of type Int::OutOfLimits, if \a p is not between
   * \a 0.0 and \a 1.0.
   *
   * \ingroup TaskModelInt
   */
  GECODE_INT_EXPORT void
  relax(Home home, const IntVarArgs& x, const IntVarArgs& sx,
        Rnd r, double p);
 
  /*
   * \brief Relaxed assignment of variables in \a x from values in \a sx
   *
   * The variables in \a x are assigned values from the assigned variables
   * in the solution \a sx with a relaxation probability \a p. That is,
   * if \f$p=0.1\f$ approximately 10% of the variables in \a x will be
   * assigned a value from \a sx.
   *
   * The random numbers are generated from the generator \a r. At least
   * one variable will not be assigned: in case the relaxation attempt
   * would suggest that all variables should be assigned, a single
   * variable will be selected randomly to remain unassigned.
   *
   * Throws an exception of type Int::ArgumentSizeMismatch, if \a x and
   * \a sx are of different size.
   *
   * Throws an exception of type Int::OutOfLimits, if \a p is not between
   * \a 0.0 and \a 1.0.
   *
   * \ingroup TaskModelInt
   */
  GECODE_INT_EXPORT void
  relax(Home home, const BoolVarArgs& x, const BoolVarArgs& sx,
        Rnd r, double p);
 
}
 
 
#include <gecode/int/trace/int-trace-view.hpp>
#include <gecode/int/trace/bool-trace-view.hpp>
 
namespace Gecode {


  class IntTraceDelta
    : public Iter::Ranges::Diff<Iter::Ranges::RangeList,
                                Int::ViewRanges<Int::IntView> > {
  protected:
    Int::ViewRanges<Int::IntView> rn;
    Iter::Ranges::RangeList ro;
  public:


    IntTraceDelta(Int::IntTraceView o, Int::IntView n, const Delta& d);
  };

  class BoolTraceDelta {
  protected:
    int delta;
  public:


    BoolTraceDelta(Int::BoolTraceView o, Int::BoolView n, const Delta& d);


    bool operator ()(void) const;
    void operator ++(void);



    int min(void) const;
    int max(void) const;
    unsigned int width(void) const;
  };
 
}
 
#include <gecode/int/trace/int-delta.hpp>
#include <gecode/int/trace/bool-delta.hpp>
 
#include <gecode/int/trace/traits.hpp>
 
namespace Gecode {

  typedef ViewTracer<Int::IntView> IntTracer;
  typedef ViewTraceRecorder<Int::IntView> IntTraceRecorder;

  class GECODE_INT_EXPORT StdIntTracer : public IntTracer {
  protected:
    std::ostream& os;
  public:
    StdIntTracer(std::ostream& os0 = std::cerr);
    virtual void init(const Space& home, const IntTraceRecorder& t);
    virtual void prune(const Space& home, const IntTraceRecorder& t,
                       const ViewTraceInfo& vti, int i, IntTraceDelta& d);
    virtual void fix(const Space& home, const IntTraceRecorder& t);
    virtual void fail(const Space& home, const IntTraceRecorder& t);
    virtual void done(const Space& home, const IntTraceRecorder& t);
    static StdIntTracer def;
  };
 

  typedef ViewTracer<Int::BoolView> BoolTracer;
  typedef ViewTraceRecorder<Int::BoolView> BoolTraceRecorder;

  class GECODE_INT_EXPORT StdBoolTracer : public BoolTracer {
  protected:
    std::ostream& os;
  public:
    StdBoolTracer(std::ostream& os0 = std::cerr);
    virtual void init(const Space& home, const BoolTraceRecorder& t);
    virtual void prune(const Space& home, const BoolTraceRecorder& t,
                       const ViewTraceInfo& vti, int i, BoolTraceDelta& d);
    virtual void fix(const Space& home, const BoolTraceRecorder& t);
    virtual void fail(const Space& home, const BoolTraceRecorder& t);
    virtual void done(const Space& home, const BoolTraceRecorder& t);
    static StdBoolTracer def;
  };

  GECODE_INT_EXPORT void
  trace(Home home, const IntVarArgs& x,
        TraceFilter tf,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        IntTracer& t = StdIntTracer::def);
  void
  trace(Home home, const IntVarArgs& x,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        IntTracer& t = StdIntTracer::def);

  GECODE_INT_EXPORT void
  trace(Home home, const BoolVarArgs& x,
        TraceFilter tf,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        BoolTracer& t = StdBoolTracer::def);
  void
  trace(Home home, const BoolVarArgs& x,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        BoolTracer& t = StdBoolTracer::def);
 
}
 
#include <gecode/int/trace.hpp>
 
#endif
 
// IFDEF: GECODE_HAS_INT_VARS
// STATISTICS: int-post