diff --git a/C/utilpreds.c b/C/utilpreds.c
index d65cdca05..1f20a9cb4 100644
--- a/C/utilpreds.c
+++ b/C/utilpreds.c
@@ -1,54 +1,57 @@
 /*************************************************************************
- *									 *
- *	 YAP Prolog 							 *
- *									 *
- *	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
- *									 *
- * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
- *
- **************************************************************************
- *									 *
- * File:		utilpreds.c * Last rev:	4/03/88
- ** mods: * comments:	new utility predicates for YAP *
- *									 *
- *************************************************************************/
+*									 *
+*	 YAP Prolog 							 *
+*									 *
+*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+*									 *
+* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
+*									 *
+**************************************************************************
+*									 *
+* File:		utilpreds.c						 *
+* Last rev:	4/03/88							 *
+* mods:									 *
+* comments:	new utility predicates for YAP				 *
+*									 *
+*************************************************************************/
 #ifdef SCCS
-static char SccsId[] = "@(#)utilpreds.c	1.3";
+static char     SccsId[] = "@(#)utilpreds.c	1.3";
 #endif
 /**
  * @addtogroup Terms
 
  */
-#include "absmi.h"
 
+#include "absmi.h"
 #include "YapHeap.h"
-#include "attvar.h"
 #include "yapio.h"
+#include "attvar.h"
 #ifdef HAVE_STRING_H
 #include "string.h"
 #endif
 
 typedef struct {
-  Term old_var;
-  Term new_var;
-} * vcell;
+	Term            old_var;
+	Term            new_var;
+}              *vcell;
 
-static int copy_complex_term(CELL *, CELL *, int, int, CELL *,
-                             CELL *CACHE_TYPE);
-static CELL vars_in_complex_term(CELL *, CELL *, Term CACHE_TYPE);
-static Int p_non_singletons_in_term(USES_REGS1);
-static CELL non_singletons_in_complex_term(CELL *, CELL *CACHE_TYPE);
-static Int p_variables_in_term(USES_REGS1);
-static Int ground_complex_term(CELL *, CELL *CACHE_TYPE);
-static Int p_ground(USES_REGS1);
-static Int p_copy_term(USES_REGS1);
-static Int var_in_complex_term(CELL *, CELL *, Term CACHE_TYPE);
+
+static int   copy_complex_term(CELL *, CELL *, int, int, CELL *, CELL * CACHE_TYPE);
+static CELL  vars_in_complex_term(CELL *, CELL *, Term CACHE_TYPE);
+static Int   p_non_singletons_in_term( USES_REGS1);
+static CELL  non_singletons_in_complex_term(CELL *, CELL * CACHE_TYPE);
+static Int   p_variables_in_term( USES_REGS1 );
+static Int   ground_complex_term(CELL *, CELL * CACHE_TYPE);
+static Int   p_ground( USES_REGS1 );
+static Int   p_copy_term( USES_REGS1 );
+static Int   var_in_complex_term(CELL *, CELL *, Term CACHE_TYPE);
 
 #ifdef DEBUG
-static Int p_force_trail_expansion(USES_REGS1);
+static Int  p_force_trail_expansion( USES_REGS1 );
 #endif /* DEBUG */
 
-static inline void clean_tr(tr_fr_ptr TR0 USES_REGS) {
+static inline void
+clean_tr(tr_fr_ptr TR0 USES_REGS) {
   if (TR != TR0) {
     do {
       Term p = TrailTerm(--TR);
@@ -57,7 +60,8 @@ static inline void clean_tr(tr_fr_ptr TR0 USES_REGS) {
   }
 }
 
-static inline void clean_dirty_tr(tr_fr_ptr TR0 USES_REGS) {
+static inline void
+clean_dirty_tr(tr_fr_ptr TR0 USES_REGS) {
   if (TR != TR0) {
     tr_fr_ptr pt = TR0;
 
@@ -69,218 +73,217 @@ static inline void clean_dirty_tr(tr_fr_ptr TR0 USES_REGS) {
   }
 }
 
-static int copy_complex_term(CELL *pt0, CELL *pt0_end, int share, int newattvs,
-                             CELL *ptf, CELL *HLow USES_REGS) {
+static int
+copy_complex_term(CELL *pt0, CELL *pt0_end, int share, int newattvs, CELL *ptf, CELL *HLow USES_REGS)
+{
 
-  struct cp_frame *to_visit0,
-      *to_visit = (struct cp_frame *)Yap_PreAllocCodeSpace();
+  struct cp_frame *to_visit0, *to_visit = (struct cp_frame *)Yap_PreAllocCodeSpace() ;
   CELL *HB0 = HB;
   tr_fr_ptr TR0 = TR;
   int ground = TRUE;
 
   HB = HR;
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, copy_term_unk);
-  copy_term_nvar : {
-    if (IsPairTerm(d0)) {
-      CELL *ap2 = RepPair(d0);
-      if (ap2 >= HB && ap2 < HR) {
-        /* If this is newer than the current term, just reuse */
-        *ptf++ = d0;
-        continue;
-      }
-      *ptf = AbsPair(HR);
-      ptf++;
+  copy_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	CELL *ap2 = RepPair(d0);
+	if (ap2 >= HB && ap2 < HR) {
+	  /* If this is newer than the current term, just reuse */
+	  *ptf++ = d0;
+	  continue;
+	}
+	*ptf = AbsPair(HR);
+	ptf++;
 #ifdef RATIONAL_TREES
-      if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldv = *pt0;
-      to_visit->ground = ground;
-      /* fool the system into thinking we had a variable there */
-      *pt0 = AbsPair(HR);
-      to_visit++;
+	if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldv = *pt0;
+	to_visit->ground = ground;
+	/* fool the system into thinking we had a variable there */
+	*pt0 = AbsPair(HR);
+	to_visit ++;
 #else
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit->ground = ground;
-        to_visit++;
-      }
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit->ground = ground;
+	  to_visit ++;
+	}
 #endif
-      ground = TRUE;
-      pt0 = ap2 - 1;
-      pt0_end = ap2 + 1;
-      ptf = HR;
-      HR += 2;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      if (ap2 >= HB && ap2 <= HR) {
-        /* If this is newer than the current term, just reuse */
-        *ptf++ = d0;
-        continue;
-      }
-      f = (Functor)(*ap2);
+	ground = TRUE;
+	pt0 = ap2 - 1;
+	pt0_end = ap2 + 1;
+	ptf = HR;
+	HR += 2;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	if (ap2 >= HB && ap2 <= HR) {
+	  /* If this is newer than the current term, just reuse */
+	  *ptf++ = d0;
+	  continue;
+	}
+	f = (Functor)(*ap2);
 
-      if (IsExtensionFunctor(f)) {
+	if (IsExtensionFunctor(f)) {
 #if MULTIPLE_STACKS
-        if (f == FunctorDBRef) {
-          DBRef entryref = DBRefOfTerm(d0);
-          if (entryref->Flags & LogUpdMask) {
-            LogUpdClause *luclause = (LogUpdClause *)entryref;
-            PELOCK(100, luclause->ClPred);
-            UNLOCK(luclause->ClPred->PELock);
-          } else {
-            LOCK(entryref->lock);
-            TRAIL_REF(entryref); /* So that fail will erase it */
-            INC_DBREF_COUNT(entryref);
-            UNLOCK(entryref->lock);
-          }
-          *ptf++ = d0; /* you can just copy other extensions. */
-        } else
+	  if (f == FunctorDBRef) {
+	    DBRef  entryref = DBRefOfTerm(d0);
+	    if (entryref->Flags & LogUpdMask) {
+	      LogUpdClause *luclause = (LogUpdClause *)entryref;
+	      PELOCK(100,luclause->ClPred);
+	      UNLOCK(luclause->ClPred->PELock);
+	    } else {
+	      LOCK(entryref->lock);
+	      TRAIL_REF(entryref);	/* So that fail will erase it */
+	      INC_DBREF_COUNT(entryref);
+	      UNLOCK(entryref->lock);
+	    }
+	    *ptf++ = d0;  /* you can just copy other extensions. */
+	  } else
 #endif
-            if (!share) {
-          UInt sz;
+	  if (!share) {
+	    UInt sz;
 
-          *ptf++ = AbsAppl(HR); /* you can just copy other extensions. */
-          /* make sure to copy floats */
-          if (f == FunctorDouble) {
-            sz = sizeof(Float) / sizeof(CELL) + 2;
-          } else if (f == FunctorLongInt) {
-            sz = 3;
-          } else if (f == FunctorString) {
-            sz = 3 + ap2[1];
-          } else {
-            CELL *pt = ap2 + 1;
-            sz = 2 + sizeof(MP_INT) +
-                 (((MP_INT *)(pt + 1))->_mp_alloc * sizeof(mp_limb_t));
-          }
-          if (HR + sz > ASP - 2048) {
-            goto overflow;
-          }
-          memmove((void *)HR, (void *)ap2, sz * sizeof(CELL));
-          HR += sz;
-        } else {
-          *ptf++ = d0; /* you can just copy other extensions. */
-        }
-        continue;
-      }
-      *ptf = AbsAppl(HR);
-      ptf++;
-      /* store the terms to visit */
+	    *ptf++ = AbsAppl(HR);  /* you can just copy other extensions. */
+	    /* make sure to copy floats */
+	    if (f== FunctorDouble) {
+	      sz = sizeof(Float)/sizeof(CELL)+2;
+	    } else if (f== FunctorLongInt) {
+	      sz = 3;
+	    } else if (f== FunctorString) {
+	      sz = 3+ap2[1];
+	    } else {
+	      CELL *pt = ap2+1;
+	      sz = 2+sizeof(MP_INT)+(((MP_INT *)(pt+1))->_mp_alloc*sizeof(mp_limb_t));
+	    }
+	    if (HR+sz > ASP - 2048) {
+	      goto overflow;
+	    }
+	    memmove((void *)HR, (void *)ap2, sz*sizeof(CELL));
+	    HR += sz;
+	  } else {
+	    *ptf++ = d0;  /* you can just copy other extensions. */
+	  }
+	  continue;
+	}
+	*ptf = AbsAppl(HR);
+	ptf++;
+	/* store the terms to visit */
 #ifdef RATIONAL_TREES
-      if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldv = *pt0;
-      to_visit->ground = ground;
-      /* fool the system into thinking we had a variable there */
-      *pt0 = AbsAppl(HR);
-      to_visit++;
+	if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldv = *pt0;
+	to_visit->ground = ground;
+	/* fool the system into thinking we had a variable there */
+	*pt0 = AbsAppl(HR);
+	to_visit ++;
 #else
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit->ground = ground;
-        to_visit++;
-      }
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit->ground = ground;
+	  to_visit ++;
+	}
 #endif
-      ground = (f != FunctorMutable);
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
-      /* store the functor for the new term */
-      HR[0] = (CELL)f;
-      ptf = HR + 1;
-      HR += 1 + d0;
-      if (HR > ASP - 2048) {
-        goto overflow;
+	ground = (f != FunctorMutable);
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+	/* store the functor for the new term */
+	HR[0] = (CELL)f;
+	ptf = HR+1;
+	HR += 1+d0;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else {
+	/* just copy atoms or integers */
+	*ptf++ = d0;
       }
-    } else {
-      /* just copy atoms or integers */
-      *ptf++ = d0;
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, copy_term_unk, copy_term_nvar);
     ground = FALSE;
     if (ptd0 >= HLow && ptd0 < HR) {
       /* we have already found this cell */
-      *ptf++ = (CELL)ptd0;
+      *ptf++ = (CELL) ptd0;
     } else
 #if COROUTINING
-        if (newattvs && IsAttachedTerm((CELL)ptd0)) {
-      /* if unbound, call the standard copy term routine */
-      struct cp_frame *bp;
+      if (newattvs && IsAttachedTerm((CELL)ptd0)) {
+	/* if unbound, call the standard copy term routine */
+	struct cp_frame *bp;
 
-      CELL new;
+	CELL new;
 
-      bp = to_visit;
-      if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp,
-                                                        ptf PASS_REGS)) {
-        goto overflow;
-      }
-      to_visit = bp;
-      new = *ptf;
-      Bind_NonAtt(ptd0, new);
-      ptf++;
-    } else {
+	bp = to_visit;
+	if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
+	  goto overflow;
+	}
+	to_visit = bp;
+	new = *ptf;
+	Bind_NonAtt(ptd0, new);
+	ptf++;
+      } else {
 #endif
-      /* first time we met this term */
-      RESET_VARIABLE(ptf);
-      if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-        /* Trail overflow */
-        if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-          goto trail_overflow;
-        }
-      }
-      Bind_NonAtt(ptd0, (CELL)ptf);
-      ptf++;
+	/* first time we met this term */
+	RESET_VARIABLE(ptf);
+	if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
+	  /* Trail overflow */
+	  if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	    goto trail_overflow;
+	  }
+	}
+	Bind_NonAtt(ptd0, (CELL)ptf);
+	ptf++;
 #ifdef COROUTINING
     }
 #endif
   }
   /* Do we still have compound terms to visit */
   if (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     if (ground && share) {
       CELL old = to_visit->oldv;
-      CELL *newp = to_visit->to - 1;
+      CELL *newp = to_visit->to-1;
       CELL new = *newp;
 
       *newp = old;
       if (IsApplTerm(new))
-        HR = RepAppl(new);
+	HR = RepAppl(new);
       else
-        HR = RepPair(new);
+	HR = RepPair(new);
     }
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
@@ -297,7 +300,7 @@ loop:
   HB = HB0;
   return ground;
 
-overflow:
+ overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -305,7 +308,7 @@ overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -324,7 +327,7 @@ trail_overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -332,15 +335,15 @@ trail_overflow:
   }
 #endif
   {
-    tr_fr_ptr oTR = TR;
+    tr_fr_ptr oTR =  TR;
     reset_trail(TR0);
-    if (!Yap_growtrail((oTR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
+    if (!Yap_growtrail((oTR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
       return -4;
     }
     return -2;
   }
 
-heap_overflow:
+ heap_overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -348,7 +351,7 @@ heap_overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -356,45 +359,50 @@ heap_overflow:
   }
 #endif
   reset_trail(TR0);
-  LOCAL_Error_Size = (ADDR)AuxSp - (ADDR)to_visit0;
+  LOCAL_Error_Size = (ADDR)AuxSp-(ADDR)to_visit0;
   return -3;
-}
+        }
 
-static Term handle_cp_overflow(int res, tr_fr_ptr TR0, UInt arity, Term t) {
+
+static Term
+handle_cp_overflow(int res, tr_fr_ptr TR0, UInt arity, Term t)
+{
   CACHE_REGS
-  XREGS[arity + 1] = t;
-  switch (res) {
+  XREGS[arity+1] = t;
+  switch(res) {
   case -1:
-    if (!Yap_gcl((ASP - HR) * sizeof(CELL), arity + 1, ENV, gc_P(P, CP))) {
+    if (!Yap_gcl((ASP-HR)*sizeof(CELL), arity+1, ENV, gc_P(P,CP))) {
       Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
       return 0L;
     }
-    return Deref(XREGS[arity + 1]);
+    return Deref(XREGS[arity+1]);
   case -2:
-    return Deref(XREGS[arity + 1]);
-  case -3: {
-    UInt size = LOCAL_Error_Size;
-    LOCAL_Error_Size = 0L;
-    if (size > 4 * 1024 * 1024)
-      size = 4 * 1024 * 1024;
-    if (!Yap_ExpandPreAllocCodeSpace(size, NULL, TRUE)) {
-      Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, TermNil, LOCAL_ErrorMessage);
-      return 0L;
+    return Deref(XREGS[arity+1]);
+  case -3:
+    {
+      UInt size = LOCAL_Error_Size;
+      LOCAL_Error_Size = 0L;
+      if (size > 4*1024*1024)
+	size = 4*1024*1024;
+      if (!Yap_ExpandPreAllocCodeSpace(size, NULL, TRUE)) {
+	Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, TermNil, LOCAL_ErrorMessage);
+	return 0L;
+      }
     }
-  }
-    return Deref(XREGS[arity + 1]);
+    return Deref(XREGS[arity+1]);
   case -4:
-    if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), FALSE)) {
+    if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), FALSE)) {
       Yap_Error(RESOURCE_ERROR_TRAIL, TermNil, LOCAL_ErrorMessage);
       return 0L;
     }
-    return Deref(XREGS[arity + 1]);
+    return Deref(XREGS[arity+1]);
   default:
     return 0L;
   }
 }
 
-static Term CopyTerm(Term inp, UInt arity, int share, int newattvs USES_REGS) {
+static Term
+CopyTerm(Term inp, UInt arity, int share, int newattvs USES_REGS) {
   Term t = Deref(inp);
   tr_fr_ptr TR0 = TR;
 
@@ -406,14 +414,13 @@ static Term CopyTerm(Term inp, UInt arity, int share, int newattvs USES_REGS) {
     restart_attached:
 
       *HR = t;
-      Hi = HR + 1;
+      Hi = HR+1;
       HR += 2;
-      if ((res = copy_complex_term(Hi - 2, Hi - 1, share, newattvs, Hi,
-                                   Hi PASS_REGS)) < 0) {
-        HR = Hi - 1;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_attached;
+      if ((res = copy_complex_term(Hi-2, Hi-1, share, newattvs, Hi, Hi PASS_REGS)) < 0) {
+	HR = Hi-1;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_attached;
       }
       return Hi[0];
     }
@@ -433,15 +440,14 @@ static Term CopyTerm(Term inp, UInt arity, int share, int newattvs USES_REGS) {
     HR += 2;
     {
       int res;
-      if ((res = copy_complex_term(ap - 1, ap + 1, share, newattvs, Hi,
-                                   Hi PASS_REGS)) < 0) {
-        HR = Hi;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_list;
+      if ((res = copy_complex_term(ap-1, ap+1, share, newattvs, Hi, Hi PASS_REGS)) < 0) {
+	HR = Hi;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_list;
       } else if (res && share) {
-        HR = Hi;
-        return t;
+	HR = Hi;
+	return t;
       }
     }
     return tf;
@@ -457,69 +463,74 @@ static Term CopyTerm(Term inp, UInt arity, int share, int newattvs USES_REGS) {
     ap = RepAppl(t);
     tf = AbsAppl(HR);
     HR[0] = (CELL)f;
-    HR += 1 + ArityOfFunctor(f);
-    if (HR > ASP - 128) {
+    HR += 1+ArityOfFunctor(f);
+    if (HR > ASP-128) {
       HR = HB0;
-      if ((t = handle_cp_overflow(-1, TR0, arity, t)) == 0L)
-        return FALSE;
+      if ((t = handle_cp_overflow(-1, TR0, arity, t))== 0L)
+	return FALSE;
       goto restart_appl;
     } else {
       int res;
 
-      if ((res = copy_complex_term(ap, ap + ArityOfFunctor(f), share, newattvs,
-                                   HB0 + 1, HB0 PASS_REGS)) < 0) {
-        HR = HB0;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_appl;
+      if ((res = copy_complex_term(ap, ap+ArityOfFunctor(f), share, newattvs, HB0+1, HB0 PASS_REGS)) < 0) {
+	HR = HB0;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_appl;
       } else if (res && share && FunctorOfTerm(t) != FunctorMutable) {
-        HR = HB0;
-        return t;
+	HR = HB0;
+	return t;
       }
     }
     return tf;
   }
 }
 
-Term Yap_CopyTerm(Term inp) {
+Term
+Yap_CopyTerm(Term inp) {
   CACHE_REGS
   return CopyTerm(inp, 0, TRUE, TRUE PASS_REGS);
 }
 
-Term Yap_CopyTermNoShare(Term inp) {
+Term
+Yap_CopyTermNoShare(Term inp) {
   CACHE_REGS
   return CopyTerm(inp, 0, FALSE, FALSE PASS_REGS);
 }
 
-static Int p_copy_term(USES_REGS1) /* copy term t to a new instance  */
+static Int
+p_copy_term( USES_REGS1 )		/* copy term t to a new instance  */
 {
   Term t = CopyTerm(ARG1, 2, TRUE, TRUE PASS_REGS);
   if (t == 0L)
     return FALSE;
   /* be careful, there may be a stack shift here */
-  return Yap_unify(ARG2, t);
+  return Yap_unify(ARG2,t);
 }
 
-static Int p_duplicate_term(USES_REGS1) /* copy term t to a new instance  */
+static Int
+p_duplicate_term( USES_REGS1 )		/* copy term t to a new instance  */
 {
   Term t = CopyTerm(ARG1, 2, FALSE, TRUE PASS_REGS);
   if (t == 0L)
     return FALSE;
   /* be careful, there may be a stack shift here */
-  return Yap_unify(ARG2, t);
+  return Yap_unify(ARG2,t);
 }
 
 static Int
-p_copy_term_no_delays(USES_REGS1) /* copy term t to a new instance  */
+p_copy_term_no_delays( USES_REGS1 )		/* copy term t to a new instance  */
 {
   Term t = CopyTerm(ARG1, 2, TRUE, FALSE PASS_REGS);
   if (t == 0L) {
     return FALSE;
   }
   /* be careful, there may be a stack shift here */
-  return (Yap_unify(ARG2, t));
+  return(Yap_unify(ARG2,t));
 }
 
+
+
 typedef struct bp_frame {
   CELL *start_cp;
   CELL *end_cp;
@@ -528,144 +539,149 @@ typedef struct bp_frame {
   CELL oldv;
 } bp_frame_t;
 
+
+
 typedef struct copy_frame {
   CELL *start_cp;
   CELL *end_cp;
   CELL *to;
 } copy_frame_t;
 
-static Term add_to_list(Term inp, Term v, Term t PASS_REGS) {
+static Term
+add_to_list( Term inp, Term v, Term t PASS_REGS)
+{
   Term ta[2];
 
   ta[0] = v;
   ta[1] = t;
-  return MkPairTerm(Yap_MkApplTerm(FunctorEq, 2, ta), inp);
+  return MkPairTerm(Yap_MkApplTerm( FunctorEq, 2, ta ), inp);
 }
 
-static int break_rationals_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf,
-                                        Term *vout, Term vin,
-                                        CELL *HLow USES_REGS) {
 
-  struct bp_frame *to_visit0,
-      *to_visit = (struct bp_frame *)Yap_PreAllocCodeSpace();
+static int
+break_rationals_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf, Term *vout, Term vin,CELL *HLow USES_REGS)
+{
+
+  struct bp_frame *to_visit0, *to_visit = (struct bp_frame *)Yap_PreAllocCodeSpace() ;
   CELL *HB0 = HB;
   tr_fr_ptr TR0 = TR;
 
   HB = HR;
   to_visit0 = to_visit;
-loop:
+  loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, copy_term_unk);
-  copy_term_nvar : {
-    if (IsPairTerm(d0)) {
-      CELL *ap2 = RepPair(d0);
-      fprintf(stderr, "%ld \n", RepPair(ap2[0]) - ptf);
-      if (IsVarTerm(ap2[0]) && IN_BETWEEN(HB, (ap2[0]), HR)) {
-        Term v = MkVarTerm();
-        *ptf = v;
-        vin = add_to_list(vin, (CELL)(ptf), AbsPair(ptf));
-        ptf++;
-        continue;
-      }
-      if (to_visit + 1 >= (struct bp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      *ptf++ = (CELL)(HR);
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldp = ap2;
-      d0 = to_visit->oldv = ap2[0];
-      /* fool the system into thinking we had a variable there */
-      to_visit++;
-      pt0 = ap2;
-      pt0_end = ap2 + 1;
-      ptf = HR;
-      *ap2 = AbsPair(HR);
-      HR += 2;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-      if (IsVarTerm(d0) && d0 == (CELL)ap2) {
-        RESET_VARIABLE(ptf);
-        ptf++;
-        continue;
-      }
-      d0 = Deref(d0);
-      if (!IsVarTerm(d0)) {
-        goto copy_term_nvar;
-      } else {
-        *ptf++ = d0;
-      }
-      continue;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0) + 1;
-      f = (Functor)(ap2[-1]);
-      if (IsExtensionFunctor(f)) {
-        *ptf++ = d0; /* you can just copy other extensions. */
-        continue;
-      }
-      if (IsApplTerm(ap2[0]) && IN_BETWEEN(HB, RepAppl(ap2[0]), HR)) {
-        RESET_VARIABLE(ptf);
-        vin = add_to_list(vin, (CELL)ptf, ap2[0]);
-        ptf++;
-        continue;
-      }
+  copy_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	CELL *ap2 = RepPair(d0);
+	fprintf(stderr, "%ld \n", RepPair(ap2[0])- ptf);
+	if (IsVarTerm(ap2[0]) && IN_BETWEEN(HB, (ap2[0]),HR)) {
+	  Term v = MkVarTerm();
+	  *ptf = v;
+	  vin = add_to_list(vin,  (CELL)(ptf), AbsPair(ptf) );
+	  ptf++;
+	  continue;
+	}
+	if (to_visit+1 >= (struct bp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	*ptf++ = (CELL)(HR);
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldp = ap2;
+	d0 = to_visit->oldv = ap2[0];
+	/* fool the system into thinking we had a variable there */
+	to_visit ++;
+	pt0 = ap2;
+	pt0_end = ap2 + 1;
+	ptf = HR;
+	*ap2 = AbsPair(HR);
+	HR += 2;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+	if (IsVarTerm(d0) && d0 == (CELL)ap2) {
+	  RESET_VARIABLE(ptf);
+	  ptf++;
+	  continue;
+	}
+	d0 = Deref(d0);
+	if (!IsVarTerm(d0)) {
+	  goto copy_term_nvar;
+	} else {
+	  *ptf++ = d0;
+	}
+	continue;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0)+1;
+	f = (Functor)(ap2[-1]);
+	if (IsExtensionFunctor(f)) {
+	    *ptf++ = d0;  /* you can just copy other extensions. */
+	  continue;
+	}
+	if (IsApplTerm(ap2[0]) && IN_BETWEEN(HB, RepAppl(ap2[0]),HR)) {
+	  RESET_VARIABLE(ptf);
+	  vin = add_to_list(vin, (CELL)ptf, ap2[0] );
+	  ptf++;
+	  continue;
+	}
 
-      arity_t arity = ArityOfFunctor(f);
-      if (to_visit + 1 >= (struct bp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      *ptf++ = AbsAppl(HR);
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldp = ap2;
-      d0 = to_visit->oldv = ap2[0];
-      /* fool the system into thinking we had a variable there */
-      to_visit++;
-      pt0 = ap2;
-      pt0_end = ap2 + (arity - 1);
-      ptf = HR;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-      *ptf++ = (CELL)f;
-      *ap2 = AbsAppl(HR);
-      HR += (arity + 1);
-      if (IsVarTerm(d0) && d0 == (CELL)(ap2)) {
-        RESET_VARIABLE(ptf);
-        ptf++;
-        continue;
-      }
-      d0 = Deref(d0);
-      if (!IsVarTerm(d0)) {
-        goto copy_term_nvar;
+	arity_t arity = ArityOfFunctor(f);
+	if (to_visit+1 >= (struct bp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	*ptf++ = AbsAppl(HR);
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldp = ap2;
+	d0 = to_visit->oldv = ap2[0];
+	/* fool the system into thinking we had a variable there */
+	to_visit ++;
+	pt0 = ap2;
+	pt0_end = ap2 + (arity-1);
+	ptf = HR;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+	*ptf++ =(CELL)f;
+	*ap2  = AbsAppl(HR);
+	HR += (arity+1);
+	if (IsVarTerm(d0) && d0 == (CELL)(ap2)) {
+	  RESET_VARIABLE(ptf);
+	  ptf++;
+	  continue;
+	}
+	d0 = Deref(d0);
+	if (!IsVarTerm(d0)) {
+	  goto copy_term_nvar;
+	} else {
+	  *ptf++ = d0;
+	}
+	continue;
       } else {
-        *ptf++ = d0;
+	/* just copy atoms or integers */
+	*ptf++ = d0;
       }
       continue;
-    } else {
-      /* just copy atoms or integers */
-      *ptf++ = d0;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, copy_term_unk, copy_term_nvar);
-    *ptf++ = (CELL)ptd0;
+    *ptf++ = (CELL) ptd0;
   }
   /* Do we still have compound terms to visit */
   if (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     *to_visit->oldp = to_visit->oldv;
     ptf = to_visit->to;
     pt0 = to_visit->start_cp;
@@ -678,7 +694,7 @@ loop:
   *vout = vin;
   return true;
 
-overflow:
+ overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -686,7 +702,7 @@ overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -697,7 +713,7 @@ overflow:
   /* follow chain of multi-assigned variables */
   return -1;
 
-heap_overflow:
+ heap_overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -705,7 +721,7 @@ heap_overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -713,11 +729,13 @@ heap_overflow:
   }
 #endif
   reset_trail(TR0);
-  LOCAL_Error_Size = (ADDR)AuxSp - (ADDR)to_visit0;
+  LOCAL_Error_Size = (ADDR)AuxSp-(ADDR)to_visit0;
   return -3;
 }
 
-Term Yap_BreakRational(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
+
+ Term
+Yap_BreakRational(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
   Term t = Deref(inp);
   Term tii = ti;
   tr_fr_ptr TR0 = TR;
@@ -726,7 +744,7 @@ Term Yap_BreakRational(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
     *to = ti;
     return t;
   } else if (IsPrimitiveTerm(t)) {
-    *to = ti;
+        *to = ti;
     return t;
   } else if (IsPairTerm(t)) {
     CELL *ap;
@@ -738,17 +756,16 @@ Term Yap_BreakRational(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
     HR += 2;
     {
       Int res;
-      if ((res = break_rationals_complex_term(ap - 1, ap + 1, Hi, to, ti,
-                                              Hi PASS_REGS)) < 0) {
-        HR = Hi;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_list;
+      if ((res = break_rationals_complex_term(ap-1, ap+1, Hi, to, ti, Hi PASS_REGS)) < 0) {
+	HR = Hi;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_list;
       } else if (*to == tii) {
-        HR = Hi;
-        return t;
+	HR = Hi;
+	return t;
       } else {
-        return AbsPair(Hi);
+	return AbsPair(Hi);
       }
     }
   } else {
@@ -766,42 +783,41 @@ Term Yap_BreakRational(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
     ap = RepAppl(t);
     HR[0] = (CELL)f;
     arity = ArityOfFunctor(f);
-    HR += 1 + arity;
+    HR += 1+arity;
 
-    {
+   {
       Int res;
-      if ((res = break_rationals_complex_term(ap, ap + (arity), HB0 + 1, to, ti,
-                                              HB0 PASS_REGS)) < 0) {
-        HR = HB0;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_appl;
+      if ((res = break_rationals_complex_term(ap, ap+(arity), HB0+1, to, ti, HB0 PASS_REGS)) < 0) {
+	HR = HB0;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_appl;
       } else if (*to == ti) {
-        HR = HB0;
-        return t;
+	HR = HB0;
+	return t;
       } else {
-        return AbsAppl(HB0);
+	return AbsAppl(HB0);
       }
     }
   }
 }
 
-static int break_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf, Term *of,
-                              Term oi, CELL *HLow USES_REGS) {
+  static int
+break_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf, Term *of, Term oi, CELL *HLow USES_REGS)
+{
 
-  struct copy_frame *to_visit0,
-      *to_visit = (struct copy_frame *)Yap_PreAllocCodeSpace();
+  struct copy_frame *to_visit0, *to_visit = (struct copy_frame *)Yap_PreAllocCodeSpace();
   CELL *HB0 = HB;
   tr_fr_ptr TR0 = TR;
   CELL new = 0L;
 
   HB = HLow;
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     if (new) {
@@ -811,92 +827,91 @@ loop:
       new = 0L;
     }
     deref_head(d0, break_rationals_unk);
-  break_rationals_nvar : {
-    CELL first;
-    CELL *newp;
-    if (IsPairTerm(d0)) {
-      CELL *ap2 = RepPair(d0);
+  break_rationals_nvar:
+    {
+      CELL first;
+      CELL *newp;
+      if (IsPairTerm(d0)) {
+	CELL *ap2 = RepPair(d0);
 
-      if (IsVarTerm(first = *ap2) && (newp = (CELL *)first) && newp >= HB &&
-          newp < HR) {
-        // found a marked term:
-      found_term:
-        if (!IsVarTerm(*newp)) {
-          Term v = (CELL)newp, t = *newp;
-          RESET_VARIABLE(newp);
-          oi = add_to_list(oi, v, t PASS_REGS);
-        }
-        *ptf++ = (CELL)newp;
-        continue;
+	if (IsVarTerm(first = *ap2) && (newp = (CELL*)first) && newp >= HB && newp < HR) {
+	  // found a marked term:
+	found_term:
+	  if (!IsVarTerm(*newp)) {
+	    Term v = (CELL)newp, t = *newp;
+	    RESET_VARIABLE(newp);
+	    oi = add_to_list( oi, v, t PASS_REGS);
+	  }
+	  *ptf++ = (CELL)newp;
+	  continue;
+	}
+	new = (CELL)ptf;
+	*ptf++ = AbsPair(HR);
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct copy_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit ++;
+	}
+	pt0 = ap2 - 1;
+	pt0_end = ap2 + 1;
+	ptf = HR;
+	HR += 2;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  *ptf++ = d0;  /* you can just share extensions, what about DB? */
+	  continue;
+	}
+	if (IsVarTerm(first = ap2[1]) && (newp = (CELL*)first) && newp >= HB && newp < HR) {
+	  goto found_term;
+	}
+	// new
+	/* store the terms to visit */
+	new = (CELL)ptf;
+	*ptf++ = AbsAppl(HR);
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct copy_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit ++;
+	}
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+	/* store the functor for the new term */
+	HR[0] = (CELL)f;
+	ptf = HR+1;
+	HR += 1+d0;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else {
+	/* just copy atoms or integers */
+	*ptf++ = d0;
       }
-      new = (CELL)ptf;
-      *ptf++ = AbsPair(HR);
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct copy_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit++;
-      }
-      pt0 = ap2 - 1;
-      pt0_end = ap2 + 1;
-      ptf = HR;
-      HR += 2;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        *ptf++ = d0; /* you can just share extensions, what about DB? */
-        continue;
-      }
-      if (IsVarTerm(first = ap2[1]) && (newp = (CELL *)first) && newp >= HB &&
-          newp < HR) {
-        goto found_term;
-      }
-      // new
-      /* store the terms to visit */
-      new = (CELL)ptf;
-      *ptf++ = AbsAppl(HR);
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct copy_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit++;
-      }
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
-      /* store the functor for the new term */
-      HR[0] = (CELL)f;
-      ptf = HR + 1;
-      HR += 1 + d0;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-    } else {
-      /* just copy atoms or integers */
-      *ptf++ = d0;
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, break_rationals_unk, break_rationals_nvar);
     *ptf++ = d0;
   }
   /* Do we still have compound terms to visit */
   if (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -909,14 +924,14 @@ loop:
   *of = oi;
   return TRUE;
 
-overflow:
+ overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
   /* restore our nice, friendly, term to its original state */
   HB = HB0;
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -925,24 +940,25 @@ overflow:
   /* follow chain of multi-assigned variables */
   return -1;
 
-heap_overflow:
+ heap_overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
   /* restore our nice, friendly, term to its original state */
   HB = HB0;
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
   }
   reset_trail(TR0);
-  LOCAL_Error_Size = (ADDR)AuxSp - (ADDR)to_visit0;
+  LOCAL_Error_Size = (ADDR)AuxSp-(ADDR)to_visit0;
   return -3;
 }
 
-Term Yap_BreakTerm(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
+ Term
+Yap_BreakTerm(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
   Term t = Deref(inp);
   tr_fr_ptr TR0 = TR;
 
@@ -952,7 +968,7 @@ Term Yap_BreakTerm(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
   } else if (IsPrimitiveTerm(t)) {
     *to = ti;
     return t;
-  } else {
+  } else  {
     CELL *ap;
     CELL *Hi = HR;
 
@@ -962,30 +978,36 @@ Term Yap_BreakTerm(Term inp, UInt arity, Term *to, Term ti USES_REGS) {
     {
       int res;
 
-      if ((res = break_complex_term(ap - 1, ap, Hi, to, ti, Hi PASS_REGS)) <
-          0) {
-        HR = Hi;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_term;
+      if ((res = break_complex_term(ap-1, ap, Hi, to, ti, Hi PASS_REGS)) < 0) {
+	HR = Hi;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_term;
       }
     }
     return Hi[0];
   }
 }
 
-static Int p_break_rational(USES_REGS1) {
+
+static Int
+p_break_rational( USES_REGS1 )
+{
   Term tf;
   return Yap_unify(ARG2, Yap_BreakTerm(ARG1, 4, &tf, ARG4 PASS_REGS)) &&
-         Yap_unify(tf, ARG3);
+    Yap_unify(tf, ARG3);
 }
 
-static Int p_break_rational3(USES_REGS1) {
+
+static Int
+p_break_rational3( USES_REGS1 )
+{
   Term tf;
   return Yap_unify(ARG2, Yap_BreakTerm(ARG1, 4, &tf, TermNil PASS_REGS)) &&
-         Yap_unify(tf, ARG3);
+    Yap_unify(tf, ARG3);
 }
 
+
 /*
    FAST EXPORT ROUTINE. Export a Prolog term to something like:
 
@@ -1003,262 +1025,266 @@ static Int p_break_rational3(USES_REGS1) {
 
  */
 
-static inline CELL *CellDifH(CELL *hptr, CELL *hlow) {
-  return (CELL *)((char *)hptr - (char *)hlow);
+static inline
+CELL *CellDifH(CELL *hptr, CELL *hlow)
+{
+  return (CELL *)((char *)hptr-(char *)hlow);
 }
 
-#define AdjustSizeAtom(X) (((CELL)(X) + (8 - 1)) & ~(8 - 1))
+#define AdjustSizeAtom(X)	(((CELL)(X)+(8-1)) & ~(8-1))
 
-static inline CELL *AdjustSize(CELL *x, char *buf) {
-  UInt offset = (char *)x - buf;
-  return (CELL *)(buf + AdjustSizeAtom(offset));
+static inline
+CELL *AdjustSize(CELL *x, char *buf)
+{
+  UInt offset = (char *)x-buf;
+  return (CELL*)(buf+AdjustSizeAtom(offset));
 }
 
 /* export an atom from the symbol table to a buffer */
-static inline Atom export_atom(Atom at, char **hpp, char *buf, size_t len) {
+static inline
+Atom export_atom(Atom at, char **hpp, char *buf, size_t len)
+{
   char *ptr, *p0;
   size_t sz;
 
   ptr = *hpp;
-  ptr = (char *)AdjustSize((CELL *)ptr, buf);
+  ptr = (char *)AdjustSize((CELL*)ptr, buf);
 
   p0 = ptr;
   *ptr++ = 0;
   sz = strlen(RepAtom(at)->StrOfAE);
-  if (sz + 1 >= len)
+  if (sz + 1  >= len)
     return (Atom)NULL;
   strcpy(ptr, RepAtom(at)->StrOfAE);
-  *hpp = ptr + (sz + 1);
-  return (Atom)(p0 - buf);
+  *hpp = ptr+(sz+1);
+  return (Atom)(p0-buf);
 }
 
 /* place a buffer: first arity then the atom */
-static inline Functor export_functor(Functor f, char **hpp, char *buf,
-                                     size_t len) {
+static inline
+Functor export_functor(Functor f, char **hpp, char *buf, size_t len)
+{
   CELL *hptr = AdjustSize((CELL *)*hpp, buf);
   UInt arity = ArityOfFunctor(f);
-  if (2 * sizeof(CELL) >= len)
+  if (2*sizeof(CELL) >= len)
     return NULL;
   hptr[0] = arity;
-  *hpp = (char *)(hptr + 1);
+  *hpp = (char *)(hptr+1);
   if (!export_atom(NameOfFunctor(f), hpp, buf, len))
     return NULL;
   /* increment so that it cannot be mistaken with a functor on the stack,
      (increment is used as a tag ........01
   */
-  return (Functor)(((char *)hptr - buf) + 1);
+  return (Functor)(((char *)hptr-buf)+1);
 }
 
-#define export_derefa_body(D, A, LabelUnk, LabelNonVar)                        \
-  do {                                                                         \
-    if ((CELL *)(D) < CellDifH(HR, HLow)) {                                    \
-      (A) = (CELL *)(D);                                                       \
-      break;                                                                   \
-    }                                                                          \
-    (A) = (CELL *)(D);                                                         \
-    (D) = *(CELL *)(D);                                                        \
-    if (!IsVarTerm(D))                                                         \
-      goto LabelNonVar;                                                        \
-  LabelUnk:;                                                                   \
-  } while (Unsigned(A) != (D))
+#define export_derefa_body(D,A,LabelUnk,LabelNonVar)	     \
+		do {                                         \
+		  if ((CELL *)(D) < CellDifH(HR,HLow)) { (A) = (CELL *)(D); break; } \
+                   (A) = (CELL *)(D);                        \
+                   (D) = *(CELL *)(D);                       \
+                   if(!IsVarTerm(D)) goto LabelNonVar;       \
+		LabelUnk:      ;                             \
+		} while (Unsigned(A) != (D))
 
-static int export_term_to_buffer(Term inpt, char *buf, char *bptr, CELL *t0,
-                                 CELL *tf, size_t len) {
+
+static int
+export_term_to_buffer(Term inpt, char *buf, char *bptr, CELL *t0 , CELL *tf, size_t len)
+{
   char *td = bptr;
   CELL *bf = (CELL *)buf;
-  if (buf + len < (char *)((CELL *)td + (tf - t0))) {
+  if (buf + len < (char *)((CELL *)td + (tf-t0))) {
     return FALSE;
   }
-  memmove((void *)td, (void *)t0, (tf - t0) * sizeof(CELL));
-  bf[0] = (td - buf);
-  bf[1] = (tf - t0);
+  memmove((void *)td, (void *)t0, (tf-t0)* sizeof(CELL));
+  bf[0] = (td-buf);
+  bf[1] = (tf-t0);
   bf[2] = inpt;
-  return bf[0] + sizeof(CELL) * bf[1];
+  return bf[0]+sizeof(CELL)*bf[1];
 }
 
-static size_t export_complex_term(Term tf, CELL *pt0, CELL *pt0_end, char *buf,
-                                  size_t len0, int newattvs, CELL *ptf,
-                                  CELL *HLow USES_REGS) {
-  struct cp_frame *to_visit0,
-      *to_visit = (struct cp_frame *)Yap_PreAllocCodeSpace();
+
+static size_t
+export_complex_term(Term tf, CELL *pt0, CELL *pt0_end, char * buf, size_t len0, int newattvs, CELL *ptf, CELL *HLow USES_REGS)
+{
+  struct cp_frame *to_visit0, *to_visit = (struct cp_frame *)Yap_PreAllocCodeSpace();
   CELL *HB0 = HB;
   tr_fr_ptr TR0 = TR;
   int ground = TRUE;
-  char *bptr = buf + 3 * sizeof(CELL);
+  char *bptr = buf+ 3*sizeof(CELL);
   size_t len = len0;
 
   HB = HLow;
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, export_term_unk);
-  export_term_nvar : {
-    if (IsPairTerm(d0)) {
-      CELL *ap2 = RepPair(d0);
-      if (ap2 < CellDifH(HR, HLow)) {
-        /* If this is newer than the current term, just reuse */
-        *ptf++ = d0;
-        continue;
-      }
-      *ptf = AbsPair(CellDifH(HR, HLow));
-      ptf++;
+  export_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	CELL *ap2 = RepPair(d0);
+	if (ap2 < CellDifH(HR,HLow)) {
+	  /* If this is newer than the current term, just reuse */
+	  *ptf++ = d0;
+	  continue;
+	}
+	*ptf = AbsPair(CellDifH(HR,HLow));
+	ptf++;
 #ifdef RATIONAL_TREES
-      if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldv = *pt0;
-      to_visit->ground = ground;
-      /* fool the system into thinking we had a variable there */
-      *pt0 = AbsPair(CellDifH(HR, HLow));
-      to_visit++;
+	if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldv = *pt0;
+	to_visit->ground = ground;
+	/* fool the system into thinking we had a variable there */
+	*pt0 = AbsPair(CellDifH(HR,HLow));
+	to_visit ++;
 #else
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit->ground = ground;
-        to_visit++;
-      }
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit->ground = ground;
+	  to_visit ++;
+	}
 #endif
-      pt0 = ap2 - 1;
-      pt0_end = ap2 + 1;
-      ptf = HR;
-      HR += 2;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      if (ap2 < CellDifH(HR, HLow)) {
-        /* If this is newer than the current term, just reuse */
-        *ptf++ = d0;
-        continue;
-      }
-      f = (Functor)(*ap2);
+	pt0 = ap2 - 1;
+	pt0_end = ap2 + 1;
+	ptf = HR;
+	HR += 2;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	if (ap2 < CellDifH(HR,HLow)) {
+	  /* If this is newer than the current term, just reuse */
+	  *ptf++ = d0;
+	  continue;
+	}
+	f = (Functor)(*ap2);
 
-      *ptf++ = AbsAppl(CellDifH(HR, HLow));
-      if (IsExtensionFunctor(f)) {
-        UInt sz;
+	*ptf++ = AbsAppl(CellDifH(HR,HLow));
+	if (IsExtensionFunctor(f)) {
+	  UInt sz;
 
-        /* make sure to export floats */
-        if (f == FunctorDouble) {
-          sz = sizeof(Float) / sizeof(CELL) + 2;
-        } else if (f == FunctorLongInt) {
-          sz = 3;
-        } else if (f == FunctorString) {
-          sz = 3 + ap2[1];
-        } else {
-          CELL *pt = ap2 + 1;
-          sz = 2 + sizeof(MP_INT) +
-               (((MP_INT *)(pt + 1))->_mp_alloc * sizeof(mp_limb_t));
-        }
-        if (HR + sz > ASP - 2048) {
-          goto overflow;
-        }
-        memmove((void *)HR, (void *)ap2, sz * sizeof(CELL));
-        HR += sz;
-        continue;
-      }
-      /* store the terms to visit */
+	  /* make sure to export floats */
+	  if (f== FunctorDouble) {
+	    sz = sizeof(Float)/sizeof(CELL)+2;
+	  } else if (f== FunctorLongInt) {
+	    sz = 3;
+	  } else if (f== FunctorString) {
+	    sz = 3+ap2[1];
+	  } else {
+	    CELL *pt = ap2+1;
+	    sz = 2+sizeof(MP_INT)+(((MP_INT *)(pt+1))->_mp_alloc*sizeof(mp_limb_t));
+	  }
+	  if (HR+sz > ASP - 2048) {
+	    goto overflow;
+	  }
+	  memmove((void *)HR, (void *)ap2, sz*sizeof(CELL));
+	  HR += sz;
+	  continue;
+	}
+	/* store the terms to visit */
 #ifdef RATIONAL_TREES
-      if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldv = *pt0;
-      to_visit->ground = ground;
-      /* fool the system into thinking we had a variable there */
-      *pt0 = AbsAppl(HR);
-      to_visit++;
+	if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldv = *pt0;
+	to_visit->ground = ground;
+	/* fool the system into thinking we had a variable there */
+	*pt0 = AbsAppl(HR);
+	to_visit ++;
 #else
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit->ground = ground;
-        to_visit++;
-      }
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit->ground = ground;
+	  to_visit ++;
+	}
 #endif
-      ground = (f != FunctorMutable);
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
-      /* store the functor for the new term */
-      ptf = HR + 1;
-      HR += 1 + d0;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-      ptf[-1] = (CELL)export_functor(f, &bptr, buf, len);
-      len = len0 - (bptr - buf);
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-    } else {
-      if (IsAtomTerm(d0)) {
-        *ptf = MkAtomTerm(export_atom(AtomOfTerm(d0), &bptr, buf, len));
-        ptf++;
-        len = len0 - (bptr - buf);
+	ground = (f != FunctorMutable);
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+	/* store the functor for the new term */
+	ptf = HR+1;
+	HR += 1+d0;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+	ptf[-1] = (CELL)export_functor(f, &bptr, buf, len);
+	len = len0 - (bptr-buf);
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
       } else {
-        *ptf++ = d0;
+	if (IsAtomTerm(d0)) {
+	  *ptf = MkAtomTerm(export_atom(AtomOfTerm(d0), &bptr, buf, len));
+	  ptf++;
+	  len = len0 - (bptr-buf);
+	} else {
+	  *ptf++ = d0;
+	}
       }
+      continue;
     }
-    continue;
-  }
 
     export_derefa_body(d0, ptd0, export_term_unk, export_term_nvar);
     ground = FALSE;
-    if (ptd0 < CellDifH(HR, HLow)) {
+    if (ptd0 < CellDifH(HR,HLow)) {
       /* we have already found this cell */
-      *ptf++ = (CELL)ptd0;
+      *ptf++ = (CELL) ptd0;
     } else {
 #if COROUTINING
       if (newattvs && IsAttachedTerm((CELL)ptd0) && FALSE) {
-        /* if unbound, call the standard export term routine */
-        struct cp_frame *bp;
+	/* if unbound, call the standard export term routine */
+	struct cp_frame *bp;
 
-        CELL new;
+	CELL new;
 
-        bp = to_visit;
-        if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp,
-                                                          ptf PASS_REGS)) {
-          goto overflow;
-        }
-        to_visit = bp;
-        new = *ptf;
-        Bind_NonAtt(ptd0, new);
-        ptf++;
+	bp = to_visit;
+	if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
+	  goto overflow;
+	}
+	to_visit = bp;
+	new = *ptf;
+	Bind_NonAtt(ptd0, new);
+	ptf++;
       } else {
 #endif
-        /* first time we met this term */
-        *ptf = (CELL)CellDifH(ptf, HLow);
-        if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-          /* Trail overflow */
-          if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-            goto trail_overflow;
-          }
-        }
-        Bind_NonAtt(ptd0, (CELL)ptf);
-        ptf++;
+	/* first time we met this term */
+	*ptf = (CELL)CellDifH(ptf,HLow);
+	if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
+	  /* Trail overflow */
+	  if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	    goto trail_overflow;
+	  }
+	}
+	Bind_NonAtt(ptd0, (CELL)ptf);
+	ptf++;
 #ifdef COROUTINING
       }
 #endif
@@ -1266,7 +1292,7 @@ loop:
   }
   /* Do we still have compound terms to visit */
   if (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -1282,7 +1308,7 @@ loop:
   HB = HB0;
   return export_term_to_buffer(tf, buf, bptr, HLow, HR, len0);
 
-overflow:
+ overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -1290,7 +1316,7 @@ overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -1309,7 +1335,7 @@ trail_overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -1317,15 +1343,15 @@ trail_overflow:
   }
 #endif
   {
-    tr_fr_ptr oTR = TR;
+    tr_fr_ptr oTR =  TR;
     reset_trail(TR0);
-    if (!Yap_growtrail((oTR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
+    if (!Yap_growtrail((oTR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
       return -4;
     }
     return -2;
   }
 
-heap_overflow:
+ heap_overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -1333,7 +1359,7 @@ heap_overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -1341,12 +1367,12 @@ heap_overflow:
   }
 #endif
   reset_trail(TR0);
-  LOCAL_Error_Size = (ADDR)AuxSp - (ADDR)to_visit0;
+  LOCAL_Error_Size = (ADDR)AuxSp-(ADDR)to_visit0;
   return -3;
 }
 
-static size_t ExportTerm(Term inp, char *buf, size_t len, UInt arity,
-                         int newattvs USES_REGS) {
+static size_t
+ExportTerm(Term inp, char * buf, size_t len, UInt arity, int newattvs USES_REGS) {
   Term t = Deref(inp);
   tr_fr_ptr TR0 = TR;
   size_t res = 0;
@@ -1354,62 +1380,73 @@ static size_t ExportTerm(Term inp, char *buf, size_t len, UInt arity,
 
   do {
     if (IsVarTerm(t) || IsIntTerm(t)) {
-      return export_term_to_buffer(t, buf, buf + 3 * sizeof(CELL), &inp, &inp,
-                                   len);
+      return export_term_to_buffer(t, buf, buf+ 3*sizeof(CELL), &inp, &inp, len);
     }
     if (IsAtomTerm(t)) {
       Atom at = AtomOfTerm(t);
-      char *b = buf + 3 * sizeof(CELL);
-      export_atom(at, &b, b, len - 3 * sizeof(CELL));
+      char *b = buf+3*sizeof(CELL);
+      export_atom(at, &b, b, len-3*sizeof(CELL));
       return export_term_to_buffer(t, buf, b, &inp, &inp, len);
     }
     if ((Int)res < 0) {
       HR = Hi;
       TR = TR0;
-      if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-        return res;
+      if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	return res;
     }
     Hi = HR;
     TR0 = TR;
-    res = export_complex_term(inp, &t - 1, &t, buf, len, newattvs, Hi,
-                              Hi PASS_REGS);
+    res = export_complex_term(inp, &t-1, &t, buf, len, newattvs, Hi, Hi PASS_REGS);
   } while ((Int)res < 0);
   return res;
 }
 
-size_t Yap_ExportTerm(Term inp, char *buf, size_t len, UInt arity) {
+size_t
+Yap_ExportTerm(Term inp, char * buf, size_t len, UInt arity) {
   CACHE_REGS
   return ExportTerm(inp, buf, len, arity, TRUE PASS_REGS);
 }
 
-static CELL *ShiftPtr(CELL t, char *base) { return (CELL *)(base + t); }
 
-static Atom addAtom(Atom t, char *buf) {
-  char *s = buf + (UInt)t;
-
-  if (!*s) {
-    return Yap_LookupAtom(s + 1);
-  }
-  return NULL;
+static CELL *
+ShiftPtr(CELL t, char *base)
+{
+  return (CELL *)(base+t);
 }
 
-static UInt FetchFunctor(CELL *pt, char *buf) {
-  CELL *ptr = (CELL *)(buf + (*pt - 1));
+static Atom
+addAtom(Atom t, char *buf)
+{
+  char *s = buf+(UInt)t;
+
+  if (!*s) {
+    return Yap_LookupAtom(s+1);
+  }
+    return NULL;
+}
+
+static UInt
+FetchFunctor(CELL *pt, char *buf)
+{
+  CELL *ptr = (CELL *)(buf+(*pt-1));
   // do arity first
   UInt arity = *ptr++;
   Atom name, at;
   // and then an atom
   ptr = AdjustSize(ptr, buf);
-  name = (Atom)((char *)ptr - buf);
+  name = (Atom)((char *)ptr-buf);
   at = addAtom(name, buf);
   *pt = (CELL)Yap_MkFunctor(at, arity);
   return arity;
 }
 
+
 static CELL *import_compound(CELL *hp, char *abase, char *buf, CELL *amax);
 static CELL *import_pair(CELL *hp, char *abase, char *buf, CELL *amax);
 
-static CELL *import_arg(CELL *hp, char *abase, char *buf, CELL *amax) {
+static CELL *
+import_arg(CELL *hp, char *abase, char *buf, CELL *amax)
+{
   Term t = *hp;
   if (IsVarTerm(t)) {
     hp[0] = (CELL)ShiftPtr(t, abase);
@@ -1431,26 +1468,31 @@ static CELL *import_arg(CELL *hp, char *abase, char *buf, CELL *amax) {
   return amax;
 }
 
-static CELL *import_compound(CELL *hp, char *abase, char *buf, CELL *amax) {
+static CELL *
+import_compound(CELL *hp, char *abase, char *buf, CELL *amax)
+{
   Functor f = (Functor)*hp;
   UInt ar, i;
 
   if (!((CELL)f & 1) && IsExtensionFunctor(f))
     return amax;
   ar = FetchFunctor(hp, buf);
-  for (i = 1; i <= ar; i++) {
-    amax = import_arg(hp + i, abase, buf, amax);
+  for (i=1; i<=ar; i++) {
+    amax = import_arg(hp+i, abase, buf, amax);
   }
   return amax;
 }
 
-static CELL *import_pair(CELL *hp, char *abase, char *buf, CELL *amax) {
+static CELL *
+import_pair(CELL *hp, char *abase, char *buf, CELL *amax)
+{
   amax = import_arg(hp, abase, buf, amax);
-  amax = import_arg(hp + 1, abase, buf, amax);
+  amax = import_arg(hp+1, abase, buf, amax);
   return amax;
 }
 
-Term Yap_ImportTerm(char *buf) {
+Term
+Yap_ImportTerm(char * buf) {
   CACHE_REGS
   CELL *bc = (CELL *)buf;
   size_t sz = bc[1];
@@ -1461,18 +1503,18 @@ Term Yap_ImportTerm(char *buf) {
   else if (IsIntTerm(tinp))
     return tinp;
   else if (IsAtomTerm(tinp)) {
-    tret = MkAtomTerm(addAtom(NULL, (char *)(bc + 3)));
+    tret = MkAtomTerm(addAtom(NULL,(char *)(bc+3)));
     return tret;
   }
   // call the gc/stack shifter mechanism
   // if not enough stack available
   while (HR + sz > ASP - 4096) {
-    if (!Yap_gcl((sz + 4096) * sizeof(CELL), PP->ArityOfPE, ENV, gc_P(P, CP))) {
+    if (!Yap_gcl( (sz+4096)*sizeof(CELL), PP->ArityOfPE, ENV, gc_P(P,CP))) {
       Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
       return 0L;
     }
   }
-  memmove(HR, buf + bc[0], sizeof(CELL) * sz);
+  memmove(HR, buf+bc[0], sizeof(CELL)*sz);
   if (IsApplTerm(tinp)) {
     tret = AbsAppl(HR);
     import_compound(HR, (char *)HR, buf, HR);
@@ -1484,17 +1526,20 @@ Term Yap_ImportTerm(char *buf) {
   return tret;
 }
 
-size_t Yap_SizeOfExportedTerm(char *buf) {
+size_t
+Yap_SizeOfExportedTerm(char * buf) {
   CELL *bc = (CELL *)buf;
 
-  return bc[0] + bc[1] * sizeof(CELL);
+  return bc[0]+bc[1]*sizeof(CELL);
 }
 
-static Int p_export_term(USES_REGS1) {
+static Int
+p_export_term( USES_REGS1 )
+{
   size_t sz = 4096, osz;
   char *export_buf;
   do {
-    export_buf = malloc(sz);
+    export_buf  = malloc(sz);
     if (!export_buf)
       return FALSE;
     if (!(osz = Yap_ExportTerm(ARG1, export_buf, sz, 1))) {
@@ -1502,19 +1547,23 @@ static Int p_export_term(USES_REGS1) {
       free(export_buf);
     }
   } while (!osz);
-  return Yap_unify(ARG3, MkIntegerTerm(osz)) &&
-         Yap_unify(ARG2, MkIntegerTerm((Int)export_buf));
+  return Yap_unify(ARG3,MkIntegerTerm(osz)) &&
+    Yap_unify(ARG2, MkIntegerTerm((Int)export_buf));
 }
 
-static Int p_import_term(USES_REGS1) {
+static Int
+p_import_term( USES_REGS1 )
+{
   char *export_buf = (char *)IntegerOfTerm(Deref(ARG1));
   if (!export_buf)
     return FALSE;
-  Int out = Yap_unify(ARG2, Yap_ImportTerm(export_buf));
+  Int out = Yap_unify(ARG2,Yap_ImportTerm(export_buf));
   return out;
 }
 
-static Int p_kill_exported_term(USES_REGS1) {
+static Int
+p_kill_exported_term( USES_REGS1 )
+{
   char *export_buf = (char *)IntegerOfTerm(Deref(ARG1));
   if (!export_buf)
     return FALSE;
@@ -1522,8 +1571,9 @@ static Int p_kill_exported_term(USES_REGS1) {
   return TRUE;
 }
 
-static Term vars_in_complex_term(register CELL *pt0, register CELL *pt0_end,
-                                 Term inp USES_REGS) {
+
+static Term vars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Term inp USES_REGS)
+{
 
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   register tr_fr_ptr TR0 = TR;
@@ -1531,82 +1581,84 @@ static Term vars_in_complex_term(register CELL *pt0, register CELL *pt0_end,
   CELL output = AbsPair(HR);
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_in_term_unk);
-  vars_in_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_in_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      /* store the terms to visit */
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	/* store the terms to visit */
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
+      continue;
     }
-    continue;
-  }
+
 
     derefa_body(d0, ptd0, vars_in_term_unk, vars_in_term_nvar);
     /* do or pt2 are unbound  */
     *ptd0 = TermNil;
     /* leave an empty slot to fill in later */
-    if (HR + 1024 > ASP) {
+    if (HR+1024 > ASP) {
       goto global_overflow;
     }
-    HR[1] = AbsPair(HR + 2);
+    HR[1] = AbsPair(HR+2);
     HR += 2;
     HR[-2] = (CELL)ptd0;
     /* next make sure noone will see this as a variable again */
     if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
       /* Trail overflow */
-      if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-        goto trail_overflow;
+      if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	goto trail_overflow;
       }
     }
     TrailTerm(TR++) = (CELL)ptd0;
@@ -1632,17 +1684,17 @@ loop:
     /* close the list */
     Term t2 = Deref(inp);
     if (IsVarTerm(t2)) {
-      RESET_VARIABLE(HR - 1);
-      Yap_unify((CELL)(HR - 1), inp);
+      RESET_VARIABLE(HR-1);
+      Yap_unify((CELL)(HR-1),inp);
     } else {
-      HR[-1] = t2; /* don't need to trail */
+      HR[-1] = t2;		/* don't need to trail */
     }
-    return (output);
+    return(output);
   } else {
-    return (inp);
+    return(inp);
   }
 
-trail_overflow:
+ trail_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -1651,14 +1703,14 @@ trail_overflow:
   }
 #endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   return 0L;
 
-aux_overflow:
-  LOCAL_Error_Size = (to_visit - to_visit0) * sizeof(CELL **);
+ aux_overflow:
+  LOCAL_Error_Size = (to_visit-to_visit0)*sizeof(CELL **);
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -1672,7 +1724,7 @@ aux_overflow:
   HR = InitialH;
   return 0L;
 
-global_overflow:
+ global_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -1684,11 +1736,14 @@ global_overflow:
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   LOCAL_Error_TYPE = RESOURCE_ERROR_STACK;
-  LOCAL_Error_Size = (ASP - HR) * sizeof(CELL);
+  LOCAL_Error_Size = (ASP-HR)*sizeof(CELL);
   return 0L;
+
 }
 
-static int expand_vts(int args USES_REGS) {
+static int
+expand_vts( int args USES_REGS )
+{
   UInt expand = LOCAL_Error_Size;
   yap_error_number yap_errno = LOCAL_Error_TYPE;
 
@@ -1701,13 +1756,13 @@ static int expand_vts(int args USES_REGS) {
     }
   } else if (yap_errno == RESOURCE_ERROR_AUXILIARY_STACK) {
     /* Aux space overflow */
-    if (expand > 4 * 1024 * 1024)
-      expand = 4 * 1024 * 1024;
+    if (expand > 4*1024*1024)
+      expand = 4*1024*1024;
     if (!Yap_ExpandPreAllocCodeSpace(expand, NULL, TRUE)) {
       return FALSE;
     }
   } else {
-    if (!Yap_gcl(expand, 3, ENV, gc_P(P, CP))) {
+    if (!Yap_gcl(expand, 3, ENV, gc_P(P,CP))) {
       Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_variables");
       return FALSE;
     }
@@ -1716,12 +1771,13 @@ static int expand_vts(int args USES_REGS) {
 }
 
 static Int
-p_variables_in_term(USES_REGS1) /* variables in term t		 */
+p_variables_in_term( USES_REGS1 )	/* variables in term t		 */
 {
   Term out, inp;
   int count;
 
-restart:
+
+ restart:
   count = 0;
   inp = Deref(ARG2);
   while (!IsVarTerm(inp) && IsPairTerm(inp)) {
@@ -1732,11 +1788,11 @@ restart:
       TrailTerm(TR++) = t;
       count++;
       if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-        clean_tr(TR - count PASS_REGS);
-        if (!Yap_growtrail(count * sizeof(tr_fr_ptr *), FALSE)) {
-          return FALSE;
-        }
-        goto restart;
+	clean_tr(TR-count PASS_REGS);
+	if (!Yap_growtrail(count*sizeof(tr_fr_ptr *), FALSE)) {
+	  return FALSE;
+	}
+	goto restart;
       }
     }
     inp = TailOfTerm(inp);
@@ -1746,35 +1802,39 @@ restart:
     if (IsVarTerm(t)) {
       out = AbsPair(HR);
       HR += 2;
-      RESET_VARIABLE(HR - 2);
-      RESET_VARIABLE(HR - 1);
-      Yap_unify((CELL)(HR - 2), ARG1);
-      Yap_unify((CELL)(HR - 1), ARG2);
-    } else if (IsPrimitiveTerm(t))
+      RESET_VARIABLE(HR-2);
+      RESET_VARIABLE(HR-1);
+      Yap_unify((CELL)(HR-2),ARG1);
+      Yap_unify((CELL)(HR-1),ARG2);
+    }  else if (IsPrimitiveTerm(t))
       out = ARG2;
     else if (IsPairTerm(t)) {
-      out =
-          vars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1, ARG2 PASS_REGS);
-    } else {
+      out = vars_in_complex_term(RepPair(t)-1,
+				 RepPair(t)+1, ARG2 PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = vars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                 ARG2 PASS_REGS);
+      out = vars_in_complex_term(RepAppl(t),
+				 RepAppl(t)+
+				 ArityOfFunctor(f), ARG2 PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
-  clean_tr(TR - count PASS_REGS);
-  return Yap_unify(ARG3, out);
+  clean_tr(TR-count PASS_REGS);
+  return Yap_unify(ARG3,out);
 }
 
-static Int p_term_variables(USES_REGS1) /* variables in term t		 */
+
+static Int
+p_term_variables( USES_REGS1 )	/* variables in term t		 */
 {
   Term out;
 
   if (!Yap_IsListOrPartialListTerm(ARG2)) {
-    Yap_Error(TYPE_ERROR_LIST, ARG2, "term_variables/2");
+    Yap_Error(TYPE_ERROR_LIST,ARG2,"term_variables/2");
     return FALSE;
   }
 
@@ -1782,55 +1842,60 @@ static Int p_term_variables(USES_REGS1) /* variables in term t		 */
     Term t = Deref(ARG1);
     if (IsVarTerm(t)) {
       Term out = Yap_MkNewPairTerm();
-      return Yap_unify(t, HeadOfTerm(out)) &&
-             Yap_unify(TermNil, TailOfTerm(out)) && Yap_unify(out, ARG2);
-    } else if (IsPrimitiveTerm(t)) {
+      return
+	Yap_unify(t,HeadOfTerm(out)) &&
+	Yap_unify(TermNil, TailOfTerm(out)) &&
+	Yap_unify(out, ARG2);
+    }  else if (IsPrimitiveTerm(t)) {
       return Yap_unify(TermNil, ARG2);
     } else if (IsPairTerm(t)) {
-      out = vars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                 TermNil PASS_REGS);
-    } else {
+      out = vars_in_complex_term(RepPair(t)-1,
+				 RepPair(t)+1, TermNil PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = vars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                 TermNil PASS_REGS);
+      out = vars_in_complex_term(RepAppl(t),
+				 RepAppl(t)+
+				 ArityOfFunctor(f), TermNil PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
-  return Yap_unify(ARG2, out);
+  return Yap_unify(ARG2,out);
 }
 
 /**
  * Exports a nil-terminated list with all the variables in a term.
  * @param[t] the term
- * @param[arity] the arity of the calling predicate (required for exact garbage
- * collection).
+ * @param[arity] the arity of the calling predicate (required for exact garbage collection).
  * @param[USES_REGS] threading
  */
-Term Yap_TermVariables(
-    Term t, UInt arity USES_REGS) /* variables in term t		 */
+Term
+Yap_TermVariables( Term t, UInt arity USES_REGS )	/* variables in term t		 */
 {
   Term out;
 
-  do {
+   do {
     t = Deref(t);
     if (IsVarTerm(t)) {
       return MkPairTerm(t, TermNil);
-    } else if (IsPrimitiveTerm(t)) {
+    }  else if (IsPrimitiveTerm(t)) {
       return TermNil;
     } else if (IsPairTerm(t)) {
-      out = vars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                 TermNil PASS_REGS);
-    } else {
+      out = vars_in_complex_term(RepPair(t)-1,
+				 RepPair(t)+1, TermNil PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = vars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                 TermNil PASS_REGS);
+      out = vars_in_complex_term(RepAppl(t),
+				 RepAppl(t)+
+				 ArityOfFunctor(f), TermNil PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(arity PASS_REGS))
-        return FALSE;
+      if (!expand_vts( arity PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
   return out;
@@ -1841,134 +1906,136 @@ typedef struct att_rec {
   CELL oval;
 } att_rec_t;
 
-static Term attvars_in_complex_term(register CELL *pt0, register CELL *pt0_end,
-                                    Term inp USES_REGS) {
+static Term attvars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Term inp USES_REGS)
+{
   int lvl = push_text_stack();
-  att_rec_t *to_visit0, *to_visit = Malloc(1024 * sizeof(att_rec_t));
+  att_rec_t *to_visit0, *to_visit = Malloc(1024*sizeof(att_rec_t));
   att_rec_t *to_visit_max;
   register tr_fr_ptr TR0 = TR;
   CELL *InitialH = HR;
   CELL output = AbsPair(HR);
 
   to_visit0 = to_visit;
-  to_visit_max = to_visit0 + 1024;
-restart:
+  to_visit_max = to_visit0+1024;
+ restart:
   do {
-    while (pt0 < pt0_end) {
-      register CELL d0;
-      register CELL *ptd0;
-      ++pt0;
-      ptd0 = pt0;
-      d0 = *ptd0;
-      deref_head(d0, attvars_in_term_unk);
-    attvars_in_term_nvar : {
+  while (pt0 < pt0_end) {
+    register CELL d0;
+    register CELL *ptd0;
+    ++ pt0;
+    ptd0 = pt0;
+    d0 = *ptd0;
+    deref_head(d0, attvars_in_term_unk);
+  attvars_in_term_nvar:
+    {
       if (IsPairTerm(d0)) {
         if (to_visit + 32 >= to_visit_max) {
           goto aux_overflow;
         }
         {
           CELL *npt0 = RepPair(d0);
-          if (IsAtomicTerm(Deref(npt0[0]))) {
+          if(IsAtomicTerm(Deref(npt0[0]))) {
             pt0 = npt0;
             pt0_end = pt0 + 1;
             continue;
           }
         }
 #ifdef RATIONAL_TREES
-        to_visit->beg = pt0;
-        to_visit->end = pt0_end;
-        to_visit->oval = *pt0;
-        to_visit++;
-        *pt0 = TermNil;
+	to_visit->beg = pt0;
+	to_visit->end = pt0_end;
+	to_visit->oval = *pt0;
+	to_visit ++;
+	*pt0 = TermNil;
 #else
-        if (pt0 < pt0_end) {
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit += 2;
-        }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-        pt0 = RepPair(d0) - 1;
-        pt0_end = pt0 + 2;
+	pt0 = RepPair(d0) - 1;
+          pt0_end = pt0+2;
       } else if (IsApplTerm(d0)) {
         Functor f;
-        CELL *ap2;
-        /* store the terms to visit */
-        ap2 = RepAppl(d0);
-        f = (Functor)(*ap2);
-        if (IsExtensionFunctor(f)) {
-          continue;
-        }
-        /* store the terms to visit */
-        if (to_visit + 32 >= to_visit_max) {
-          goto aux_overflow;
-        }
+	 CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	/* store the terms to visit */
+	if (to_visit + 32 >= to_visit_max) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-        to_visit->beg = pt0;
-        to_visit->end = pt0_end;
-        to_visit->oval = *pt0;
-        to_visit++;
-        *pt0 = TermNil;
+	to_visit->beg = pt0;
+	to_visit->end = pt0_end;
+	to_visit->oval = *pt0;
+	to_visit ++;
+	*pt0 = TermNil;
 #else
-        if (pt0 < pt0_end) {
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit += 2;
-        }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-        arity_t a = ArityOfFunctor(f);
-        pt0 = ap2;
-        pt0_end = ap2 + a;
+	arity_t a = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + a;
       }
       continue;
     }
 
-      derefa_body(d0, ptd0, attvars_in_term_unk, attvars_in_term_nvar);
-      if (IsAttVar(ptd0)) {
-        /* do or pt2 are unbound  */
-        *ptd0 = TermNil;
-        /* next make sure noone will see this as a variable again */
-        if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-          /* Trail overflow */
-          if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-            goto trail_overflow;
-          }
-        }
-        TrailTerm(TR++) = (CELL)ptd0;
-        /* leave an empty slot to fill in later */
-        if (HR + 1024 > ASP) {
-          goto global_overflow;
-        }
-        HR[1] = AbsPair(HR + 2);
-        HR += 2;
-        HR[-2] = (CELL)ptd0;
-        /* store the terms to visit */
-        if (to_visit + 32 >= to_visit_max) {
-          goto aux_overflow;
+
+    derefa_body(d0, ptd0, attvars_in_term_unk, attvars_in_term_nvar);
+    if (IsAttVar(ptd0)) {
+      /* do or pt2 are unbound  */
+      *ptd0 = TermNil;
+      /* next make sure noone will see this as a variable again */
+      if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
+	/* Trail overflow */
+        if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+          goto trail_overflow;
         }
+      }
+      TrailTerm(TR++) = (CELL)ptd0;
+      /* leave an empty slot to fill in later */
+      if (HR+1024 > ASP) {
+        goto global_overflow;
+      }
+      HR[1] = AbsPair(HR+2);
+      HR += 2;
+      HR[-2] = (CELL)ptd0;
+      /* store the terms to visit */
+      if (to_visit + 32 >= to_visit_max) {
+	goto aux_overflow;
+      }
 #ifdef RATIONAL_TREES
 
-        to_visit->beg = pt0;
-        to_visit->end = pt0_end;
-        to_visit->oval = *pt0;
-        to_visit++;
-        *pt0 = TermNil;
+	to_visit->beg = pt0;
+	to_visit->end = pt0_end;
+	to_visit->oval = *pt0;
+	to_visit ++;
+	*pt0 = TermNil;
 #else
-        if (pt0 < pt0_end) {
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit += 2;
-        }
-#endif
-        pt0 = &RepAttVar(ptd0)->Value;
-        pt0_end = &RepAttVar(ptd0)->Atts;
+      if (pt0 < pt0_end) {
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit += 2;
       }
-      continue;
+#endif
+      pt0 = &RepAttVar(ptd0)->Value;
+      pt0_end = &RepAttVar(ptd0)->Atts;
     }
-    /* Do we still have compound terms to visit */
-    if (to_visit == to_visit0)
-      break;
+    continue;
+  }
+  /* Do we still have compound terms to visit */
+  if (to_visit == to_visit0)
+    break;
 #ifdef RATIONAL_TREES
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->beg;
     pt0_end = to_visit->end;
     *pt0 = to_visit->oval;
@@ -1977,95 +2044,101 @@ restart:
     pt0 = to_visit[0];
     pt0_end = to_visit[1];
 #endif
-  } while (true);
+  } while(true);
 
   clean_tr(TR0 PASS_REGS);
-  pop_text_stack(lvl);
+ pop_text_stack(lvl);
   if (HR != InitialH) {
     /* close the list */
     Term t2 = Deref(inp);
     if (IsVarTerm(t2)) {
-      RESET_VARIABLE(HR - 1);
-      Yap_unify((CELL)(HR - 1), t2);
+      RESET_VARIABLE(HR-1);
+      Yap_unify((CELL)(HR-1), t2);
     } else {
-      HR[-1] = t2; /* don't need to trail */
+      HR[-1] = t2;		/* don't need to trail */
     }
-    return (output);
+    return(output);
   } else {
-    return (inp);
+    return(inp);
   }
 
-trail_overflow:
+ trail_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->beg;
     *pt0 = to_visit->oval;
   }
 #endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
-  pop_text_stack(lvl);
+ pop_text_stack(lvl);
   HR = InitialH;
   return 0L;
 
-aux_overflow : {
-  size_t d1 = to_visit - to_visit0;
-  size_t d2 = to_visit_max - to_visit0;
-  to_visit0 = Realloc(to_visit0, d2 * sizeof(CELL *) + 64 * 1024);
-  to_visit = to_visit0 + d1;
-  to_visit_max = to_visit0 + (d2 + (64 * 1024)) / sizeof(CELL **);
+ aux_overflow:
+  {
+  size_t d1 = to_visit-to_visit0;
+  size_t d2 = to_visit_max-to_visit0;
+  to_visit0 = Realloc(to_visit0,d2*sizeof(CELL*)+64*1024);
+  to_visit = to_visit0+d1;
+  to_visit_max = to_visit0+(d2+(64*1024))/sizeof(CELL **);
 }
-  pt0--;
-  goto restart;
+pt0--;
+goto restart;
 
-global_overflow:
+ global_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->beg;
     *pt0 = to_visit->oval;
   }
 #endif
   clean_tr(TR0 PASS_REGS);
-  pop_text_stack(lvl);
+pop_text_stack(lvl);
   HR = InitialH;
   LOCAL_Error_TYPE = RESOURCE_ERROR_STACK;
-  LOCAL_Error_Size = (ASP - HR) * sizeof(CELL);
+  LOCAL_Error_Size = (ASP-HR)*sizeof(CELL);
   return 0L;
+
 }
 
-static Int p_term_attvars(USES_REGS1) /* variables in term t		 */
+static Int
+p_term_attvars( USES_REGS1 )	/* variables in term t		 */
 {
   Term out;
 
   do {
     Term t = Deref(ARG1);
     if (IsVarTerm(t)) {
-      out = attvars_in_complex_term(VarOfTerm(t) - 1, VarOfTerm(t) + 1,
-                                    TermNil PASS_REGS);
-    } else if (IsPrimitiveTerm(t)) {
+      out = attvars_in_complex_term(VarOfTerm(t)-1,
+				    VarOfTerm(t)+1, TermNil PASS_REGS);
+    }  else if (IsPrimitiveTerm(t)) {
       return Yap_unify(TermNil, ARG2);
     } else if (IsPairTerm(t)) {
-      out = attvars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                    TermNil PASS_REGS);
-    } else {
+      out = attvars_in_complex_term(RepPair(t)-1,
+				 RepPair(t)+1, TermNil PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
       if (IsExtensionFunctor(f))
-        return Yap_unify(TermNil, ARG2);
-      out = attvars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                    TermNil PASS_REGS);
+	return Yap_unify(TermNil, ARG2);
+      out = attvars_in_complex_term(RepAppl(t),
+				 RepAppl(t)+
+				 ArityOfFunctor(f), TermNil PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
-  return Yap_unify(ARG2, out);
+  return Yap_unify(ARG2,out);
 }
 
-static Int p_term_variables3(USES_REGS1) /* variables in term t		 */
+static Int
+p_term_variables3( USES_REGS1 )	/* variables in term t		 */
 {
   Term out;
 
@@ -2073,29 +2146,34 @@ static Int p_term_variables3(USES_REGS1) /* variables in term t		 */
     Term t = Deref(ARG1);
     if (IsVarTerm(t)) {
       Term out = Yap_MkNewPairTerm();
-      return Yap_unify(t, HeadOfTerm(out)) &&
-             Yap_unify(ARG3, TailOfTerm(out)) && Yap_unify(out, ARG2);
-    } else if (IsPrimitiveTerm(t)) {
+      return
+	Yap_unify(t,HeadOfTerm(out)) &&
+	Yap_unify(ARG3, TailOfTerm(out)) &&
+	Yap_unify(out, ARG2);
+    }  else if (IsPrimitiveTerm(t)) {
       return Yap_unify(ARG2, ARG3);
     } else if (IsPairTerm(t)) {
-      out =
-          vars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1, ARG3 PASS_REGS);
-    } else {
+      out = vars_in_complex_term(RepPair(t)-1,
+				 RepPair(t)+1, ARG3 PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = vars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                 ARG3 PASS_REGS);
+      out = vars_in_complex_term(RepAppl(t),
+				 RepAppl(t)+
+				 ArityOfFunctor(f), ARG3 PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
 
-  return Yap_unify(ARG2, out);
+  return Yap_unify(ARG2,out);
 }
 
-static Term vars_within_complex_term(register CELL *pt0, register CELL *pt0_end,
-                                     Term inp USES_REGS) {
+
+static Term vars_within_complex_term(register CELL *pt0, register CELL *pt0_end, Term inp USES_REGS)
+{
 
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   register tr_fr_ptr TR0 = TR;
@@ -2110,82 +2188,83 @@ static Term vars_within_complex_term(register CELL *pt0, register CELL *pt0_end,
       *ptr = TermFoundVar;
       TrailTerm(TR++) = t;
       if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-        if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-          goto trail_overflow;
-        }
+	if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	  goto trail_overflow;
+	}
       }
     }
     inp = TailOfTerm(inp);
   }
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_within_term_unk);
-  vars_within_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_within_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      /* store the terms to visit */
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	/* store the terms to visit */
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
-    } else if (d0 == TermFoundVar) {
-      /* leave an empty slot to fill in later */
-      if (HR + 1024 > ASP) {
-        goto global_overflow;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      } else if (d0 == TermFoundVar) {
+	/* leave an empty slot to fill in later */
+	if (HR+1024 > ASP) {
+	  goto global_overflow;
+	}
+	HR[1] = AbsPair(HR+2);
+	HR += 2;
+	HR[-2] = (CELL)ptd0;
+	*ptd0 = TermNil;
       }
-      HR[1] = AbsPair(HR + 2);
-      HR += 2;
-      HR[-2] = (CELL)ptd0;
-      *ptd0 = TermNil;
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, vars_within_term_unk, vars_within_term_nvar);
   }
@@ -2213,7 +2292,7 @@ loop:
     return TermNil;
   }
 
-trail_overflow:
+ trail_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2222,14 +2301,14 @@ trail_overflow:
   }
 #endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   return 0L;
 
-aux_overflow:
-  LOCAL_Error_Size = (to_visit - to_visit0) * sizeof(CELL **);
+ aux_overflow:
+  LOCAL_Error_Size = (to_visit-to_visit0)*sizeof(CELL **);
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2243,7 +2322,7 @@ aux_overflow:
   HR = InitialH;
   return 0L;
 
-global_overflow:
+ global_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2255,41 +2334,44 @@ global_overflow:
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   LOCAL_Error_TYPE = RESOURCE_ERROR_STACK;
-  LOCAL_Error_Size = (ASP - HR) * sizeof(CELL);
+  LOCAL_Error_Size = (ASP-HR)*sizeof(CELL);
   return 0L;
+
 }
 
 static Int
-p_variables_within_term(USES_REGS1) /* variables within term t		 */
+p_variables_within_term( USES_REGS1 )	/* variables within term t		 */
 {
   Term out;
 
   do {
     Term t = Deref(ARG2);
     if (IsVarTerm(t)) {
-      out = vars_within_complex_term(VarOfTerm(t) - 1, VarOfTerm(t),
-                                     Deref(ARG1) PASS_REGS);
+      out = vars_within_complex_term(VarOfTerm(t)-1,
+				     VarOfTerm(t), Deref(ARG1) PASS_REGS);
 
-    } else if (IsPrimitiveTerm(t))
+    }  else if (IsPrimitiveTerm(t))
       out = TermNil;
     else if (IsPairTerm(t)) {
-      out = vars_within_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                     Deref(ARG1) PASS_REGS);
-    } else {
+      out = vars_within_complex_term(RepPair(t)-1,
+				     RepPair(t)+1, Deref(ARG1) PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = vars_within_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                     Deref(ARG1) PASS_REGS);
+      out = vars_within_complex_term(RepAppl(t),
+				 RepAppl(t)+
+				     ArityOfFunctor(f), Deref(ARG1) PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
-  return Yap_unify(ARG3, out);
+  return Yap_unify(ARG3,out);
 }
 
-static Term new_vars_in_complex_term(register CELL *pt0, register CELL *pt0_end,
-                                     Term inp USES_REGS) {
+static Term new_vars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Term inp USES_REGS)
+{
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   register tr_fr_ptr TR0 = TR;
   CELL *InitialH = HR;
@@ -2303,89 +2385,90 @@ static Term new_vars_in_complex_term(register CELL *pt0, register CELL *pt0_end,
       *ptr = TermFoundVar;
       TrailTerm(TR++) = t;
       if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-        if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-          goto trail_overflow;
-        }
+	if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	  goto trail_overflow;
+	}
       }
     }
     inp = TailOfTerm(inp);
   }
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_within_term_unk);
-  vars_within_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_within_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      /* store the terms to visit */
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	/* store the terms to visit */
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, vars_within_term_unk, vars_within_term_nvar);
     /* do or pt2 are unbound  */
     *ptd0 = TermNil;
     /* leave an empty slot to fill in later */
-    if (HR + 1024 > ASP) {
+    if (HR+1024 > ASP) {
       goto global_overflow;
     }
-    HR[1] = AbsPair(HR + 2);
+    HR[1] = AbsPair(HR+2);
     HR += 2;
     HR[-2] = (CELL)ptd0;
     /* next make sure noone will see this as a variable again */
     if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
       /* Trail overflow */
-      if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-        goto trail_overflow;
+      if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	goto trail_overflow;
       }
     }
     TrailTerm(TR++) = (CELL)ptd0;
@@ -2414,7 +2497,7 @@ loop:
     return TermNil;
   }
 
-trail_overflow:
+ trail_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2423,14 +2506,14 @@ trail_overflow:
   }
 #endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   return 0L;
 
-aux_overflow:
-  LOCAL_Error_Size = (to_visit - to_visit0) * sizeof(CELL **);
+ aux_overflow:
+  LOCAL_Error_Size = (to_visit-to_visit0)*sizeof(CELL **);
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2444,7 +2527,7 @@ aux_overflow:
   HR = InitialH;
   return 0L;
 
-global_overflow:
+ global_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2456,122 +2539,125 @@ global_overflow:
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   LOCAL_Error_TYPE = RESOURCE_ERROR_STACK;
-  LOCAL_Error_Size = (ASP - HR) * sizeof(CELL);
+  LOCAL_Error_Size = (ASP-HR)*sizeof(CELL);
   return 0L;
+
 }
 
 static Int
-p_new_variables_in_term(USES_REGS1) /* variables within term t		 */
+p_new_variables_in_term( USES_REGS1 )	/* variables within term t		 */
 {
   Term out;
 
   do {
     Term t = Deref(ARG2);
     if (IsVarTerm(t)) {
-      out = new_vars_in_complex_term(VarOfTerm(t) - 1, VarOfTerm(t),
-                                     Deref(ARG1) PASS_REGS);
+      out = new_vars_in_complex_term(VarOfTerm(t)-1,
+				     VarOfTerm(t), Deref(ARG1) PASS_REGS);
 
-    } else if (IsPrimitiveTerm(t))
+    }  else if (IsPrimitiveTerm(t))
       out = TermNil;
     else if (IsPairTerm(t)) {
-      out = new_vars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                     Deref(ARG1) PASS_REGS);
-    } else {
+      out = new_vars_in_complex_term(RepPair(t)-1,
+				     RepPair(t)+1, Deref(ARG1) PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = new_vars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                     Deref(ARG1) PASS_REGS);
+      out = new_vars_in_complex_term(RepAppl(t),
+			     RepAppl(t)+
+			     ArityOfFunctor(f), Deref(ARG1) PASS_REGS);
     }
     if (out == 0L) {
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
-  return Yap_unify(ARG3, out);
+  return Yap_unify(ARG3,out);
 }
 
-static Term free_vars_in_complex_term(register CELL *pt0,
-                                      register CELL *pt0_end,
-                                      tr_fr_ptr TR0 USES_REGS) {
+static Term free_vars_in_complex_term(register CELL *pt0, register CELL *pt0_end, tr_fr_ptr TR0 USES_REGS)
+{
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   CELL *InitialH = HR;
   *HR++ = MkAtomTerm(AtomDollar);
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_within_term_unk);
-  vars_within_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_within_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      /* store the terms to visit */
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	/* store the terms to visit */
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, vars_within_term_unk, vars_within_term_nvar);
     /* do or pt2 are unbound  */
     *ptd0 = TermNil;
     /* leave an empty slot to fill in later */
-    if (HR + 1024 > ASP) {
+    if (HR+1024 > ASP) {
       goto global_overflow;
     }
-    HR[0] = (CELL)ptd0;
-    HR++;
+    HR[0] =  (CELL)ptd0;
+    HR ++;
     /* next make sure noone will see this as a variable again */
     if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
       /* Trail overflow */
-      if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-        goto trail_overflow;
+      if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	goto trail_overflow;
       }
     }
     TrailTerm(TR++) = (CELL)ptd0;
@@ -2593,14 +2679,14 @@ loop:
 
   clean_tr(TR0 PASS_REGS);
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
-  if (HR != InitialH + 1) {
-    InitialH[0] = (CELL)Yap_MkFunctor(AtomDollar, (HR - InitialH) - 1);
+  if (HR != InitialH+1) {
+    InitialH[0] = (CELL)Yap_MkFunctor(AtomDollar, (HR-InitialH)-1);
     return AbsAppl(InitialH);
   } else {
     return MkAtomTerm(AtomDollar);
   }
 
-trail_overflow:
+ trail_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2609,14 +2695,14 @@ trail_overflow:
   }
 #endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   return 0L;
 
-aux_overflow:
-  LOCAL_Error_Size = (to_visit - to_visit0) * sizeof(CELL **);
+ aux_overflow:
+  LOCAL_Error_Size = (to_visit-to_visit0)*sizeof(CELL **);
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2630,7 +2716,7 @@ aux_overflow:
   HR = InitialH;
   return 0L;
 
-global_overflow:
+ global_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2642,77 +2728,78 @@ global_overflow:
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   LOCAL_Error_TYPE = RESOURCE_ERROR_STACK;
-  LOCAL_Error_Size = (ASP - HR) * sizeof(CELL);
+  LOCAL_Error_Size = (ASP-HR)*sizeof(CELL);
   return 0L;
+
 }
 
-static Term bind_vars_in_complex_term(register CELL *pt0,
-                                      register CELL *pt0_end,
-                                      tr_fr_ptr TR0 USES_REGS) {
+static Term bind_vars_in_complex_term(register CELL *pt0, register CELL *pt0_end, tr_fr_ptr TR0 USES_REGS)
+{
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   CELL *InitialH = HR;
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_within_term_unk);
-  vars_within_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_within_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      /* store the terms to visit */
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	/* store the terms to visit */
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, vars_within_term_unk, vars_within_term_nvar);
     /* do or pt2 are unbound  */
@@ -2720,8 +2807,8 @@ loop:
     /* next make sure noone will see this as a variable again */
     if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
       /* Trail overflow */
-      if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-        goto trail_overflow;
+      if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	goto trail_overflow;
       }
     }
     TrailTerm(TR++) = (CELL)ptd0;
@@ -2744,7 +2831,7 @@ loop:
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   return TermNil;
 
-trail_overflow:
+ trail_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2753,14 +2840,14 @@ trail_overflow:
   }
 #endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   return 0L;
 
-aux_overflow:
-  LOCAL_Error_Size = (to_visit - to_visit0) * sizeof(CELL **);
+ aux_overflow:
+  LOCAL_Error_Size = (to_visit-to_visit0)*sizeof(CELL **);
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2773,10 +2860,11 @@ aux_overflow:
   Yap_ReleasePreAllocCodeSpace((ADDR)to_visit0);
   HR = InitialH;
   return 0L;
+
 }
 
 static Int
-p_free_variables_in_term(USES_REGS1) /* variables within term t		 */
+p_free_variables_in_term( USES_REGS1 )	/* variables within term t		 */
 {
   Term out;
   Term t, t0;
@@ -2789,56 +2877,60 @@ p_free_variables_in_term(USES_REGS1) /* variables within term t		 */
     while (!IsVarTerm(t) && IsApplTerm(t)) {
       Functor f = FunctorOfTerm(t);
       if (f == FunctorHat) {
-        out = bind_vars_in_complex_term(RepAppl(t), RepAppl(t) + 1,
-                                        TR0 PASS_REGS);
-        if (out == 0L) {
-          goto trail_overflow;
-        }
+	out = bind_vars_in_complex_term(RepAppl(t),
+			     RepAppl(t)+1, TR0 PASS_REGS);
+	if (out == 0L) {
+	  goto trail_overflow;
+	}
       } else if (f == FunctorModule) {
-        found_module = ArgOfTerm(1, t);
+	found_module = ArgOfTerm(1, t);
       } else if (f == FunctorCall) {
-        t = ArgOfTerm(1, t);
-        continue;
+	t = ArgOfTerm(1, t);
+	continue;
       } else if (f == FunctorExecuteInMod) {
-        found_module = ArgOfTerm(2, t);
-        t = ArgOfTerm(1, t);
-        continue;
+	found_module = ArgOfTerm(2, t);
+	t = ArgOfTerm(1, t);
+	continue;
       } else {
-        break;
+	break;
       }
-      t = ArgOfTerm(2, t);
+      t = ArgOfTerm(2,t);
     }
     if (IsVarTerm(t)) {
-      out = free_vars_in_complex_term(VarOfTerm(t) - 1, VarOfTerm(t),
-                                      TR0 PASS_REGS);
+      out = free_vars_in_complex_term(VarOfTerm(t)-1,
+				      VarOfTerm(t), TR0 PASS_REGS);
 
-    } else if (IsPrimitiveTerm(t))
+    }  else if (IsPrimitiveTerm(t))
       out = TermNil;
     else if (IsPairTerm(t)) {
-      out = free_vars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                      TR0 PASS_REGS);
-    } else {
+      out = free_vars_in_complex_term(RepPair(t)-1,
+				      RepPair(t)+1, TR0 PASS_REGS);
+    }
+    else {
       Functor f = FunctorOfTerm(t);
-      out = free_vars_in_complex_term(
-          RepAppl(t), RepAppl(t) + ArityOfFunctor(f), TR0 PASS_REGS);
+      out = free_vars_in_complex_term(RepAppl(t),
+			     RepAppl(t)+
+				      ArityOfFunctor(f), TR0 PASS_REGS);
     }
     if (out == 0L) {
     trail_overflow:
-      if (!expand_vts(3 PASS_REGS))
-        return FALSE;
+      if (!expand_vts( 3 PASS_REGS ))
+	return FALSE;
     }
   } while (out == 0L);
-  if (found_module && t != t0) {
+  if (found_module && t!=t0) {
     Term ts[2];
     ts[0] = found_module;
     ts[1] = t;
     t = Yap_MkApplTerm(FunctorModule, 2, ts);
   }
-  return Yap_unify(ARG2, t) && Yap_unify(ARG3, out);
+  return
+    Yap_unify(ARG2, t) &&
+    Yap_unify(ARG3,out);
 }
 
-static Term non_singletons_in_complex_term(register CELL *pt0,
-                                           register CELL *pt0_end USES_REGS) {
+static Term non_singletons_in_complex_term(register CELL *pt0, register CELL *pt0_end USES_REGS)
+{
 
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   register tr_fr_ptr TR0 = TR;
@@ -2846,76 +2938,78 @@ static Term non_singletons_in_complex_term(register CELL *pt0,
   CELL output = AbsPair(HR);
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_in_term_unk);
-  vars_in_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_in_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
 
-      if (IsExtensionFunctor(f)) {
+	if (IsExtensionFunctor(f)) {
 
-        continue;
-      }
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	  continue;
+	}
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      /* store the terms to visit */
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
-    } else if (d0 == TermFoundVar) {
-      CELL *pt2 = pt0;
-      while (IsVarTerm(*pt2))
-        pt2 = (CELL *)(*pt2);
-      HR[0] = (CELL)pt2;
-      HR[1] = AbsPair(HR + 2);
-      HR += 2;
-      *pt2 = TermRefoundVar;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      } else if (d0 == TermFoundVar) {
+	CELL *pt2 = pt0;
+	while(IsVarTerm(*pt2))
+	  pt2 = (CELL *)(*pt2);
+	HR[1] = AbsPair(HR+2);
+	HR += 2;
+	HR[-2] = (CELL)pt2;
+	*pt2 = TermRefoundVar;
+      }
+      continue;
     }
-    continue;
-  }
+
 
     derefa_body(d0, ptd0, vars_in_term_unk, vars_in_term_nvar);
     /* do or pt2 are unbound  */
@@ -2941,14 +3035,14 @@ loop:
   clean_tr(TR0 PASS_REGS);
   if (HR != InitialH) {
     /* close the list */
-    RESET_VARIABLE(HR - 1);
-    Yap_unify((CELL)(HR - 1), ARG2);
+    RESET_VARIABLE(HR-1);
+    Yap_unify((CELL)(HR-1),ARG2);
     return output;
   } else {
     return ARG2;
   }
 
-aux_overflow:
+ aux_overflow:
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
     to_visit -= 3;
@@ -2959,13 +3053,13 @@ aux_overflow:
   clean_tr(TR0 PASS_REGS);
   if (HR != InitialH) {
     /* close the list */
-    RESET_VARIABLE(HR - 1);
+    RESET_VARIABLE(HR-1);
   }
   return 0L;
 }
 
-static Int p_non_singletons_in_term(
-    USES_REGS1) /* non_singletons in term t		 */
+static Int
+p_non_singletons_in_term( USES_REGS1 )	/* non_singletons in term t		 */
 {
   Term t;
   Term out;
@@ -2973,35 +3067,35 @@ static Int p_non_singletons_in_term(
   while (TRUE) {
     t = Deref(ARG1);
     if (IsVarTerm(t)) {
-      out = ARG2;
-    } else if (IsPrimitiveTerm(t)) {
+      out = MkPairTerm(t,ARG2);
+    }  else if (IsPrimitiveTerm(t)) {
       out = ARG2;
     } else if (IsPairTerm(t)) {
-      out = non_singletons_in_complex_term(RepPair(t) - 1,
-                                           RepPair(t) + 1 PASS_REGS);
+      out = non_singletons_in_complex_term(RepPair(t)-1,
+					   RepPair(t)+1 PASS_REGS);
     } else {
-      out = non_singletons_in_complex_term(
-          RepAppl(t), RepAppl(t) + ArityOfFunctor(FunctorOfTerm(t)) PASS_REGS);
+      out = non_singletons_in_complex_term(RepAppl(t),
+					   RepAppl(t)+
+					   ArityOfFunctor(FunctorOfTerm(t)) PASS_REGS);
     }
     if (out != 0L) {
-      return Yap_unify(ARG3, out);
+      return Yap_unify(ARG3,out);
     } else {
       if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
-        Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1,
-                  "overflow in singletons");
-        return FALSE;
+	Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in singletons");
+	return FALSE;
       }
     }
   }
 }
 
-static Int ground_complex_term(register CELL *pt0,
-                               register CELL *pt0_end USES_REGS) {
+static Int ground_complex_term(register CELL *pt0, register CELL *pt0_end USES_REGS)
+{
 
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
@@ -3010,59 +3104,61 @@ loop:
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_in_term_unk);
-  vars_in_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_in_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
 
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      /* store the terms to visit */
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
+      continue;
     }
-    continue;
-  }
+
 
     derefa_body(d0, ptd0, vars_in_term_unk, vars_in_term_nvar);
 #ifdef RATIONAL_TREES
@@ -3091,7 +3187,7 @@ loop:
   }
   return TRUE;
 
-aux_overflow:
+ aux_overflow:
   /* unwind stack */
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
@@ -3103,77 +3199,81 @@ aux_overflow:
   return -1;
 }
 
-bool Yap_IsGroundTerm(Term t) {
+bool Yap_IsGroundTerm(Term t)
+{
   CACHE_REGS
   while (TRUE) {
     Int out;
 
     if (IsVarTerm(t)) {
       return FALSE;
-    } else if (IsPrimitiveTerm(t)) {
+    }  else if (IsPrimitiveTerm(t)) {
       return TRUE;
     } else if (IsPairTerm(t)) {
-      if ((out = ground_complex_term(RepPair(t) - 1,
-                                     RepPair(t) + 1 PASS_REGS)) >= 0) {
-        return out != 0;
+      if ((out =ground_complex_term(RepPair(t)-1,
+				    RepPair(t)+1 PASS_REGS)) >= 0) {
+	return out != 0;
       }
     } else {
       Functor fun = FunctorOfTerm(t);
 
       if (IsExtensionFunctor(fun))
-        return TRUE;
-      else if ((out = ground_complex_term(
-                    RepAppl(t), RepAppl(t) + ArityOfFunctor(fun) PASS_REGS)) >=
-               0) {
-        return out != 0;
+	return TRUE;
+      else if ((out = ground_complex_term(RepAppl(t),
+					     RepAppl(t)+
+					     ArityOfFunctor(fun) PASS_REGS)) >= 0) {
+	     return out != 0;
       }
     }
     if (out < 0) {
       *HR++ = t;
       if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
-        Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in ground");
-        return false;
+	Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in ground");
+	return false;
       }
       t = *--HR;
     }
   }
 }
 
-static Int p_ground(USES_REGS1) /* ground(+T)		 */
+static Int
+p_ground( USES_REGS1 )			/* ground(+T)		 */
 {
   return Yap_IsGroundTerm(Deref(ARG1));
 }
 
-static int SizeOfExtension(Term t) {
+static int
+SizeOfExtension(Term t)
+{
   Functor f = FunctorOfTerm(t);
-  if (f == FunctorDouble) {
-    return 2 + sizeof(Float) / sizeof(CELL);
+  if (f== FunctorDouble) {
+    return 2 + sizeof(Float)/sizeof(CELL);
   }
-  if (f == FunctorString) {
+  if (f== FunctorString) {
     return 3 + RepAppl(t)[1];
   }
-  if (f == FunctorLongInt) {
-    return 2 + sizeof(Float) / sizeof(CELL);
+  if (f== FunctorLongInt) {
+    return 2 + sizeof(Float)/sizeof(CELL);
   }
-  if (f == FunctorDBRef) {
+  if (f== FunctorDBRef) {
     return 0;
   }
-  if (f == FunctorBigInt) {
-    CELL *pt = RepAppl(t) + 2;
-    return 3 + sizeof(MP_INT) +
-           (((MP_INT *)(pt))->_mp_alloc * sizeof(mp_limb_t));
+  if (f== FunctorBigInt) {
+    CELL *pt = RepAppl(t)+2;
+    return 3+sizeof(MP_INT)+(((MP_INT *)(pt))->_mp_alloc*sizeof(mp_limb_t));
   }
   return 0;
 }
 
-static Int sz_ground_complex_term(register CELL *pt0, register CELL *pt0_end,
-                                  int ground USES_REGS) {
+
+static Int sz_ground_complex_term(register CELL *pt0, register CELL *pt0_end, int ground USES_REGS)
+{
 
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   Int sz = 0;
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
@@ -3182,62 +3282,64 @@ loop:
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_in_term_unk);
-  vars_in_term_nvar : {
-    if (IsPairTerm(d0)) {
-      sz += 2;
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  vars_in_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	sz += 2;
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
 
-      if (IsExtensionFunctor(f)) {
-        sz += SizeOfExtension(d0);
-        continue;
-      }
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+	if (IsExtensionFunctor(f)) {
+	  sz += SizeOfExtension(d0);
+	  continue;
+	}
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      /* store the terms to visit */
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      d0 = ArityOfFunctor(f);
-      sz += (1 + d0);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+	d0 = ArityOfFunctor(f);
+	sz += (1+d0);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
+      continue;
     }
-    continue;
-  }
+
 
     derefa_body(d0, ptd0, vars_in_term_unk, vars_in_term_nvar);
     if (!ground)
@@ -3268,7 +3370,7 @@ loop:
   }
   return sz;
 
-aux_overflow:
+ aux_overflow:
   /* unwind stack */
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
@@ -3280,117 +3382,124 @@ aux_overflow:
   return -1;
 }
 
-int Yap_SizeGroundTerm(Term t, int ground) {
+int
+Yap_SizeGroundTerm(Term t, int ground)
+{
   CACHE_REGS
   if (IsVarTerm(t)) {
     if (!ground)
       return 1;
     return 0;
-  } else if (IsPrimitiveTerm(t)) {
+  }  else if (IsPrimitiveTerm(t)) {
     return 1;
   } else if (IsPairTerm(t)) {
-    int sz = sz_ground_complex_term(RepPair(t) - 1, RepPair(t) + 1,
-                                    ground PASS_REGS);
+    int sz = sz_ground_complex_term(RepPair(t)-1, RepPair(t)+1, ground PASS_REGS);
     if (sz <= 0)
       return sz;
-    return sz + 2;
-  } else {
-    int sz = 0;
-    Functor fun = FunctorOfTerm(t);
+    return sz+2;
+} else {
+  int sz = 0;
+  Functor fun = FunctorOfTerm(t);
 
-    if (IsExtensionFunctor(fun))
-      return 1 + SizeOfExtension(t);
+  if (IsExtensionFunctor(fun))
+    return 1+ SizeOfExtension(t);
 
-    sz = sz_ground_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(fun),
-                                ground PASS_REGS);
-    if (sz <= 0)
-      return sz;
-    return 1 + ArityOfFunctor(fun) + sz;
+   sz = sz_ground_complex_term(RepAppl(t),
+			    RepAppl(t)+
+			    ArityOfFunctor(fun),
+			    ground PASS_REGS);
+   if (sz <= 0)
+     return sz;
+   return 1+ArityOfFunctor(fun)+sz;
   }
 }
 
-static Int var_in_complex_term(register CELL *pt0, register CELL *pt0_end,
-                               Term v USES_REGS) {
+static Int var_in_complex_term(register CELL *pt0,
+			       register CELL *pt0_end,
+			       Term v USES_REGS)
+{
 
   register CELL **to_visit0, **to_visit = (CELL **)Yap_PreAllocCodeSpace();
   register tr_fr_ptr TR0 = TR;
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, var_in_term_unk);
-  var_in_term_nvar : {
-    if (IsPairTerm(d0)) {
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
+  var_in_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
 #ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
 #else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
 #endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+	continue;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+
+	if (IsExtensionFunctor(f)) {
+
+	  continue;
+	}
+	if (to_visit + 1024 >= (CELL **)AuxSp) {
+	  goto aux_overflow;
+	}
+#ifdef RATIONAL_TREES
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = (CELL *)*pt0;
+	to_visit += 3;
+	*pt0 = TermNil;
+#else
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit += 2;
+	}
+#endif
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+      }
       continue;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-
-      if (IsExtensionFunctor(f)) {
-
-        continue;
-      }
-      if (to_visit + 1024 >= (CELL **)AuxSp) {
-        goto aux_overflow;
-      }
-#ifdef RATIONAL_TREES
-      to_visit[0] = pt0;
-      to_visit[1] = pt0_end;
-      to_visit[2] = (CELL *)*pt0;
-      to_visit += 3;
-      *pt0 = TermNil;
-#else
-      /* store the terms to visit */
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
-      }
-#endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
     }
-    continue;
-  }
+
 
     deref_body(d0, ptd0, var_in_term_unk, var_in_term_nvar);
     if ((CELL)ptd0 == v) { /* we found it */
 #ifdef RATIONAL_TREES
       while (to_visit > to_visit0) {
-        to_visit -= 3;
-        pt0 = to_visit[0];
-        *pt0 = (CELL)to_visit[2];
+	to_visit -= 3;
+	pt0 = to_visit[0];
+	*pt0 = (CELL)to_visit[2];
       }
 #endif
       clean_tr(TR0 PASS_REGS);
-      return (TRUE);
+      return(TRUE);
     }
     /* do or pt2 are unbound  */
     *ptd0 = TermNil;
@@ -3421,7 +3530,8 @@ loop:
   clean_tr(TR0 PASS_REGS);
   return FALSE;
 
-aux_overflow:
+
+ aux_overflow:
   /* unwind stack */
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
@@ -3433,30 +3543,34 @@ aux_overflow:
   return -1;
 }
 
-static Int var_in_term(Term v,
-                       Term t USES_REGS) /* variables in term t		 */
+static Int
+var_in_term(Term v, Term t USES_REGS)	/* variables in term t		 */
 {
 
   if (IsVarTerm(t)) {
-    return (v == t);
+    return(v == t);
   } else if (IsPrimitiveTerm(t)) {
-    return (FALSE);
+    return(FALSE);
   } else if (IsPairTerm(t)) {
-    return (var_in_complex_term(RepPair(t) - 1, RepPair(t) + 1, v PASS_REGS));
-  } else
-    return (var_in_complex_term(RepAppl(t),
-                                RepAppl(t) + ArityOfFunctor(FunctorOfTerm(t)),
-                                v PASS_REGS));
+    return(var_in_complex_term(RepPair(t)-1,
+			       RepPair(t)+1,v PASS_REGS));
+  }
+  else return(var_in_complex_term(RepAppl(t),
+				  RepAppl(t)+
+				  ArityOfFunctor(FunctorOfTerm(t)),v PASS_REGS));
 }
 
-static Int p_var_in_term(USES_REGS1) {
-  return (var_in_term(Deref(ARG2), Deref(ARG1) PASS_REGS));
+static Int
+p_var_in_term( USES_REGS1 )
+{
+  return(var_in_term(Deref(ARG2), Deref(ARG1) PASS_REGS));
 }
 
 /* The code for TermHash was originally contributed by Gertjen Van Noor */
 
 /* This code with max_depth == -1 will loop for infinite trees */
 
+
 //-----------------------------------------------------------------------------
 // MurmurHash2, by Austin Appleby
 
@@ -3471,188 +3585,200 @@ static Int p_var_in_term(USES_REGS1) {
 // 2. It will not produce the same results on little-endian and big-endian
 //    machines.
 
-static unsigned int MurmurHashNeutral2(const void *key, int len,
-                                       unsigned int seed) {
-  const unsigned int m = 0x5bd1e995;
-  const int r = 24;
+static unsigned int
+MurmurHashNeutral2 ( const void * key, int len, unsigned int seed )
+{
+	const unsigned int m = 0x5bd1e995;
+	const int r = 24;
 
-  unsigned int h = seed ^ len;
+	unsigned int h = seed ^ len;
 
-  const unsigned char *data = (const unsigned char *)key;
+	const unsigned char * data = (const unsigned char *)key;
 
-  while (len >= 4) {
-    unsigned int k;
+	while(len >= 4)
+	{
+		unsigned int k;
 
-    k = data[0];
-    k |= data[1] << 8;
-    k |= data[2] << 16;
-    k |= data[3] << 24;
+		k  = data[0];
+		k |= data[1] << 8;
+		k |= data[2] << 16;
+		k |= data[3] << 24;
 
-    k *= m;
-    k ^= k >> r;
-    k *= m;
+		k *= m;
+		k ^= k >> r;
+		k *= m;
 
-    h *= m;
-    h ^= k;
+		h *= m;
+		h ^= k;
 
-    data += 4;
-    len -= 4;
-  }
+		data += 4;
+		len -= 4;
+	}
 
-  switch (len) {
-  case 3:
-    h ^= data[2] << 16;
-  case 2:
-    h ^= data[1] << 8;
-  case 1:
-    h ^= data[0];
-    h *= m;
-  };
+	switch(len)
+	{
+	case 3: h ^= data[2] << 16;
+	case 2: h ^= data[1] << 8;
+	case 1: h ^= data[0];
+	        h *= m;
+	};
 
-  h ^= h >> 13;
-  h *= m;
-  h ^= h >> 15;
+	h ^= h >> 13;
+	h *= m;
+	h ^= h >> 15;
 
-  return h;
+	return h;
 }
 
-static CELL *addAtomToHash(CELL *st, Atom at) {
+static CELL *
+addAtomToHash(CELL *st, Atom at)
+{
   unsigned int len;
 
-  char *c = RepAtom(at)->StrOfAE;
-  int ulen = strlen(c);
-  /* fix hashing over empty atom */
-  if (!ulen) {
-    return st;
-  }
-  if (ulen % CellSize == 0) {
-    len = ulen / CellSize;
-  } else {
-    len = ulen / CellSize;
-    len++;
-  }
-  st[len - 1] = 0L;
-  strncpy((char *)st, c, ulen);
-  return st + len;
+    char *c = RepAtom(at)->StrOfAE;
+    int ulen = strlen(c);
+    /* fix hashing over empty atom */
+    if (!ulen) {
+      return st;
+    }
+    if (ulen % CellSize == 0) {
+      len = ulen/CellSize;
+    } else {
+      len = ulen/CellSize;
+      len++;
+    }
+    st[len-1] = 0L;
+    strncpy((char *)st, c, ulen);
+  return st+len;
 }
 
 typedef struct visited {
   CELL *start;
-  CELL *end;
+  CELL  *end;
   CELL old;
   UInt vdepth;
 } visited_t;
 
-static CELL *hash_complex_term(register CELL *pt0, register CELL *pt0_end,
-                               Int depth, CELL *st, int variant USES_REGS) {
-  register visited_t *to_visit0,
-      *to_visit = (visited_t *)Yap_PreAllocCodeSpace();
+static CELL *
+hash_complex_term(register CELL *pt0,
+		  register CELL *pt0_end,
+		  Int depth,
+		  CELL *st,
+		  int variant USES_REGS)
+{
+  register visited_t *to_visit0, *to_visit = (visited_t *)Yap_PreAllocCodeSpace();
 
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, hash_complex_unk);
-  hash_complex_nvar : {
-    if (st + 1024 >= ASP) {
-      goto global_overflow;
-    }
-    if (IsAtomOrIntTerm(d0)) {
-      if (d0 != TermFoundVar) {
-        if (IsAtomTerm(d0)) {
-          st = addAtomToHash(st, AtomOfTerm(d0));
-        } else {
-          *st++ = IntOfTerm(d0);
-        }
+  hash_complex_nvar:
+    {
+      if (st + 1024 >= ASP) {
+	goto global_overflow;
       }
-      continue;
-    } else if (IsPairTerm(d0)) {
-      st = addAtomToHash(st, AtomDot);
-      if (depth == 1)
-        continue;
-      if (to_visit + 256 >= (visited_t *)AuxSp) {
-        goto aux_overflow;
-      }
-      to_visit->start = pt0;
-      to_visit->end = pt0_end;
-      to_visit->old = *pt0;
-      to_visit->vdepth = depth;
-      to_visit++;
-      depth--;
-      *pt0 = TermFoundVar;
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-      continue;
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
+      if (IsAtomOrIntTerm(d0)) {
+	if (d0 != TermFoundVar) {
+	  if (IsAtomTerm(d0)) {
+	    st = addAtomToHash(st, AtomOfTerm(d0));
+	  } else {
+	    *st++ = IntOfTerm(d0);
+	  }
+	}
+	continue;
+      } else if (IsPairTerm(d0)) {
+	st = addAtomToHash(st, AtomDot);
+	if (depth == 1)
+	  continue;
+	if (to_visit + 256 >= (visited_t *)AuxSp) {
+	  goto aux_overflow;
+	}
+	to_visit->start = pt0;
+	to_visit->end = pt0_end;
+	to_visit->old = *pt0;
+	to_visit->vdepth = depth;
+	to_visit++;
+	depth--;
+	*pt0 = TermFoundVar;
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+	continue;
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
 
-      if (IsExtensionFunctor(f)) {
-        CELL fc = (CELL)f;
+	if (IsExtensionFunctor(f)) {
+	  CELL fc = (CELL)f;
 
-        switch (fc) {
+	  switch(fc) {
 
-        case (CELL)FunctorDBRef:
-          *st++ = fc;
-          break;
-        case (CELL)FunctorLongInt:
-          *st++ = LongIntOfTerm(d0);
-          break;
-        case (CELL)FunctorString:
-          memmove(st, RepAppl(d0), (3 + RepAppl(d0)[1]) * sizeof(CELL));
-          st += 3 + RepAppl(d0)[1];
-          break;
+	  case (CELL)FunctorDBRef:
+	    *st++ = fc;
+	    break;
+	  case (CELL)FunctorLongInt:
+	    *st++ = LongIntOfTerm(d0);
+	    break;
+	  case (CELL)FunctorString:
+	    memmove(st, RepAppl(d0), (3+RepAppl(d0)[1])*sizeof(CELL));
+	    st += 3+RepAppl(d0)[1];
+	    break;
 #ifdef USE_GMP
-        case (CELL)FunctorBigInt: {
-          CELL *pt = RepAppl(d0);
-          Int sz = sizeof(MP_INT) + 1 +
-                   (((MP_INT *)(pt + 2))->_mp_alloc * sizeof(mp_limb_t));
+	  case (CELL)FunctorBigInt:
+	    {
+	      CELL *pt = RepAppl(d0);
+	      Int sz =
+		sizeof(MP_INT)+1+
+		(((MP_INT *)(pt+2))->_mp_alloc*sizeof(mp_limb_t));
 
-          if (st + (1024 + sz / CellSize) >= ASP) {
-            goto global_overflow;
-          }
-          /* then the actual number */
-          memmove((void *)(st + 1), (void *)(pt + 1), sz);
-          st = st + sz / CellSize;
-        } break;
+	      if (st + (1024 + sz/CellSize) >= ASP) {
+		goto global_overflow;
+	      }
+	      /* then the actual number */
+	      memmove((void *)(st+1), (void *)(pt+1), sz);
+	      st = st+sz/CellSize;
+	    }
+	    break;
 #endif
-        case (CELL)FunctorDouble: {
-          CELL *pt = RepAppl(d0);
-          *st++ = pt[1];
-#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
-          *st++ = pt[2];
+	  case (CELL)FunctorDouble:
+	    {
+	      CELL *pt = RepAppl(d0);
+	      *st++ = pt[1];
+#if  SIZEOF_DOUBLE == 2*SIZEOF_INT_P
+	      *st++ = pt[2];
 #endif
-          break;
-        }
-        }
-        continue;
+	      break;
+	    }
+	  }
+	  continue;
+	}
+	st = addAtomToHash(st, NameOfFunctor(f));
+	if (depth == 1)
+	  continue;
+	if (to_visit + 1024 >= (visited_t *)AuxSp) {
+	  goto aux_overflow;
+	}
+	to_visit->start = pt0;
+	to_visit->end = pt0_end;
+	to_visit->old = *pt0;
+	to_visit->vdepth = depth;
+	to_visit++;
+	depth--;
+	*pt0 = TermFoundVar;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
       }
-      st = addAtomToHash(st, NameOfFunctor(f));
-      if (depth == 1)
-        continue;
-      if (to_visit + 1024 >= (visited_t *)AuxSp) {
-        goto aux_overflow;
-      }
-      to_visit->start = pt0;
-      to_visit->end = pt0_end;
-      to_visit->old = *pt0;
-      to_visit->vdepth = depth;
-      to_visit++;
-      depth--;
-      *pt0 = TermFoundVar;
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+      continue;
     }
-    continue;
-  }
+
 
     deref_body(d0, ptd0, hash_complex_unk, hash_complex_nvar);
     if (!variant)
@@ -3671,50 +3797,50 @@ loop:
   }
   return st;
 
-aux_overflow:
+ aux_overflow:
   /* unwind stack */
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start;
     *pt0 = to_visit->old;
   }
   return (CELL *)-1;
 
-global_overflow:
+ global_overflow:
   /* unwind stack */
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start;
     *pt0 = to_visit->old;
   }
-  return (CELL *)-2;
+  return (CELL *) -2;
 }
 
-Int Yap_TermHash(Term t, Int size, Int depth, int variant) {
+Int
+Yap_TermHash(Term t, Int size, Int depth, int variant)
+{
   CACHE_REGS
   unsigned int i1;
   Term t1 = Deref(t);
 
   while (TRUE) {
-    CELL *ar = hash_complex_term(&t1 - 1, &t1, depth, HR, FALSE PASS_REGS);
+    CELL *ar = hash_complex_term(&t1-1, &t1, depth, HR, FALSE PASS_REGS);
     if (ar == (CELL *)-1) {
       if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
-        Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1,
-                  "overflow in term_hash");
-        return FALSE;
+	Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in term_hash");
+	return FALSE;
       }
       t1 = Deref(ARG1);
-    } else if (ar == (CELL *)-2) {
-      if (!Yap_gcl((ASP - HR) * sizeof(CELL), 0, ENV, gc_P(P, CP))) {
-        Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_hash");
-        return FALSE;
+    } else if(ar == (CELL *)-2) {
+      if (!Yap_gcl((ASP-HR)*sizeof(CELL), 0, ENV, gc_P(P,CP))) {
+	Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_hash");
+	return FALSE;
       }
       t1 = Deref(ARG1);
     } else if (ar == NULL) {
       return FALSE;
     } else {
-      i1 = MurmurHashNeutral2((const void *)HR, CellSize * (ar - HR),
-                              0x1a3be34a);
+      i1 = MurmurHashNeutral2((const void *)HR, CellSize*(ar-HR),0x1a3be34a);
       break;
     }
   }
@@ -3722,7 +3848,9 @@ Int Yap_TermHash(Term t, Int size, Int depth, int variant) {
   return i1 % size;
 }
 
-static Int p_term_hash(USES_REGS1) {
+static Int
+p_term_hash( USES_REGS1 )
+{
   unsigned int i1;
   Term t1 = Deref(ARG1);
   Term t2 = Deref(ARG2);
@@ -3731,57 +3859,56 @@ static Int p_term_hash(USES_REGS1) {
   Int size, depth;
 
   if (IsVarTerm(t2)) {
-    Yap_Error(INSTANTIATION_ERROR, t2, "term_hash/4");
-    return (FALSE);
+    Yap_Error(INSTANTIATION_ERROR,t2,"term_hash/4");
+    return(FALSE);
   }
   if (!IsIntegerTerm(t2)) {
-    Yap_Error(TYPE_ERROR_INTEGER, t2, "term_hash/4");
-    return (FALSE);
+    Yap_Error(TYPE_ERROR_INTEGER,t2,"term_hash/4");
+    return(FALSE);
   }
   depth = IntegerOfTerm(t2);
   if (depth == 0) {
-    if (IsVarTerm(t1))
-      return (TRUE);
-    return (Yap_unify(ARG4, MkIntTerm(0)));
+    if (IsVarTerm(t1)) return(TRUE);
+    return(Yap_unify(ARG4,MkIntTerm(0)));
   }
   if (IsVarTerm(t3)) {
-    Yap_Error(INSTANTIATION_ERROR, t3, "term_hash/4");
-    return (FALSE);
+    Yap_Error(INSTANTIATION_ERROR,t3,"term_hash/4");
+    return(FALSE);
   }
   if (!IsIntegerTerm(t3)) {
-    Yap_Error(TYPE_ERROR_INTEGER, t3, "term_hash/4");
-    return (FALSE);
+    Yap_Error(TYPE_ERROR_INTEGER,t3,"term_hash/4");
+    return(FALSE);
   }
   size = IntegerOfTerm(t3);
   while (TRUE) {
-    CELL *ar = hash_complex_term(&t1 - 1, &t1, depth, HR, FALSE PASS_REGS);
+    CELL *ar = hash_complex_term(&t1-1, &t1, depth, HR, FALSE PASS_REGS);
     if (ar == (CELL *)-1) {
       if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
-        Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1,
-                  "overflow in term_hash");
-        return FALSE;
+	Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in term_hash");
+	return FALSE;
       }
       t1 = Deref(ARG1);
-    } else if (ar == (CELL *)-2) {
-      if (!Yap_gcl((ASP - HR) * sizeof(CELL), 4, ENV, gc_P(P, CP))) {
-        Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_hash");
-        return FALSE;
+    } else if(ar == (CELL *)-2) {
+      if (!Yap_gcl((ASP-HR)*sizeof(CELL), 4, ENV, gc_P(P,CP))) {
+	Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_hash");
+	return FALSE;
       }
       t1 = Deref(ARG1);
     } else if (ar == NULL) {
       return FALSE;
     } else {
-      i1 = MurmurHashNeutral2((const void *)HR, CellSize * (ar - HR),
-                              0x1a3be34a);
+      i1 = MurmurHashNeutral2((const void *)HR, CellSize*(ar-HR),0x1a3be34a);
       break;
     }
   }
   /* got the seed and hash from SWI-Prolog */
   result = MkIntegerTerm(i1 % size);
-  return Yap_unify(ARG4, result);
+  return Yap_unify(ARG4,result);
 }
 
-static Int p_instantiated_term_hash(USES_REGS1) {
+static Int
+p_instantiated_term_hash( USES_REGS1 )
+{
   unsigned int i1;
   Term t1 = Deref(ARG1);
   Term t2 = Deref(ARG2);
@@ -3790,173 +3917,170 @@ static Int p_instantiated_term_hash(USES_REGS1) {
   Int size, depth;
 
   if (IsVarTerm(t2)) {
-    Yap_Error(INSTANTIATION_ERROR, t2, "term_hash/4");
-    return (FALSE);
+    Yap_Error(INSTANTIATION_ERROR,t2,"term_hash/4");
+    return(FALSE);
   }
   if (!IsIntegerTerm(t2)) {
-    Yap_Error(TYPE_ERROR_INTEGER, t2, "term_hash/4");
-    return (FALSE);
+    Yap_Error(TYPE_ERROR_INTEGER,t2,"term_hash/4");
+    return(FALSE);
   }
   depth = IntegerOfTerm(t2);
   if (depth == 0) {
-    if (IsVarTerm(t1))
-      return (TRUE);
-    return (Yap_unify(ARG4, MkIntTerm(0)));
+    if (IsVarTerm(t1)) return(TRUE);
+    return(Yap_unify(ARG4,MkIntTerm(0)));
   }
   if (IsVarTerm(t3)) {
-    Yap_Error(INSTANTIATION_ERROR, t3, "term_hash/4");
-    return (FALSE);
+    Yap_Error(INSTANTIATION_ERROR,t3,"term_hash/4");
+    return(FALSE);
   }
   if (!IsIntegerTerm(t3)) {
-    Yap_Error(TYPE_ERROR_INTEGER, t3, "term_hash/4");
-    return (FALSE);
+    Yap_Error(TYPE_ERROR_INTEGER,t3,"term_hash/4");
+    return(FALSE);
   }
   size = IntegerOfTerm(t3);
   while (TRUE) {
-    CELL *ar = hash_complex_term(&t1 - 1, &t1, depth, HR, TRUE PASS_REGS);
+    CELL *ar = hash_complex_term(&t1-1, &t1, depth, HR, TRUE PASS_REGS);
     if (ar == (CELL *)-1) {
       if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
-        Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1,
-                  "overflow in term_hash");
-        return FALSE;
+	Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in term_hash");
+	return FALSE;
       }
       t1 = Deref(ARG1);
-    } else if (ar == (CELL *)-2) {
-      if (!Yap_gcl((ASP - HR) * sizeof(CELL), 4, ENV, gc_P(P, CP))) {
-        Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_hash");
-        return FALSE;
+    } else if(ar == (CELL *)-2) {
+      if (!Yap_gcl((ASP-HR)*sizeof(CELL), 4, ENV, gc_P(P,CP))) {
+	Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_hash");
+	return FALSE;
       }
       t1 = Deref(ARG1);
     } else if (ar == NULL) {
       return FALSE;
     } else {
-      i1 = MurmurHashNeutral2((const void *)HR, CellSize * (ar - HR),
-                              0x1a3be34a);
+      i1 = MurmurHashNeutral2((const void *)HR, CellSize*(ar-HR),0x1a3be34a);
       break;
     }
   }
   /* got the seed and hash from SWI-Prolog */
   result = MkIntegerTerm(i1 % size);
-  return Yap_unify(ARG4, result);
+  return Yap_unify(ARG4,result);
 }
 
-static int variant_complex(register CELL *pt0, register CELL *pt0_end,
-                           register CELL *pt1 USES_REGS) {
+static int variant_complex(register CELL *pt0, register CELL *pt0_end, register
+		   CELL *pt1 USES_REGS)
+{
   tr_fr_ptr OLDTR = TR;
   register CELL **to_visit = (CELL **)ASP;
   /* make sure that unification always forces trailing */
   HBREG = HR;
 
-loop:
+
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0, d1;
-    ++pt0;
-    ++pt1;
+    ++ pt0;
+    ++ pt1;
     d0 = Derefa(pt0);
     d1 = Derefa(pt1);
     if (IsVarTerm(d0)) {
       if (IsVarTerm(d1)) {
-        CELL *pt0 = VarOfTerm(d0);
-        CELL *pt1 = VarOfTerm(d1);
-        if (pt0 >= HBREG || pt1 >= HBREG) {
-          /* one of the variables has been found before */
-          if (VarOfTerm(d0) + 1 == VarOfTerm(d1))
-            continue;
-          goto fail;
-        } else {
-          /* two new occurrences of the same variable */
-          Term n0 = MkVarTerm(), n1 = MkVarTerm();
-          Bind_Global(VarOfTerm(d0), n0);
-          Bind_Global(VarOfTerm(d1), n1);
-        }
-        continue;
+	CELL *pt0 = VarOfTerm(d0);
+	CELL *pt1 = VarOfTerm(d1);
+	if (pt0 >= HBREG || pt1 >= HBREG) {
+	  /* one of the variables has been found before */
+	  if (VarOfTerm(d0)+1 == VarOfTerm(d1)) continue;
+	  goto fail;
+	} else {
+	  /* two new occurrences of the same variable */
+	  Term n0 = MkVarTerm(), n1 = MkVarTerm();
+	  Bind_Global(VarOfTerm(d0), n0);
+	  Bind_Global(VarOfTerm(d1), n1);
+	}
+	continue;
       } else {
-        goto fail;
+	goto fail;
       }
     } else if (IsVarTerm(d1)) {
       goto fail;
     } else {
-      if (d0 == d1)
-        continue;
+      if (d0 == d1) continue;
       else if (IsAtomOrIntTerm(d0)) {
-        goto fail;
+	goto fail;
       } else if (IsPairTerm(d0)) {
-        if (!IsPairTerm(d1)) {
-          goto fail;
-        }
+	if (!IsPairTerm(d1)) {
+	  goto fail;
+	}
 #ifdef RATIONAL_TREES
-        /* now link the two structures so that no one else will */
-        /* come here */
-        to_visit -= 4;
-        if ((CELL *)to_visit < HR + 1024)
-          goto out_of_stack;
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit[2] = pt1;
-        to_visit[3] = (CELL *)*pt0;
-        *pt0 = d1;
+	/* now link the two structures so that no one else will */
+	/* come here */
+	to_visit -= 4;
+	if ((CELL *)to_visit < HR+1024)
+	  goto out_of_stack;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = pt1;
+	to_visit[3] = (CELL *)*pt0;
+	*pt0 = d1;
 #else
-        /* store the terms to visit */
-        if (pt0 < pt0_end) {
-          to_visit -= 3;
-          if ((CELL *)to_visit < HR + 1024)
-            goto out_of_stack;
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit[2] = pt1;
-        }
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit -= 3;
+	  if ((CELL *)to_visit < HR+1024)
+	    goto out_of_stack;
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit[2] = pt1;
+	}
 #endif
-        pt0 = RepPair(d0) - 1;
-        pt0_end = RepPair(d0) + 1;
-        pt1 = RepPair(d1) - 1;
-        continue;
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+	pt1 = RepPair(d1) - 1;
+	continue;
       } else if (IsApplTerm(d0)) {
-        register Functor f;
-        register CELL *ap2, *ap3;
-        if (!IsApplTerm(d1)) {
-          goto fail;
-        } else {
-          /* store the terms to visit */
-          Functor f2;
-          ap2 = RepAppl(d0);
-          ap3 = RepAppl(d1);
-          f = (Functor)(*ap2);
-          f2 = (Functor)(*ap3);
-          if (f != f2)
-            goto fail;
-          if (IsExtensionFunctor(f)) {
-            if (!unify_extension(f, d0, ap2, d1))
-              goto fail;
-            continue;
-          }
+	register Functor f;
+	register CELL *ap2, *ap3;
+	if (!IsApplTerm(d1)) {
+	  goto fail;
+	} else {
+	  /* store the terms to visit */
+	  Functor f2;
+	  ap2 = RepAppl(d0);
+	  ap3 = RepAppl(d1);
+	  f = (Functor)(*ap2);
+	  f2 = (Functor)(*ap3);
+	  if (f != f2)
+	    goto fail;
+	  if (IsExtensionFunctor(f)) {
+	    if (!unify_extension(f, d0, ap2, d1))
+	      goto fail;
+	    continue;
+	  }
 #ifdef RATIONAL_TREES
-          /* now link the two structures so that no one else will */
-          /* come here */
-          to_visit -= 4;
-          if ((CELL *)to_visit < HR + 1024)
-            goto out_of_stack;
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit[2] = pt1;
-          to_visit[3] = (CELL *)*pt0;
-          *pt0 = d1;
+	/* now link the two structures so that no one else will */
+	/* come here */
+	to_visit -= 4;
+	if ((CELL *)to_visit < HR+1024)
+	  goto out_of_stack;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = pt1;
+	to_visit[3] = (CELL *)*pt0;
+	*pt0 = d1;
 #else
-          /* store the terms to visit */
-          if (pt0 < pt0_end) {
-            to_visit -= 3;
-            if ((CELL *)to_visit < HR + 1024)
-              goto out_of_stack;
-            to_visit[0] = pt0;
-            to_visit[1] = pt0_end;
-            to_visit[2] = pt1;
-          }
+	  /* store the terms to visit */
+	  if (pt0 < pt0_end) {
+	    to_visit -= 3;
+	    if ((CELL *)to_visit < HR+1024)
+	      goto out_of_stack;
+	    to_visit[0] = pt0;
+	    to_visit[1] = pt0_end;
+	    to_visit[2] = pt1;
+	  }
 #endif
-          d0 = ArityOfFunctor(f);
-          pt0 = ap2;
-          pt0_end = ap2 + d0;
-          pt1 = ap3;
-          continue;
-        }
+	  d0 = ArityOfFunctor(f);
+	  pt0 = ap2;
+	  pt0_end = ap2 + d0;
+	  pt1 = ap3;
+	  continue;
+	}
       }
     }
   }
@@ -3980,13 +4104,13 @@ loop:
   HR = HBREG;
   /* untrail all bindings made by variant */
   while (TR != (tr_fr_ptr)OLDTR) {
-    CELL *pt1 = (CELL *)TrailTerm(--TR);
+    CELL *pt1 = (CELL *) TrailTerm(--TR);
     RESET_VARIABLE(pt1);
   }
   HBREG = B->cp_h;
   return TRUE;
 
-out_of_stack:
+ out_of_stack:
   HR = HBREG;
   /* untrail all bindings made by variant */
 #ifdef RATIONAL_TREES
@@ -3999,13 +4123,14 @@ out_of_stack:
   }
 #endif
   while (TR != (tr_fr_ptr)OLDTR) {
-    CELL *pt1 = (CELL *)TrailTerm(--TR);
+    CELL *pt1 = (CELL *) TrailTerm(--TR);
     RESET_VARIABLE(pt1);
   }
   HBREG = B->cp_h;
   return -1;
 
-fail:
+
+ fail:
   /* failure */
   HR = HBREG;
 #ifdef RATIONAL_TREES
@@ -4019,14 +4144,16 @@ fail:
 #endif
   /* untrail all bindings made by variant */
   while (TR != (tr_fr_ptr)OLDTR) {
-    CELL *pt1 = (CELL *)TrailTerm(--TR);
+    CELL *pt1 = (CELL *) TrailTerm(--TR);
     RESET_VARIABLE(pt1);
   }
   HBREG = B->cp_h;
   return FALSE;
 }
 
-static bool is_variant(Term t1, Term t2, int parity USES_REGS) {
+static bool
+is_variant(Term t1, Term t2, int parity USES_REGS)
+{
   int out;
 
   if (t1 == t2)
@@ -4038,37 +4165,36 @@ static bool is_variant(Term t1, Term t2, int parity USES_REGS) {
   } else if (IsVarTerm(t2))
     return false;
   if (IsAtomOrIntTerm(t1)) {
-    return (t1 == t2);
+    return(t1 == t2);
   }
   if (IsPairTerm(t1)) {
     if (IsPairTerm(t2)) {
-      out = variant_complex(RepPair(t1) - 1, RepPair(t1) + 1,
-                            RepPair(t2) - 1 PASS_REGS);
-      if (out < 0)
-        goto error;
+      out = variant_complex(RepPair(t1)-1,
+			    RepPair(t1)+1,
+			    RepPair(t2)-1 PASS_REGS);
+      if (out < 0) goto error;
       return out != 0;
-    } else
-      return false;
+    }
+    else return false;
   }
   if (!IsApplTerm(t2)) {
     return false;
   } else {
     Functor f1 = FunctorOfTerm(t1);
 
-    if (f1 != FunctorOfTerm(t2))
-      return (FALSE);
+    if (f1 != FunctorOfTerm(t2)) return(FALSE);
     if (IsExtensionFunctor(f1)) {
-      return (unify_extension(f1, t1, RepAppl(t1), t2));
+      return(unify_extension(f1, t1, RepAppl(t1), t2));
     }
-    out = variant_complex(RepAppl(t1), RepAppl(t1) + ArityOfFunctor(f1),
-                          RepAppl(t2) PASS_REGS);
-    if (out < 0)
-      goto error;
+    out = variant_complex(RepAppl(t1),
+			  RepAppl(t1)+ArityOfFunctor(f1),
+			  RepAppl(t2) PASS_REGS);
+    if (out < 0) goto error;
     return out != 0;
   }
-error:
+ error:
   if (out == -1) {
-    if (!Yap_gcl((ASP - HR) * sizeof(CELL), parity, ENV, gc_P(P, CP))) {
+    if (!Yap_gcl((ASP-HR)*sizeof(CELL), parity, ENV, gc_P(P,CP))) {
       Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in variant");
       return FALSE;
     }
@@ -4077,30 +4203,36 @@ error:
   return false;
 }
 
-bool Yap_Variant(Term t1, Term t2) {
+bool
+Yap_Variant(Term t1, Term t2)
+{
   CACHE_REGS
   return is_variant(t1, t2, 0 PASS_REGS);
 }
 
-static Int p_variant(USES_REGS1) /* variant terms t1 and t2	 */
+static Int
+p_variant( USES_REGS1 ) /* variant terms t1 and t2	 */
 {
   return is_variant(Deref(ARG1), Deref(ARG2), 2 PASS_REGS);
 }
 
-static int subsumes_complex(register CELL *pt0, register CELL *pt0_end,
-                            register CELL *pt1 USES_REGS) {
+
+static int subsumes_complex(register CELL *pt0, register CELL *pt0_end, register
+		   CELL *pt1 USES_REGS)
+{
   register CELL **to_visit = (CELL **)ASP;
   tr_fr_ptr OLDTR = TR, new_tr;
   UInt write_mode = TRUE;
 
+
   HBREG = HR;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0, d1;
     Int our_write_mode = write_mode;
 
-    ++pt0;
-    ++pt1;
+    ++ pt0;
+    ++ pt1;
     /* this is a version of Derefa that checks whether we are trying to
        do something evil */
     {
@@ -4108,12 +4240,14 @@ loop:
 
     restart_d0:
       if (npt0 >= HBREG) {
-        our_write_mode = FALSE;
+	our_write_mode = FALSE;
       }
       d0 = *npt0;
-      if (IsVarTerm(d0) && d0 != (CELL)npt0) {
-        npt0 = (CELL *)d0;
-        goto restart_d0;
+      if (IsVarTerm(d0) &&
+	  d0 != (CELL)npt0
+	  ) {
+	npt0 = (CELL *)d0;
+	goto restart_d0;
       }
     }
     {
@@ -4121,117 +4255,116 @@ loop:
 
     restart_d1:
       d1 = *npt1;
-      if (IsVarTerm(d1) && d1 != (CELL)npt1) {
-        /* never dereference through a variable from the left-side */
-        if (npt1 >= HBREG) {
-          goto fail;
-        } else {
-          npt1 = (CELL *)d1;
-          goto restart_d1;
-        }
+      if (IsVarTerm(d1)
+	  && d1 != (CELL)npt1
+	  ) {
+	/* never dereference through a variable from the left-side */
+	if (npt1 >= HBREG) {
+	  goto fail;
+	} else {
+	  npt1 = (CELL *)d1;
+	  goto restart_d1;
+	}
       }
     }
     if (IsVarTerm(d0)) {
       if (our_write_mode) {
-        /* generate a new binding */
-        CELL *pt0 = VarOfTerm(d0);
-        Term new = MkVarTerm();
+	/* generate a new binding */
+	CELL *pt0 = VarOfTerm(d0);
+	Term new = MkVarTerm();
 
-        Bind_Global(pt0, new);
-        if (d0 != d1) { /* avoid loops */
-          Bind_Global(VarOfTerm(new), d1);
-          if (Yap_rational_tree_loop(VarOfTerm(new) - 1, VarOfTerm(new),
-                                     (CELL **)AuxSp, (CELL **)AuxBase))
-            goto fail;
-        }
+	Bind_Global(pt0, new);
+	if (d0 != d1) { /* avoid loops */
+	  Bind_Global(VarOfTerm(new), d1);
+	  if (Yap_rational_tree_loop(VarOfTerm(new)-1,VarOfTerm(new),(CELL **)AuxSp,(CELL **)AuxBase))
+	    goto fail;
+	}
       } else {
-        if (d0 == d1)
-          continue;
-        goto fail;
+	if (d0 == d1) continue;
+	goto fail;
       }
       continue;
     } else if (IsVarTerm(d1)) {
       goto fail;
     } else {
-      if (d0 == d1)
-        continue;
+      if (d0 == d1) continue;
       else if (IsAtomOrIntTerm(d0)) {
-        goto fail;
+	goto fail;
       } else if (IsPairTerm(d0)) {
-        if (!IsPairTerm(d1)) {
-          goto fail;
-        }
+	if (!IsPairTerm(d1)) {
+	  goto fail;
+	}
 #ifdef RATIONAL_TREES
-        /* now link the two structures so that no one else will */
-        /* come here */
-        to_visit -= 5;
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit[2] = pt1;
-        to_visit[3] = (CELL *)*pt0;
-        to_visit[4] = (CELL *)write_mode;
-        *pt0 = d1;
+	/* now link the two structures so that no one else will */
+	/* come here */
+	to_visit -= 5;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = pt1;
+	to_visit[3] = (CELL *)*pt0;
+	to_visit[4] = (CELL *)write_mode;
+	*pt0 = d1;
 #else
-        /* store the terms to visit */
-        if (pt0 < pt0_end) {
-          to_visit -= 4;
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit[2] = pt1;
-          to_visit[3] = (CELL *)write_mode;
-        }
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit -= 4;
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit[2] = pt1;
+	  to_visit[3] = (CELL *)write_mode;
+	}
 #endif
-        write_mode = our_write_mode;
-        pt0 = RepPair(d0) - 1;
-        pt0_end = RepPair(d0) + 1;
-        pt1 = RepPair(d1) - 1;
-        continue;
+	write_mode = our_write_mode;
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+	pt1 = RepPair(d1) - 1;
+	continue;
       } else if (IsApplTerm(d0)) {
-        register Functor f;
-        register CELL *ap2, *ap3;
-        if (!IsApplTerm(d1)) {
-          goto fail;
-        } else {
-          /* store the terms to visit */
-          Functor f2;
-          ap2 = RepAppl(d0);
-          ap3 = RepAppl(d1);
-          f = (Functor)(*ap2);
-          f2 = (Functor)(*ap3);
-          if (f != f2)
-            goto fail;
-          if (IsExtensionFunctor(f)) {
-            if (!unify_extension(f, d0, ap2, d1))
-              goto fail;
-            continue;
-          }
+	register Functor f;
+	register CELL *ap2, *ap3;
+	if (!IsApplTerm(d1)) {
+	  goto fail;
+	} else {
+	  /* store the terms to visit */
+	  Functor f2;
+	  ap2 = RepAppl(d0);
+	  ap3 = RepAppl(d1);
+	  f = (Functor)(*ap2);
+	  f2 = (Functor)(*ap3);
+	  if (f != f2)
+	    goto fail;
+	  if (IsExtensionFunctor(f)) {
+	    if (!unify_extension(f, d0, ap2, d1))
+	      goto fail;
+	    continue;
+	  }
 #ifdef RATIONAL_TREES
-          /* now link the two structures so that no one else will */
-          /* come here */
-          to_visit -= 5;
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit[2] = pt1;
-          to_visit[3] = (CELL *)*pt0;
-          to_visit[4] = (CELL *)write_mode;
-          *pt0 = d1;
+	  /* now link the two structures so that no one else will */
+	  /* come here */
+	  to_visit -= 5;
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit[2] = pt1;
+	  to_visit[3] = (CELL *)*pt0;
+	  to_visit[4] = (CELL *)write_mode;
+	  *pt0 = d1;
 #else
-          /* store the terms to visit */
-          if (pt0 < pt0_end) {
-            to_visit -= 4;
-            to_visit[0] = pt0;
-            to_visit[1] = pt0_end;
-            to_visit[2] = pt1;
-            to_visit[3] = (CELL *)write_mode;
-          }
+	  /* store the terms to visit */
+	  if (pt0 < pt0_end) {
+	    to_visit -= 4;
+	    to_visit[0] = pt0;
+	    to_visit[1] = pt0_end;
+	    to_visit[2] = pt1;
+	    to_visit[3] = (CELL *)write_mode;
+	  }
 #endif
-          write_mode = our_write_mode;
-          d0 = ArityOfFunctor(f);
-          pt0 = ap2;
-          pt0_end = ap2 + d0;
-          pt1 = ap3;
-          continue;
-        }
+	  write_mode = our_write_mode;
+	  d0 = ArityOfFunctor(f);
+	  pt0 = ap2;
+	  pt0_end = ap2 + d0;
+	  pt1 = ap3;
+	  continue;
+	}
       }
     }
   }
@@ -4242,7 +4375,7 @@ loop:
     pt0_end = to_visit[1];
     pt1 = to_visit[2];
     *pt0 = (CELL)to_visit[3];
-    write_mode = (Int)to_visit[4];
+    write_mode = (Int)to_visit[ 4];
     to_visit += 5;
 #else
     pt0 = to_visit[0];
@@ -4259,7 +4392,7 @@ loop:
   new_tr = TR;
   while (TR != OLDTR) {
     /* cell we bound */
-    CELL *pt1 = (CELL *)TrailTerm(--TR);
+    CELL *pt1 = (CELL *) TrailTerm(--TR);
     /* cell we created */
     CELL *npt1 = (CELL *)*pt1;
     /* shorten the chain */
@@ -4273,7 +4406,7 @@ loop:
   HBREG = B->cp_h;
   return TRUE;
 
-fail:
+ fail:
   HR = HBREG;
 #ifdef RATIONAL_TREES
   while (to_visit < (CELL **)ASP) {
@@ -4286,14 +4419,15 @@ fail:
 #endif
   /* untrail all bindings made by variant */
   while (TR != (tr_fr_ptr)OLDTR) {
-    CELL *pt1 = (CELL *)TrailTerm(--TR);
+    CELL *pt1 = (CELL *) TrailTerm(--TR);
     RESET_VARIABLE(pt1);
   }
   HBREG = B->cp_h;
   return FALSE;
 }
 
-static Int p_subsumes(USES_REGS1) /* subsumes terms t1 and t2	 */
+static Int
+p_subsumes( USES_REGS1 ) /* subsumes terms t1 and t2	 */
 {
   Term t1 = Deref(ARG1);
   Term t2 = Deref(ARG2);
@@ -4302,51 +4436,53 @@ static Int p_subsumes(USES_REGS1) /* subsumes terms t1 and t2	 */
     return (TRUE);
   if (IsVarTerm(t1)) {
     YapBind(VarOfTerm(t1), t2);
-    if (Yap_rational_tree_loop(VarOfTerm(t1) - 1, VarOfTerm(t1), (CELL **)AuxSp,
-                               (CELL **)AuxBase))
+    if (Yap_rational_tree_loop(VarOfTerm(t1)-1,VarOfTerm(t1),(CELL **)AuxSp,(CELL **)AuxBase))
       return FALSE;
     return TRUE;
   } else if (IsVarTerm(t2))
-    return (FALSE);
+    return(FALSE);
   if (IsAtomOrIntTerm(t1)) {
-    return (t1 == t2);
+    return(t1 == t2);
   }
   if (IsPairTerm(t1)) {
     if (IsPairTerm(t2)) {
-      return (subsumes_complex(RepPair(t1) - 1, RepPair(t1) + 1,
-                               RepPair(t2) - 1 PASS_REGS));
-    } else
-      return (FALSE);
+      return(subsumes_complex(RepPair(t1)-1,
+			     RepPair(t1)+1,
+			     RepPair(t2)-1 PASS_REGS));
+    }
+    else return (FALSE);
   } else {
     Functor f1;
 
-    if (!IsApplTerm(t2))
-      return (FALSE);
+    if (!IsApplTerm(t2)) return(FALSE);
     f1 = FunctorOfTerm(t1);
     if (f1 != FunctorOfTerm(t2))
-      return (FALSE);
+      return(FALSE);
     if (IsExtensionFunctor(f1)) {
-      return (unify_extension(f1, t1, RepAppl(t1), t2));
+      return(unify_extension(f1, t1, RepAppl(t1), t2));
     }
-    return (subsumes_complex(RepAppl(t1), RepAppl(t1) + ArityOfFunctor(f1),
-                             RepAppl(t2) PASS_REGS));
+    return(subsumes_complex(RepAppl(t1),
+			   RepAppl(t1)+ArityOfFunctor(f1),
+			   RepAppl(t2) PASS_REGS));
   }
 }
 
-static int term_subsumer_complex(register CELL *pt0, register CELL *pt0_end,
-                                 register CELL *pt1, CELL *npt USES_REGS) {
+
+static int term_subsumer_complex(register CELL *pt0, register CELL *pt0_end, register
+				 CELL *pt1, CELL *npt USES_REGS)
+{
   register CELL **to_visit = (CELL **)ASP;
   tr_fr_ptr OLDTR = TR;
   int out;
   CELL *bindings = NULL, *tbindings = NULL;
   HB = HR;
 
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0, d1;
 
-    ++pt0;
-    ++pt1;
+    ++ pt0;
+    ++ pt1;
     d0 = Derefa(pt0);
     d1 = Derefa(pt1);
     if (d0 == d1) {
@@ -4357,38 +4493,38 @@ loop:
 
       match = VarOfTerm(d0);
       if (match >= HB) {
-        while (match >= HB) {
-          /* chained to a sequence */
-          if (Yap_eq(d1, match[1])) {
-            *npt++ = match[2];
-            break;
-          }
-          omatch = match;
-          match = (CELL *)match[3];
-        }
-        /* found a match */
-        if (match >= HB)
-          continue;
-        /* could not find a match, add to end of chain */
-        RESET_VARIABLE(HR);  /* key */
-        HR[1] = d1;          /* comparison value */
-        HR[2] = (CELL)npt;   /* new value */
-        HR[3] = (CELL)match; /* end of chain points back to first cell */
-        omatch[3] = (CELL)HR;
-        HR += 4;
-        RESET_VARIABLE(npt);
-        npt++;
-        continue;
+	while (match >= HB) {
+	  /* chained to a sequence */
+	  if (Yap_eq(d1, match[1]) ) {
+	    *npt++ = match[2];
+	    break;
+	  }
+	  omatch = match;
+	  match = (CELL *)match[3];
+	}
+	/* found a match */
+	if (match >= HB)
+	  continue;
+	/* could not find a match, add to end of chain */
+ 	RESET_VARIABLE(HR); /* key */
+ 	HR[1] = d1; /* comparison value */
+	HR[2] = (CELL)npt; /* new value */
+	HR[3] = (CELL)match; /* end of chain points back to first cell */
+	omatch[3] = (CELL)HR;
+	HR+=4;
+	RESET_VARIABLE(npt);
+	npt++;
+	continue;
       }
       if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
-        goto trail_overflow;
+	goto trail_overflow;
       }
       RESET_VARIABLE(HR);
       HR[1] = d1;
       HR[2] = (CELL)npt;
       HR[3] = d0;
       YapBind(VarOfTerm(d0), (CELL)HR);
-      HR += 4;
+      HR+=4;
       RESET_VARIABLE(npt);
       npt++;
       continue;
@@ -4396,26 +4532,26 @@ loop:
       CELL *match = bindings;
 
       while (match) {
-        if (match[0] == d0 && match[1] == d1) {
-          *npt++ = match[2];
-          break;
-        }
-        match = (CELL *)match[3];
+	if (match[0] == d0 && match[1] == d1) {
+	  *npt++ = match[2];
+	  break;
+	}
+	match = (CELL *)match[3];
       }
       if (match) {
-        continue;
+	continue;
       }
       if (bindings) {
-        *tbindings = (CELL)HR;
+	*tbindings = (CELL)HR;
       } else {
-        bindings = HR;
+	bindings = HR;
       }
       HR[0] = d0;
       HR[1] = d1;
-      HR[2] = AbsPair(HR + 4);
+      HR[2] = AbsPair(HR+4);
       HR[3] = (CELL)NULL;
-      tbindings = HR + 3;
-      HR += 4;
+      tbindings = HR+3;
+      HR+=4;
       *npt++ = AbsPair(HR);
 #ifdef RATIONAL_TREES
       /* now link the two structures so that no one else will */
@@ -4429,11 +4565,11 @@ loop:
 #else
       /* store the terms to visit */
       if (pt0 < pt0_end) {
-        to_visit -= 4;
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit[2] = pt1;
-        to_visit[3] = npt;
+	to_visit -= 4;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = pt1;
+	to_visit[3] = npt;
       }
 #endif
       pt0 = RepPair(d0) - 1;
@@ -4441,8 +4577,8 @@ loop:
       pt1 = RepPair(d1) - 1;
       npt = HR;
       HR += 2;
-      if (HR > (CELL *)to_visit - 1024)
-        goto stack_overflow;
+      if (HR > (CELL *)to_visit -1024)
+	goto stack_overflow;
       continue;
     } else if (IsApplTerm(d0) && IsApplTerm(d1)) {
       CELL *ap2 = RepAppl(d0);
@@ -4450,65 +4586,65 @@ loop:
       Functor f = (Functor)(*ap2);
       Functor f2 = (Functor)(*ap3);
       if (f == f2) {
-        CELL *match = bindings;
+	CELL *match = bindings;
 
-        if (IsExtensionFunctor(f)) {
-          if (unify_extension(f, d0, ap2, d1)) {
-            *npt++ = d0;
-            continue;
-          }
-        }
-        while (match) {
-          if (match[0] == d0 && match[1] == d1) {
-            *npt++ = match[2];
-            break;
-          }
-          match = (CELL *)match[3];
-        }
-        if (match) {
-          continue;
-        }
-        if (bindings) {
-          *tbindings = (CELL)HR;
-        } else {
-          bindings = HR;
-        }
-        HR[0] = d0;
-        HR[1] = d1;
-        HR[2] = AbsAppl(HR + 4);
-        HR[3] = (CELL)NULL;
-        tbindings = HR + 3;
-        HR += 4;
-        *npt++ = AbsAppl(HR);
+	if (IsExtensionFunctor(f)) {
+	  if (unify_extension(f, d0, ap2, d1)) {
+	    *npt++ = d0;
+	    continue;
+	  }
+	}
+	while (match) {
+	  if (match[0] == d0 && match[1] == d1) {
+	    *npt++ = match[2];
+	    break;
+	  }
+	  match = (CELL *)match[3];
+	}
+	if (match) {
+	  continue;
+	}
+	if (bindings) {
+	  *tbindings = (CELL)HR;
+	} else {
+	  bindings = HR;
+	}
+	HR[0] = d0;
+	HR[1] = d1;
+	HR[2] = AbsAppl(HR+4);
+	HR[3] = (CELL)NULL;
+	tbindings = HR+3;
+	HR+=4;
+	*npt++ = AbsAppl(HR);
 #ifdef RATIONAL_TREES
-        /* now link the two structures so that no one else will */
-        /* come here */
-        to_visit -= 5;
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit[2] = pt1;
-        to_visit[3] = tbindings;
-        to_visit[4] = npt;
+	/* now link the two structures so that no one else will */
+	/* come here */
+	to_visit -= 5;
+	to_visit[0] = pt0;
+	to_visit[1] = pt0_end;
+	to_visit[2] = pt1;
+	to_visit[3] = tbindings;
+	to_visit[4] = npt;
 #else
-        /* store the terms to visit */
-        if (pt0 < pt0_end) {
-          to_visit -= 4;
-          to_visit[0] = pt0;
-          to_visit[1] = pt0_end;
-          to_visit[2] = pt1;
-          to_visit[3] = npt;
-        }
+	/* store the terms to visit */
+	if (pt0 < pt0_end) {
+	  to_visit -= 4;
+	  to_visit[0] = pt0;
+	  to_visit[1] = pt0_end;
+	  to_visit[2] = pt1;
+	  to_visit[3] = npt;
+	}
 #endif
-        d0 = ArityOfFunctor(f);
-        pt0 = ap2;
-        pt0_end = ap2 + d0;
-        pt1 = ap3;
-        npt = HR;
-        *npt++ = (CELL)f;
-        HR += d0;
-        if (HR > (CELL *)to_visit - 1024)
-          goto stack_overflow;
-        continue;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+	pt1 = ap3;
+	npt = HR;
+	*npt++ = (CELL)f;
+	HR += d0;
+	if (HR > (CELL *)to_visit -1024)
+	  goto stack_overflow;
+	continue;
       }
     }
     RESET_VARIABLE(npt);
@@ -4521,7 +4657,7 @@ loop:
     pt0_end = to_visit[1];
     pt1 = to_visit[2];
     tbindings = to_visit[3];
-    npt = to_visit[4];
+    npt = to_visit[ 4];
     if (!tbindings) {
       bindings = NULL;
     }
@@ -4537,25 +4673,27 @@ loop:
   }
   out = 1;
 
-complete:
+ complete:
   /* get rid of intermediate variables  */
   while (TR != OLDTR) {
-    CELL *pt1 = (CELL *)TrailTerm(--TR);
+    CELL *pt1 = (CELL *) TrailTerm(--TR);
     RESET_VARIABLE(pt1);
   }
   HBREG = B->cp_h;
   return out;
 
-stack_overflow:
+ stack_overflow:
   out = -1;
   goto complete;
 
-trail_overflow:
+ trail_overflow:
   out = -2;
   goto complete;
+
 }
 
-static Int p_term_subsumer(USES_REGS1) /* term_subsumer terms t1 and t2	 */
+static Int
+p_term_subsumer( USES_REGS1 ) /* term_subsumer terms t1 and t2	 */
 {
   int out = 0;
 
@@ -4565,38 +4703,38 @@ static Int p_term_subsumer(USES_REGS1) /* term_subsumer terms t1 and t2	 */
     CELL *oldH = HR;
 
     if (t1 == t2)
-      return Yap_unify(ARG3, t1);
+      return Yap_unify(ARG3,t1);
     if (IsPairTerm(t1) && IsPairTerm(t2)) {
       Term tf = AbsAppl(HR);
       HR += 2;
       HB = HR;
-      if ((out = term_subsumer_complex(RepPair(t1) - 1, RepPair(t1) + 1,
-                                       RepPair(t2) - 1, HR - 2 PASS_REGS)) >
-          0) {
-        HB = B->cp_h;
-        return Yap_unify(ARG3, tf);
+      if ((out = term_subsumer_complex(RepPair(t1)-1,
+				       RepPair(t1)+1,
+				       RepPair(t2)-1, HR-2 PASS_REGS)) > 0) {
+	HB = B->cp_h;
+	return Yap_unify(ARG3,tf);
       }
-    } else if (IsApplTerm(t1) && IsApplTerm(t2)) {
+  } else if (IsApplTerm(t1) && IsApplTerm(t2)) {
       Functor f1;
 
       if ((f1 = FunctorOfTerm(t1)) == FunctorOfTerm(t2)) {
-        if (IsExtensionFunctor(f1)) {
-          if (unify_extension(f1, t1, RepAppl(t1), t2)) {
-            return Yap_unify(ARG3, t1);
-          }
-        } else {
-          Term tf = AbsAppl(HR);
-          UInt ar = ArityOfFunctor(f1);
-          HR[0] = (CELL)f1;
-          HR += 1 + ar;
-          HB = HR;
-          if ((out = term_subsumer_complex(
-                   RepAppl(t1), RepAppl(t1) + ArityOfFunctor(f1), RepAppl(t2),
-                   HR - ar PASS_REGS)) > 0) {
-            HB = B->cp_h;
-            return Yap_unify(ARG3, tf);
-          }
-        }
+	if (IsExtensionFunctor(f1)) {
+	  if (unify_extension(f1, t1, RepAppl(t1), t2)) {
+	    return Yap_unify(ARG3,t1);
+	  }
+	} else {
+	  Term tf = AbsAppl(HR);
+	  UInt ar = ArityOfFunctor(f1);
+	  HR[0] = (CELL)f1;
+	  HR += 1+ar;
+	  HB = HR;
+	  if ((out = term_subsumer_complex(RepAppl(t1),
+					   RepAppl(t1)+ArityOfFunctor(f1),
+					   RepAppl(t2), HR-ar PASS_REGS)) > 0) {
+	    HB = B->cp_h;
+	    return Yap_unify(ARG3,tf);
+	  }
+	}
       }
     }
     HB = B->cp_h;
@@ -4605,16 +4743,16 @@ static Int p_term_subsumer(USES_REGS1) /* term_subsumer terms t1 and t2	 */
     } else {
       HR = oldH;
       if (out == -1) {
-        if (!Yap_gcl((ASP - HR) * sizeof(CELL), 0, ENV, gc_P(P, CP))) {
-          Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_subsumer");
-          return FALSE;
-        }
+	if (!Yap_gcl((ASP-HR)*sizeof(CELL), 0, ENV, gc_P(P,CP))) {
+	  Yap_Error(RESOURCE_ERROR_STACK, TermNil, "in term_subsumer");
+	  return FALSE;
+	}
       } else {
-        /* Trail overflow */
-        if (!Yap_growtrail(0, FALSE)) {
-          Yap_Error(RESOURCE_ERROR_TRAIL, TermNil, "in term_subsumer");
-          return FALSE;
-        }
+	/* Trail overflow */
+	if (!Yap_growtrail(0, FALSE)) {
+	  Yap_Error(RESOURCE_ERROR_TRAIL, TermNil, "in term_subsumer");
+	  return FALSE;
+	}
       }
     }
   }
@@ -4622,8 +4760,10 @@ static Int p_term_subsumer(USES_REGS1) /* term_subsumer terms t1 and t2	 */
 }
 
 #ifdef DEBUG
-static Int p_force_trail_expansion(USES_REGS1) {
-  Int i = IntOfTerm(Deref(ARG1)) * 1024, j = 0;
+static Int
+p_force_trail_expansion( USES_REGS1 )
+{
+  Int i = IntOfTerm(Deref(ARG1))*1024, j = 0;
   tr_fr_ptr OTR = TR;
 
   for (j = 0; j < i; j++) {
@@ -4632,55 +4772,75 @@ static Int p_force_trail_expansion(USES_REGS1) {
   }
   TR = OTR;
 
-  return (TRUE);
+  return(TRUE);
 }
 
-static Int camacho_dum(USES_REGS1) {
+static Int
+camacho_dum( USES_REGS1 )
+{
   Term t1, t2;
-  int max = 3;
+  int  max = 3;
 
   /* build output list */
 
   t1 = TermNil;
   t2 = MkPairTerm(MkIntegerTerm(max), t1);
 
-  return (Yap_unify(t2, ARG1));
+  return(Yap_unify(t2, ARG1));
 }
 
+
+
 #endif /* DEBUG */
 
-bool Yap_IsListTerm(Term t) {
+bool
+Yap_IsListTerm(Term t)
+{
   Term *tailp;
   Yap_SkipList(&t, &tailp);
   return *tailp == TermNil;
 }
 
-static Int p_is_list(USES_REGS1) { return Yap_IsListTerm(Deref(ARG1)); }
+static Int
+p_is_list( USES_REGS1 )
+{
+  return Yap_IsListTerm(Deref(ARG1));
+}
 
-bool Yap_IsListOrPartialListTerm(Term t) {
+bool
+Yap_IsListOrPartialListTerm(Term t)
+{
   Term *tailp, tail;
   Yap_SkipList(&t, &tailp);
   tail = *tailp;
   return tail == TermNil || IsVarTerm(tail);
 }
 
-static Int p_is_list_or_partial_list(USES_REGS1) {
+static Int
+p_is_list_or_partial_list( USES_REGS1 )
+{
   return Yap_IsListOrPartialListTerm(Deref(ARG1));
 }
 
-static Term numbervar(Int id USES_REGS) {
+static Term
+numbervar(Int id USES_REGS)
+{
   Term ts[1];
   ts[0] = MkIntegerTerm(id);
   return Yap_MkApplTerm(FunctorDollarVar, 1, ts);
 }
 
-static Term numbervar_singleton(USES_REGS1) {
+static Term
+numbervar_singleton(USES_REGS1)
+{
   Term ts[1];
   ts[0] = MkIntegerTerm(-1);
   return Yap_MkApplTerm(FunctorDollarVar, 1, ts);
 }
 
-static void renumbervar(Term t, Int id USES_REGS) {
+static void
+renumbervar(Term t, Int id USES_REGS)
+{
   Term *ts = RepAppl(t);
   ts[1] = MkIntegerTerm(id);
 }
@@ -4689,93 +4849,83 @@ extern int vsc;
 
 int vsc;
 
-static Int numbervars_in_complex_term(register CELL *pt0,
-                                      register CELL *pt0_end, Int numbv,
-                                      int singles USES_REGS) {
+static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Int numbv, int singles USES_REGS)
+{
 
   int lvl = push_text_stack();
-  att_rec_t *to_visit0, *to_visit = Malloc(1024 * sizeof(att_rec_t));
+  att_rec_t *to_visit0, *to_visit = Malloc(1024*sizeof(att_rec_t));
   att_rec_t *to_visit_max;
   register tr_fr_ptr TR0 = TR;
   CELL *InitialH = HR;
 
   to_visit0 = to_visit;
-  to_visit_max = to_visit0 + 1024;
+   to_visit_max = to_visit0+1024;
 loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, vars_in_term_unk);
-  vars_in_term_nvar : {
-    if (IsPairTerm(d0)) {
+  vars_in_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	if (to_visit + 32 >= to_visit_max) {
+	  goto aux_overflow;
+	}
+	to_visit->beg = pt0;
+	to_visit->end = pt0_end;
+	to_visit->oval = *pt0;
+	to_visit ++;
+	*pt0 = TermNil;
+	pt0 = RepPair(d0) - 1;
+	pt0_end = RepPair(d0) + 1;
+      } else if (IsApplTerm(d0)) {
+	 Functor f;
+	 CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	f = (Functor)(*ap2);
+	if (IsExtensionFunctor(f)) {
+	  continue;
+	}
+	if (singles && ap2 >= InitialH && ap2 < HR) {
+	  renumbervar(d0, numbv++ PASS_REGS);
+	  continue;
+	}
+	/* store the terms to visit */
       if (to_visit + 32 >= to_visit_max) {
-        goto aux_overflow;
+	goto aux_overflow;
       }
-#ifdef RATIONAL_TREES
-      to_visit->beg = pt0;
-      to_visit->end = pt0_end;
-      to_visit->oval = *pt0;
-      to_visit++;
-      *pt0 = TermNil;
-#else
-      if (pt0 < pt0_end) {
-        to_visit[0] = pt0;
-        to_visit[1] = pt0_end;
-        to_visit += 2;
+	to_visit->beg = pt0;
+	to_visit->end = pt0_end;
+	to_visit->oval = *pt0;
+	to_visit ++;
+	*pt0 = TermNil;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
       }
-#endif
-      pt0 = RepPair(d0) - 1;
-      pt0_end = RepPair(d0) + 1;
-    } else if (IsApplTerm(d0)) {
-      Functor f;
-      CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      f = (Functor)(*ap2);
-      if (IsExtensionFunctor(f)) {
-        continue;
-      }
-      if (singles && ap2 >= InitialH && ap2 < HR) {
-        renumbervar(d0, numbv++ PASS_REGS);
-        continue;
-      }
-      /* store the terms to visit */
-      if (to_visit + 32 >= to_visit_max) {
-        goto aux_overflow;
-      }
-#ifdef RATIONAL_TREES
-#else
-      to_visit->beg = pt0;
-      to_visit->end = pt0_end;
-      to_visit->oval = *pt0;
-      to_visit++;
-      *pt0 = TermNil;
-#endif
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
+      continue;
     }
-    continue;
-  }
+
 
     derefa_body(d0, ptd0, vars_in_term_unk, vars_in_term_nvar);
     /* do or pt2 are unbound  */
     if (singles)
-      *ptd0 = numbervar_singleton(PASS_REGS1);
+      *ptd0 = numbervar_singleton( PASS_REGS1 );
     else
       *ptd0 = numbervar(numbv++ PASS_REGS);
     /* leave an empty slot to fill in later */
-    if (HR + 1024 > ASP) {
+    if (HR+1024 > ASP) {
       goto global_overflow;
     }
     /* next make sure noone will see this as a variable again */
     if (TR > (tr_fr_ptr)LOCAL_TrailTop - 256) {
       /* Trail overflow */
-      if (!Yap_growtrail((TR - TR0) * sizeof(tr_fr_ptr *), TRUE)) {
-        goto trail_overflow;
+      if (!Yap_growtrail((TR-TR0)*sizeof(tr_fr_ptr *), TRUE)) {
+	goto trail_overflow;
       }
     }
 
@@ -4786,16 +4936,10 @@ loop:
   }
   /* Do we still have compound terms to visit */
   if (to_visit > to_visit0) {
-#ifdef RATIONAL_TREES
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->beg;
     pt0_end = to_visit->end;
     *pt0 = to_visit->oval;
-#else
-    to_visit -= 2;
-    pt0 = to_visit[0];
-    pt0_end = to_visit[1];
-#endif
     goto loop;
   }
 
@@ -4803,110 +4947,111 @@ loop:
   pop_text_stack(lvl);
   return numbv;
 
-trail_overflow:
-#ifdef RATIONAL_TREES
+ trail_overflow:
   while (to_visit > to_visit0) {
-    to_visit--;
+     to_visit --;
     pt0 = to_visit->beg;
     pt0_end = to_visit->end;
     *pt0 = to_visit->oval;
   }
-#endif
   LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
-  LOCAL_Error_Size = (TR - TR0) * sizeof(tr_fr_ptr *);
+  LOCAL_Error_Size = (TR-TR0)*sizeof(tr_fr_ptr *);
   clean_tr(TR0 PASS_REGS);
   HR = InitialH;
   pop_text_stack(lvl);
-  return numbv - 1;
+  return numbv-1;
 
-aux_overflow : {
-  size_t d1 = to_visit - to_visit0;
-  size_t d2 = to_visit_max - to_visit0;
-  to_visit0 = Realloc(to_visit0, d2 * sizeof(CELL *) + 64 * 1024);
-  to_visit = to_visit0 + d1;
-  to_visit_max = to_visit0 + (d2 + (64 * 1024)) / sizeof(CELL **);
+ aux_overflow:
+  {
+  size_t d1 = to_visit-to_visit0;
+  size_t d2 = to_visit_max-to_visit0;
+  to_visit0 = Realloc(to_visit0,d2*sizeof(CELL*)+64*1024);
+  to_visit = to_visit0+d1;
+  to_visit_max = to_visit0+(d2+(64*1024))/sizeof(CELL **);
 }
-  pt0--;
-  goto loop;
+pt0--;
+goto loop;
 
-global_overflow:
-#ifdef RATIONAL_TREES
+ global_overflow:
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->beg;
     pt0_end = to_visit->end;
     *pt0 = to_visit->oval;
   }
-#endif
   clean_tr(TR0 PASS_REGS);
   HR = InitialH;
   LOCAL_Error_TYPE = RESOURCE_ERROR_STACK;
-  LOCAL_Error_Size = (ASP - HR) * sizeof(CELL);
+  LOCAL_Error_Size = (ASP-HR)*sizeof(CELL);
   pop_text_stack(lvl);
-  return numbv - 1;
+  return numbv-1;
+
 }
 
-Int Yap_NumberVars(Term inp, Int numbv,
-                   bool handle_singles) /*
-                                         * numbervariables in term t	 */
+Int
+Yap_NumberVars( Term inp, Int numbv, bool handle_singles )	/*
+ * numbervariables in term t	 */
 {
   CACHE_REGS
   Int out;
   Term t;
 
-restart:
+ restart:
   t = Deref(inp);
   if (IsVarTerm(t)) {
     CELL *ptd0 = VarOfTerm(t);
     TrailTerm(TR++) = (CELL)ptd0;
     if (handle_singles) {
-      *ptd0 = numbervar_singleton(PASS_REGS1);
+      *ptd0 = numbervar_singleton( PASS_REGS1 );
       return numbv;
     } else {
       *ptd0 = numbervar(numbv PASS_REGS);
-      return numbv + 1;
+      return numbv+1;
     }
-  } else if (IsPrimitiveTerm(t)) {
+  }  else if (IsPrimitiveTerm(t)) {
     return numbv;
   } else if (IsPairTerm(t)) {
-    out = numbervars_in_complex_term(RepPair(t) - 1, RepPair(t) + 1, numbv,
-                                     handle_singles PASS_REGS);
+    out = numbervars_in_complex_term(RepPair(t)-1,
+				     RepPair(t)+1, numbv, handle_singles PASS_REGS);
   } else {
     Functor f = FunctorOfTerm(t);
 
-    out = numbervars_in_complex_term(RepAppl(t), RepAppl(t) + ArityOfFunctor(f),
-                                     numbv, handle_singles PASS_REGS);
+    out = numbervars_in_complex_term(RepAppl(t),
+			       RepAppl(t)+
+				     ArityOfFunctor(f), numbv, handle_singles PASS_REGS);
   }
   if (out < numbv) {
-    if (!expand_vts(3 PASS_REGS))
+    if (!expand_vts( 3 PASS_REGS ))
       return FALSE;
     goto restart;
   }
   return out;
 }
 
-static Int p_numbervars(USES_REGS1) {
+static Int
+p_numbervars( USES_REGS1 )
+{
   Term t2 = Deref(ARG2);
   Int out;
 
   if (IsVarTerm(t2)) {
-    Yap_Error(INSTANTIATION_ERROR, t2, "numbervars/3");
+    Yap_Error(INSTANTIATION_ERROR,t2,"numbervars/3");
     return FALSE;
   }
   if (!IsIntegerTerm(t2)) {
-    Yap_Error(TYPE_ERROR_INTEGER, t2, "term_hash/4");
-    return (FALSE);
+    Yap_Error(TYPE_ERROR_INTEGER,t2,"term_hash/4");
+    return(FALSE);
   }
   if ((out = Yap_NumberVars(ARG1, IntegerOfTerm(t2), FALSE)) < 0)
     return FALSE;
   return Yap_unify(ARG3, MkIntegerTerm(out));
 }
 
-static int unnumber_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf,
-                                 CELL *HLow, int share USES_REGS) {
+static int
+unnumber_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf, CELL *HLow, int share USES_REGS)
+{
 
-  struct cp_frame *to_visit0,
-      *to_visit = (struct cp_frame *)Yap_PreAllocCodeSpace();
+  struct cp_frame *to_visit0, *to_visit = (struct cp_frame *)Yap_PreAllocCodeSpace();
   CELL *HB0 = HB;
   tr_fr_ptr TR0 = TR;
   int ground = share;
@@ -4914,171 +5059,158 @@ static int unnumber_complex_term(CELL *pt0, CELL *pt0_end, CELL *ptf,
 
   HB = HLow;
   to_visit0 = to_visit;
-loop:
+ loop:
   while (pt0 < pt0_end) {
     register CELL d0;
     register CELL *ptd0;
-    ++pt0;
+    ++ pt0;
     ptd0 = pt0;
     d0 = *ptd0;
     deref_head(d0, unnumber_term_unk);
-  unnumber_term_nvar : {
-    if (IsPairTerm(d0)) {
-      CELL *ap2 = RepPair(d0);
-      if (ap2 >= HB && ap2 < HR) {
-        /* If this is newer than the current term, just reuse */
-        *ptf++ = d0;
-        continue;
-      }
-      *ptf = AbsPair(HR);
-      ptf++;
-#ifdef RATIONAL_TREES
-      if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldv = *pt0;
-      to_visit->ground = ground;
-      /* fool the system into thinking we had a variable there */
-      *pt0 = AbsPair(HR);
-      to_visit++;
-#else
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit->ground = ground;
-        to_visit++;
-      }
-#endif
-      ground = share;
-      pt0 = ap2 - 1;
-      pt0_end = ap2 + 1;
-      ptf = HR;
-      HR += 2;
-      if (HR > ASP - 2048) {
-        goto overflow;
-      }
-    } else if (IsApplTerm(d0)) {
-      register Functor f;
-      register CELL *ap2;
-      /* store the terms to visit */
-      ap2 = RepAppl(d0);
-      if (ap2 >= HB && ap2 <= HR) {
-        /* If this is newer than the current term, just reuse */
-        *ptf++ = d0;
-        continue;
-      }
-      f = (Functor)(*ap2);
+  unnumber_term_nvar:
+    {
+      if (IsPairTerm(d0)) {
+	CELL *ap2 = RepPair(d0);
+	if (ap2 >= HB && ap2 < HR) {
+	  /* If this is newer than the current term, just reuse */
+	  *ptf++ = d0;
+	  continue;
+	}
+	*ptf = AbsPair(HR);
+	ptf++;
+	if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldv = *pt0;
+	to_visit->ground = ground;
+	/* fool the system into thinking we had a variable there */
+	*pt0 = AbsPair(HR);
+	to_visit ++;
+	ground = share;
+	pt0 = ap2 - 1;
+	pt0_end = ap2 + 1;
+	ptf = HR;
+	HR += 2;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else if (IsApplTerm(d0)) {
+	register Functor f;
+	register CELL *ap2;
+	/* store the terms to visit */
+	ap2 = RepAppl(d0);
+	if (ap2 >= HB && ap2 <= HR) {
+	  /* If this is newer than the current term, just reuse */
+	  *ptf++ = d0;
+	  continue;
+	}
+	f = (Functor)(*ap2);
 
-      if (IsExtensionFunctor(f)) {
-        *ptf++ = d0; /* you can just unnumber other extensions. */
-        continue;
-      }
-      if (f == FunctorDollarVar) {
-        Int id = IntegerOfTerm(ap2[1]);
-        ground = FALSE;
-        if (id < -1) {
-          Yap_Error(RESOURCE_ERROR_STACK, TermNil,
-                    "unnumber vars cannot cope with VAR(-%d)", id);
-          return 0L;
-        }
-        if (id <= max) {
-          if (ASP - (max + 1) <= HR) {
-            goto overflow;
-          }
-          /* we found this before? */
-          if (ASP[-id - 1])
-            *ptf++ = ASP[-id - 1];
-          else {
-            RESET_VARIABLE(ptf);
-            ASP[-id - 1] = (CELL)ptf;
-            ptf++;
-          }
-          continue;
-        }
-        /* alloc more space */
-        if (ASP - (id + 1) <= HR) {
-          goto overflow;
-        }
-        while (id > max) {
-          ASP[-(id + 1)] = 0L;
-          max++;
-        }
-        /* new variable */
-        RESET_VARIABLE(ptf);
-        ASP[-(id + 1)] = (CELL)ptf;
-        ptf++;
-        continue;
-      }
-      *ptf = AbsAppl(HR);
-      ptf++;
-      /* store the terms to visit */
+	if (IsExtensionFunctor(f)) {
+	  *ptf++ = d0;  /* you can just unnumber other extensions. */
+	  continue;
+	}
+	if (f == FunctorDollarVar) {
+	  Int id = IntegerOfTerm(ap2[1]);
+	  ground = FALSE;
+	  if (id < -1) {
+	    Yap_Error(RESOURCE_ERROR_STACK, TermNil, "unnumber vars cannot cope with VAR(-%d)", id);
+	    return 0L;
+	  }
+	  if (id <= max) {
+	    if (ASP-(max+1) <= HR) {
+	      goto overflow;
+	    }
+	    /* we found this before? */
+	    if (ASP[-id-1])
+	      *ptf++ = ASP[-id-1];
+	    else {
+	      RESET_VARIABLE(ptf);
+	      ASP[-id-1] = (CELL)ptf;
+	      ptf++;
+	    }
+	    continue;
+	  }
+	  /* alloc more space */
+	  if (ASP-(id+1) <= HR) {
+	    goto overflow;
+	  }
+	  while (id > max) {
+	    ASP[-(id+1)] = 0L;
+	    max++;
+	  }
+	  /* new variable */
+	  RESET_VARIABLE(ptf);
+	  ASP[-(id+1)] = (CELL)ptf;
+	  ptf++;
+	  continue;
+	}
+	*ptf = AbsAppl(HR);
+	ptf++;
+	/* store the terms to visit */
 #ifdef RATIONAL_TREES
-      if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-        goto heap_overflow;
-      }
-      to_visit->start_cp = pt0;
-      to_visit->end_cp = pt0_end;
-      to_visit->to = ptf;
-      to_visit->oldv = *pt0;
-      to_visit->ground = ground;
-      /* fool the system into thinking we had a variable there */
-      *pt0 = AbsAppl(HR);
-      to_visit++;
+	if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	  goto heap_overflow;
+	}
+	to_visit->start_cp = pt0;
+	to_visit->end_cp = pt0_end;
+	to_visit->to = ptf;
+	to_visit->oldv = *pt0;
+	to_visit->ground = ground;
+	/* fool the system into thinking we had a variable there */
+	*pt0 = AbsAppl(HR);
+	to_visit ++;
 #else
-      if (pt0 < pt0_end) {
-        if (to_visit + 1 >= (struct cp_frame *)AuxSp) {
-          goto heap_overflow;
-        }
-        to_visit->start_cp = pt0;
-        to_visit->end_cp = pt0_end;
-        to_visit->to = ptf;
-        to_visit->ground = ground;
-        to_visit++;
-      }
+	if (pt0 < pt0_end) {
+	  if (to_visit+1 >= (struct cp_frame *)AuxSp) {
+	    goto heap_overflow;
+	  }
+	  to_visit->start_cp = pt0;
+	  to_visit->end_cp = pt0_end;
+	  to_visit->to = ptf;
+	  to_visit->ground = ground;
+	  to_visit ++;
+	}
 #endif
-      ground = (f != FunctorMutable) && share;
-      d0 = ArityOfFunctor(f);
-      pt0 = ap2;
-      pt0_end = ap2 + d0;
-      /* store the functor for the new term */
-      HR[0] = (CELL)f;
-      ptf = HR + 1;
-      HR += 1 + d0;
-      if (HR > ASP - 2048) {
-        goto overflow;
+	ground = (f != FunctorMutable) && share;
+	d0 = ArityOfFunctor(f);
+	pt0 = ap2;
+	pt0_end = ap2 + d0;
+	/* store the functor for the new term */
+	HR[0] = (CELL)f;
+	ptf = HR+1;
+	HR += 1+d0;
+	if (HR > ASP - 2048) {
+	  goto overflow;
+	}
+      } else {
+	/* just unnumber atoms or integers */
+	*ptf++ = d0;
       }
-    } else {
-      /* just unnumber atoms or integers */
-      *ptf++ = d0;
+      continue;
     }
-    continue;
-  }
 
     derefa_body(d0, ptd0, unnumber_term_unk, unnumber_term_nvar);
     /* this should never happen ? */
     ground = FALSE;
-    *ptf++ = (CELL)ptd0;
+    *ptf++ = (CELL) ptd0;
   }
   /* Do we still have compound terms to visit */
   if (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     if (ground) {
       CELL old = to_visit->oldv;
-      CELL *newp = to_visit->to - 1;
+      CELL *newp = to_visit->to-1;
       CELL new = *newp;
 
       *newp = old;
       if (IsApplTerm(new))
-        HR = RepAppl(new);
+	HR = RepAppl(new);
       else
-        HR = RepPair(new);
+	HR = RepPair(new);
     }
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
@@ -5095,7 +5227,7 @@ loop:
   HB = HB0;
   return ground;
 
-overflow:
+ overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -5103,7 +5235,7 @@ overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -5114,7 +5246,7 @@ overflow:
   /* follow chain of multi-assigned variables */
   return -1;
 
-heap_overflow:
+ heap_overflow:
   /* oops, we're in trouble */
   HR = HLow;
   /* we've done it */
@@ -5122,7 +5254,7 @@ heap_overflow:
   HB = HB0;
 #ifdef RATIONAL_TREES
   while (to_visit > to_visit0) {
-    to_visit--;
+    to_visit --;
     pt0 = to_visit->start_cp;
     pt0_end = to_visit->end_cp;
     ptf = to_visit->to;
@@ -5130,11 +5262,13 @@ heap_overflow:
   }
 #endif
   reset_trail(TR0);
-  LOCAL_Error_Size = (ADDR)AuxSp - (ADDR)to_visit0;
+  LOCAL_Error_Size = (ADDR)AuxSp-(ADDR)to_visit0;
   return -3;
 }
 
-static Term UnnumberTerm(Term inp, UInt arity, int share USES_REGS) {
+
+static Term
+UnnumberTerm(Term inp, UInt arity, int share USES_REGS) {
   Term t = Deref(inp);
   tr_fr_ptr TR0 = TR;
 
@@ -5154,15 +5288,14 @@ static Term UnnumberTerm(Term inp, UInt arity, int share USES_REGS) {
     HR += 2;
     {
       int res;
-      if ((res = unnumber_complex_term(ap - 1, ap + 1, Hi, Hi,
-                                       share PASS_REGS)) < 0) {
-        HR = Hi;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_list;
+      if ((res = unnumber_complex_term(ap-1, ap+1, Hi, Hi, share PASS_REGS)) < 0) {
+	HR = Hi;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_list;
       } else if (res) {
-        HR = Hi;
-        return t;
+	HR = Hi;
+	return t;
       }
     }
     return tf;
@@ -5178,75 +5311,82 @@ static Term UnnumberTerm(Term inp, UInt arity, int share USES_REGS) {
     ap = RepAppl(t);
     tf = AbsAppl(HR);
     HR[0] = (CELL)f;
-    HR += 1 + ArityOfFunctor(f);
-    if (HR > ASP - 128) {
+    HR += 1+ArityOfFunctor(f);
+    if (HR > ASP-128) {
       HR = HB0;
-      if ((t = handle_cp_overflow(-1, TR0, arity, t)) == 0L)
-        return FALSE;
+      if ((t = handle_cp_overflow(-1, TR0, arity, t))== 0L)
+	return FALSE;
       goto restart_appl;
     } else {
       int res;
 
-      if ((res = unnumber_complex_term(ap, ap + ArityOfFunctor(f), HB0 + 1, HB0,
-                                       share PASS_REGS)) < 0) {
-        HR = HB0;
-        if ((t = handle_cp_overflow(res, TR0, arity, t)) == 0L)
-          return FALSE;
-        goto restart_appl;
+      if ((res = unnumber_complex_term(ap, ap+ArityOfFunctor(f), HB0+1, HB0, share PASS_REGS)) < 0) {
+	HR = HB0;
+	if ((t = handle_cp_overflow(res, TR0, arity, t))== 0L)
+	  return FALSE;
+	goto restart_appl;
       } else if (res && FunctorOfTerm(t) != FunctorMutable) {
-        HR = HB0;
-        return t;
+	HR = HB0;
+	return t;
       }
     }
     return tf;
   }
 }
 
-Term Yap_UnNumberTerm(Term inp, int share) {
+Term
+Yap_UnNumberTerm(Term inp, int share) {
   CACHE_REGS
   return UnnumberTerm(inp, 0, share PASS_REGS);
 }
 
-static Int p_unnumbervars(USES_REGS1) {
+static Int
+p_unnumbervars( USES_REGS1 ) {
   /* this should be a standard Prolog term, so we allow sharing? */
   return Yap_unify(UnnumberTerm(ARG1, 2, FALSE PASS_REGS), ARG2);
 }
 
-Int Yap_SkipList(Term *l, Term **tailp) {
+Int
+Yap_SkipList(Term *l, Term **tailp)
+{
   Int length = 0;
   Term *s; /* slow */
-  Term v;  /* temporary */
+  Term v; /* temporary */
 
-  do_derefa(v, l, derefa_unk, derefa_nonvar);
+  do_derefa(v,l,derefa_unk,derefa_nonvar);
   s = l;
 
-  if (IsPairTerm(*l)) {
-    intptr_t power = 1, lam = 0;
-    do {
-      if (power == lam) {
-        s = l;
-        power *= 2;
-        lam = 0;
+  if ( IsPairTerm(*l) )
+  { intptr_t power = 1, lam = 0;
+    do
+    { if ( power == lam )
+      { s = l;
+	power *= 2;
+	lam = 0;
       }
       lam++;
       length++;
-      l = RepPair(*l) + 1;
-      do_derefa(v, l, derefa2_unk, derefa2_nonvar);
-    } while (*l != *s && IsPairTerm(*l));
+      l = RepPair(*l)+1;
+      do_derefa(v,l,derefa2_unk,derefa2_nonvar);
+    } while ( *l != *s && IsPairTerm(*l) );
   }
   *tailp = l;
 
   return length;
 }
 
-static Int p_skip_list(USES_REGS1) {
-  Term *tail;
-  Int len = Yap_SkipList(XREGS + 2, &tail);
 
-  return Yap_unify(MkIntegerTerm(len), ARG1) && Yap_unify(*tail, ARG3);
+static Int
+p_skip_list( USES_REGS1 ) {
+  Term *tail;
+  Int len = Yap_SkipList(XREGS+2, &tail);
+
+  return Yap_unify(MkIntegerTerm(len), ARG1) &&
+    Yap_unify(*tail, ARG3);
 }
 
-static Int p_skip_list4(USES_REGS1) {
+static Int
+p_skip_list4( USES_REGS1 ) {
   Term *tail;
   Int len, len1 = -1;
   Term t2 = Deref(ARG2), t;
@@ -5262,21 +5402,26 @@ static Int p_skip_list4(USES_REGS1) {
     }
   }
   /* we need len here */
-  len = Yap_SkipList(XREGS + 1, &tail);
+  len = Yap_SkipList(XREGS+1, &tail);
   t = *tail;
   /* don't set M0 if full list, just check M */
   if (t == TermNil) {
     if (len1 >= 0) { /* ARG2 was bound */
-      return len1 == len && Yap_unify(t, ARG4);
+      return
+	len1 == len &&
+	Yap_unify(t, ARG4);
     } else {
       return Yap_unify_constant(ARG4, TermNil) &&
-             Yap_unify_constant(ARG2, MkIntegerTerm(len));
+	Yap_unify_constant(ARG2, MkIntegerTerm(len));
     }
   }
-  return Yap_unify(MkIntegerTerm(len), ARG3) && Yap_unify(t, ARG4);
+  return Yap_unify(MkIntegerTerm(len), ARG3) &&
+    Yap_unify(t, ARG4);
 }
 
-static Int p_free_arguments(USES_REGS1) {
+static Int
+p_free_arguments( USES_REGS1 )
+{
   Term t = Deref(ARG1);
   if (IsVarTerm(t))
     return FALSE;
@@ -5294,34 +5439,33 @@ static Int p_free_arguments(USES_REGS1) {
     if (IsExtensionFunctor(f))
       return TRUE;
     ar = ArityOfFunctor(f);
-    for (i = 1; i <= ar; i++) {
+    for (i = 1 ; i <= ar; i++) {
       Term ta = ArgOfTerm(i, t);
       Int j;
 
       ret = IsVarTerm(ta);
-      if (!ret)
-        break;
+      if (!ret) break;
       /* stupid quadractic algorithm, but needs no testing for overflows */
-      for (j = 1; j < i; j++) {
-        ret = ArgOfTerm(j, t) != ta;
-        if (!ret)
-          break;
+      for (j = 1 ; j < i; j++) {
+	ret = ArgOfTerm(j, t) != ta;
+	if (!ret) break;
       }
-      if (!ret)
-        break;
+      if (!ret) break;
     }
     return ret;
   }
 }
 
-static Int p_freshen_variables(USES_REGS1) {
+static Int
+p_freshen_variables( USES_REGS1 )
+{
   Term t = Deref(ARG1);
   Functor f = FunctorOfTerm(t);
   UInt arity = ArityOfFunctor(f), i;
   Term tn = Yap_MkNewApplTerm(f, arity);
-  CELL *src = RepAppl(t) + 1;
-  CELL *targ = RepAppl(tn) + 1;
-  for (i = 0; i < arity; i++) {
+  CELL *src = RepAppl(t)+1;
+  CELL *targ = RepAppl(tn)+1;
+  for (i=0; i< arity; i++) {
     RESET_VARIABLE(targ);
     *VarOfTerm(*src) = (CELL)targ;
     targ++;
@@ -5330,141 +5474,142 @@ static Int p_freshen_variables(USES_REGS1) {
   return TRUE;
 }
 
-static Int p_reset_variables(USES_REGS1) {
+static Int
+p_reset_variables( USES_REGS1 )
+{
   Term t = Deref(ARG1);
   Functor f = FunctorOfTerm(t);
   UInt arity = ArityOfFunctor(f), i;
-  CELL *src = RepAppl(t) + 1;
+  CELL *src = RepAppl(t)+1;
 
-  for (i = 0; i < arity; i++) {
+  for (i=0; i< arity; i++) {
     RESET_VARIABLE(VarOfTerm(*src));
     src++;
   }
   return TRUE;
 }
 
-void Yap_InitUtilCPreds(void) {
+void Yap_InitUtilCPreds(void)
+{
   CACHE_REGS
   Term cm = CurrentModule;
   Yap_InitCPred("copy_term", 2, p_copy_term, 0);
-  /** @pred  copy_term(? _TI_,- _TF_) is iso
+/** @pred  copy_term(? _TI_,- _TF_) is iso
 
 
-  Term  _TF_ is a variant of the original term  _TI_, such that for
-  each variable  _V_ in the term  _TI_ there is a new variable  _V'_
-  in term  _TF_. Notice that:
+Term  _TF_ is a variant of the original term  _TI_, such that for
+each variable  _V_ in the term  _TI_ there is a new variable  _V'_
+in term  _TF_. Notice that:
 
-  + suspended goals and attributes for attributed variables in _TI_ are also
-  duplicated;
-  + ground terms are shared between the new and the old term.
++ suspended goals and attributes for attributed variables in _TI_ are also duplicated;
++ ground terms are shared between the new and the old term.
 
-  If you do not want any sharing to occur please use
-  duplicate_term/2.
+If you do not want any sharing to occur please use
+duplicate_term/2.
 
 
-  */
+*/
   Yap_InitCPred("duplicate_term", 2, p_duplicate_term, 0);
-  /** @pred  duplicate_term(? _TI_,- _TF_)
+/** @pred  duplicate_term(? _TI_,- _TF_)
 
 
-  Term  _TF_ is a variant of the original term  _TI_, such that
-  for each variable  _V_ in the term  _TI_ there is a new variable
-   _V'_ in term  _TF_, and the two terms do not share any
-  structure. All suspended goals and attributes for attributed variables
-  in  _TI_ are also duplicated.
+Term  _TF_ is a variant of the original term  _TI_, such that
+for each variable  _V_ in the term  _TI_ there is a new variable
+ _V'_ in term  _TF_, and the two terms do not share any
+structure. All suspended goals and attributes for attributed variables
+in  _TI_ are also duplicated.
 
-  Also refer to copy_term/2.
+Also refer to copy_term/2.
 
 
-  */
+*/
   Yap_InitCPred("copy_term_nat", 2, p_copy_term_no_delays, 0);
-  /** @pred copy_term_nat(? _TI_,- _TF_)
+/** @pred copy_term_nat(? _TI_,- _TF_)
 
 
-  As copy_term/2.  Attributes however, are <em>not</em> copied but replaced
-  by fresh variables.
+As copy_term/2.  Attributes however, are <em>not</em> copied but replaced
+by fresh variables.
 
 
 
 
-   */
+ */
   Yap_InitCPred("ground", 1, p_ground, SafePredFlag);
-  /** @pred  ground( _T_) is iso
+/** @pred  ground( _T_) is iso
 
 
-  Succeeds if there are no free variables in the term  _T_.
+Succeeds if there are no free variables in the term  _T_.
 
 
-  */
+*/
   Yap_InitCPred("$variables_in_term", 3, p_variables_in_term, 0);
   Yap_InitCPred("$free_variables_in_term", 3, p_free_variables_in_term, 0);
   Yap_InitCPred("$non_singletons_in_term", 3, p_non_singletons_in_term, 0);
   Yap_InitCPred("term_variables", 2, p_term_variables, 0);
-  /** @pred  term_variables(? _Term_, - _Variables_) is iso
+/** @pred  term_variables(? _Term_, - _Variables_) is iso
 
 
 
-  Unify  _Variables_ with the list of all variables of term
-   _Term_.  The variables occur in the order of their first
-  appearance when traversing the term depth-first, left-to-right.
+Unify  _Variables_ with the list of all variables of term
+ _Term_.  The variables occur in the order of their first
+appearance when traversing the term depth-first, left-to-right.
 
 
-  */
+*/
   Yap_InitCPred("term_variables", 3, p_term_variables3, 0);
   Yap_InitCPred("term_attvars", 2, p_term_attvars, 0);
-  /** @pred term_attvars(+ _Term_,- _AttVars_)
+/** @pred term_attvars(+ _Term_,- _AttVars_)
 
 
-   _AttVars_ is a list of all attributed variables in  _Term_ and
-  its attributes. I.e., term_attvars/2 works recursively through
-  attributes.  This predicate is Cycle-safe.
+ _AttVars_ is a list of all attributed variables in  _Term_ and
+its attributes. I.e., term_attvars/2 works recursively through
+attributes.  This predicate is Cycle-safe.
 
 
-  */
-  Yap_InitCPred("is_list", 1, p_is_list, SafePredFlag | TestPredFlag);
-  Yap_InitCPred("$is_list_or_partial_list", 1, p_is_list_or_partial_list,
-                SafePredFlag | TestPredFlag);
+*/
+  Yap_InitCPred("is_list", 1, p_is_list, SafePredFlag|TestPredFlag);
+  Yap_InitCPred("$is_list_or_partial_list", 1, p_is_list_or_partial_list, SafePredFlag|TestPredFlag);
   Yap_InitCPred("rational_term_to_tree", 4, p_break_rational, 0);
-  /** @pred  rational_term_to_tree(? _TI_,- _TF_, ?SubTerms, ?MoreSubterms)
+/** @pred  rational_term_to_tree(? _TI_,- _TF_, ?SubTerms, ?MoreSubterms)
 
 
-  The term _TF_ is a forest representation (without cycles and repeated
-  terms) for the Prolog term _TI_. The term _TF_ is the main term.  The
-  difference list _SubTerms_-_MoreSubterms_ stores terms of the form
-  _V=T_, where _V_ is a new variable occuring in _TF_, and _T_ is a copy
-  of a sub-term from _TI_.
+The term _TF_ is a forest representation (without cycles and repeated
+terms) for the Prolog term _TI_. The term _TF_ is the main term.  The
+difference list _SubTerms_-_MoreSubterms_ stores terms of the form
+_V=T_, where _V_ is a new variable occuring in _TF_, and _T_ is a copy
+of a sub-term from _TI_.
 
 
-  */
+*/
   Yap_InitCPred("term_factorized", 3, p_break_rational3, 0);
-  /** @pred  term_factorized(? _TI_,- _TF_, ?SubTerms)
+/** @pred  term_factorized(? _TI_,- _TF_, ?SubTerms)
 
 
-  Similar to rational_term_to_tree/4, but _SubTerms_ is a proper list.
+Similar to rational_term_to_tree/4, but _SubTerms_ is a proper list.
 
 
-  */
+*/
   Yap_InitCPred("=@=", 2, p_variant, 0);
   Yap_InitCPred("numbervars", 3, p_numbervars, 0);
-  /** @pred  numbervars( _T_,+ _N1_,- _Nn_)
+/** @pred  numbervars( _T_,+ _N1_,- _Nn_)
 
 
-  Instantiates each variable in term  _T_ to a term of the form:
-  `$VAR( _I_)`, with  _I_ increasing from  _N1_ to  _Nn_.
+Instantiates each variable in term  _T_ to a term of the form:
+`$VAR( _I_)`, with  _I_ increasing from  _N1_ to  _Nn_.
 
 
-  */
+*/
   Yap_InitCPred("unnumbervars", 2, p_unnumbervars, 0);
-  /** @pred  unnumbervars( _T_,+ _NT_)
+/** @pred  unnumbervars( _T_,+ _NT_)
 
 
-  Replace every `$VAR( _I_)` by a free variable.
+Replace every `$VAR( _I_)` by a free variable.
 
 
-  */
+*/
   /* use this carefully */
-  Yap_InitCPred("$skip_list", 3, p_skip_list, SafePredFlag | TestPredFlag);
-  Yap_InitCPred("$skip_list", 4, p_skip_list4, SafePredFlag | TestPredFlag);
+  Yap_InitCPred("$skip_list", 3, p_skip_list, SafePredFlag|TestPredFlag);
+  Yap_InitCPred("$skip_list", 4, p_skip_list4, SafePredFlag|TestPredFlag);
   Yap_InitCPred("$free_arguments", 1, p_free_arguments, TestPredFlag);
   CurrentModule = TERMS_MODULE;
   Yap_InitCPred("variable_in_term", 2, p_var_in_term, 0);
@@ -5482,8 +5627,7 @@ void Yap_InitUtilCPreds(void) {
   Yap_InitCPred("reset_variables", 1, p_reset_variables, 0);
   CurrentModule = cm;
 #ifdef DEBUG
-  Yap_InitCPred("$force_trail_expansion", 1, p_force_trail_expansion,
-                SafePredFlag);
+  Yap_InitCPred("$force_trail_expansion", 1, p_force_trail_expansion, SafePredFlag);
   Yap_InitCPred("dum", 1, camacho_dum, SafePredFlag);
 #endif
 }