diff --git a/C/bignum.c b/C/bignum.c
index 6de6c8367..9da08c0a6 100644
--- a/C/bignum.c
+++ b/C/bignum.c
@@ -169,7 +169,7 @@ int Yap_CleanOpaqueVariable(CELL d) {
   }
   blob_info = blob_tag - USER_BLOB_START;
   if (!GLOBAL_OpaqueHandlers)
-    return FALSE;
+    return false;
   if (!GLOBAL_OpaqueHandlers[blob_info].fail_handler)
     return true;
   return (GLOBAL_OpaqueHandlers[blob_info].fail_handler)(d);
@@ -509,4 +509,4 @@ void Yap_InitBigNums(void) {
   Yap_InitCPred("string", 1, p_is_string, SafePredFlag);
   Yap_InitCPred("opaque", 1, p_is_opaque, SafePredFlag);
   Yap_InitCPred("nb_set_bit", 2, p_nb_set_bit, SafePredFlag);
-}
+}
\ No newline at end of file
diff --git a/include/YapDefs.h b/include/YapDefs.h
index 277534807..ffa0f2fa6 100755
--- a/include/YapDefs.h
+++ b/include/YapDefs.h
@@ -390,7 +390,7 @@ typedef YAP_Bool (*YAP_Opaque_CallOnGCRelocate)(YAP_opaque_tag_t, void *,
 /// opaque variables can interact with the system
 typedef struct YAP_opaque_handler_struct {
   YAP_Opaque_CallOnCut cut_handler; //< called at cut, which may be a forward
-                                    //cut or an exception.
+                                    // cut or an exception.
   YAP_Opaque_CallOnFail
       fail_handler; //< called at exit, it can be used to cleanup resources
   YAP_Opaque_CallOnWrite write_handler; //< text representation
diff --git a/packages/gecode/gecode4_yap.cc b/packages/gecode/gecode4_yap.cc
index a8871531f..294562932 100644
--- a/packages/gecode/gecode4_yap.cc
+++ b/packages/gecode/gecode4_yap.cc
@@ -6,12 +6,12 @@
 // under the terms of the GNU Lesser General Public License as published by the
 // Free Software Foundation, either version 3 of the License, or (at your
 // option) any later version.
-// 
+//
 // This program is distributed in the hope that it will be useful, but WITHOUT
 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 // more details.
-// 
+//
 // You should have received a copy of the GNU Lesser General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //=============================================================================
@@ -22,1953 +22,1958 @@ using namespace std;
 using namespace generic_gecode;
 using namespace Gecode;
 
-extern "C"
-{
+extern "C" {
 void gecode_init(void);
-    
+
 #include "config.h"
 }
 
-namespace generic_gecode
-{
+namespace generic_gecode {
 #ifndef HAVE_DYNARRAY
-  template <typename T> struct DynArray
-  {
-    T* _array;
-    DynArray(int n): _array(new T[n]) {}
-    ~DynArray() { delete[] _array; }
-    T& operator[](int i) { return _array[i]; }
-  };
-#define DYNARRAY(T,A,N) DynArray<T> A(N)
+template <typename T> struct DynArray {
+  T *_array;
+  DynArray(int n) : _array(new T[n]) {}
+  ~DynArray() { delete[] _array; }
+  T &operator[](int i) { return _array[i]; }
+};
+#define DYNARRAY(T, A, N) DynArray<T> A(N)
 #else
-#define DYNARRAY(T,A,N) T A[N]
+#define DYNARRAY(T, A, N) T A[N]
 #endif
 
 #ifndef HAVE_DYNARRAY
-  struct SpecArray
-  {
-    int (*_array)[2];
-    SpecArray(int n): _array((int (*)[2]) new int[n*2]) {}
-    ~SpecArray() { delete[] _array; }
-    int& operator()(int i,int j) { return _array[i][j]; }
-  };
-#define SPECARRAY(A,N) SpecArray A(N)
-#define SPECARRAYELEM(A,I,J) A(I,J)
+struct SpecArray {
+  int (*_array)[2];
+  SpecArray(int n) : _array((int (*)[2]) new int[n * 2]) {}
+  ~SpecArray() { delete[] _array; }
+  int &operator()(int i, int j) { return _array[i][j]; }
+};
+#define SPECARRAY(A, N) SpecArray A(N)
+#define SPECARRAYELEM(A, I, J) A(I, J)
 #define SPECARRAYDEREF(A) A._array
 #else
-#define SPECARRAY(A,N) int A[N][2]
-#define SPECARRAYELEM(A,I,J) A[I][J]
+#define SPECARRAY(A, N) int A[N][2]
+#define SPECARRAYELEM(A, I, J) A[I][J]
 #define SPECARRAYDEREF(A) A
 #endif
 }
 
-extern "C"
-{
+extern "C" {
 #include "YapInterface.h"
 
-  static YAP_opaque_tag_t gecode_space_tag;
-  static YAP_opaque_handler_t gecode_space_handler;
+static YAP_opaque_tag_t gecode_space_tag;
+static YAP_opaque_handler_t gecode_space_handler;
 
-  static YAP_Bool gecode_space_fail_handler(void* p)
-  {
-    delete *(GenericSpace**)p;
-    return TRUE;
-  }
+static YAP_Bool gecode_space_fail_handler(YAP_Term p) {
+  delete *(GenericSpace **)YAP_OpaqueObjectFromTerm(p);
+  return TRUE;
+}
 
-  static YAP_Bool
-  gecode_space_write_handler
-  (FILE  *stream, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<space %p>", p);
-    return TRUE;
-  }
+static YAP_Bool gecode_space_write_handler(FILE *stream, YAP_opaque_tag_t type,
+                                           void *p, int flags) {
+  fprintf(stream, "<space %p>", p);
+  return TRUE;
+}
 
-  static YAP_Term gecode_term_from_space(GenericSpace* s)
-  {
-    YAP_Term term =
-      YAP_NewOpaqueObject(gecode_space_tag, sizeof(GenericSpace*));
-    GenericSpace** ptr =
-      (GenericSpace**) YAP_OpaqueObjectFromTerm(term);
-    *ptr = s;
-    return term;
-  }
-
-  static YAP_Bool gecode_new_space(void)
-  {
-    YAP_Term term = gecode_term_from_space(new GenericSpace);
-    return YAP_Unify(YAP_ARG1, term);
-  }
+static YAP_Term gecode_term_from_space(GenericSpace *s) {
+  YAP_Term term = YAP_NewOpaqueObject(gecode_space_tag, sizeof(GenericSpace *));
+  GenericSpace **ptr = (GenericSpace **)YAP_OpaqueObjectFromTerm(term);
+  *ptr = s;
+  return term;
+}
 
+static YAP_Bool gecode_new_space(void) {
+  YAP_Term term = gecode_term_from_space(new GenericSpace);
+  return YAP_Unify(YAP_ARG1, term);
+}
 
 #ifndef DISJUNCTOR
-  static inline GenericSpace*
-  gecode_Space_from_term(YAP_Term t)
-  {
-    return * (GenericSpace**) YAP_OpaqueObjectFromTerm(t);
-  }
+static inline GenericSpace *gecode_Space_from_term(YAP_Term t) {
+  return *(GenericSpace **)YAP_OpaqueObjectFromTerm(t);
+}
 #else
-  struct YapDisjunctor
-  {
-    GenericSpace* home;
-    Disjunctor disj;
-    YapDisjunctor(GenericSpace* home_)
-      : home(home_), disj(*home_) {}
-  };
+struct YapDisjunctor {
+  GenericSpace *home;
+  Disjunctor disj;
+  YapDisjunctor(GenericSpace *home_) : home(home_), disj(*home_) {}
+};
 
-  static YAP_opaque_tag_t gecode_disjunctor_tag;
-  static YAP_opaque_handler_t gecode_disjunctor_handler;
-  static YAP_opaque_tag_t gecode_disjunctor_clause_tag;
-  static YAP_opaque_handler_t gecode_disjunctor_clause_handler;
+static YAP_opaque_tag_t gecode_disjunctor_tag;
+static YAP_opaque_handler_t gecode_disjunctor_handler;
+static YAP_opaque_tag_t gecode_disjunctor_clause_tag;
+static YAP_opaque_handler_t gecode_disjunctor_clause_handler;
 
-  static inline Disjunctor&
-  gecode_Disjunctor_from_term(YAP_Term t)
-  {
-    return ((YapDisjunctor*) YAP_OpaqueObjectFromTerm(t))->disj;
-  }
-
-  static inline YapDisjunctor&
-  gecode_YapDisjunctor_from_term(YAP_Term t)
-  {
-    return * (YapDisjunctor*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline Clause&
-  gecode_Clause_from_term(YAP_Term t)
-  {
-    return * (Clause*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline GenericSpace*
-  gecode_Space_from_term(YAP_Term t)
-  {
-    if (YAP_IsOpaqueObjectTerm(t, gecode_disjunctor_clause_tag))
-      {
-	Clause& c = gecode_Clause_from_term(t);
-	return & (GenericSpace&) c;
-      }
-    return * (GenericSpace**) YAP_OpaqueObjectFromTerm(t);
+static inline Disjunctor &gecode_Disjunctor_from_term(YAP_Term t) {
+  return ((YapDisjunctor *)YAP_OpaqueObjectFromTerm(t))->disj;
+}
+
+static inline YapDisjunctor &gecode_YapDisjunctor_from_term(YAP_Term t) {
+  return *(YapDisjunctor *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline Clause &gecode_Clause_from_term(YAP_Term t) {
+  return *(Clause *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline GenericSpace *gecode_Space_from_term(YAP_Term t) {
+  if (YAP_IsOpaqueObjectTerm(t, gecode_disjunctor_clause_tag)) {
+    Clause &c = gecode_Clause_from_term(t);
+    return &(GenericSpace &)c;
   }
+  return *(GenericSpace **)YAP_OpaqueObjectFromTerm(t);
+}
 #endif
 
-  static inline FloatAssign&
-  gecode_FloatAssign_from_term(YAP_Term t)
-  {
-    return * (FloatAssign*) YAP_OpaqueObjectFromTerm(t);
+static inline FloatAssign &gecode_FloatAssign_from_term(YAP_Term t) {
+  return *(FloatAssign *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline IntAssign &gecode_IntAssign_from_term(YAP_Term t) {
+  return *(IntAssign *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline SetAssign &gecode_SetAssign_from_term(YAP_Term t) {
+  return *(SetAssign *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline TupleSet &gecode_TupleSet_from_term(YAP_Term t) {
+  return *(TupleSet *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline DFA &gecode_DFA_from_term(YAP_Term t) {
+  return *(DFA *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline FloatNum gecode_FloatNum_from_term(YAP_Term t) {
+  return (FloatNum)YAP_FloatOfTerm(t);
+}
+
+static YAP_Term gecode_SET_VAR_NONE;
+static YAP_Term gecode_SET_VAR_DEGREE_MIN;
+static YAP_Term gecode_SET_VAR_DEGREE_MAX;
+static YAP_Term gecode_SET_VAR_MIN_MIN;
+static YAP_Term gecode_SET_VAR_MIN_MAX;
+static YAP_Term gecode_SET_VAR_MAX_MIN;
+static YAP_Term gecode_SET_VAR_MAX_MAX;
+static YAP_Term gecode_SET_VAR_SIZE_MIN;
+static YAP_Term gecode_SET_VAR_SIZE_MAX;
+static YAP_Term gecode_SET_VAR_DEGREE_SIZE_MIN;
+static YAP_Term gecode_SET_VAR_DEGREE_SIZE_MAX;
+
+static inline SetVarBranch gecode_SetVarBranch_from_term(YAP_Term t) {
+
+  if (YAP_IsAtomTerm(t)) {
+    if (t == gecode_SET_VAR_SIZE_MIN)
+      return SET_VAR_SIZE_MIN();
+    if (t == gecode_SET_VAR_SIZE_MAX)
+      return SET_VAR_SIZE_MAX();
+    if (t == gecode_SET_VAR_NONE)
+      return SET_VAR_NONE();
+    if (t == gecode_SET_VAR_DEGREE_MIN)
+      return SET_VAR_DEGREE_MIN();
+    if (t == gecode_SET_VAR_DEGREE_MAX)
+      return SET_VAR_DEGREE_MAX();
+    if (t == gecode_SET_VAR_MIN_MIN)
+      return SET_VAR_MIN_MIN();
+    if (t == gecode_SET_VAR_MIN_MAX)
+      return SET_VAR_MIN_MAX();
+    if (t == gecode_SET_VAR_MAX_MIN)
+      return SET_VAR_MAX_MIN();
+    if (t == gecode_SET_VAR_MAX_MAX)
+      return SET_VAR_MAX_MAX();
+    if (t == gecode_SET_VAR_DEGREE_SIZE_MIN)
+      return SET_VAR_DEGREE_SIZE_MIN();
+    if (t == gecode_SET_VAR_DEGREE_SIZE_MAX)
+      return SET_VAR_DEGREE_SIZE_MAX();
   }
+  cerr << "unsupported SET VAR" << endl;
+  exit(1);
+}
 
-  static inline IntAssign&
-  gecode_IntAssign_from_term(YAP_Term t)
-  {
-    return * (IntAssign*) YAP_OpaqueObjectFromTerm(t);
+static YAP_Term gecode_SET_VAL_MIN_INC;
+static YAP_Term gecode_SET_VAL_MIN_EXC;
+static YAP_Term gecode_SET_VAL_MED_INC;
+static YAP_Term gecode_SET_VAL_MED_EXC;
+static YAP_Term gecode_SET_VAL_MAX_INC;
+static YAP_Term gecode_SET_VAL_MAX_EXC;
+
+static inline SetValBranch gecode_SetValBranch_from_term(YAP_Term t) {
+  if (YAP_IsAtomTerm(t)) {
+    if (t == gecode_SET_VAL_MIN_INC)
+      return SET_VAL_MIN_INC();
+    if (t == gecode_SET_VAL_MIN_EXC)
+      return SET_VAL_MIN_EXC();
+    if (t == gecode_SET_VAL_MED_INC)
+      return SET_VAL_MED_INC();
+    if (t == gecode_SET_VAL_MED_EXC)
+      return SET_VAL_MED_EXC();
+    if (t == gecode_SET_VAL_MAX_INC)
+      return SET_VAL_MAX_INC();
+    if (t == gecode_SET_VAL_MAX_EXC)
+      return SET_VAL_MAX_EXC();
   }
+  cerr << "unsupported INT VAL" << endl;
+  exit(1);
+}
 
-  static inline SetAssign&
-  gecode_SetAssign_from_term(YAP_Term t)
-  {
-    return * (SetAssign*) YAP_OpaqueObjectFromTerm(t);
+static inline SetBranchFilter &gecode_SetBranchFilter_from_term(YAP_Term t) {
+  return *(SetBranchFilter *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static YAP_Term gecode_INT_VAR_NONE;
+static YAP_Term gecode_INT_VAR_DEGREE_MIN;
+static YAP_Term gecode_INT_VAR_DEGREE_MAX;
+static YAP_Term gecode_INT_VAR_MIN_MIN;
+static YAP_Term gecode_INT_VAR_MIN_MAX;
+static YAP_Term gecode_INT_VAR_MAX_MIN;
+static YAP_Term gecode_INT_VAR_MAX_MAX;
+static YAP_Term gecode_INT_VAR_SIZE_MIN;
+static YAP_Term gecode_INT_VAR_SIZE_MAX;
+static YAP_Term gecode_INT_VAR_DEGREE_SIZE_MIN;
+static YAP_Term gecode_INT_VAR_DEGREE_SIZE_MAX;
+static YAP_Term gecode_INT_VAR_REGRET_MIN_MIN;
+static YAP_Term gecode_INT_VAR_REGRET_MIN_MAX;
+static YAP_Term gecode_INT_VAR_REGRET_MAX_MIN;
+static YAP_Term gecode_INT_VAR_REGRET_MAX_MAX;
+
+static inline IntVarBranch gecode_IntVarBranch_from_term(YAP_Term t) {
+  if (YAP_IsAtomTerm(t)) {
+    if (t == gecode_INT_VAR_SIZE_MIN)
+      return INT_VAR_SIZE_MIN();
+    if (t == gecode_INT_VAR_SIZE_MAX)
+      return INT_VAR_SIZE_MAX();
+    if (t == gecode_INT_VAR_NONE)
+      return INT_VAR_NONE();
+    if (t == gecode_INT_VAR_DEGREE_MIN)
+      return INT_VAR_DEGREE_MIN();
+    if (t == gecode_INT_VAR_DEGREE_MAX)
+      return INT_VAR_DEGREE_MAX();
+    if (t == gecode_INT_VAR_MIN_MIN)
+      return INT_VAR_MIN_MIN();
+    if (t == gecode_INT_VAR_MIN_MAX)
+      return INT_VAR_MIN_MAX();
+    if (t == gecode_INT_VAR_MAX_MIN)
+      return INT_VAR_MAX_MIN();
+    if (t == gecode_INT_VAR_MAX_MAX)
+      return INT_VAR_MAX_MAX();
+    if (t == gecode_INT_VAR_DEGREE_SIZE_MIN)
+      return INT_VAR_DEGREE_SIZE_MIN();
+    if (t == gecode_INT_VAR_DEGREE_SIZE_MAX)
+      return INT_VAR_DEGREE_SIZE_MAX();
+    if (t == gecode_INT_VAR_REGRET_MIN_MIN)
+      return INT_VAR_REGRET_MIN_MIN();
+    if (t == gecode_INT_VAR_REGRET_MIN_MAX)
+      return INT_VAR_REGRET_MIN_MAX();
+    if (t == gecode_INT_VAR_REGRET_MAX_MIN)
+      return INT_VAR_REGRET_MAX_MIN();
+    if (t == gecode_INT_VAR_REGRET_MAX_MAX)
+      return INT_VAR_REGRET_MAX_MAX();
   }
+  cerr << "unsupported INT VAR" << endl;
+  exit(1);
+}
 
-  static inline TupleSet&
-  gecode_TupleSet_from_term(YAP_Term t)
-  {
-    return *(TupleSet *) YAP_OpaqueObjectFromTerm(t);
+static YAP_Term gecode_FLOAT_VAR_NONE;
+static YAP_Term gecode_FLOAT_VAR_DEGREE_MIN;
+static YAP_Term gecode_FLOAT_VAR_DEGREE_MAX;
+static YAP_Term gecode_FLOAT_VAR_MIN_MIN;
+static YAP_Term gecode_FLOAT_VAR_MIN_MAX;
+static YAP_Term gecode_FLOAT_VAR_MAX_MIN;
+static YAP_Term gecode_FLOAT_VAR_MAX_MAX;
+static YAP_Term gecode_FLOAT_VAR_SIZE_MIN;
+static YAP_Term gecode_FLOAT_VAR_SIZE_MAX;
+static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MIN;
+static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MAX;
+
+static inline FloatVarBranch gecode_FloatVarBranch_from_term(YAP_Term t) {
+  if (YAP_IsAtomTerm(t)) {
+    if (t == gecode_FLOAT_VAR_SIZE_MIN)
+      return FLOAT_VAR_SIZE_MIN();
+    if (t == gecode_FLOAT_VAR_SIZE_MAX)
+      return FLOAT_VAR_SIZE_MAX();
+    if (t == gecode_FLOAT_VAR_NONE)
+      return FLOAT_VAR_NONE();
+    if (t == gecode_FLOAT_VAR_DEGREE_MIN)
+      return FLOAT_VAR_DEGREE_MIN();
+    if (t == gecode_FLOAT_VAR_DEGREE_MAX)
+      return FLOAT_VAR_DEGREE_MAX();
+    if (t == gecode_FLOAT_VAR_MIN_MIN)
+      return FLOAT_VAR_MIN_MIN();
+    if (t == gecode_FLOAT_VAR_MIN_MAX)
+      return FLOAT_VAR_MIN_MAX();
+    if (t == gecode_FLOAT_VAR_MAX_MIN)
+      return FLOAT_VAR_MAX_MIN();
+    if (t == gecode_FLOAT_VAR_MAX_MAX)
+      return FLOAT_VAR_MAX_MAX();
+    if (t == gecode_FLOAT_VAR_DEGREE_SIZE_MIN)
+      return FLOAT_VAR_DEGREE_SIZE_MIN();
+    if (t == gecode_FLOAT_VAR_DEGREE_SIZE_MAX)
+      return FLOAT_VAR_DEGREE_SIZE_MAX();
   }
+  cerr << "unsupported FLOAT VAR" << endl;
+  exit(1);
+}
 
-  static inline DFA&
-  gecode_DFA_from_term(YAP_Term t)
-  {
-    return *(DFA *) YAP_OpaqueObjectFromTerm(t);
+static YAP_Term gecode_INT_VAL_MIN;
+static YAP_Term gecode_INT_VAL_MED;
+static YAP_Term gecode_INT_VAL_MAX;
+static YAP_Term gecode_INT_VAL_SPLIT_MIN;
+static YAP_Term gecode_INT_VAL_SPLIT_MAX;
+static YAP_Term gecode_INT_VAL_RANGE_MIN;
+static YAP_Term gecode_INT_VAL_RANGE_MAX;
+static YAP_Term gecode_INT_VALUES_MIN;
+static YAP_Term gecode_INT_VALUES_MAX;
+
+static inline IntValBranch gecode_IntValBranch_from_term(YAP_Term t) {
+  if (YAP_IsAtomTerm(t)) {
+    if (t == gecode_INT_VAL_MIN)
+      return INT_VAL_MIN();
+    if (t == gecode_INT_VAL_MED)
+      return INT_VAL_MED();
+    if (t == gecode_INT_VAL_MAX)
+      return INT_VAL_MAX();
+    if (t == gecode_INT_VAL_SPLIT_MIN)
+      return INT_VAL_SPLIT_MIN();
+    if (t == gecode_INT_VAL_SPLIT_MAX)
+      return INT_VAL_SPLIT_MAX();
+    if (t == gecode_INT_VAL_RANGE_MIN)
+      return INT_VAL_RANGE_MIN();
+    if (t == gecode_INT_VAL_RANGE_MAX)
+      return INT_VAL_RANGE_MAX();
+    if (t == gecode_INT_VALUES_MIN)
+      return INT_VALUES_MIN();
+    if (t == gecode_INT_VALUES_MAX)
+      return INT_VALUES_MAX();
   }
+  cerr << "unsupported INT VAL" << endl;
+  exit(1);
+}
 
-  static inline FloatNum
-  gecode_FloatNum_from_term(YAP_Term t)
-  {
-    return  (FloatNum) YAP_FloatOfTerm(t);
+static YAP_Term gecode_FLOAT_VAL_SPLIT_MIN;
+static YAP_Term gecode_FLOAT_VAL_SPLIT_MAX;
+
+static inline FloatValBranch gecode_FloatValBranch_from_term(YAP_Term t) {
+  if (YAP_IsAtomTerm(t)) {
+    if (t == gecode_FLOAT_VAL_SPLIT_MIN)
+      return FLOAT_VAL_SPLIT_MIN();
+    if (t == gecode_FLOAT_VAL_SPLIT_MAX)
+      return FLOAT_VAL_SPLIT_MAX();
   }
+  cerr << "unsupported FLOAT VAL" << endl;
+  exit(1);
+}
 
-  static YAP_Term gecode_SET_VAR_NONE;
-  static YAP_Term gecode_SET_VAR_DEGREE_MIN;
-  static YAP_Term gecode_SET_VAR_DEGREE_MAX;
-  static YAP_Term gecode_SET_VAR_MIN_MIN;
-  static YAP_Term gecode_SET_VAR_MIN_MAX;
-  static YAP_Term gecode_SET_VAR_MAX_MIN;
-  static YAP_Term gecode_SET_VAR_MAX_MAX;
-  static YAP_Term gecode_SET_VAR_SIZE_MIN;
-  static YAP_Term gecode_SET_VAR_SIZE_MAX;
-  static YAP_Term gecode_SET_VAR_DEGREE_SIZE_MIN;
-  static YAP_Term gecode_SET_VAR_DEGREE_SIZE_MAX;
+static inline FloatVal &gecode_FloatVal_from_term(YAP_Term t) {
+  return *(FloatVal *)YAP_OpaqueObjectFromTerm(t);
+}
 
-  static inline SetVarBranch
-  gecode_SetVarBranch_from_term(YAP_Term t)
-  {
+static inline Symmetries &gecode_Symmetries_from_term(YAP_Term t) {
+  return *(Symmetries *)YAP_OpaqueObjectFromTerm(t);
+}
 
-    if (YAP_IsAtomTerm(t)) {
-      if ( t == gecode_SET_VAR_SIZE_MIN)
-	return SET_VAR_SIZE_MIN();
-      if ( t == gecode_SET_VAR_SIZE_MAX)
-	return SET_VAR_SIZE_MAX();
-      if ( t == gecode_SET_VAR_NONE)
-	return SET_VAR_NONE();
-      if ( t == gecode_SET_VAR_DEGREE_MIN)
-	return SET_VAR_DEGREE_MIN();
-      if ( t == gecode_SET_VAR_DEGREE_MAX)
-	return SET_VAR_DEGREE_MAX();
-      if ( t == gecode_SET_VAR_MIN_MIN)
-	return SET_VAR_MIN_MIN();
-      if ( t == gecode_SET_VAR_MIN_MAX)
-	return SET_VAR_MIN_MAX();
-      if ( t == gecode_SET_VAR_MAX_MIN)
-	return SET_VAR_MAX_MIN();
-      if ( t == gecode_SET_VAR_MAX_MAX)
-	return SET_VAR_MAX_MAX();
-      if ( t == gecode_SET_VAR_DEGREE_SIZE_MIN)
-	return SET_VAR_DEGREE_SIZE_MIN();
-      if ( t == gecode_SET_VAR_DEGREE_SIZE_MAX)
-	return SET_VAR_DEGREE_SIZE_MAX();
-    }
-    cerr << "unsupported SET VAR" << endl; exit(1);
+static inline IntBranchFilter &gecode_IntBranchFilter_from_term(YAP_Term t) {
+  return *(IntBranchFilter *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline BoolBranchFilter &gecode_BoolBranchFilter_from_term(YAP_Term t) {
+  return *(BoolBranchFilter *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline FloatBranchFilter &
+gecode_FloatBranchFilter_from_term(YAP_Term t) {
+  return *(FloatBranchFilter *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline SetVarValPrint &gecode_SetVarValPrint_from_term(YAP_Term t) {
+  return *(SetVarValPrint *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline IntVarValPrint &gecode_IntVarValPrint_from_term(YAP_Term t) {
+  return *(IntVarValPrint *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline BoolVarValPrint &gecode_BoolVarValPrint_from_term(YAP_Term t) {
+  return *(BoolVarValPrint *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static inline FloatVarValPrint &gecode_FloatVarValPrint_from_term(YAP_Term t) {
+  return *(FloatVarValPrint *)YAP_OpaqueObjectFromTerm(t);
+}
+
+static YAP_opaque_tag_t gecode_engine_tag;
+static YAP_opaque_handler_t gecode_engine_handler;
+
+static RestartMode gecode_RestartMode_from_term(YAP_Term t);
+
+static YAP_Bool gecode_new_engine(void) {
+  YAP_Term arg1 = YAP_ARG1;
+  YAP_Term arg2 = YAP_ARG2;
+  YAP_Term arg3 = YAP_ARG3;
+  bool restart = YAP_IntOfTerm(YAP_ArgOfTerm(1, arg3));
+  double threads = YAP_FloatOfTerm(YAP_ArgOfTerm(2, arg3));
+  unsigned int c_d = YAP_IntOfTerm(YAP_ArgOfTerm(3, arg3));
+  unsigned int a_d = YAP_IntOfTerm(YAP_ArgOfTerm(4, arg3));
+  unsigned int nogoods_limit = YAP_IntOfTerm(YAP_ArgOfTerm(6, arg3));
+  bool clone = (YAP_IntOfTerm(YAP_ArgOfTerm(7, arg3)) == 0 ? FALSE : TRUE);
+  RestartMode md;
+  YAP_Term t = YAP_ArgOfTerm(5, arg3);
+  if (YAP_IsAtomTerm(t)) {
+    md = gecode_RestartMode_from_term(t);
+  } else if (YAP_IsApplTerm(t)) {
+    md = gecode_RestartMode_from_term(
+        YAP_MkAtomTerm(YAP_NameOfFunctor(YAP_FunctorOfTerm(t))));
+  } else {
+    cerr << "bad engine cutoff option" << endl;
+    exit(1);
   }
-
-  static YAP_Term gecode_SET_VAL_MIN_INC;
-  static YAP_Term gecode_SET_VAL_MIN_EXC;
-  static YAP_Term gecode_SET_VAL_MED_INC;
-  static YAP_Term gecode_SET_VAL_MED_EXC;
-  static YAP_Term gecode_SET_VAL_MAX_INC;
-  static YAP_Term gecode_SET_VAL_MAX_EXC;
-
-  static inline SetValBranch
-  gecode_SetValBranch_from_term(YAP_Term t)
-  {
-    if (YAP_IsAtomTerm(t)) {
-      if ( t == gecode_SET_VAL_MIN_INC)
-	return SET_VAL_MIN_INC();
-      if ( t == gecode_SET_VAL_MIN_EXC)
-	return SET_VAL_MIN_EXC();
-      if ( t == gecode_SET_VAL_MED_INC)
-	return SET_VAL_MED_INC();
-      if ( t == gecode_SET_VAL_MED_EXC)
-	return SET_VAL_MED_EXC();
-      if ( t == gecode_SET_VAL_MAX_INC)
-	return SET_VAL_MAX_INC();
-      if ( t == gecode_SET_VAL_MAX_EXC)
-	return SET_VAL_MAX_EXC();
-    }
-    cerr << "unsupported INT VAL" << endl; exit(1);
-  }
-
-  static inline SetBranchFilter&
-  gecode_SetBranchFilter_from_term(YAP_Term t)
-  {
-    return * (SetBranchFilter*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static YAP_Term gecode_INT_VAR_NONE;
-  static YAP_Term gecode_INT_VAR_DEGREE_MIN;
-  static YAP_Term gecode_INT_VAR_DEGREE_MAX;
-  static YAP_Term gecode_INT_VAR_MIN_MIN;
-  static YAP_Term gecode_INT_VAR_MIN_MAX;
-  static YAP_Term gecode_INT_VAR_MAX_MIN;
-  static YAP_Term gecode_INT_VAR_MAX_MAX;
-  static YAP_Term gecode_INT_VAR_SIZE_MIN;
-  static YAP_Term gecode_INT_VAR_SIZE_MAX;
-  static YAP_Term gecode_INT_VAR_DEGREE_SIZE_MIN;
-  static YAP_Term gecode_INT_VAR_DEGREE_SIZE_MAX;
-  static YAP_Term gecode_INT_VAR_REGRET_MIN_MIN;
-  static YAP_Term gecode_INT_VAR_REGRET_MIN_MAX;
-  static YAP_Term gecode_INT_VAR_REGRET_MAX_MIN;
-  static YAP_Term gecode_INT_VAR_REGRET_MAX_MAX;
-
-  static inline IntVarBranch
-  gecode_IntVarBranch_from_term(YAP_Term t)
-  {
-    if (YAP_IsAtomTerm(t)) {
-      if ( t == gecode_INT_VAR_SIZE_MIN)
-	return INT_VAR_SIZE_MIN();
-      if ( t == gecode_INT_VAR_SIZE_MAX)
-	return INT_VAR_SIZE_MAX();
-      if ( t == gecode_INT_VAR_NONE)
-	return INT_VAR_NONE();
-      if ( t == gecode_INT_VAR_DEGREE_MIN)
-	return INT_VAR_DEGREE_MIN();
-      if ( t == gecode_INT_VAR_DEGREE_MAX)
-	return INT_VAR_DEGREE_MAX();
-      if ( t == gecode_INT_VAR_MIN_MIN)
-	return INT_VAR_MIN_MIN();
-      if ( t == gecode_INT_VAR_MIN_MAX)
-	return INT_VAR_MIN_MAX();
-      if ( t == gecode_INT_VAR_MAX_MIN)
-	return INT_VAR_MAX_MIN();
-      if ( t == gecode_INT_VAR_MAX_MAX)
-	return INT_VAR_MAX_MAX();
-      if ( t == gecode_INT_VAR_DEGREE_SIZE_MIN)
-	return INT_VAR_DEGREE_SIZE_MIN();
-      if ( t == gecode_INT_VAR_DEGREE_SIZE_MAX)
-	return INT_VAR_DEGREE_SIZE_MAX();
-      if ( t == gecode_INT_VAR_REGRET_MIN_MIN)
-	return INT_VAR_REGRET_MIN_MIN();
-      if ( t == gecode_INT_VAR_REGRET_MIN_MAX)
-	return INT_VAR_REGRET_MIN_MAX();
-      if ( t == gecode_INT_VAR_REGRET_MAX_MIN)
-	return INT_VAR_REGRET_MAX_MIN();
-      if ( t == gecode_INT_VAR_REGRET_MAX_MAX)
-	return INT_VAR_REGRET_MAX_MAX();
-    }
-    cerr << "unsupported INT VAR" << endl; exit(1);
-  }
-
-  static YAP_Term gecode_FLOAT_VAR_NONE;
-  static YAP_Term gecode_FLOAT_VAR_DEGREE_MIN;
-  static YAP_Term gecode_FLOAT_VAR_DEGREE_MAX;
-  static YAP_Term gecode_FLOAT_VAR_MIN_MIN;
-  static YAP_Term gecode_FLOAT_VAR_MIN_MAX;
-  static YAP_Term gecode_FLOAT_VAR_MAX_MIN;
-  static YAP_Term gecode_FLOAT_VAR_MAX_MAX;
-  static YAP_Term gecode_FLOAT_VAR_SIZE_MIN;
-  static YAP_Term gecode_FLOAT_VAR_SIZE_MAX;
-  static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MIN;
-  static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MAX;
-  
-  static inline FloatVarBranch
-  gecode_FloatVarBranch_from_term(YAP_Term t)
-  {
-    if (YAP_IsAtomTerm(t)) {
-      if ( t == gecode_FLOAT_VAR_SIZE_MIN)
-	return FLOAT_VAR_SIZE_MIN();
-      if ( t == gecode_FLOAT_VAR_SIZE_MAX)
-	return FLOAT_VAR_SIZE_MAX();
-      if ( t == gecode_FLOAT_VAR_NONE)
-	return FLOAT_VAR_NONE();
-      if ( t == gecode_FLOAT_VAR_DEGREE_MIN)
-	return FLOAT_VAR_DEGREE_MIN();
-      if ( t == gecode_FLOAT_VAR_DEGREE_MAX)
-	return FLOAT_VAR_DEGREE_MAX();
-      if ( t == gecode_FLOAT_VAR_MIN_MIN)
-	return FLOAT_VAR_MIN_MIN();
-      if ( t == gecode_FLOAT_VAR_MIN_MAX)
-	return FLOAT_VAR_MIN_MAX();
-      if ( t == gecode_FLOAT_VAR_MAX_MIN)
-	return FLOAT_VAR_MAX_MIN();
-      if ( t == gecode_FLOAT_VAR_MAX_MAX)
-	return FLOAT_VAR_MAX_MAX();
-      if ( t == gecode_FLOAT_VAR_DEGREE_SIZE_MIN)
-	return FLOAT_VAR_DEGREE_SIZE_MIN();
-      if ( t == gecode_FLOAT_VAR_DEGREE_SIZE_MAX)
-	return FLOAT_VAR_DEGREE_SIZE_MAX();
-    }
-    cerr << "unsupported FLOAT VAR" << endl; exit(1);
-  }
-
-  static YAP_Term gecode_INT_VAL_MIN;
-  static YAP_Term gecode_INT_VAL_MED;
-  static YAP_Term gecode_INT_VAL_MAX;
-  static YAP_Term gecode_INT_VAL_SPLIT_MIN;
-  static YAP_Term gecode_INT_VAL_SPLIT_MAX;
-  static YAP_Term gecode_INT_VAL_RANGE_MIN;
-  static YAP_Term gecode_INT_VAL_RANGE_MAX;
-  static YAP_Term gecode_INT_VALUES_MIN;
-  static YAP_Term gecode_INT_VALUES_MAX;
-
-  static inline IntValBranch
-  gecode_IntValBranch_from_term(YAP_Term t)
-  {
-    if (YAP_IsAtomTerm(t)) {
-      if ( t == gecode_INT_VAL_MIN)
-	return INT_VAL_MIN();
-      if ( t == gecode_INT_VAL_MED)
-	return INT_VAL_MED();
-      if ( t == gecode_INT_VAL_MAX)
-	return INT_VAL_MAX();
-      if ( t == gecode_INT_VAL_SPLIT_MIN)
-	return INT_VAL_SPLIT_MIN();
-      if ( t == gecode_INT_VAL_SPLIT_MAX)
-	return INT_VAL_SPLIT_MAX();
-      if ( t == gecode_INT_VAL_RANGE_MIN)
-	return INT_VAL_RANGE_MIN();
-      if ( t == gecode_INT_VAL_RANGE_MAX)
-	return INT_VAL_RANGE_MAX();
-      if ( t == gecode_INT_VALUES_MIN)
-	return INT_VALUES_MIN();
-      if ( t == gecode_INT_VALUES_MAX)
-	return INT_VALUES_MAX();
-    }
-    cerr << "unsupported INT VAL" << endl; exit(1);
-  }
-
-  static YAP_Term gecode_FLOAT_VAL_SPLIT_MIN;
-  static YAP_Term gecode_FLOAT_VAL_SPLIT_MAX;
-
-  static inline FloatValBranch
-  gecode_FloatValBranch_from_term(YAP_Term t)
-  {
-    if (YAP_IsAtomTerm(t)) {
-      if ( t == gecode_FLOAT_VAL_SPLIT_MIN)
-	return FLOAT_VAL_SPLIT_MIN();
-      if ( t == gecode_FLOAT_VAL_SPLIT_MAX)
-	return FLOAT_VAL_SPLIT_MAX();
-    }
-    cerr << "unsupported FLOAT VAL" << endl; exit(1);
-  }
-
-  static inline FloatVal&
-  gecode_FloatVal_from_term(YAP_Term t)
-  {
-    return * (FloatVal*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline Symmetries&
-  gecode_Symmetries_from_term(YAP_Term t)
-  {
-    return * (Symmetries*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline IntBranchFilter&
-  gecode_IntBranchFilter_from_term(YAP_Term t)
-  {
-    return * (IntBranchFilter*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline BoolBranchFilter&
-  gecode_BoolBranchFilter_from_term(YAP_Term t)
-  {
-    return * (BoolBranchFilter*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline FloatBranchFilter&
-  gecode_FloatBranchFilter_from_term(YAP_Term t)
-  {
-    return * (FloatBranchFilter*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline SetVarValPrint&
-  gecode_SetVarValPrint_from_term(YAP_Term t)
-  {
-    return * (SetVarValPrint*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline IntVarValPrint&
-  gecode_IntVarValPrint_from_term(YAP_Term t)
-  {
-    return * (IntVarValPrint*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline BoolVarValPrint&
-  gecode_BoolVarValPrint_from_term(YAP_Term t)
-  {
-    return * (BoolVarValPrint*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static inline FloatVarValPrint&
-  gecode_FloatVarValPrint_from_term(YAP_Term t)
-  {
-    return * (FloatVarValPrint*) YAP_OpaqueObjectFromTerm(t);
-  }
-
-  static YAP_opaque_tag_t gecode_engine_tag;
-  static YAP_opaque_handler_t gecode_engine_handler;
-
-  static RestartMode gecode_RestartMode_from_term(YAP_Term t);
-
-  static YAP_Bool gecode_new_engine(void)
-  {
-    YAP_Term arg1 = YAP_ARG1;
-    YAP_Term arg2 = YAP_ARG2;
-    YAP_Term arg3 = YAP_ARG3;
-    bool restart = YAP_IntOfTerm(YAP_ArgOfTerm(1, arg3));
-    double threads = YAP_FloatOfTerm(YAP_ArgOfTerm(2, arg3));
-    unsigned int c_d = YAP_IntOfTerm(YAP_ArgOfTerm(3, arg3));
-    unsigned int a_d = YAP_IntOfTerm(YAP_ArgOfTerm(4, arg3));
-    unsigned int nogoods_limit = YAP_IntOfTerm(YAP_ArgOfTerm(6, arg3));
-    bool clone = ( YAP_IntOfTerm(YAP_ArgOfTerm(7, arg3)) == 0 ?  FALSE : TRUE );
-    RestartMode md;
-    YAP_Term t = YAP_ArgOfTerm(5, arg3);
-    if (YAP_IsAtomTerm(t)) {
-      md = gecode_RestartMode_from_term(t);
-    } else if (YAP_IsApplTerm(t)) {
-      md = gecode_RestartMode_from_term(YAP_MkAtomTerm(YAP_NameOfFunctor(YAP_FunctorOfTerm(t))));
+  Search::Cutoff *cutoff;
+  YAP_Term t_s, t_b;
+  switch (md) {
+  case RM_CONSTANT:
+    YAP_Term t_a;
+    if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 &&
+        YAP_IsIntTerm(t_a = YAP_ArgOfTerm(1, t))) {
+      unsigned long int a = YAP_IntOfTerm(t_a);
+      cutoff = Search::Cutoff::constant(a);
     } else {
-      cerr << "bad engine cutoff option" << endl; exit(1);
+      cerr << "bad parameter for constant" << endl;
+      exit(1);
     }
-    Search::Cutoff* cutoff;
-    YAP_Term t_s, t_b;
-    switch (md) {
-    case RM_CONSTANT:
-      YAP_Term t_a;
-      if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 &&
-	  YAP_IsIntTerm(t_a = YAP_ArgOfTerm(1,t))) {
-	unsigned long int a = YAP_IntOfTerm(t_a); 
-	cutoff = Search::Cutoff::constant(a);
-      } else {
-	cerr << "bad parameter for constant" << endl; exit(1);
-      }
-      break;
-    case RM_GEOMETRIC:
-      if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 2 &&
-	  YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1,t)) &&
-	  YAP_IsIntTerm(t_b = YAP_ArgOfTerm(2,t))) {
-	unsigned long int s = YAP_IntOfTerm(t_s); 
-	unsigned long int b = YAP_IntOfTerm(t_b); 
-	cutoff = Search::Cutoff::geometric(s,b);
-      } else {
-	cerr << "bad parameter for geometric" << endl; exit(1);
-      }
-      break;
-    case RM_LUBY:
-      if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 &&
-	  YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1,t))) {
-	unsigned long int s = YAP_IntOfTerm(t_s); 
-	cutoff = Search::Cutoff::luby(s);
-      } else {
-	cerr << "bad parameter for luby" << endl; exit(1);
-      }
-      break;
-    case RM_LINEAR:
-      if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 &&
-	  YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1,t))) {
-	unsigned long int s = YAP_IntOfTerm(t_s); 
-	cutoff = Search::Cutoff::linear(s);
-      } else {
-	cerr << "bad parameter for linear" << endl; exit(1);
-      }
-      break;
-    default:
-      cutoff = NULL;
+    break;
+  case RM_GEOMETRIC:
+    if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 2 &&
+        YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1, t)) &&
+        YAP_IsIntTerm(t_b = YAP_ArgOfTerm(2, t))) {
+      unsigned long int s = YAP_IntOfTerm(t_s);
+      unsigned long int b = YAP_IntOfTerm(t_b);
+      cutoff = Search::Cutoff::geometric(s, b);
+    } else {
+      cerr << "bad parameter for geometric" << endl;
+      exit(1);
     }
-    Search::Options opt;
-    opt.threads = threads;
-    opt.c_d = c_d;
-    opt.a_d = a_d;
-    opt.cutoff = cutoff;
-    opt.nogoods_limit = nogoods_limit;
-    opt.clone = clone;
-    opt.stop = NULL;
-    GenericSpace* space = gecode_Space_from_term(arg1);
-    GenericEngine* engine = space->new_engine(restart,opt);
-    YAP_Term y_engine =
-      YAP_NewOpaqueObject(gecode_engine_tag, sizeof(GenericEngine*));
-    GenericEngine** ptr =
-      (GenericEngine**) YAP_OpaqueObjectFromTerm(y_engine);
-    *ptr = engine;
-    return YAP_Unify(arg2, y_engine);
+    break;
+  case RM_LUBY:
+    if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 &&
+        YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1, t))) {
+      unsigned long int s = YAP_IntOfTerm(t_s);
+      cutoff = Search::Cutoff::luby(s);
+    } else {
+      cerr << "bad parameter for luby" << endl;
+      exit(1);
+    }
+    break;
+  case RM_LINEAR:
+    if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 &&
+        YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1, t))) {
+      unsigned long int s = YAP_IntOfTerm(t_s);
+      cutoff = Search::Cutoff::linear(s);
+    } else {
+      cerr << "bad parameter for linear" << endl;
+      exit(1);
+    }
+    break;
+  default:
+    cutoff = NULL;
   }
+  Search::Options opt;
+  opt.threads = threads;
+  opt.c_d = c_d;
+  opt.a_d = a_d;
+  opt.cutoff = cutoff;
+  opt.nogoods_limit = nogoods_limit;
+  opt.clone = clone;
+  opt.stop = NULL;
+  GenericSpace *space = gecode_Space_from_term(arg1);
+  GenericEngine *engine = space->new_engine(restart, opt);
+  YAP_Term y_engine =
+      YAP_NewOpaqueObject(gecode_engine_tag, sizeof(GenericEngine *));
+  GenericEngine **ptr = (GenericEngine **)YAP_OpaqueObjectFromTerm(y_engine);
+  *ptr = engine;
+  return YAP_Unify(arg2, y_engine);
+}
 
-  static inline GenericEngine*
-  gecode_engine_from_term(YAP_Term t)
-  {
-    return * (GenericEngine**) YAP_OpaqueObjectFromTerm(t);
-  }
+static inline GenericEngine *gecode_engine_from_term(YAP_Term t) {
+  return *(GenericEngine **)YAP_OpaqueObjectFromTerm(t);
+}
 
-  static YAP_Bool gecode_engine_fail_handler(void* p)
-  {
-    delete *(GenericEngine**)p;
-    return TRUE;
-  }
+static YAP_Bool gecode_engine_fail_handler(YAP_Term p) {
+  delete *(GenericEngine **)YAP_OpaqueObjectFromTerm(p);
+  return TRUE;
+}
 
-  static YAP_Bool
-  gecode_engine_write_handler
-  (FILE *stream, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<engine %p>", p);
-    return TRUE;
-  }
+static YAP_Bool gecode_engine_write_handler(FILE *stream, YAP_opaque_tag_t type,
+                                            void *p, int flags) {
+  fprintf(stream, "<engine %p>", p);
+  return TRUE;
+}
 
-  static YAP_Bool gecode_engine_search(void)
-  {
-    GenericEngine* engine = gecode_engine_from_term(YAP_ARG1);
-    GenericSpace* space = engine->next();
-    if (space)
-      {
-	YAP_Term term = gecode_term_from_space(space);
-	return YAP_Unify(YAP_ARG2, term);
-      }
-    else YAP_cut_fail();
-  }
+static YAP_Bool gecode_engine_search(void) {
+  GenericEngine *engine = gecode_engine_from_term(YAP_ARG1);
+  GenericSpace *space = engine->next();
+  if (space) {
+    YAP_Term term = gecode_term_from_space(space);
+    return YAP_Unify(YAP_ARG2, term);
+  } else
+    YAP_cut_fail();
+}
 
 #ifdef DISJUNCTOR
-  static  YAP_Bool gecode_new_disjunctor(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    YAP_Term term =
+static YAP_Bool gecode_new_disjunctor(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  YAP_Term term =
       YAP_NewOpaqueObject(gecode_disjunctor_tag, sizeof(YapDisjunctor));
-    new (YAP_OpaqueObjectFromTerm(term)) YapDisjunctor(space);
-    return YAP_Unify(result, term);
-  }
+  new (YAP_OpaqueObjectFromTerm(term)) YapDisjunctor(space);
+  return YAP_Unify(result, term);
+}
 
-  static YAP_Bool
-  gecode_disjunctor_write_handler
-  (FILE *stream, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<disjunctor %p>", p);
-    return TRUE;
-  }
+static YAP_Bool gecode_disjunctor_write_handler(FILE *stream,
+                                                YAP_opaque_tag_t type, void *p,
+                                                int flags) {
+  fprintf(stream, "<disjunctor %p>", p);
+  return TRUE;
+}
 
-  static YAP_Bool gecode_new_clause(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    YapDisjunctor& disj = gecode_YapDisjunctor_from_term(YAP_ARG2);
-    YAP_Term term =
+static YAP_Bool gecode_new_clause(void) {
+  YAP_Term result = YAP_ARG1;
+  YapDisjunctor &disj = gecode_YapDisjunctor_from_term(YAP_ARG2);
+  YAP_Term term =
       YAP_NewOpaqueObject(gecode_disjunctor_clause_tag, sizeof(Clause));
-    new (YAP_OpaqueObjectFromTerm(term)) Clause(*disj.home,disj.disj);
-    return YAP_Unify(result, term);
-  }
+  new (YAP_OpaqueObjectFromTerm(term)) Clause(*disj.home, disj.disj);
+  return YAP_Unify(result, term);
+}
 
-  static YAP_Bool
-  gecode_clause_write_handler
-  (FILE *stream_, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<clause %p>", p);
-    return TRUE;
-  }
+static YAP_Bool gecode_clause_write_handler(FILE *stream_,
+                                            YAP_opaque_tag_t type, void *p,
+                                            int flags) {
+  fprintf(stream, "<clause %p>", p);
+  return TRUE;
+}
 
-  static IntVar gecode_IntVar_from_term(GenericSpace*,YAP_Term);
-  static BoolVar gecode_BoolVar_from_term(GenericSpace*,YAP_Term);
-  static FloatVar gecode_FloatVar_from_term(GenericSpace*,YAP_Term);
-  static SetVar gecode_SetVar_from_term(GenericSpace*,YAP_Term);
+static IntVar gecode_IntVar_from_term(GenericSpace *, YAP_Term);
+static BoolVar gecode_BoolVar_from_term(GenericSpace *, YAP_Term);
+static FloatVar gecode_FloatVar_from_term(GenericSpace *, YAP_Term);
+static SetVar gecode_SetVar_from_term(GenericSpace *, YAP_Term);
 
-  static YAP_Bool gecode_clause_intvar_forward(void)
-  {
-    Clause& clause = gecode_Clause_from_term(YAP_ARG1);
-    GenericSpace* outer = clause.generic_parent();
-    GenericSpace* inner = clause.generic_space();
-    IntVar outer_var = gecode_IntVar_from_term(outer, YAP_ARG2);
-    IntVar inner_var = gecode_IntVar_from_term(inner, YAP_ARG3);
-    clause.forward(outer_var,inner_var);
-    return TRUE;
-  }
+static YAP_Bool gecode_clause_intvar_forward(void) {
+  Clause &clause = gecode_Clause_from_term(YAP_ARG1);
+  GenericSpace *outer = clause.generic_parent();
+  GenericSpace *inner = clause.generic_space();
+  IntVar outer_var = gecode_IntVar_from_term(outer, YAP_ARG2);
+  IntVar inner_var = gecode_IntVar_from_term(inner, YAP_ARG3);
+  clause.forward(outer_var, inner_var);
+  return TRUE;
+}
 
-  static YAP_Bool gecode_clause_boolvar_forward(void)
-  {
-    Clause& clause = gecode_Clause_from_term(YAP_ARG1);
-    GenericSpace* outer = clause.generic_parent();
-    GenericSpace* inner = clause.generic_space();
-    BoolVar outer_var = gecode_BoolVar_from_term(outer, YAP_ARG2);
-    BoolVar inner_var = gecode_BoolVar_from_term(inner, YAP_ARG3);
-    clause.forward(outer_var,inner_var);
-    return TRUE;
-  }
+static YAP_Bool gecode_clause_boolvar_forward(void) {
+  Clause &clause = gecode_Clause_from_term(YAP_ARG1);
+  GenericSpace *outer = clause.generic_parent();
+  GenericSpace *inner = clause.generic_space();
+  BoolVar outer_var = gecode_BoolVar_from_term(outer, YAP_ARG2);
+  BoolVar inner_var = gecode_BoolVar_from_term(inner, YAP_ARG3);
+  clause.forward(outer_var, inner_var);
+  return TRUE;
+}
 
-  static YAP_Bool gecode_clause_setvar_forward(void)
-  {
-    Clause& clause = gecode_Clause_from_term(YAP_ARG1);
-    GenericSpace* outer = clause.generic_parent();
-    GenericSpace* inner = clause.generic_space();
-    SetVar outer_var = gecode_SetVar_from_term(outer, YAP_ARG2);
-    SetVar inner_var = gecode_SetVar_from_term(inner, YAP_ARG3);
-    clause.forward(outer_var,inner_var);
-    return TRUE;
-  }
+static YAP_Bool gecode_clause_setvar_forward(void) {
+  Clause &clause = gecode_Clause_from_term(YAP_ARG1);
+  GenericSpace *outer = clause.generic_parent();
+  GenericSpace *inner = clause.generic_space();
+  SetVar outer_var = gecode_SetVar_from_term(outer, YAP_ARG2);
+  SetVar inner_var = gecode_SetVar_from_term(inner, YAP_ARG3);
+  clause.forward(outer_var, inner_var);
+  return TRUE;
+}
 #endif
 
-  static YAP_Bool gecode_new_intvar_from_bounds(void)
-  {
-    YAP_Term ivar = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int lo = YAP_IntOfTerm(YAP_ARG3);
-    int hi = YAP_IntOfTerm(YAP_ARG4);
-    int i = space->new_ivar(lo, hi);
-    YAP_Term y_i = YAP_MkIntTerm(i);
-    return YAP_Unify(ivar, y_i);
-  }
+static YAP_Bool gecode_new_intvar_from_bounds(void) {
+  YAP_Term ivar = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int lo = YAP_IntOfTerm(YAP_ARG3);
+  int hi = YAP_IntOfTerm(YAP_ARG4);
+  int i = space->new_ivar(lo, hi);
+  YAP_Term y_i = YAP_MkIntTerm(i);
+  return YAP_Unify(ivar, y_i);
+}
 
-  static YAP_Bool gecode_new_floatvar_from_bounds(void)
-  {
-    YAP_Term ivar = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    double lo = YAP_FloatOfTerm(YAP_ARG3);
-    double hi = YAP_FloatOfTerm(YAP_ARG4);
-    int i = space->new_fvar(lo, hi);
-    YAP_Term y_i = YAP_MkIntTerm(i);
-    return YAP_Unify(ivar, y_i);
-  }
+static YAP_Bool gecode_new_floatvar_from_bounds(void) {
+  YAP_Term ivar = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  double lo = YAP_FloatOfTerm(YAP_ARG3);
+  double hi = YAP_FloatOfTerm(YAP_ARG4);
+  int i = space->new_fvar(lo, hi);
+  YAP_Term y_i = YAP_MkIntTerm(i);
+  return YAP_Unify(ivar, y_i);
+}
 
-  static int
-  gecode_list_length(YAP_Term l)
-  {
-    int n = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	n += 1;
-	l = YAP_TailOfTerm(l);
-      }
-    return n;
+static int gecode_list_length(YAP_Term l) {
+  int n = 0;
+  while (YAP_IsPairTerm(l)) {
+    n += 1;
+    l = YAP_TailOfTerm(l);
   }
+  return n;
+}
 
-  static IntSet
-  gecode_IntSet_from_term(YAP_Term specs)
+static IntSet gecode_IntSet_from_term(YAP_Term specs) {
+  int n = gecode_list_length(specs);
+  SPECARRAY(r, n);
+  int i = 0;
+  while (YAP_IsPairTerm(specs)) {
+    YAP_Term head = YAP_HeadOfTerm(specs);
+    specs = YAP_TailOfTerm(specs);
+    SPECARRAYELEM(r, i, 0) = YAP_IntOfTerm(YAP_ArgOfTerm(1, head));
+    SPECARRAYELEM(r, i, 1) = YAP_IntOfTerm(YAP_ArgOfTerm(2, head));
+    i += 1;
+  }
+  return IntSet(SPECARRAYDEREF(r), n);
+}
+
+static YAP_Bool gecode_new_intvar_from_intset(void) {
+  YAP_Term ivar = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  YAP_Term specs = YAP_ARG3;
+  IntSet iset = gecode_IntSet_from_term(specs);
+  int i = space->new_ivar(iset);
+  return YAP_Unify(ivar, YAP_MkIntTerm(i));
+}
+
+static YAP_Bool gecode_new_boolvar(void) {
+  YAP_Term bvar = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int i = space->new_bvar();
+  return YAP_Unify(bvar, YAP_MkIntTerm(i));
+}
+
+static YAP_Bool gecode_new_setvar_1(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int GlbMin = YAP_IntOfTerm(YAP_ARG3);
+  int GlbMax = YAP_IntOfTerm(YAP_ARG4);
+  int LubMin = YAP_IntOfTerm(YAP_ARG5);
+  int LubMax = YAP_IntOfTerm(YAP_ARG6);
+  int CardMin = YAP_IntOfTerm(YAP_ARG7);
+  int CardMax = YAP_IntOfTerm(YAP_ARG8);
+  int idx = space->new_svar(GlbMin, GlbMax, LubMin, LubMax, CardMin, CardMax);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_2(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int GlbMin = YAP_IntOfTerm(YAP_ARG3);
+  int GlbMax = YAP_IntOfTerm(YAP_ARG4);
+  int LubMin = YAP_IntOfTerm(YAP_ARG5);
+  int LubMax = YAP_IntOfTerm(YAP_ARG6);
+  int CardMin = YAP_IntOfTerm(YAP_ARG7);
+  int idx = space->new_svar(GlbMin, GlbMax, LubMin, LubMax, CardMin);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_3(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int GlbMin = YAP_IntOfTerm(YAP_ARG3);
+  int GlbMax = YAP_IntOfTerm(YAP_ARG4);
+  int LubMin = YAP_IntOfTerm(YAP_ARG5);
+  int LubMax = YAP_IntOfTerm(YAP_ARG6);
+  int idx = space->new_svar(GlbMin, GlbMax, LubMin, LubMax);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_4(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
+  int LubMin = YAP_IntOfTerm(YAP_ARG4);
+  int LubMax = YAP_IntOfTerm(YAP_ARG5);
+  int CardMin = YAP_IntOfTerm(YAP_ARG6);
+  int CardMax = YAP_IntOfTerm(YAP_ARG7);
+  int idx = space->new_svar(Glb, LubMin, LubMax, CardMin, CardMax);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_5(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
+  int LubMin = YAP_IntOfTerm(YAP_ARG4);
+  int LubMax = YAP_IntOfTerm(YAP_ARG5);
+  int CardMin = YAP_IntOfTerm(YAP_ARG6);
+  int idx = space->new_svar(Glb, LubMin, LubMax, CardMin);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_6(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
+  int LubMin = YAP_IntOfTerm(YAP_ARG4);
+  int LubMax = YAP_IntOfTerm(YAP_ARG5);
+  int idx = space->new_svar(Glb, LubMin, LubMax);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_7(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int GlbMin = YAP_IntOfTerm(YAP_ARG3);
+  int GlbMax = YAP_IntOfTerm(YAP_ARG4);
+  IntSet Lub = gecode_IntSet_from_term(YAP_ARG5);
+  int CardMin = YAP_IntOfTerm(YAP_ARG6);
+  int CardMax = YAP_IntOfTerm(YAP_ARG7);
+  int idx = space->new_svar(GlbMin, GlbMax, Lub, CardMin, CardMax);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_8(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int GlbMin = YAP_IntOfTerm(YAP_ARG3);
+  int GlbMax = YAP_IntOfTerm(YAP_ARG4);
+  IntSet Lub = gecode_IntSet_from_term(YAP_ARG5);
+  int CardMin = YAP_IntOfTerm(YAP_ARG6);
+  int idx = space->new_svar(GlbMin, GlbMax, Lub, CardMin);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_9(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  int GlbMin = YAP_IntOfTerm(YAP_ARG3);
+  int GlbMax = YAP_IntOfTerm(YAP_ARG4);
+  IntSet Lub = gecode_IntSet_from_term(YAP_ARG5);
+  int idx = space->new_svar(GlbMin, GlbMax, Lub);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_10(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
+  IntSet Lub = gecode_IntSet_from_term(YAP_ARG4);
+  int CardMin = YAP_IntOfTerm(YAP_ARG5);
+  int CardMax = YAP_IntOfTerm(YAP_ARG6);
+  int idx = space->new_svar(Glb, Lub, CardMin, CardMax);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_11(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
+  IntSet Lub = gecode_IntSet_from_term(YAP_ARG4);
+  int CardMin = YAP_IntOfTerm(YAP_ARG5);
+  int idx = space->new_svar(Glb, Lub, CardMin);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_new_setvar_12(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
+  IntSet Lub = gecode_IntSet_from_term(YAP_ARG4);
+  int idx = space->new_svar(Glb, Lub);
+  return YAP_Unify(result, YAP_MkIntTerm(idx));
+}
+
+static YAP_Bool gecode_space_minimize(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  int i = YAP_IntOfTerm(YAP_ARG2);
+  space->minimize(i);
+  return TRUE;
+}
+
+static YAP_Bool gecode_space_maximize(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  int i = YAP_IntOfTerm(YAP_ARG2);
+  space->maximize(i);
+  return TRUE;
+}
+
+static YAP_Bool gecode_space_minimize_ratio(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  int i = YAP_IntOfTerm(YAP_ARG2);
+  int j = YAP_IntOfTerm(YAP_ARG3);
+  space->minimize(i, j);
+  return TRUE;
+}
+
+static YAP_Bool gecode_space_maximize_ratio(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  int i = YAP_IntOfTerm(YAP_ARG2);
+  int j = YAP_IntOfTerm(YAP_ARG3);
+  space->maximize(i, j);
+  return TRUE;
+}
+
+static IntVar gecode_IntVar_from_term(GenericSpace *space, YAP_Term x) {
+  int i = YAP_IntOfTerm(x);
+  return space->get_ivar(i);
+}
+
+static BoolVar gecode_BoolVar_from_term(GenericSpace *space, YAP_Term x) {
+  int i = YAP_IntOfTerm(x);
+  return space->get_bvar(i);
+}
+
+static SetVar gecode_SetVar_from_term(GenericSpace *space, YAP_Term x) {
+  int i = YAP_IntOfTerm(x);
+  return space->get_svar(i);
+}
+
+static IntVarArgs gecode_IntVarArgs_from_term(GenericSpace *space, YAP_Term l) {
+  int n = gecode_list_length(l);
+  IntVarArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
+    v[i] = space->get_ivar(idx);
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static BoolVarArgs gecode_BoolVarArgs_from_term(GenericSpace *space,
+                                                YAP_Term l) {
+  int n = gecode_list_length(l);
+  BoolVarArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
+    v[i] = space->get_bvar(idx);
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static FloatVar gecode_FloatVar_from_term(GenericSpace *space, YAP_Term x) {
+  int i = YAP_IntOfTerm(x);
+  return space->get_fvar(i);
+}
+
+static FloatVarArgs gecode_FloatVarArgs_from_term(GenericSpace *space,
+                                                  YAP_Term l) {
+  int n = gecode_list_length(l);
+  FloatVarArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
+    v[i] = space->get_fvar(idx);
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static FloatValArgs gecode_FloatValArgs_from_term(YAP_Term l) {
+  int n = gecode_list_length(l);
+  FloatValArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    YAP_Term t = YAP_HeadOfTerm(l);
+    v[i] = *(FloatVal *)YAP_OpaqueObjectFromTerm(t);
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static SetVarArgs gecode_SetVarArgs_from_term(GenericSpace *space, YAP_Term l) {
+  int n = gecode_list_length(l);
+  SetVarArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
+    v[i] = space->get_svar(idx);
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static IntArgs gecode_IntArgs_from_term(YAP_Term l) {
+  int n = gecode_list_length(l);
+  IntArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
+    v[i] = idx;
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static IntSetArgs gecode_IntSetArgs_from_term(YAP_Term l) {
+  int n = gecode_list_length(l);
+  IntSetArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    IntSet s = gecode_IntSet_from_term(YAP_HeadOfTerm(l));
+    v[i] = s;
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static TaskType gecode_TaskType_from_term(YAP_Term);
+
+static TaskTypeArgs gecode_TaskTypeArgs_from_term(YAP_Term l) {
+  int n = gecode_list_length(l);
+  TaskTypeArgs v(n);
+  int i = 0;
+  while (YAP_IsPairTerm(l)) {
+    TaskType tt = gecode_TaskType_from_term(YAP_HeadOfTerm(l));
+    v[i] = tt;
+    l = YAP_TailOfTerm(l);
+    i += 1;
+  }
+  return v;
+}
+
+static YAP_Term gecode_TRUE;
+static YAP_Term gecode_FALSE;
+
+static bool gecode_bool_from_term(YAP_Term X) {
+  if (X == gecode_TRUE)
+    return true;
+  if (X == gecode_FALSE)
+    return false;
+  cerr << "this should never happen" << endl;
+  exit(1);
+}
+
+static YAP_Bool gecode_space_use_keep_index(void) {
+  YAP_Term arg1 = YAP_ARG1;
+  YAP_Term arg2 = YAP_ARG2;
+  GenericSpace *space = gecode_Space_from_term(arg1);
+  return YAP_Unify(arg2,
+                   (space->use_keep_index() ? gecode_TRUE : gecode_FALSE));
+}
+
+static YAP_Bool gecode_intvar_keep(void) {
+  YAP_Term arg1 = YAP_ARG1;
+  YAP_Term arg2 = YAP_ARG2;
+  YAP_Term arg3 = YAP_ARG3;
+  GenericSpace *space = gecode_Space_from_term(arg1);
+  int idx = YAP_IntOfTerm(arg2);
+  int kidx = space->keep_ivar(idx);
+  return YAP_Unify(arg3, YAP_MkIntTerm(kidx));
+}
+
+static YAP_Bool gecode_boolvar_keep(void) {
+  YAP_Term arg1 = YAP_ARG1;
+  YAP_Term arg2 = YAP_ARG2;
+  YAP_Term arg3 = YAP_ARG3;
+  GenericSpace *space = gecode_Space_from_term(arg1);
+  int idx = YAP_IntOfTerm(arg2);
+  int kidx = space->keep_bvar(idx);
+  return YAP_Unify(arg3, YAP_MkIntTerm(kidx));
+}
+
+static YAP_Bool gecode_setvar_keep(void) {
+  YAP_Term arg1 = YAP_ARG1;
+  YAP_Term arg2 = YAP_ARG2;
+  YAP_Term arg3 = YAP_ARG3;
+  GenericSpace *space = gecode_Space_from_term(arg1);
+  int idx = YAP_IntOfTerm(arg2);
+  int kidx = space->keep_svar(idx);
+  return YAP_Unify(arg3, YAP_MkIntTerm(kidx));
+}
+
+// INFO ON INTVARS
+static YAP_Bool gecode_intvar_assigned(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG2);
+  return (x.assigned()) ? TRUE : FALSE;
+}
+
+static YAP_Bool gecode_intvar_min(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.min()));
+}
+
+static YAP_Bool gecode_intvar_max(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.max()));
+}
+
+static YAP_Bool gecode_intvar_med(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.med()));
+}
+
+static YAP_Bool gecode_intvar_val(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.val()));
+}
+
+static YAP_Bool gecode_intvar_size(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.size()));
+}
+
+static YAP_Bool gecode_intvar_width(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.width()));
+}
+
+static YAP_Bool gecode_intvar_regret_min(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.regret_min()));
+}
+
+static YAP_Bool gecode_intvar_regret_max(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.regret_max()));
+}
+
+static YAP_Functor gecode_COMMA2;
+
+static YAP_Bool gecode_intvar_ranges(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  int n = 0;
   {
-    int n = gecode_list_length(specs);
-    SPECARRAY(r,n);
+    IntVarRanges it(x);
+    while (it()) {
+      ++n;
+      ++it;
+    }
+  }
+  DYNARRAY(int, min, n);
+  DYNARRAY(int, max, n);
+  {
+    IntVarRanges it(x);
     int i = 0;
-    while (YAP_IsPairTerm(specs))
-      {
-	YAP_Term head = YAP_HeadOfTerm(specs);
-	specs = YAP_TailOfTerm(specs);
-	SPECARRAYELEM(r,i,0) = YAP_IntOfTerm(YAP_ArgOfTerm(1, head));
-	SPECARRAYELEM(r,i,1) = YAP_IntOfTerm(YAP_ArgOfTerm(2, head));
-	i += 1;
-      }
-    return IntSet(SPECARRAYDEREF(r), n);
+    while (it()) {
+      min[i] = it.min();
+      max[i] = it.max();
+      ++it;
+      ++i;
+    }
   }
-
-  static YAP_Bool gecode_new_intvar_from_intset(void)
-  {
-    YAP_Term ivar = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    YAP_Term specs = YAP_ARG3;
-    IntSet iset = gecode_IntSet_from_term(specs);
-    int i = space->new_ivar(iset);
-    return YAP_Unify(ivar, YAP_MkIntTerm(i));
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;) {
+    YAP_Term args[2];
+    args[0] = YAP_MkIntTerm(min[n]);
+    args[1] = YAP_MkIntTerm(max[n]);
+    YAP_Term range = YAP_MkApplTerm(gecode_COMMA2, 2, args);
+    lst = YAP_MkPairTerm(range, lst);
   }
+  return YAP_Unify(result, lst);
+}
 
-  static YAP_Bool gecode_new_boolvar(void)
+static YAP_Bool gecode_intvar_values(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
+  int n = x.size();
+  DYNARRAY(int, a, n);
   {
-    YAP_Term bvar = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int i = space->new_bvar();
-    return YAP_Unify(bvar, YAP_MkIntTerm(i));
-  }
-
-  static YAP_Bool gecode_new_setvar_1(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int GlbMin = YAP_IntOfTerm(YAP_ARG3);
-    int GlbMax = YAP_IntOfTerm(YAP_ARG4);
-    int LubMin = YAP_IntOfTerm(YAP_ARG5);
-    int LubMax = YAP_IntOfTerm(YAP_ARG6);
-    int CardMin= YAP_IntOfTerm(YAP_ARG7);
-    int CardMax= YAP_IntOfTerm(YAP_ARG8);
-    int idx = space->new_svar(GlbMin,GlbMax,LubMin,LubMax,CardMin,CardMax);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_2(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int GlbMin = YAP_IntOfTerm(YAP_ARG3);
-    int GlbMax = YAP_IntOfTerm(YAP_ARG4);
-    int LubMin = YAP_IntOfTerm(YAP_ARG5);
-    int LubMax = YAP_IntOfTerm(YAP_ARG6);
-    int CardMin= YAP_IntOfTerm(YAP_ARG7);
-    int idx = space->new_svar(GlbMin,GlbMax,LubMin,LubMax,CardMin);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_3(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int GlbMin = YAP_IntOfTerm(YAP_ARG3);
-    int GlbMax = YAP_IntOfTerm(YAP_ARG4);
-    int LubMin = YAP_IntOfTerm(YAP_ARG5);
-    int LubMax = YAP_IntOfTerm(YAP_ARG6);
-    int idx = space->new_svar(GlbMin,GlbMax,LubMin,LubMax);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_4(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
-    int LubMin = YAP_IntOfTerm(YAP_ARG4);
-    int LubMax = YAP_IntOfTerm(YAP_ARG5);
-    int CardMin = YAP_IntOfTerm(YAP_ARG6);
-    int CardMax = YAP_IntOfTerm(YAP_ARG7);
-    int idx = space->new_svar(Glb,LubMin,LubMax,CardMin,CardMax);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_5(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
-    int LubMin = YAP_IntOfTerm(YAP_ARG4);
-    int LubMax = YAP_IntOfTerm(YAP_ARG5);
-    int CardMin = YAP_IntOfTerm(YAP_ARG6);
-    int idx = space->new_svar(Glb,LubMin,LubMax,CardMin);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_6(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
-    int LubMin = YAP_IntOfTerm(YAP_ARG4);
-    int LubMax = YAP_IntOfTerm(YAP_ARG5);
-    int idx = space->new_svar(Glb,LubMin,LubMax);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_7(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int GlbMin = YAP_IntOfTerm(YAP_ARG3);
-    int GlbMax = YAP_IntOfTerm(YAP_ARG4);
-    IntSet Lub = gecode_IntSet_from_term(YAP_ARG5);
-    int CardMin = YAP_IntOfTerm(YAP_ARG6);
-    int CardMax = YAP_IntOfTerm(YAP_ARG7);
-    int idx = space->new_svar(GlbMin,GlbMax,Lub,CardMin,CardMax);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_8(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int GlbMin = YAP_IntOfTerm(YAP_ARG3);
-    int GlbMax = YAP_IntOfTerm(YAP_ARG4);
-    IntSet Lub = gecode_IntSet_from_term(YAP_ARG5);
-    int CardMin = YAP_IntOfTerm(YAP_ARG6);
-    int idx = space->new_svar(GlbMin,GlbMax,Lub,CardMin);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_9(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    int GlbMin = YAP_IntOfTerm(YAP_ARG3);
-    int GlbMax = YAP_IntOfTerm(YAP_ARG4);
-    IntSet Lub = gecode_IntSet_from_term(YAP_ARG5);
-    int idx = space->new_svar(GlbMin,GlbMax,Lub);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_10(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
-    IntSet Lub = gecode_IntSet_from_term(YAP_ARG4);
-    int CardMin = YAP_IntOfTerm(YAP_ARG5);
-    int CardMax = YAP_IntOfTerm(YAP_ARG6);
-    int idx = space->new_svar(Glb,Lub,CardMin,CardMax);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_11(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
-    IntSet Lub = gecode_IntSet_from_term(YAP_ARG4);
-    int CardMin = YAP_IntOfTerm(YAP_ARG5);
-    int idx = space->new_svar(Glb,Lub,CardMin);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_new_setvar_12(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntSet Glb = gecode_IntSet_from_term(YAP_ARG3);
-    IntSet Lub = gecode_IntSet_from_term(YAP_ARG4);
-    int idx = space->new_svar(Glb,Lub);
-    return YAP_Unify(result, YAP_MkIntTerm(idx));
-  }
-
-  static YAP_Bool gecode_space_minimize(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    int i = YAP_IntOfTerm(YAP_ARG2);
-    space->minimize(i);
-    return TRUE;
-  }
-
-  static YAP_Bool gecode_space_maximize(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    int i = YAP_IntOfTerm(YAP_ARG2);
-    space->maximize(i);
-    return TRUE;
-  }
-
-  static YAP_Bool gecode_space_minimize_ratio(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    int i = YAP_IntOfTerm(YAP_ARG2);
-    int j = YAP_IntOfTerm(YAP_ARG3);
-    space->minimize(i,j);
-    return TRUE;
-  }
-
-  static YAP_Bool gecode_space_maximize_ratio(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    int i = YAP_IntOfTerm(YAP_ARG2);
-    int j = YAP_IntOfTerm(YAP_ARG3);
-    space->maximize(i,j);
-    return TRUE;
-  }
-
-  static IntVar
-  gecode_IntVar_from_term(GenericSpace* space, YAP_Term x)
-  {
-    int i = YAP_IntOfTerm(x);
-    return space->get_ivar(i);
-  }
-
-  static BoolVar
-  gecode_BoolVar_from_term(GenericSpace* space, YAP_Term x)
-  {
-    int i = YAP_IntOfTerm(x);
-    return space->get_bvar(i);
-  }
-
-  static SetVar
-  gecode_SetVar_from_term(GenericSpace* space, YAP_Term x)
-  {
-    int i = YAP_IntOfTerm(x);
-    return space->get_svar(i);
-  }
-
-  static IntVarArgs
-  gecode_IntVarArgs_from_term(GenericSpace* space, YAP_Term l)
-  {
-    int n = gecode_list_length(l);
-    IntVarArgs v(n);
+    IntVarValues it(x);
     int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
-	v[i] = space->get_ivar(idx);
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+    while (it()) {
+      a[i] = it.val();
+      ++it;
+      ++i;
+    }
   }
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;) {
+    lst = YAP_MkPairTerm(YAP_MkIntTerm(a[n]), lst);
+  }
+  return YAP_Unify(result, lst);
+}
 
-  static BoolVarArgs
-  gecode_BoolVarArgs_from_term(GenericSpace* space, YAP_Term l)
+// INFO ON BOOLVARS
+static YAP_Bool gecode_boolvar_assigned(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG2);
+  return (x.assigned()) ? TRUE : FALSE;
+}
+
+static YAP_Bool gecode_boolvar_min(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.min()));
+}
+
+static YAP_Bool gecode_boolvar_max(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.max()));
+}
+
+static YAP_Bool gecode_boolvar_med(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.med()));
+}
+
+static YAP_Bool gecode_boolvar_val(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.val()));
+}
+
+static YAP_Bool gecode_boolvar_size(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.size()));
+}
+
+static YAP_Bool gecode_boolvar_width(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.width()));
+}
+
+static YAP_Bool gecode_boolvar_regret_min(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.regret_min()));
+}
+
+static YAP_Bool gecode_boolvar_regret_max(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.regret_max()));
+}
+
+// INFO ON SETVARS
+static YAP_Bool gecode_setvar_assigned(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG2);
+  return (x.assigned()) ? TRUE : FALSE;
+}
+
+static YAP_Bool gecode_setvar_glbSize(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.glbSize()));
+}
+
+static YAP_Bool gecode_setvar_lubSize(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.lubSize()));
+}
+
+static YAP_Bool gecode_setvar_unknownSize(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.unknownSize()));
+}
+
+static YAP_Bool gecode_setvar_cardMin(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.cardMin()));
+}
+
+static YAP_Bool gecode_setvar_cardMax(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.cardMax()));
+}
+
+static YAP_Bool gecode_setvar_lubMin(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.lubMin()));
+}
+
+static YAP_Bool gecode_setvar_lubMax(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.lubMax()));
+}
+
+static YAP_Bool gecode_setvar_glbMin(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.glbMin()));
+}
+
+static YAP_Bool gecode_setvar_glbMax(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkIntTerm(x.glbMax()));
+}
+
+static YAP_Bool gecode_setvar_glb_ranges(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  int n = 0;
   {
-    int n = gecode_list_length(l);
-    BoolVarArgs v(n);
+    SetVarGlbRanges it(x);
+    while (it()) {
+      ++n;
+      ++it;
+    }
+  }
+  DYNARRAY(int, min, n);
+  DYNARRAY(int, max, n);
+  {
+    SetVarGlbRanges it(x);
     int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
-	v[i] = space->get_bvar(idx);
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+    while (it()) {
+      min[i] = it.min();
+      max[i] = it.max();
+      ++it;
+      ++i;
+    }
   }
-
-  static FloatVar
-  gecode_FloatVar_from_term(GenericSpace* space, YAP_Term x)
-  {
-    int i = YAP_IntOfTerm(x);
-    return space->get_fvar(i);
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;) {
+    YAP_Term args[2];
+    args[0] = YAP_MkIntTerm(min[n]);
+    args[1] = YAP_MkIntTerm(max[n]);
+    YAP_Term range = YAP_MkApplTerm(gecode_COMMA2, 2, args);
+    lst = YAP_MkPairTerm(range, lst);
   }
+  return YAP_Unify(result, lst);
+}
 
-  static FloatVarArgs
-  gecode_FloatVarArgs_from_term(GenericSpace* space, YAP_Term l)
+static YAP_Bool gecode_setvar_lub_ranges(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  int n = 0;
   {
-    int n = gecode_list_length(l);
-    FloatVarArgs v(n);
+    SetVarLubRanges it(x);
+    while (it()) {
+      ++n;
+      ++it;
+    }
+  }
+  DYNARRAY(int, min, n);
+  DYNARRAY(int, max, n);
+  {
+    SetVarLubRanges it(x);
     int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
-	v[i] = space->get_fvar(idx);
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+    while (it()) {
+      min[i] = it.min();
+      max[i] = it.max();
+      ++it;
+      ++i;
+    }
   }
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;) {
+    YAP_Term args[2];
+    args[0] = YAP_MkIntTerm(min[n]);
+    args[1] = YAP_MkIntTerm(max[n]);
+    YAP_Term range = YAP_MkApplTerm(gecode_COMMA2, 2, args);
+    lst = YAP_MkPairTerm(range, lst);
+  }
+  return YAP_Unify(result, lst);
+}
 
-  static FloatValArgs
-  gecode_FloatValArgs_from_term(YAP_Term l)
+static YAP_Bool gecode_setvar_unknown_ranges(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  int n = 0;
   {
-    int n = gecode_list_length(l);
-    FloatValArgs v(n);
+    SetVarUnknownRanges it(x);
+    while (it()) {
+      ++n;
+      ++it;
+    }
+  }
+  DYNARRAY(int, min, n);
+  DYNARRAY(int, max, n);
+  {
+    SetVarUnknownRanges it(x);
     int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	YAP_Term t = YAP_HeadOfTerm(l);
-	v[i] = * (FloatVal*) YAP_OpaqueObjectFromTerm(t);
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+    while (it()) {
+      min[i] = it.min();
+      max[i] = it.max();
+      ++it;
+      ++i;
+    }
   }
-
-  static SetVarArgs
-  gecode_SetVarArgs_from_term(GenericSpace* space, YAP_Term l)
-  {
-    int n = gecode_list_length(l);
-    SetVarArgs v(n);
-    int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
-	v[i] = space->get_svar(idx);
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;) {
+    YAP_Term args[2];
+    args[0] = YAP_MkIntTerm(min[n]);
+    args[1] = YAP_MkIntTerm(max[n]);
+    YAP_Term range = YAP_MkApplTerm(gecode_COMMA2, 2, args);
+    lst = YAP_MkPairTerm(range, lst);
   }
+  return YAP_Unify(result, lst);
+}
 
-  static IntArgs
-  gecode_IntArgs_from_term(YAP_Term l)
-  {
-    int n = gecode_list_length(l);
-    IntArgs v(n);
-    int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l));
-	v[i] = idx;
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+static YAP_Bool gecode_setvar_glb_values(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  DYNARRAY(YAP_Term, elems, x.glbSize());
+  SetVarGlbValues it(x);
+  int n = 0;
+  while (it()) {
+    elems[n] = YAP_MkIntTerm(it.val());
+    ++it;
+    ++n;
   }
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;)
+    lst = YAP_MkPairTerm(elems[n], lst);
+  return YAP_Unify(result, lst);
+}
 
-  static IntSetArgs
-  gecode_IntSetArgs_from_term(YAP_Term l)
-  {
-    int n = gecode_list_length(l);
-    IntSetArgs v(n);
-    int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	IntSet s = gecode_IntSet_from_term(YAP_HeadOfTerm(l));
-	v[i] = s;
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+static YAP_Bool gecode_setvar_lub_values(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  DYNARRAY(YAP_Term, elems, x.lubSize());
+  SetVarLubValues it(x);
+  int n = 0;
+  while (it()) {
+    elems[n] = YAP_MkIntTerm(it.val());
+    ++it;
+    ++n;
   }
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;)
+    lst = YAP_MkPairTerm(elems[n], lst);
+  return YAP_Unify(result, lst);
+}
 
-  static TaskType gecode_TaskType_from_term(YAP_Term);
-
-  static TaskTypeArgs
-  gecode_TaskTypeArgs_from_term(YAP_Term l)
-  {
-    int n = gecode_list_length(l);
-    TaskTypeArgs v(n);
-    int i = 0;
-    while (YAP_IsPairTerm(l))
-      {
-	TaskType tt = gecode_TaskType_from_term(YAP_HeadOfTerm(l));
-	v[i] = tt;
-	l = YAP_TailOfTerm(l);
-	i += 1;
-      }
-    return v;
+static YAP_Bool gecode_setvar_unknown_values(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
+  DYNARRAY(YAP_Term, elems, x.unknownSize());
+  SetVarUnknownValues it(x);
+  int n = 0;
+  while (it()) {
+    elems[n] = YAP_MkIntTerm(it.val());
+    ++it;
+    ++n;
   }
+  YAP_Term lst = YAP_TermNil();
+  for (; n--;)
+    lst = YAP_MkPairTerm(elems[n], lst);
+  return YAP_Unify(result, lst);
+}
 
-  static YAP_Term gecode_TRUE;
-  static YAP_Term gecode_FALSE;
+// INFO ON FLOATVARS
+static YAP_Bool gecode_floatvar_assigned(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG2);
+  return (x.assigned()) ? TRUE : FALSE;
+}
 
-  static bool
-  gecode_bool_from_term(YAP_Term X)
-  {
-    if (X==gecode_TRUE) return true;
-    if (X==gecode_FALSE) return false;
-    cerr << "this should never happen" << endl; exit(1);
-  }
+static YAP_Bool gecode_floatvar_min(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkFloatTerm(x.min()));
+}
 
-  static YAP_Bool gecode_space_use_keep_index(void)
-  {
-    YAP_Term arg1 = YAP_ARG1;
-    YAP_Term arg2 = YAP_ARG2;
-    GenericSpace* space = gecode_Space_from_term(arg1);
-    return YAP_Unify(arg2,(space->use_keep_index()
-			   ?gecode_TRUE:gecode_FALSE));
-  }
+static YAP_Bool gecode_floatvar_max(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkFloatTerm(x.max()));
+}
 
-  static YAP_Bool gecode_intvar_keep(void)
-  {
-    YAP_Term arg1 = YAP_ARG1;
-    YAP_Term arg2 = YAP_ARG2;
-    YAP_Term arg3 = YAP_ARG3;
-    GenericSpace* space = gecode_Space_from_term(arg1);
-    int idx = YAP_IntOfTerm(arg2);
-    int kidx = space->keep_ivar(idx);
-    return YAP_Unify(arg3,YAP_MkIntTerm(kidx));
-  }
+static YAP_Bool gecode_floatvar_med(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkFloatTerm(x.med()));
+}
 
-  static YAP_Bool gecode_boolvar_keep(void)
-  {
-    YAP_Term arg1 = YAP_ARG1;
-    YAP_Term arg2 = YAP_ARG2;
-    YAP_Term arg3 = YAP_ARG3;
-    GenericSpace* space = gecode_Space_from_term(arg1);
-    int idx = YAP_IntOfTerm(arg2);
-    int kidx = space->keep_bvar(idx);
-    return YAP_Unify(arg3,YAP_MkIntTerm(kidx));
-  }
+static YAP_Bool gecode_floatvar_size(void) {
+  YAP_Term result = YAP_ARG1;
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG2);
+  FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
+  return YAP_Unify(result, YAP_MkFloatTerm(x.size()));
+}
 
-  static YAP_Bool gecode_setvar_keep(void)
-  {
-    YAP_Term arg1 = YAP_ARG1;
-    YAP_Term arg2 = YAP_ARG2;
-    YAP_Term arg3 = YAP_ARG3;
-    GenericSpace* space = gecode_Space_from_term(arg1);
-    int idx = YAP_IntOfTerm(arg2);
-    int kidx = space->keep_svar(idx);
-    return YAP_Unify(arg3,YAP_MkIntTerm(kidx));
-  }
-
-  // INFO ON INTVARS
-  static YAP_Bool gecode_intvar_assigned(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG2);
-    return (x.assigned()) ? TRUE : FALSE;
-  }
-
-  static YAP_Bool gecode_intvar_min(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.min()));
-  }
-
-  static YAP_Bool gecode_intvar_max(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.max()));
-  }
-
-  static YAP_Bool gecode_intvar_med(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.med()));
-  }
-
-  static YAP_Bool gecode_intvar_val(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.val()));
-  }
-
-  static YAP_Bool gecode_intvar_size(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.size()));
-  }
-
-  static YAP_Bool gecode_intvar_width(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.width()));
-  }
-
-  static YAP_Bool gecode_intvar_regret_min(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.regret_min()));
-  }
-
-  static YAP_Bool gecode_intvar_regret_max(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.regret_max()));
-  }
-
-  static YAP_Functor gecode_COMMA2;
-
-  static YAP_Bool gecode_intvar_ranges(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    int n = 0;
-    { IntVarRanges it(x); while (it()) { ++n; ++it; } }
-    DYNARRAY(int,min,n);
-    DYNARRAY(int,max,n);
-    { IntVarRanges it(x); int i=0;
-      while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;)
-      {
-	YAP_Term args[2];
-	args[0] = YAP_MkIntTerm(min[n]);
-	args[1] = YAP_MkIntTerm(max[n]);
-	YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args);
-	lst = YAP_MkPairTerm(range,lst);
-      }
-    return YAP_Unify(result,lst);
-  }
-
-  static YAP_Bool gecode_intvar_values(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    IntVar x = gecode_IntVar_from_term(space, YAP_ARG3);
-    int n = x.size();
-    DYNARRAY(int,a,n);
-    { IntVarValues it(x); int i=0;
-      while (it()) { a[i]=it.val(); ++it; ++i; } }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;)
-      {
-	lst = YAP_MkPairTerm(YAP_MkIntTerm(a[n]),lst);
-      }
-    return YAP_Unify(result,lst);
-  }
-
-  // INFO ON BOOLVARS
-  static YAP_Bool gecode_boolvar_assigned(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG2);
-    return (x.assigned()) ? TRUE : FALSE;
-  }
-
-  static YAP_Bool gecode_boolvar_min(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.min()));
-  }
-
-  static YAP_Bool gecode_boolvar_max(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.max()));
-  }
-
-  static YAP_Bool gecode_boolvar_med(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.med()));
-  }
-
-  static YAP_Bool gecode_boolvar_val(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.val()));
-  }
-
-  static YAP_Bool gecode_boolvar_size(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.size()));
-  }
-
-  static YAP_Bool gecode_boolvar_width(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.width()));
-  }
-
-  static YAP_Bool gecode_boolvar_regret_min(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.regret_min()));
-  }
-
-  static YAP_Bool gecode_boolvar_regret_max(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.regret_max()));
-  }
-
-  // INFO ON SETVARS
-  static YAP_Bool gecode_setvar_assigned(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG2);
-    return (x.assigned()) ? TRUE : FALSE;
-  }
-
-  static YAP_Bool gecode_setvar_glbSize(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.glbSize()));
-  }
-
-  static YAP_Bool gecode_setvar_lubSize(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.lubSize()));
-  }
-
-  static YAP_Bool gecode_setvar_unknownSize(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.unknownSize()));
-  }
-
-  static YAP_Bool gecode_setvar_cardMin(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.cardMin()));
-  }
-
-  static YAP_Bool gecode_setvar_cardMax(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.cardMax()));
-  }
-
-  static YAP_Bool gecode_setvar_lubMin(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.lubMin()));
-  }
-
-  static YAP_Bool gecode_setvar_lubMax(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.lubMax()));
-  }
-
-  static YAP_Bool gecode_setvar_glbMin(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.glbMin()));
-  }
-
-  static YAP_Bool gecode_setvar_glbMax(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkIntTerm(x.glbMax()));
-  }
-
-  static YAP_Bool gecode_setvar_glb_ranges(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    int n = 0;
-    { SetVarGlbRanges it(x); while (it()) { ++n; ++it; } }
-    DYNARRAY(int,min,n);
-    DYNARRAY(int,max,n);
-    { SetVarGlbRanges it(x); int i=0;
-      while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;)
-      {
-	YAP_Term args[2];
-	args[0] = YAP_MkIntTerm(min[n]);
-	args[1] = YAP_MkIntTerm(max[n]);
-	YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args);
-	lst = YAP_MkPairTerm(range,lst);
-      }
-    return YAP_Unify(result,lst);
-  }
-
-  static YAP_Bool gecode_setvar_lub_ranges(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    int n = 0;
-    { SetVarLubRanges it(x); while (it()) { ++n; ++it; } }
-    DYNARRAY(int,min,n);
-    DYNARRAY(int,max,n);
-    { SetVarLubRanges it(x); int i=0;
-      while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;)
-      {
-	YAP_Term args[2];
-	args[0] = YAP_MkIntTerm(min[n]);
-	args[1] = YAP_MkIntTerm(max[n]);
-	YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args);
-	lst = YAP_MkPairTerm(range,lst);
-      }
-    return YAP_Unify(result,lst);
-  }
-
-  static YAP_Bool gecode_setvar_unknown_ranges(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    int n = 0;
-    { SetVarUnknownRanges it(x); while (it()) { ++n; ++it; } }
-    DYNARRAY(int,min,n);
-    DYNARRAY(int,max,n);
-    { SetVarUnknownRanges it(x); int i=0;
-      while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;)
-      {
-	YAP_Term args[2];
-	args[0] = YAP_MkIntTerm(min[n]);
-	args[1] = YAP_MkIntTerm(max[n]);
-	YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args);
-	lst = YAP_MkPairTerm(range,lst);
-      }
-    return YAP_Unify(result,lst);
-  }
-
-  static YAP_Bool gecode_setvar_glb_values(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    DYNARRAY(YAP_Term,elems,x.glbSize());
-    SetVarGlbValues it(x);
-    int n = 0;
-    while (it()) { elems[n] = YAP_MkIntTerm(it.val()); ++it; ++n; }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;) lst = YAP_MkPairTerm(elems[n],lst);
-    return YAP_Unify(result,lst);
-  }
-
-  static YAP_Bool gecode_setvar_lub_values(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    DYNARRAY(YAP_Term,elems,x.lubSize());
-    SetVarLubValues it(x);
-    int n = 0;
-    while (it()) { elems[n] = YAP_MkIntTerm(it.val()); ++it; ++n; }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;) lst = YAP_MkPairTerm(elems[n],lst);
-    return YAP_Unify(result,lst);
-  }
-
-  static YAP_Bool gecode_setvar_unknown_values(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    SetVar x = gecode_SetVar_from_term(space, YAP_ARG3);
-    DYNARRAY(YAP_Term,elems,x.unknownSize());
-    SetVarUnknownValues it(x);
-    int n = 0;
-    while (it()) { elems[n] = YAP_MkIntTerm(it.val()); ++it; ++n; }
-    YAP_Term lst = YAP_TermNil();
-    for (;n--;) lst = YAP_MkPairTerm(elems[n],lst);
-    return YAP_Unify(result,lst);
-  }
-
-  // INFO ON FLOATVARS
-  static YAP_Bool gecode_floatvar_assigned(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG2);
-    return (x.assigned()) ? TRUE : FALSE;
-  }
-
-  static YAP_Bool gecode_floatvar_min(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkFloatTerm(x.min()));
-  }
-
-  static YAP_Bool gecode_floatvar_max(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkFloatTerm(x.max()));
-  }
-
-  static YAP_Bool gecode_floatvar_med(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkFloatTerm(x.med()));
-  }
-
-  static YAP_Bool gecode_floatvar_size(void)
-  {
-    YAP_Term result = YAP_ARG1;
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG2);
-    FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3);
-    return YAP_Unify(result, YAP_MkFloatTerm(x.size()));
-  }
-
-  static inline Reify
-  gecode_Reify_from_term(YAP_Term t)
-  {
-    return * (Reify*) YAP_OpaqueObjectFromTerm(t);
-  }
+static inline Reify gecode_Reify_from_term(YAP_Term t) {
+  return *(Reify *)YAP_OpaqueObjectFromTerm(t);
+}
 
 #define gecode_int_from_term YAP_IntOfTerm
 
 #include "gecode_yap_cc_forward_auto_generated.icc"
 #include "gecode_yap_cc_impl_auto_generated.icc"
 
-  static YAP_opaque_tag_t gecode_reify_tag;
-  static YAP_opaque_handler_t gecode_reify_handler;
+static YAP_opaque_tag_t gecode_reify_tag;
+static YAP_opaque_handler_t gecode_reify_handler;
 
-  static YAP_Bool
-  gecode_reify_write_handler
-  (FILE *stream, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<reify %p>", p);
-    return TRUE;
-  }
-
-  static YAP_Term gecode_term_from_reify(Reify r)
-  {
-    YAP_Term term =
-      YAP_NewOpaqueObject(gecode_reify_tag, sizeof(Reify));
-    Reify *ptr =
-      (Reify*) YAP_OpaqueObjectFromTerm(term);
-    *ptr = r;
-    return term;
-  }
-
-  static YAP_Bool gecode_new_reify(void)
-  {
-    GenericSpace* space = gecode_Space_from_term(YAP_ARG1);
-    BoolVar b = gecode_BoolVar_from_term(space, YAP_ARG2);
-    ReifyMode flag = gecode_ReifyMode_from_term(YAP_ARG3);
-    Reify r = Reify(b,flag);
-
-    YAP_Term term = gecode_term_from_reify(r);
-    return YAP_Unify(YAP_ARG4, term);
-  }
-
-  static YAP_opaque_tag_t gecode_tupleset_tag;
-  static YAP_opaque_handler_t gecode_tupleset_handler;
-
-  static YAP_Bool gecode_tupleset_fail_handler(void* p)
-  {
-    return TRUE;
-  }
-
-  static YAP_Bool
-  gecode_tupleset_write_handler
-  (FILE *stream, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<tupleset %p>", p);
-    return TRUE;
-  }
-
-  static YAP_Bool gecode_new_tupleset(void)
-  {
-    YAP_Term term =
-      YAP_NewOpaqueObject(gecode_tupleset_tag, sizeof(TupleSet));
-    TupleSet *ts = new (YAP_OpaqueObjectFromTerm(term)) TupleSet;
-    YAP_Term t = YAP_ARG1;
-    while (YAP_IsPairTerm( t ) ) {
-      YAP_Term l = YAP_HeadOfTerm(t);
-      int n = gecode_list_length(l);
-      int i = 0;
-      IntArgs is(n);
-      while (YAP_IsPairTerm( l ) ) {
-	YAP_Term ll = YAP_HeadOfTerm(l);
-	if (!YAP_IsIntTerm(ll)) {
-	    cerr << "non-integer on tuple set" << endl; exit(1);
-	}
-	is[i++] = YAP_IntOfTerm(ll);
-	l = YAP_TailOfTerm(l);
-      }
-      ts->add(is);
-      if (l != YAP_TermNil()) {
-	  cerr << "non-list on tuple set" << endl; exit(1);
-      }
-      t = YAP_TailOfTerm(t);
-    }
-    if (t != YAP_TermNil()) {
-      cerr << "non-list on tuple set" << endl; exit(1);
-    }
-    ts->finalize();
-    return YAP_Unify(YAP_ARG2, term);
-  }
-
-  static YAP_opaque_tag_t gecode_dfa_tag;
-  static YAP_opaque_handler_t gecode_dfa_handler;
-
-  static YAP_Bool gecode_dfa_fail_handler(void* p)
-  {
-    return TRUE;
-  }
-
-  static YAP_Bool
-  gecode_dfa_write_handler
-  (FILE *stream, YAP_opaque_tag_t type, void *p, int flags)
-  {
-    fprintf(stream,"<dfa %p>", p);
-    return TRUE;
-  }
-
-  static YAP_Bool gecode_new_dfa(void)
-  {
-    YAP_Term term =
-      YAP_NewOpaqueObject(gecode_dfa_tag, sizeof(DFA));
-    //    DFA ts = new (YAP_OpaqueObjectFromTerm(term)) DFA;
-    YAP_Term t2 = YAP_ARG2;
-    int s0 = YAP_IntOfTerm(t2);
-    YAP_Term t3 = YAP_ARG3;
-    int n = gecode_list_length(t3), i=0;
-    DFA::Transition t[1024];
-    if (n > 1024) cerr<< "DFA too long" << endl;
-    while (YAP_IsPairTerm( t3 ) ) {
-      YAP_Term tt = YAP_HeadOfTerm(t3);
-      int is, sy, os;
-      is = YAP_IntOfTerm(YAP_ArgOfTerm(1,tt));
-      sy = YAP_IntOfTerm(YAP_ArgOfTerm(2,tt));
-      os = YAP_IntOfTerm(YAP_ArgOfTerm(3,tt));
-      t[i++] = DFA::Transition(is, sy, os);
-      t3 = YAP_TailOfTerm(t3);
-    }
-    if (t3 != YAP_TermNil()) {
-      cerr << "non-list on DFA" << endl; exit(1);
-    }
-    YAP_Term t4 = YAP_ARG4;
-    n = gecode_list_length(t4)+1;
-    i=0;
-    int s[n];
-    s[n-1] = -1;
-    while (YAP_IsPairTerm( t4 ) ) {
-      YAP_Term tt = YAP_HeadOfTerm(t4);
-      s[i++] = YAP_IntOfTerm(tt);
-      t4 = YAP_TailOfTerm(t4);
-    }
-    if (t4 != YAP_TermNil()) {
-      cerr << "non-list on DFA" << endl; exit(1);
-    }
-    new (YAP_OpaqueObjectFromTerm(term)) DFA(s0, t, s);
-    return YAP_Unify(YAP_ARG1, term);
-  }
-
-  void gecode_init(void)
-  {
-    { YAP_Atom X= YAP_LookupAtom("true");
-      gecode_TRUE = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("false");
-      gecode_FALSE = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom(",");
-      YAP_AtomGetHold(X);
-      gecode_COMMA2 = YAP_MkFunctor(X,2); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_NONE");
-      gecode_INT_VAR_NONE = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_MIN");
-      gecode_INT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_MAX");
-      gecode_INT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_MIN_MIN");
-      gecode_INT_VAR_MIN_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_MIN_MAX");
-      gecode_INT_VAR_MIN_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_MAX_MIN");
-      gecode_INT_VAR_MAX_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_MAX_MAX");
-      gecode_INT_VAR_MAX_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_MIN");
-      gecode_INT_VAR_SIZE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_MAX");
-      gecode_INT_VAR_SIZE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_SIZE_MIN");
-      gecode_INT_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_SIZE_MAX");
-      gecode_INT_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MIN_MIN");
-      gecode_INT_VAR_REGRET_MIN_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MIN_MAX");
-      gecode_INT_VAR_REGRET_MIN_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MAX_MIN");
-      gecode_INT_VAR_REGRET_MAX_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MAX_MAX");
-      gecode_INT_VAR_REGRET_MAX_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_MIN");
-      gecode_INT_VAL_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_MED");
-      gecode_INT_VAL_MED = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_MAX");
-      gecode_INT_VAL_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_SPLIT_MIN");
-      gecode_INT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_SPLIT_MAX");
-      gecode_INT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_RANGE_MIN");
-      gecode_INT_VAL_RANGE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VAL_RANGE_MAX");
-      gecode_INT_VAL_RANGE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VALUES_MIN");
-      gecode_INT_VALUES_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("INT_VALUES_MAX");
-      gecode_INT_VALUES_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_NONE");
-      gecode_SET_VAR_NONE = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_MIN");
-      gecode_SET_VAR_DEGREE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_MAX");
-      gecode_SET_VAR_DEGREE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_MIN_MIN");
-      gecode_SET_VAR_MIN_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_MIN_MAX");
-      gecode_SET_VAR_MIN_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_MAX_MIN");
-      gecode_SET_VAR_MAX_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_MAX_MAX");
-      gecode_SET_VAR_MAX_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_MIN");
-      gecode_SET_VAR_SIZE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_MAX");
-      gecode_SET_VAR_SIZE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_SIZE_MIN");
-      gecode_SET_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_SIZE_MAX");
-      gecode_SET_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAL_MIN_INC");
-      gecode_SET_VAL_MIN_INC = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAL_MED_INC");
-      gecode_SET_VAL_MED_INC = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAL_MAX_INC");
-      gecode_SET_VAL_MAX_INC = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAL_MIN_EXC");
-      gecode_SET_VAL_MIN_EXC = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAL_MED_EXC");
-      gecode_SET_VAL_MED_EXC = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("SET_VAL_MAX_EXC");
-      gecode_SET_VAL_MAX_EXC = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_NONE");
-      gecode_FLOAT_VAR_NONE = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_MIN");
-      gecode_FLOAT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_MAX");
-      gecode_FLOAT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MIN_MIN");
-      gecode_FLOAT_VAR_MIN_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MIN_MAX");
-      gecode_FLOAT_VAR_MIN_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MAX_MIN");
-      gecode_FLOAT_VAR_MAX_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MAX_MAX");
-      gecode_FLOAT_VAR_MAX_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_SIZE_MIN");
-      gecode_FLOAT_VAR_SIZE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_SIZE_MAX");
-      gecode_FLOAT_VAR_SIZE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_SIZE_MIN");
-      gecode_FLOAT_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_SIZE_MAX");
-      gecode_FLOAT_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAL_SPLIT_MIN");
-      gecode_FLOAT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-    { YAP_Atom X= YAP_LookupAtom("FLOAT_VAL_SPLIT_MAX");
-      gecode_FLOAT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X);
-      YAP_AtomGetHold(X); }
-#include "gecode_yap_cc_init_auto_generated.icc"
-    // opaque spaces
-    gecode_space_handler.fail_handler = gecode_space_fail_handler;
-    gecode_space_handler.write_handler = gecode_space_write_handler;
-    gecode_space_tag = YAP_NewOpaqueType(&gecode_space_handler);
-    YAP_UserCPredicate("gecode_new_space", gecode_new_space, 1);
-    // opaque engines
-    gecode_engine_handler.fail_handler = gecode_engine_fail_handler;
-    gecode_engine_handler.write_handler = gecode_engine_write_handler;
-    gecode_engine_tag = YAP_NewOpaqueType(&gecode_engine_handler);
-    YAP_UserCPredicate("gecode_new_engine", gecode_new_engine, 3);
-    // opaque reifications
-    gecode_reify_handler.fail_handler = NULL;
-    gecode_reify_handler.write_handler = gecode_reify_write_handler;
-    gecode_reify_tag = YAP_NewOpaqueType(&gecode_reify_handler);
-    YAP_UserCPredicate("gecode_new_reify", gecode_new_reify, 4);
-    // Opaque TupleSet
-    gecode_tupleset_handler.fail_handler = gecode_tupleset_fail_handler;
-    gecode_tupleset_handler.write_handler = gecode_tupleset_write_handler;
-    gecode_tupleset_tag = YAP_NewOpaqueType(&gecode_tupleset_handler);
-    YAP_UserCPredicate("gecode_new_tupleset", gecode_new_tupleset, 2);
-    // Opaque DFA
-    gecode_dfa_handler.fail_handler = gecode_dfa_fail_handler;
-    gecode_dfa_handler.write_handler = gecode_dfa_write_handler;
-    gecode_dfa_tag = YAP_NewOpaqueType(&gecode_dfa_handler);
-    YAP_UserCPredicate("gecode_new_dfa", gecode_new_dfa, 4);
-#ifdef DISJUNCTOR
-    // opaque disjunctors and clauses
-    gecode_disjunctor_handler.write_handler = gecode_disjunctor_write_handler;
-    gecode_disjunctor_tag = YAP_NewOpaqueType(&gecode_disjunctor_handler);
-    gecode_disjunctor_clause_handler.write_handler = gecode_clause_write_handler;
-    gecode_disjunctor_clause_tag =
-      YAP_NewOpaqueType(&gecode_disjunctor_clause_handler);
-    YAP_UserCPredicate("gecode_new_disjunctor", gecode_new_disjunctor, 2);
-    YAP_UserCPredicate("gecode_new_clause", gecode_new_clause, 2);
-    YAP_UserCPredicate("gecode_clause_intvar_forward", gecode_clause_intvar_forward, 3);
-    YAP_UserCPredicate("gecode_clause_boolvar_forward", gecode_clause_boolvar_forward, 3);
-    YAP_UserCPredicate("gecode_clause_setvar_forward", gecode_clause_setvar_forward, 3);
-#endif
-    // backtracking search using an engine
-    YAP_UserBackCutCPredicate("gecode_engine_search",
-			      gecode_engine_search, gecode_engine_search,
-			      NULL, 2, 0);
-    // creating variables
-    YAP_UserCPredicate("gecode_new_intvar_from_bounds",
-		       gecode_new_intvar_from_bounds, 4);
-    YAP_UserCPredicate("gecode_new_intvar_from_intset",
-		       gecode_new_intvar_from_intset, 3);
-    YAP_UserCPredicate("gecode_new_floatvar_from_bounds",
-		       gecode_new_floatvar_from_bounds, 4);
-    YAP_UserCPredicate("gecode_new_boolvar", gecode_new_boolvar, 2);
-    YAP_UserCPredicate("gecode_new_setvar_1", gecode_new_setvar_1, 8);
-    YAP_UserCPredicate("gecode_new_setvar_2", gecode_new_setvar_2, 7);
-    YAP_UserCPredicate("gecode_new_setvar_3", gecode_new_setvar_3, 6);
-    YAP_UserCPredicate("gecode_new_setvar_4", gecode_new_setvar_4, 7);
-    YAP_UserCPredicate("gecode_new_setvar_5", gecode_new_setvar_5, 6);
-    YAP_UserCPredicate("gecode_new_setvar_6", gecode_new_setvar_6, 5);
-    YAP_UserCPredicate("gecode_new_setvar_7", gecode_new_setvar_7, 7);
-    YAP_UserCPredicate("gecode_new_setvar_8", gecode_new_setvar_8, 6);
-    YAP_UserCPredicate("gecode_new_setvar_9", gecode_new_setvar_9, 5);
-    YAP_UserCPredicate("gecode_new_setvar_10", gecode_new_setvar_10, 6);
-    YAP_UserCPredicate("gecode_new_setvar_11", gecode_new_setvar_11, 5);
-    YAP_UserCPredicate("gecode_new_setvar_12", gecode_new_setvar_12, 4);
-    YAP_UserCPredicate("gecode_space_minimize", gecode_space_minimize, 2);
-    YAP_UserCPredicate("gecode_space_maximize", gecode_space_maximize, 2);
-    YAP_UserCPredicate("gecode_space_minimize_ratio", gecode_space_minimize_ratio, 3);
-    YAP_UserCPredicate("gecode_space_maximize_ratio", gecode_space_maximize_ratio, 3);
-    // INFO ON INTVARS
-    YAP_UserCPredicate("gecode_intvar_assigned", gecode_intvar_assigned, 2);
-    YAP_UserCPredicate("gecode_intvar_min", gecode_intvar_min, 3);
-    YAP_UserCPredicate("gecode_intvar_max", gecode_intvar_max, 3);
-    YAP_UserCPredicate("gecode_intvar_med", gecode_intvar_med, 3);
-    YAP_UserCPredicate("gecode_intvar_val", gecode_intvar_val, 3);
-    YAP_UserCPredicate("gecode_intvar_size", gecode_intvar_size, 3);
-    YAP_UserCPredicate("gecode_intvar_width", gecode_intvar_width, 3);
-    YAP_UserCPredicate("gecode_intvar_regret_min", gecode_intvar_regret_min, 3);
-    YAP_UserCPredicate("gecode_intvar_regret_max", gecode_intvar_regret_max, 3);
-    YAP_UserCPredicate("gecode_intvar_ranges", gecode_intvar_ranges, 3);
-    YAP_UserCPredicate("gecode_intvar_values", gecode_intvar_values, 3);
-    // INFO ON BOOLVARS
-    YAP_UserCPredicate("gecode_boolvar_assigned", gecode_boolvar_assigned, 2);
-    YAP_UserCPredicate("gecode_boolvar_min", gecode_boolvar_min, 3);
-    YAP_UserCPredicate("gecode_boolvar_max", gecode_boolvar_max, 3);
-    YAP_UserCPredicate("gecode_boolvar_med", gecode_boolvar_med, 3);
-    YAP_UserCPredicate("gecode_boolvar_val", gecode_boolvar_val, 3);
-    YAP_UserCPredicate("gecode_boolvar_size", gecode_boolvar_size, 3);
-    YAP_UserCPredicate("gecode_boolvar_width", gecode_boolvar_width, 3);
-    YAP_UserCPredicate("gecode_boolvar_regret_min", gecode_boolvar_regret_min, 3);
-    YAP_UserCPredicate("gecode_boolvar_regret_max", gecode_boolvar_regret_max, 3);
-    // INFO ON SETVARS
-    YAP_UserCPredicate("gecode_setvar_assigned", gecode_setvar_assigned, 2);
-    YAP_UserCPredicate("gecode_setvar_glbSize", gecode_setvar_glbSize, 3);
-    YAP_UserCPredicate("gecode_setvar_lubSize", gecode_setvar_lubSize, 3);
-    YAP_UserCPredicate("gecode_setvar_unknownSize", gecode_setvar_unknownSize, 3);
-    YAP_UserCPredicate("gecode_setvar_cardMin", gecode_setvar_cardMin, 3);
-    YAP_UserCPredicate("gecode_setvar_cardMax", gecode_setvar_cardMax, 3);
-    YAP_UserCPredicate("gecode_setvar_lubMin", gecode_setvar_lubMin, 3);
-    YAP_UserCPredicate("gecode_setvar_lubMax", gecode_setvar_lubMax, 3);
-    YAP_UserCPredicate("gecode_setvar_glbMin", gecode_setvar_glbMin, 3);
-    YAP_UserCPredicate("gecode_setvar_glbMax", gecode_setvar_glbMax, 3);
-    YAP_UserCPredicate("gecode_setvar_glb_ranges", gecode_setvar_glb_ranges, 3);
-    YAP_UserCPredicate("gecode_setvar_lub_ranges", gecode_setvar_lub_ranges, 3);
-    YAP_UserCPredicate("gecode_setvar_unknown_ranges", gecode_setvar_unknown_ranges, 3);
-    YAP_UserCPredicate("gecode_setvar_glb_values", gecode_setvar_glb_values, 3);
-    YAP_UserCPredicate("gecode_setvar_lub_values", gecode_setvar_lub_values, 3);
-    YAP_UserCPredicate("gecode_setvar_unknown_values", gecode_setvar_unknown_values, 3);
-    YAP_UserCPredicate("gecode_space_use_keep_index", gecode_space_use_keep_index, 2);
-    YAP_UserCPredicate("gecode_intvar_keep", gecode_intvar_keep, 3);
-    YAP_UserCPredicate("gecode_boolvar_keep", gecode_boolvar_keep, 3);
-    YAP_UserCPredicate("gecode_setvar_keep", gecode_setvar_keep, 3);
-    // INFO ON FLOATVARS
-    YAP_UserCPredicate("gecode_floatvar_assigned", gecode_floatvar_assigned, 2);
-    YAP_UserCPredicate("gecode_floatvar_min", gecode_floatvar_min, 3);
-    YAP_UserCPredicate("gecode_floatvar_max", gecode_floatvar_max, 3);
-    YAP_UserCPredicate("gecode_floatvar_med", gecode_floatvar_med, 3);
-    YAP_UserCPredicate("gecode_floatvar_size", gecode_floatvar_size, 3);
-  }
+static YAP_Bool gecode_reify_write_handler(FILE *stream, YAP_opaque_tag_t type,
+                                           void *p, int flags) {
+  fprintf(stream, "<reify %p>", p);
+  return TRUE;
+}
+
+static YAP_Term gecode_term_from_reify(Reify r) {
+  YAP_Term term = YAP_NewOpaqueObject(gecode_reify_tag, sizeof(Reify));
+  Reify *ptr = (Reify *)YAP_OpaqueObjectFromTerm(term);
+  *ptr = r;
+  return term;
+}
+
+static YAP_Bool gecode_new_reify(void) {
+  GenericSpace *space = gecode_Space_from_term(YAP_ARG1);
+  BoolVar b = gecode_BoolVar_from_term(space, YAP_ARG2);
+  ReifyMode flag = gecode_ReifyMode_from_term(YAP_ARG3);
+  Reify r = Reify(b, flag);
+
+  YAP_Term term = gecode_term_from_reify(r);
+  return YAP_Unify(YAP_ARG4, term);
+}
+
+static YAP_opaque_tag_t gecode_tupleset_tag;
+static YAP_opaque_handler_t gecode_tupleset_handler;
+
+static YAP_Bool gecode_tupleset_fail_handler(YAP_Term p) { return TRUE; }
+
+static YAP_Bool gecode_tupleset_write_handler(FILE *stream,
+                                              YAP_opaque_tag_t type, void *p,
+                                              int flags) {
+  fprintf(stream, "<tupleset %p>", p);
+  return TRUE;
+}
+
+static YAP_Bool gecode_new_tupleset(void) {
+  YAP_Term term = YAP_NewOpaqueObject(gecode_tupleset_tag, sizeof(TupleSet));
+  TupleSet *ts = new (YAP_OpaqueObjectFromTerm(term)) TupleSet;
+  YAP_Term t = YAP_ARG1;
+  while (YAP_IsPairTerm(t)) {
+    YAP_Term l = YAP_HeadOfTerm(t);
+    int n = gecode_list_length(l);
+    int i = 0;
+    IntArgs is(n);
+    while (YAP_IsPairTerm(l)) {
+      YAP_Term ll = YAP_HeadOfTerm(l);
+      if (!YAP_IsIntTerm(ll)) {
+        cerr << "non-integer on tuple set" << endl;
+        exit(1);
+      }
+      is[i++] = YAP_IntOfTerm(ll);
+      l = YAP_TailOfTerm(l);
+    }
+    ts->add(is);
+    if (l != YAP_TermNil()) {
+      cerr << "non-list on tuple set" << endl;
+      exit(1);
+    }
+    t = YAP_TailOfTerm(t);
+  }
+  if (t != YAP_TermNil()) {
+    cerr << "non-list on tuple set" << endl;
+    exit(1);
+  }
+  ts->finalize();
+  return YAP_Unify(YAP_ARG2, term);
+}
+
+static YAP_opaque_tag_t gecode_dfa_tag;
+static YAP_opaque_handler_t gecode_dfa_handler;
+
+static YAP_Bool gecode_dfa_fail_handler(YAP_Term p) { return TRUE; }
+
+static YAP_Bool gecode_dfa_write_handler(FILE *stream, YAP_opaque_tag_t type,
+                                         void *p, int flags) {
+  fprintf(stream, "<dfa %p>", p);
+  return TRUE;
+}
+
+static YAP_Bool gecode_new_dfa(void) {
+  YAP_Term term = YAP_NewOpaqueObject(gecode_dfa_tag, sizeof(DFA));
+  //    DFA ts = new (YAP_OpaqueObjectFromTerm(term)) DFA;
+  YAP_Term t2 = YAP_ARG2;
+  int s0 = YAP_IntOfTerm(t2);
+  YAP_Term t3 = YAP_ARG3;
+  int n = gecode_list_length(t3), i = 0;
+  DFA::Transition t[1024];
+  if (n > 1024)
+    cerr << "DFA too long" << endl;
+  while (YAP_IsPairTerm(t3)) {
+    YAP_Term tt = YAP_HeadOfTerm(t3);
+    int is, sy, os;
+    is = YAP_IntOfTerm(YAP_ArgOfTerm(1, tt));
+    sy = YAP_IntOfTerm(YAP_ArgOfTerm(2, tt));
+    os = YAP_IntOfTerm(YAP_ArgOfTerm(3, tt));
+    t[i++] = DFA::Transition(is, sy, os);
+    t3 = YAP_TailOfTerm(t3);
+  }
+  if (t3 != YAP_TermNil()) {
+    cerr << "non-list on DFA" << endl;
+    exit(1);
+  }
+  YAP_Term t4 = YAP_ARG4;
+  n = gecode_list_length(t4) + 1;
+  i = 0;
+  int s[n];
+  s[n - 1] = -1;
+  while (YAP_IsPairTerm(t4)) {
+    YAP_Term tt = YAP_HeadOfTerm(t4);
+    s[i++] = YAP_IntOfTerm(tt);
+    t4 = YAP_TailOfTerm(t4);
+  }
+  if (t4 != YAP_TermNil()) {
+    cerr << "non-list on DFA" << endl;
+    exit(1);
+  }
+  new (YAP_OpaqueObjectFromTerm(term)) DFA(s0, t, s);
+  return YAP_Unify(YAP_ARG1, term);
+}
+
+void gecode_init(void) {
+  {
+    YAP_Atom X = YAP_LookupAtom("true");
+    gecode_TRUE = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("false");
+    gecode_FALSE = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom(",");
+    YAP_AtomGetHold(X);
+    gecode_COMMA2 = YAP_MkFunctor(X, 2);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_NONE");
+    gecode_INT_VAR_NONE = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_DEGREE_MIN");
+    gecode_INT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_DEGREE_MAX");
+    gecode_INT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_MIN_MIN");
+    gecode_INT_VAR_MIN_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_MIN_MAX");
+    gecode_INT_VAR_MIN_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_MAX_MIN");
+    gecode_INT_VAR_MAX_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_MAX_MAX");
+    gecode_INT_VAR_MAX_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_SIZE_MIN");
+    gecode_INT_VAR_SIZE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_SIZE_MAX");
+    gecode_INT_VAR_SIZE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_DEGREE_SIZE_MIN");
+    gecode_INT_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_DEGREE_SIZE_MAX");
+    gecode_INT_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_REGRET_MIN_MIN");
+    gecode_INT_VAR_REGRET_MIN_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_REGRET_MIN_MAX");
+    gecode_INT_VAR_REGRET_MIN_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_REGRET_MAX_MIN");
+    gecode_INT_VAR_REGRET_MAX_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAR_REGRET_MAX_MAX");
+    gecode_INT_VAR_REGRET_MAX_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_MIN");
+    gecode_INT_VAL_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_MED");
+    gecode_INT_VAL_MED = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_MAX");
+    gecode_INT_VAL_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_SPLIT_MIN");
+    gecode_INT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_SPLIT_MAX");
+    gecode_INT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_RANGE_MIN");
+    gecode_INT_VAL_RANGE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VAL_RANGE_MAX");
+    gecode_INT_VAL_RANGE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VALUES_MIN");
+    gecode_INT_VALUES_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("INT_VALUES_MAX");
+    gecode_INT_VALUES_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_NONE");
+    gecode_SET_VAR_NONE = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_DEGREE_MIN");
+    gecode_SET_VAR_DEGREE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_DEGREE_MAX");
+    gecode_SET_VAR_DEGREE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_MIN_MIN");
+    gecode_SET_VAR_MIN_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_MIN_MAX");
+    gecode_SET_VAR_MIN_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_MAX_MIN");
+    gecode_SET_VAR_MAX_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_MAX_MAX");
+    gecode_SET_VAR_MAX_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_SIZE_MIN");
+    gecode_SET_VAR_SIZE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_SIZE_MAX");
+    gecode_SET_VAR_SIZE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_DEGREE_SIZE_MIN");
+    gecode_SET_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAR_DEGREE_SIZE_MAX");
+    gecode_SET_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAL_MIN_INC");
+    gecode_SET_VAL_MIN_INC = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAL_MED_INC");
+    gecode_SET_VAL_MED_INC = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAL_MAX_INC");
+    gecode_SET_VAL_MAX_INC = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAL_MIN_EXC");
+    gecode_SET_VAL_MIN_EXC = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAL_MED_EXC");
+    gecode_SET_VAL_MED_EXC = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("SET_VAL_MAX_EXC");
+    gecode_SET_VAL_MAX_EXC = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_NONE");
+    gecode_FLOAT_VAR_NONE = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_DEGREE_MIN");
+    gecode_FLOAT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_DEGREE_MAX");
+    gecode_FLOAT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_MIN_MIN");
+    gecode_FLOAT_VAR_MIN_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_MIN_MAX");
+    gecode_FLOAT_VAR_MIN_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_MAX_MIN");
+    gecode_FLOAT_VAR_MAX_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_MAX_MAX");
+    gecode_FLOAT_VAR_MAX_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_SIZE_MIN");
+    gecode_FLOAT_VAR_SIZE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_SIZE_MAX");
+    gecode_FLOAT_VAR_SIZE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_DEGREE_SIZE_MIN");
+    gecode_FLOAT_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAR_DEGREE_SIZE_MAX");
+    gecode_FLOAT_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAL_SPLIT_MIN");
+    gecode_FLOAT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+  {
+    YAP_Atom X = YAP_LookupAtom("FLOAT_VAL_SPLIT_MAX");
+    gecode_FLOAT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X);
+    YAP_AtomGetHold(X);
+  }
+#include "gecode_yap_cc_init_auto_generated.icc"
+  // opaque spaces
+  gecode_space_handler.fail_handler = gecode_space_fail_handler;
+  gecode_space_handler.write_handler = gecode_space_write_handler;
+  gecode_space_tag = YAP_NewOpaqueType(&gecode_space_handler);
+  YAP_UserCPredicate("gecode_new_space", gecode_new_space, 1);
+  // opaque engines
+  gecode_engine_handler.fail_handler = gecode_engine_fail_handler;
+  gecode_engine_handler.write_handler = gecode_engine_write_handler;
+  gecode_engine_tag = YAP_NewOpaqueType(&gecode_engine_handler);
+  YAP_UserCPredicate("gecode_new_engine", gecode_new_engine, 3);
+  // opaque reifications
+  gecode_reify_handler.fail_handler = NULL;
+  gecode_reify_handler.write_handler = gecode_reify_write_handler;
+  gecode_reify_tag = YAP_NewOpaqueType(&gecode_reify_handler);
+  YAP_UserCPredicate("gecode_new_reify", gecode_new_reify, 4);
+  // Opaque TupleSet
+  gecode_tupleset_handler.fail_handler = gecode_tupleset_fail_handler;
+  gecode_tupleset_handler.write_handler = gecode_tupleset_write_handler;
+  gecode_tupleset_tag = YAP_NewOpaqueType(&gecode_tupleset_handler);
+  YAP_UserCPredicate("gecode_new_tupleset", gecode_new_tupleset, 2);
+  // Opaque DFA
+  gecode_dfa_handler.fail_handler = gecode_dfa_fail_handler;
+  gecode_dfa_handler.write_handler = gecode_dfa_write_handler;
+  gecode_dfa_tag = YAP_NewOpaqueType(&gecode_dfa_handler);
+  YAP_UserCPredicate("gecode_new_dfa", gecode_new_dfa, 4);
+#ifdef DISJUNCTOR
+  // opaque disjunctors and clauses
+  gecode_disjunctor_handler.write_handler = gecode_disjunctor_write_handler;
+  gecode_disjunctor_tag = YAP_NewOpaqueType(&gecode_disjunctor_handler);
+  gecode_disjunctor_clause_handler.write_handler = gecode_clause_write_handler;
+  gecode_disjunctor_clause_tag =
+      YAP_NewOpaqueType(&gecode_disjunctor_clause_handler);
+  YAP_UserCPredicate("gecode_new_disjunctor", gecode_new_disjunctor, 2);
+  YAP_UserCPredicate("gecode_new_clause", gecode_new_clause, 2);
+  YAP_UserCPredicate("gecode_clause_intvar_forward",
+                     gecode_clause_intvar_forward, 3);
+  YAP_UserCPredicate("gecode_clause_boolvar_forward",
+                     gecode_clause_boolvar_forward, 3);
+  YAP_UserCPredicate("gecode_clause_setvar_forward",
+                     gecode_clause_setvar_forward, 3);
+#endif
+  // backtracking search using an engine
+  YAP_UserBackCutCPredicate("gecode_engine_search", gecode_engine_search,
+                            gecode_engine_search, NULL, 2, 0);
+  // creating variables
+  YAP_UserCPredicate("gecode_new_intvar_from_bounds",
+                     gecode_new_intvar_from_bounds, 4);
+  YAP_UserCPredicate("gecode_new_intvar_from_intset",
+                     gecode_new_intvar_from_intset, 3);
+  YAP_UserCPredicate("gecode_new_floatvar_from_bounds",
+                     gecode_new_floatvar_from_bounds, 4);
+  YAP_UserCPredicate("gecode_new_boolvar", gecode_new_boolvar, 2);
+  YAP_UserCPredicate("gecode_new_setvar_1", gecode_new_setvar_1, 8);
+  YAP_UserCPredicate("gecode_new_setvar_2", gecode_new_setvar_2, 7);
+  YAP_UserCPredicate("gecode_new_setvar_3", gecode_new_setvar_3, 6);
+  YAP_UserCPredicate("gecode_new_setvar_4", gecode_new_setvar_4, 7);
+  YAP_UserCPredicate("gecode_new_setvar_5", gecode_new_setvar_5, 6);
+  YAP_UserCPredicate("gecode_new_setvar_6", gecode_new_setvar_6, 5);
+  YAP_UserCPredicate("gecode_new_setvar_7", gecode_new_setvar_7, 7);
+  YAP_UserCPredicate("gecode_new_setvar_8", gecode_new_setvar_8, 6);
+  YAP_UserCPredicate("gecode_new_setvar_9", gecode_new_setvar_9, 5);
+  YAP_UserCPredicate("gecode_new_setvar_10", gecode_new_setvar_10, 6);
+  YAP_UserCPredicate("gecode_new_setvar_11", gecode_new_setvar_11, 5);
+  YAP_UserCPredicate("gecode_new_setvar_12", gecode_new_setvar_12, 4);
+  YAP_UserCPredicate("gecode_space_minimize", gecode_space_minimize, 2);
+  YAP_UserCPredicate("gecode_space_maximize", gecode_space_maximize, 2);
+  YAP_UserCPredicate("gecode_space_minimize_ratio", gecode_space_minimize_ratio,
+                     3);
+  YAP_UserCPredicate("gecode_space_maximize_ratio", gecode_space_maximize_ratio,
+                     3);
+  // INFO ON INTVARS
+  YAP_UserCPredicate("gecode_intvar_assigned", gecode_intvar_assigned, 2);
+  YAP_UserCPredicate("gecode_intvar_min", gecode_intvar_min, 3);
+  YAP_UserCPredicate("gecode_intvar_max", gecode_intvar_max, 3);
+  YAP_UserCPredicate("gecode_intvar_med", gecode_intvar_med, 3);
+  YAP_UserCPredicate("gecode_intvar_val", gecode_intvar_val, 3);
+  YAP_UserCPredicate("gecode_intvar_size", gecode_intvar_size, 3);
+  YAP_UserCPredicate("gecode_intvar_width", gecode_intvar_width, 3);
+  YAP_UserCPredicate("gecode_intvar_regret_min", gecode_intvar_regret_min, 3);
+  YAP_UserCPredicate("gecode_intvar_regret_max", gecode_intvar_regret_max, 3);
+  YAP_UserCPredicate("gecode_intvar_ranges", gecode_intvar_ranges, 3);
+  YAP_UserCPredicate("gecode_intvar_values", gecode_intvar_values, 3);
+  // INFO ON BOOLVARS
+  YAP_UserCPredicate("gecode_boolvar_assigned", gecode_boolvar_assigned, 2);
+  YAP_UserCPredicate("gecode_boolvar_min", gecode_boolvar_min, 3);
+  YAP_UserCPredicate("gecode_boolvar_max", gecode_boolvar_max, 3);
+  YAP_UserCPredicate("gecode_boolvar_med", gecode_boolvar_med, 3);
+  YAP_UserCPredicate("gecode_boolvar_val", gecode_boolvar_val, 3);
+  YAP_UserCPredicate("gecode_boolvar_size", gecode_boolvar_size, 3);
+  YAP_UserCPredicate("gecode_boolvar_width", gecode_boolvar_width, 3);
+  YAP_UserCPredicate("gecode_boolvar_regret_min", gecode_boolvar_regret_min, 3);
+  YAP_UserCPredicate("gecode_boolvar_regret_max", gecode_boolvar_regret_max, 3);
+  // INFO ON SETVARS
+  YAP_UserCPredicate("gecode_setvar_assigned", gecode_setvar_assigned, 2);
+  YAP_UserCPredicate("gecode_setvar_glbSize", gecode_setvar_glbSize, 3);
+  YAP_UserCPredicate("gecode_setvar_lubSize", gecode_setvar_lubSize, 3);
+  YAP_UserCPredicate("gecode_setvar_unknownSize", gecode_setvar_unknownSize, 3);
+  YAP_UserCPredicate("gecode_setvar_cardMin", gecode_setvar_cardMin, 3);
+  YAP_UserCPredicate("gecode_setvar_cardMax", gecode_setvar_cardMax, 3);
+  YAP_UserCPredicate("gecode_setvar_lubMin", gecode_setvar_lubMin, 3);
+  YAP_UserCPredicate("gecode_setvar_lubMax", gecode_setvar_lubMax, 3);
+  YAP_UserCPredicate("gecode_setvar_glbMin", gecode_setvar_glbMin, 3);
+  YAP_UserCPredicate("gecode_setvar_glbMax", gecode_setvar_glbMax, 3);
+  YAP_UserCPredicate("gecode_setvar_glb_ranges", gecode_setvar_glb_ranges, 3);
+  YAP_UserCPredicate("gecode_setvar_lub_ranges", gecode_setvar_lub_ranges, 3);
+  YAP_UserCPredicate("gecode_setvar_unknown_ranges",
+                     gecode_setvar_unknown_ranges, 3);
+  YAP_UserCPredicate("gecode_setvar_glb_values", gecode_setvar_glb_values, 3);
+  YAP_UserCPredicate("gecode_setvar_lub_values", gecode_setvar_lub_values, 3);
+  YAP_UserCPredicate("gecode_setvar_unknown_values",
+                     gecode_setvar_unknown_values, 3);
+  YAP_UserCPredicate("gecode_space_use_keep_index", gecode_space_use_keep_index,
+                     2);
+  YAP_UserCPredicate("gecode_intvar_keep", gecode_intvar_keep, 3);
+  YAP_UserCPredicate("gecode_boolvar_keep", gecode_boolvar_keep, 3);
+  YAP_UserCPredicate("gecode_setvar_keep", gecode_setvar_keep, 3);
+  // INFO ON FLOATVARS
+  YAP_UserCPredicate("gecode_floatvar_assigned", gecode_floatvar_assigned, 2);
+  YAP_UserCPredicate("gecode_floatvar_min", gecode_floatvar_min, 3);
+  YAP_UserCPredicate("gecode_floatvar_max", gecode_floatvar_max, 3);
+  YAP_UserCPredicate("gecode_floatvar_med", gecode_floatvar_med, 3);
+  YAP_UserCPredicate("gecode_floatvar_size", gecode_floatvar_size, 3);
+}
 }
diff --git a/packages/python/yap_kernel/setup.py.in b/packages/python/yap_kernel/setup.py.in
index 99af1e970..3eb5c9f82 100644
--- a/packages/python/yap_kernel/setup.py.in
+++ b/packages/python/yap_kernel/setup.py.in
@@ -108,12 +108,14 @@ if any(a.startswith(('bdist', 'build', 'install')) for a in sys.argv):
         (pjoin('share', 'jupyter', 'kernels', KERNEL_NAME), glob(pjoin(dest, '*'))),
     ]
     mode_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'components', 'codemirror', 'mode', 'prolog')
+    custom_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'custom')
     try:
-        os.mkdir(mode_loc)
+        os.makedirs(mode_loc)
+        shutil.copy( "${CMAKE_SOURCE_DIR}/misc/editors/prolog.js" , mode_loc)
     except:
         pass
-    shutil.copy( "${CMAKE_SOURCE_DIR}/misc/editors/prolog.js" , mode_loc)
-
+    shutil.copy( pjoin( custom_loc, "custom.js") , pjoin( custom_loc, "custom.js.orig"))
+    shutil.copy( "${CMAKE_CURRENT_SOURCE_DIR}/custom.js" , pjoin( custom_loc, "custom.js"))
 
 extras_require = setuptools_args['extras_require'] = {
     'test:python_version=="2.7"': ['mock'],
@@ -124,4 +126,4 @@ if 'setuptools' in sys.modules:
     setup_args.update(setuptools_args)
 
 if __name__ == '__main__':
-    setup(**setup_args)
+    setup(**setup_args)
\ No newline at end of file