From 04fd092e49b7fe6f3d79348d571822c06327a946 Mon Sep 17 00:00:00 2001
From: Vitor Santos Costa <vsc@dcc.fc.up.pt>
Date: Sun, 31 Jul 2016 10:18:50 -0500
Subject: [PATCH] indenting

---
 packages/cplint/slipcase/bddem.c | 1519 ++++++++++++++----------------
 1 file changed, 686 insertions(+), 833 deletions(-)

diff --git a/packages/cplint/slipcase/bddem.c b/packages/cplint/slipcase/bddem.c
index 04226ffef..7b8187686 100644
--- a/packages/cplint/slipcase/bddem.c
+++ b/packages/cplint/slipcase/bddem.c
@@ -9,12 +9,12 @@ for the relative license.
 
 */
 
-#include <math.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
 #include "config.h"
 #include "cudd_config.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #if HAVE_CUDD_CUDDINT_H
 #include <cudd/cuddInt.h>
 #elif HAVE_CUDDINT_H
@@ -22,34 +22,29 @@ for the relative license.
 #endif
 #include "YapInterface.h"
 #define LOGZERO log(0.000001)
-#define CACHE_SLOTS 1 
+#define CACHE_SLOTS 1
 #define UNIQUE_SLOTS 1
 
-
-typedef struct
-{
-  int nVal,nRule;
+typedef struct {
+  int nVal, nRule;
   int firstBoolVar;
 } variable;
 
-
-typedef struct 
-{
+typedef struct {
   DdNode *key;
   double value;
 } rowel;
 
-typedef struct  
-{
+typedef struct {
   int cnt;
   rowel *row;
 } tablerow;
 
-tablerow * table;
+tablerow *table;
 
-static variable ** vars_ex;
-static int ** bVar2mVar_ex;
-static double * sigma;
+static variable **vars_ex;
+static int **bVar2mVar_ex;
+static double *sigma;
 static double ***eta;
 static double ***eta_temp;
 static double **arrayprob;
@@ -57,17 +52,17 @@ static int *rules;
 static DdManager **mgr_ex;
 static int *nVars_ex;
 static int nRules;
-double * nodes_probs_ex;
-double ** probs_ex;
-static int * boolVars_ex; 
-tablerow * nodesB;
-tablerow * nodesF;
-int ex,cycle;
-DdNode *** nodesToVisit;
-int * NnodesToVisit;
-double * example_prob;
+double *nodes_probs_ex;
+double **probs_ex;
+static int *boolVars_ex;
+tablerow *nodesB;
+tablerow *nodesF;
+int ex, cycle;
+DdNode ***nodesToVisit;
+int *NnodesToVisit;
+double *example_prob;
 static YAP_Bool ret_prob(void);
-double Prob(DdNode *node,int comp_par);
+double Prob(DdNode *node, int comp_par);
 static YAP_Bool end_bdd(void);
 static YAP_Bool init_test(void);
 static YAP_Bool add_var(void);
@@ -80,131 +75,121 @@ static YAP_Bool rec_deref(void);
 int indexMvar(DdNode *node);
 void Forward(DdNode *node, int nex);
 void GetForward(DdNode *node, double ForwProbPath);
-void UpdateForward(DdNode * node, int nex);
-double GetOutsideExpe(DdNode *root,double ex_prob, int nex);
+void UpdateForward(DdNode *node, int nex);
+double GetOutsideExpe(DdNode *root, double ex_prob, int nex);
 void Maximization(void);
 static double Expectation(DdNode **nodes_ex, int lenNodes);
 void init_my_predicates(void);
 FILE *open_file(char *filename, const char *mode);
-tablerow* init_table(int varcnt);
-double * get_value(tablerow *tab,  DdNode *node);
+tablerow *init_table(int varcnt);
+double *get_value(tablerow *tab, DdNode *node);
 void add_or_replace_node(tablerow *tab, DdNode *node, double value);
 void add_node(tablerow *tab, DdNode *node, double value);
-void destroy_table(tablerow *tab,int varcnt);
+void destroy_table(tablerow *tab, int varcnt);
 
-static YAP_Bool init(void)
-{
-  int j,i;
-  YAP_Term arg1,arg2,list;
+static YAP_Bool init(void) {
+  int j, i;
+  YAP_Term arg1, arg2, list;
 
-  ex=0;
-  cycle=0;
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  nRules=YAP_IntOfTerm(arg1);
+  ex = 0;
+  cycle = 0;
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  nRules = YAP_IntOfTerm(arg1);
 
-  vars_ex=NULL;
-  nVars_ex=NULL;
-  eta= (double ***) malloc(nRules * sizeof(double **));
-  eta_temp= (double ***) malloc(nRules * sizeof(double **));
-  rules= (int *) malloc(nRules * sizeof(int));
-  arrayprob=(double **) malloc(nRules * sizeof(double *));
-  probs_ex=NULL;
-  bVar2mVar_ex=NULL;
-  boolVars_ex=NULL;
-  mgr_ex=NULL;
-  nodes_probs_ex=NULL;
-  list=arg2;
-  for (j=0;j<nRules;j++)  
-  {
-    rules[j]=YAP_IntOfTerm(YAP_HeadOfTerm(list));
-    list=YAP_TailOfTerm(list);
-    eta[j]= (double **) malloc((rules[j]-1)*sizeof(double *));
-    eta_temp[j]= (double **) malloc((rules[j]-1)*sizeof(double *));
-    arrayprob[j]= (double *) malloc((rules[j]-1)*sizeof(double));
-    for (i=0;i<rules[j]-1;i++)
-    {
-      eta[j][i]=(double *) malloc(2*sizeof(double));
-      eta_temp[j][i]=(double *) malloc(2*sizeof(double));
+  vars_ex = NULL;
+  nVars_ex = NULL;
+  eta = (double ***)malloc(nRules * sizeof(double **));
+  eta_temp = (double ***)malloc(nRules * sizeof(double **));
+  rules = (int *)malloc(nRules * sizeof(int));
+  arrayprob = (double **)malloc(nRules * sizeof(double *));
+  probs_ex = NULL;
+  bVar2mVar_ex = NULL;
+  boolVars_ex = NULL;
+  mgr_ex = NULL;
+  nodes_probs_ex = NULL;
+  list = arg2;
+  for (j = 0; j < nRules; j++) {
+    rules[j] = YAP_IntOfTerm(YAP_HeadOfTerm(list));
+    list = YAP_TailOfTerm(list);
+    eta[j] = (double **)malloc((rules[j] - 1) * sizeof(double *));
+    eta_temp[j] = (double **)malloc((rules[j] - 1) * sizeof(double *));
+    arrayprob[j] = (double *)malloc((rules[j] - 1) * sizeof(double));
+    for (i = 0; i < rules[j] - 1; i++) {
+      eta[j][i] = (double *)malloc(2 * sizeof(double));
+      eta_temp[j][i] = (double *)malloc(2 * sizeof(double));
     }
   }
   return 1;
 }
 
-static YAP_Bool init_bdd(void)  
-{
-  mgr_ex=(DdManager **) realloc(mgr_ex, (ex+1)* sizeof(DdManager *)); 
-  mgr_ex[ex]=Cudd_Init(0,0,UNIQUE_SLOTS,CACHE_SLOTS,5120);
+static YAP_Bool init_bdd(void) {
+  mgr_ex = (DdManager **)realloc(mgr_ex, (ex + 1) * sizeof(DdManager *));
+  mgr_ex[ex] = Cudd_Init(0, 0, UNIQUE_SLOTS, CACHE_SLOTS, 5120);
   Cudd_AutodynEnable(mgr_ex[ex], CUDD_REORDER_GROUP_SIFT);
   Cudd_SetMaxCacheHard(mgr_ex[ex], 0);
   Cudd_SetLooseUpTo(mgr_ex[ex], 0);
   Cudd_SetMinHit(mgr_ex[ex], 15);
 
-  bVar2mVar_ex=(int **) realloc(bVar2mVar_ex, (ex+1)* sizeof(int *));
-  bVar2mVar_ex[ex]=NULL;
+  bVar2mVar_ex = (int **)realloc(bVar2mVar_ex, (ex + 1) * sizeof(int *));
+  bVar2mVar_ex[ex] = NULL;
 
-  vars_ex=(variable **) realloc(vars_ex, (ex+1)* sizeof(variable *));
-  vars_ex[ex]=NULL;
-  
-  nVars_ex=(int *) realloc(nVars_ex, (ex+1)* sizeof(int ));
-  nVars_ex[ex]=0;
+  vars_ex = (variable **)realloc(vars_ex, (ex + 1) * sizeof(variable *));
+  vars_ex[ex] = NULL;
 
-  probs_ex=(double **) realloc(probs_ex, (ex+1)* sizeof(double *)); 
-  probs_ex[ex]=NULL;
-  
-  boolVars_ex=(int *) realloc(boolVars_ex, (ex+1)* sizeof(int ));
-  boolVars_ex[ex]=0;
+  nVars_ex = (int *)realloc(nVars_ex, (ex + 1) * sizeof(int));
+  nVars_ex[ex] = 0;
+
+  probs_ex = (double **)realloc(probs_ex, (ex + 1) * sizeof(double *));
+  probs_ex[ex] = NULL;
+
+  boolVars_ex = (int *)realloc(boolVars_ex, (ex + 1) * sizeof(int));
+  boolVars_ex[ex] = 0;
 
   return 1;
 }
 
-static YAP_Bool end_bdd(void)
-{
+static YAP_Bool end_bdd(void) {
 
-  ex=ex+1;
+  ex = ex + 1;
   return 1;
 }
 
+static YAP_Bool init_test(void) {
+  YAP_Term arg1;
 
+  arg1 = YAP_ARG1;
+  nRules = YAP_IntOfTerm(arg1);
 
-static YAP_Bool init_test(void)
-{
-  YAP_Term arg1;  
-
-  arg1=YAP_ARG1;
-  nRules=YAP_IntOfTerm(arg1);
-
-  ex=0;
-  mgr_ex=(DdManager **) malloc((ex+1)* sizeof(DdManager *));
-  mgr_ex[ex]=Cudd_Init(0,0,UNIQUE_SLOTS,CACHE_SLOTS,5120);
+  ex = 0;
+  mgr_ex = (DdManager **)malloc((ex + 1) * sizeof(DdManager *));
+  mgr_ex[ex] = Cudd_Init(0, 0, UNIQUE_SLOTS, CACHE_SLOTS, 5120);
   Cudd_AutodynEnable(mgr_ex[ex], CUDD_REORDER_GROUP_SIFT);
   Cudd_SetMaxCacheHard(mgr_ex[ex], 0);
   Cudd_SetLooseUpTo(mgr_ex[ex], 0);
   Cudd_SetMinHit(mgr_ex[ex], 15);
 
-  bVar2mVar_ex=(int **) malloc((ex+1)* sizeof(int *));
-  bVar2mVar_ex[ex]=NULL;
+  bVar2mVar_ex = (int **)malloc((ex + 1) * sizeof(int *));
+  bVar2mVar_ex[ex] = NULL;
 
-  vars_ex=(variable **) malloc((ex+1)* sizeof(variable *));
-  vars_ex[ex]=NULL;
+  vars_ex = (variable **)malloc((ex + 1) * sizeof(variable *));
+  vars_ex[ex] = NULL;
 
-  nVars_ex=(int *) malloc((ex+1)* sizeof(int ));
-  nVars_ex[ex]=0;
+  nVars_ex = (int *)malloc((ex + 1) * sizeof(int));
+  nVars_ex[ex] = 0;
 
-  probs_ex=(double **) malloc((ex+1)* sizeof(double *));
-  probs_ex[ex]=NULL;
+  probs_ex = (double **)malloc((ex + 1) * sizeof(double *));
+  probs_ex[ex] = NULL;
 
-  boolVars_ex=(int *) malloc((ex+1)* sizeof(int ));
-  boolVars_ex[ex]=0;
+  boolVars_ex = (int *)malloc((ex + 1) * sizeof(int));
+  boolVars_ex[ex] = 0;
 
-  rules= (int *) malloc(nRules * sizeof(int));
+  rules = (int *)malloc(nRules * sizeof(int));
 
   return 1;
-
 }
 
-static YAP_Bool end_test(void)
-{
+static YAP_Bool end_test(void) {
   free(bVar2mVar_ex[ex]);
   free(vars_ex[ex]);
   Cudd_Quit(mgr_ex[ex]);
@@ -220,67 +205,54 @@ static YAP_Bool end_test(void)
   return 1;
 }
 
-
-
-static double Expectation(DdNode **nodes_ex,int lenNodes)
-{
+static double Expectation(DdNode **nodes_ex, int lenNodes) {
   int i;
-  double rootProb,CLL=0;
+  double rootProb, CLL = 0;
 
-  for(i=0;i<lenNodes;i++)  
-  {
-    if (!Cudd_IsConstant(nodes_ex[i]))
-    {
-      nodesB=init_table(boolVars_ex[i]);
-      nodesF=init_table(boolVars_ex[i]);
-      
-      Forward(nodes_ex[i],i);
-      rootProb=GetOutsideExpe(nodes_ex[i],example_prob[i],i);
+  for (i = 0; i < lenNodes; i++) {
+    if (!Cudd_IsConstant(nodes_ex[i])) {
+      nodesB = init_table(boolVars_ex[i]);
+      nodesF = init_table(boolVars_ex[i]);
 
-      if (rootProb<=0.0)
-        CLL = CLL + LOGZERO*example_prob[i];
+      Forward(nodes_ex[i], i);
+      rootProb = GetOutsideExpe(nodes_ex[i], example_prob[i], i);
+
+      if (rootProb <= 0.0)
+        CLL = CLL + LOGZERO * example_prob[i];
       else
-        CLL = CLL + log(rootProb)*example_prob[i];
-      
-      nodes_probs_ex[i]=rootProb;
-      destroy_table(nodesB,boolVars_ex[i]);
-      destroy_table(nodesF,boolVars_ex[i]);
-    }
-    else
-      if (nodes_ex[i]==Cudd_ReadLogicZero(mgr_ex[i]))
-      {
-        CLL=CLL+LOGZERO*example_prob[i];
-	nodes_probs_ex[i]=0.0;
-      }
-      else
-        nodes_probs_ex[i]=1.0;
+        CLL = CLL + log(rootProb) * example_prob[i];
+
+      nodes_probs_ex[i] = rootProb;
+      destroy_table(nodesB, boolVars_ex[i]);
+      destroy_table(nodesF, boolVars_ex[i]);
+    } else if (nodes_ex[i] == Cudd_ReadLogicZero(mgr_ex[i])) {
+      CLL = CLL + LOGZERO * example_prob[i];
+      nodes_probs_ex[i] = 0.0;
+    } else
+      nodes_probs_ex[i] = 1.0;
   }
   return CLL;
 }
 
-static YAP_Bool end(void)
-{
-  int r,i;
+static YAP_Bool end(void) {
+  int r, i;
 
-  for (i=0;i<ex;i++)
-  {
+  for (i = 0; i < ex; i++) {
     Cudd_Quit(mgr_ex[i]);
     free(bVar2mVar_ex[i]);
     free(vars_ex[i]);
     free(probs_ex[i]);
     fflush(stdout);
   }
-  
+
   free(mgr_ex);
   free(bVar2mVar_ex);
   free(vars_ex);
   free(probs_ex);
   free(nVars_ex);
   free(boolVars_ex);
-  for (r=0;r<nRules;r++)
-  {
-    for (i=0;i<rules[r]-1;i++)
-    {
+  for (r = 0; r < nRules; r++) {
+    for (i = 0; i < rules[r] - 1; i++) {
       free(eta[r][i]);
       free(eta_temp[r][i]);
     }
@@ -289,8 +261,7 @@ static YAP_Bool end(void)
   }
   free(eta);
   free(eta_temp);
-  for (r=0;r<nRules;r++)
-  {
+  for (r = 0; r < nRules; r++) {
     free(arrayprob[r]);
   }
   free(arrayprob);
@@ -299,500 +270,440 @@ static YAP_Bool end(void)
   return 1;
 }
 
+static YAP_Bool ret_prob(void) {
+  YAP_Term arg1, arg2, out;
+  DdNode *node;
 
-static YAP_Bool ret_prob(void)
-{
-  YAP_Term arg1,arg2,out;
-  DdNode * node;
-  
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  node=(DdNode *)YAP_IntOfTerm(arg1);
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  node = (DdNode *)YAP_IntOfTerm(arg1);
 
-  if (!Cudd_IsConstant(node))
-  {
-    table=init_table(boolVars_ex[ex]);
-    out=YAP_MkFloatTerm(Prob(node,0));
-    destroy_table(table,boolVars_ex[ex]);
-  }
-  else
-  {
-    if (node==Cudd_ReadOne(mgr_ex[ex]))
-      out=YAP_MkFloatTerm(1.0);
-    else  
-      out=YAP_MkFloatTerm(0.0);
+  if (!Cudd_IsConstant(node)) {
+    table = init_table(boolVars_ex[ex]);
+    out = YAP_MkFloatTerm(Prob(node, 0));
+    destroy_table(table, boolVars_ex[ex]);
+  } else {
+    if (node == Cudd_ReadOne(mgr_ex[ex]))
+      out = YAP_MkFloatTerm(1.0);
+    else
+      out = YAP_MkFloatTerm(0.0);
   }
 
-  return(YAP_Unify(out,arg2));
+  return (YAP_Unify(out, arg2));
 }
 
-double Prob(DdNode *node,int comp_par)
+double Prob(DdNode *node, int comp_par)
 /* compute the probability of the expression rooted at node.
 table is used to store nodeB for which the probability has alread been computed
 so that it is not recomputed
  */
 {
-  int index,mVarIndex,comp,pos;
+  int index, mVarIndex, comp, pos;
   variable v;
   double res;
-  double p,pt,pf,BChild0,BChild1;
-  double * value_p;
-  DdNode *nodekey,*T,*F;
+  double p, pt, pf, BChild0, BChild1;
+  double *value_p;
+  DdNode *nodekey, *T, *F;
 
-  comp=Cudd_IsComplement(node);   
-  comp=(comp && !comp_par) ||(!comp && comp_par);
-  if (Cudd_IsConstant(node))
-  {
+  comp = Cudd_IsComplement(node);
+  comp = (comp && !comp_par) || (!comp && comp_par);
+  if (Cudd_IsConstant(node)) {
     if (comp)
       return 0.0;
     else
       return 1.0;
-  }
-  else
-  {
-    nodekey=Cudd_Regular(node);
-    value_p=get_value(table,nodekey);
-    if (value_p!=NULL)
+  } else {
+    nodekey = Cudd_Regular(node);
+    value_p = get_value(table, nodekey);
+    if (value_p != NULL)
       return *value_p;
-    else
-    {
-      index=Cudd_NodeReadIndex(node);  //Returns the index of the node. The node pointer can be either regular or complemented.
-      //The index field holds the name of the variable that labels the node. The index of a variable is a permanent attribute that reflects the order of creation.
-      p=probs_ex[ex][index];
+    else {
+      index = Cudd_NodeReadIndex(node); // Returns the index of the node. The
+                                        // node pointer can be either regular or
+                                        // complemented.
+      // The index field holds the name of the variable that labels the node.
+      // The index of a variable is a permanent attribute that reflects the
+      // order of creation.
+      p = probs_ex[ex][index];
       T = Cudd_T(node);
       F = Cudd_E(node);
-      pf=Prob(F,comp);
-      pt=Prob(T,comp);
-      BChild0=pf*(1-p);
-      BChild1=pt*p;
-      mVarIndex=bVar2mVar_ex[ex][index];
-      v=vars_ex[ex][mVarIndex];
-      pos=index-v.firstBoolVar;
-      res=BChild0+BChild1;
-      add_node(table,nodekey,res);
+      pf = Prob(F, comp);
+      pt = Prob(T, comp);
+      BChild0 = pf * (1 - p);
+      BChild1 = pt * p;
+      mVarIndex = bVar2mVar_ex[ex][index];
+      v = vars_ex[ex][mVarIndex];
+      pos = index - v.firstBoolVar;
+      res = BChild0 + BChild1;
+      add_node(table, nodekey, res);
       return res;
     }
   }
 }
 
-
-
-static YAP_Bool add_var(void)
-{
-  YAP_Term arg1,arg2,arg3,arg4,out,probTerm,probTerm_temp;
-  variable * v;
+static YAP_Bool add_var(void) {
+  YAP_Term arg1, arg2, arg3, arg4, out, probTerm, probTerm_temp;
+  variable *v;
   int i;
-  DdNode * node;
-  double p,p0;
+  DdNode *node;
+  double p, p0;
 
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  arg3 = YAP_ARG3;
+  arg4 = YAP_ARG4;
+  nVars_ex[ex] = nVars_ex[ex] + 1;
+  vars_ex[ex] =
+      (variable *)realloc(vars_ex[ex], nVars_ex[ex] * sizeof(variable));
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  arg3=YAP_ARG3; 
-  arg4=YAP_ARG4;
-  nVars_ex[ex]=nVars_ex[ex]+1;
-  vars_ex[ex]=(variable *) realloc(vars_ex[ex],nVars_ex[ex] * sizeof(variable));
-
-  v=&vars_ex[ex][nVars_ex[ex]-1];
-  v->nVal=YAP_IntOfTerm(arg1);
-  v->nRule=YAP_IntOfTerm(arg3);
-  v->firstBoolVar=boolVars_ex[ex];
-  probs_ex[ex]=(double *) realloc(probs_ex[ex],(((boolVars_ex[ex]+v->nVal-1)* sizeof(double))));
-  bVar2mVar_ex[ex]=(int *) realloc(bVar2mVar_ex[ex],((boolVars_ex[ex]+v->nVal-1)* sizeof(int)));
-  probTerm=arg2; 
-  p0=1;
-  for (i=0;i<v->nVal-1;i++)
-  {
-    node=Cudd_bddIthVar(mgr_ex[ex],boolVars_ex[ex]+i);
-    p=YAP_FloatOfTerm(YAP_HeadOfTerm(probTerm));
-    bVar2mVar_ex[ex][boolVars_ex[ex]+i]=nVars_ex[ex]-1;
-    probs_ex[ex][boolVars_ex[ex]+i]=p/p0;
-    probTerm_temp=YAP_TailOfTerm(probTerm);
-    probTerm=probTerm_temp;
-    p0=p0*(1-p/p0);
+  v = &vars_ex[ex][nVars_ex[ex] - 1];
+  v->nVal = YAP_IntOfTerm(arg1);
+  v->nRule = YAP_IntOfTerm(arg3);
+  v->firstBoolVar = boolVars_ex[ex];
+  probs_ex[ex] = (double *)realloc(
+      probs_ex[ex], (((boolVars_ex[ex] + v->nVal - 1) * sizeof(double))));
+  bVar2mVar_ex[ex] = (int *)realloc(
+      bVar2mVar_ex[ex], ((boolVars_ex[ex] + v->nVal - 1) * sizeof(int)));
+  probTerm = arg2;
+  p0 = 1;
+  for (i = 0; i < v->nVal - 1; i++) {
+    node = Cudd_bddIthVar(mgr_ex[ex], boolVars_ex[ex] + i);
+    p = YAP_FloatOfTerm(YAP_HeadOfTerm(probTerm));
+    bVar2mVar_ex[ex][boolVars_ex[ex] + i] = nVars_ex[ex] - 1;
+    probs_ex[ex][boolVars_ex[ex] + i] = p / p0;
+    probTerm_temp = YAP_TailOfTerm(probTerm);
+    probTerm = probTerm_temp;
+    p0 = p0 * (1 - p / p0);
   }
-  boolVars_ex[ex]=boolVars_ex[ex]+v->nVal-1;
-  rules[v->nRule]= v->nVal; 
-  out=YAP_MkIntTerm((YAP_Int) nVars_ex[ex]-1);
-  return YAP_Unify(out,arg4);
+  boolVars_ex[ex] = boolVars_ex[ex] + v->nVal - 1;
+  rules[v->nRule] = v->nVal;
+  out = YAP_MkIntTerm((YAP_Int)nVars_ex[ex] - 1);
+  return YAP_Unify(out, arg4);
 }
 
-static YAP_Bool equality(void)
-{
-  YAP_Term arg1,arg2,arg3,out;
+static YAP_Bool equality(void) {
+  YAP_Term arg1, arg2, arg3, out;
   int varIndex;
   int value;
   int i;
   variable v;
-  DdNode * node, * tmp,*var;
+  DdNode *node, *tmp, *var;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  arg3=YAP_ARG3;
-  varIndex=YAP_IntOfTerm(arg1);
-  value=YAP_IntOfTerm(arg2);
-  v=vars_ex[ex][varIndex];
-  i=v.firstBoolVar;
-  tmp=Cudd_ReadOne(mgr_ex[ex]);
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  arg3 = YAP_ARG3;
+  varIndex = YAP_IntOfTerm(arg1);
+  value = YAP_IntOfTerm(arg2);
+  v = vars_ex[ex][varIndex];
+  i = v.firstBoolVar;
+  tmp = Cudd_ReadOne(mgr_ex[ex]);
   Cudd_Ref(tmp);
-  node=NULL;
-  for (i=v.firstBoolVar;i<v.firstBoolVar+value;i++)
-  {
-    var=Cudd_bddIthVar(mgr_ex[ex],i);
-    node=Cudd_bddAnd(mgr_ex[ex],tmp,Cudd_Not(var));
+  node = NULL;
+  for (i = v.firstBoolVar; i < v.firstBoolVar + value; i++) {
+    var = Cudd_bddIthVar(mgr_ex[ex], i);
+    node = Cudd_bddAnd(mgr_ex[ex], tmp, Cudd_Not(var));
     Cudd_Ref(node);
-    Cudd_RecursiveDeref(mgr_ex[ex],tmp);
-    tmp=node;
+    Cudd_RecursiveDeref(mgr_ex[ex], tmp);
+    tmp = node;
   }
-  if (!(value==v.nVal-1))
-  {
-    var=Cudd_bddIthVar(mgr_ex[ex],v.firstBoolVar+value);
-    node=Cudd_bddAnd(mgr_ex[ex],tmp,var);
+  if (!(value == v.nVal - 1)) {
+    var = Cudd_bddIthVar(mgr_ex[ex], v.firstBoolVar + value);
+    node = Cudd_bddAnd(mgr_ex[ex], tmp, var);
     Cudd_Ref(node);
-    Cudd_RecursiveDeref(mgr_ex[ex],tmp);
+    Cudd_RecursiveDeref(mgr_ex[ex], tmp);
   }
-  out=YAP_MkIntTerm((YAP_Int) node);
-  return(YAP_Unify(out,arg3));
+  out = YAP_MkIntTerm((YAP_Int)node);
+  return (YAP_Unify(out, arg3));
 }
 
-static YAP_Bool one(void)
-{
-  YAP_Term arg,out;
-  DdNode * node;
+static YAP_Bool one(void) {
+  YAP_Term arg, out;
+  DdNode *node;
 
-  arg=YAP_ARG1;
-  node =  Cudd_ReadOne(mgr_ex[ex]);
+  arg = YAP_ARG1;
+  node = Cudd_ReadOne(mgr_ex[ex]);
   Cudd_Ref(node);
-  out=YAP_MkIntTerm((YAP_Int) node);
-  return(YAP_Unify(out,arg));
+  out = YAP_MkIntTerm((YAP_Int)node);
+  return (YAP_Unify(out, arg));
 }
 
-static YAP_Bool zero(void)
-{
-  YAP_Term arg,out;
-  DdNode * node;
+static YAP_Bool zero(void) {
+  YAP_Term arg, out;
+  DdNode *node;
 
-  arg=YAP_ARG1;
+  arg = YAP_ARG1;
   node = Cudd_ReadLogicZero(mgr_ex[ex]);
   Cudd_Ref(node);
-  out=YAP_MkIntTerm((YAP_Int) node);
-  return(YAP_Unify(out,arg));
+  out = YAP_MkIntTerm((YAP_Int)node);
+  return (YAP_Unify(out, arg));
 }
 
-static YAP_Bool bdd_not(void)
-{
-  YAP_Term arg1,arg2,out;
-  DdNode * node;
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
+static YAP_Bool bdd_not(void) {
+  YAP_Term arg1, arg2, out;
+  DdNode *node;
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
 
   node = (DdNode *)YAP_IntOfTerm(arg1);
-  node=Cudd_Not(node);
-  out=YAP_MkIntTerm((YAP_Int) node);
-  return(YAP_Unify(out,arg2));
+  node = Cudd_Not(node);
+  out = YAP_MkIntTerm((YAP_Int)node);
+  return (YAP_Unify(out, arg2));
 }
 
-static YAP_Bool and(void)
-{
-  YAP_Term arg1,arg2,arg3,out;
-  DdNode * node1, *node2,*nodeout;
+static YAP_Bool and (void) {
+  YAP_Term arg1, arg2, arg3, out;
+  DdNode *node1, *node2, *nodeout;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  arg3=YAP_ARG3;
-  node1=(DdNode *)YAP_IntOfTerm(arg1);
-  node2=(DdNode *)YAP_IntOfTerm(arg2);
-  nodeout=Cudd_bddAnd(mgr_ex[ex],node1,node2);
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  arg3 = YAP_ARG3;
+  node1 = (DdNode *)YAP_IntOfTerm(arg1);
+  node2 = (DdNode *)YAP_IntOfTerm(arg2);
+  nodeout = Cudd_bddAnd(mgr_ex[ex], node1, node2);
   Cudd_Ref(nodeout);
-  out=YAP_MkIntTerm((YAP_Int) nodeout);
-  return(YAP_Unify(out,arg3));
+  out = YAP_MkIntTerm((YAP_Int)nodeout);
+  return (YAP_Unify(out, arg3));
 }
 
-static YAP_Bool or(void)
-{
-  YAP_Term arg1,arg2,arg3,out;
-  DdNode * node1,*node2,*nodeout;
+static YAP_Bool or (void) {
+  YAP_Term arg1, arg2, arg3, out;
+  DdNode *node1, *node2, *nodeout;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  arg3=YAP_ARG3;
-  node1=(DdNode *)YAP_IntOfTerm(arg1);
-  node2=(DdNode *)YAP_IntOfTerm(arg2);
-  nodeout=Cudd_bddOr(mgr_ex[ex],node1,node2);
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  arg3 = YAP_ARG3;
+  node1 = (DdNode *)YAP_IntOfTerm(arg1);
+  node2 = (DdNode *)YAP_IntOfTerm(arg2);
+  nodeout = Cudd_bddOr(mgr_ex[ex], node1, node2);
   Cudd_Ref(nodeout);
-  out=YAP_MkIntTerm((YAP_Int) nodeout);
-  return(YAP_Unify(out,arg3));
+  out = YAP_MkIntTerm((YAP_Int)nodeout);
+  return (YAP_Unify(out, arg3));
 }
 
-static YAP_Bool garbage_collect(void)
-{
-  YAP_Term arg1,arg2,out;
-  YAP_Int nodes,clearCache;
+static YAP_Bool garbage_collect(void) {
+  YAP_Term arg1, arg2, out;
+  YAP_Int nodes, clearCache;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  clearCache=YAP_IntOfTerm(arg1);
-  nodes=(YAP_Int)cuddGarbageCollect(mgr_ex[ex],clearCache);
-  out=YAP_MkIntTerm(nodes);
-  return(YAP_Unify(out,arg2));
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  clearCache = YAP_IntOfTerm(arg1);
+  nodes = (YAP_Int)cuddGarbageCollect(mgr_ex[ex], clearCache);
+  out = YAP_MkIntTerm(nodes);
+  return (YAP_Unify(out, arg2));
 }
 
-static YAP_Bool bdd_to_add(void)
-{
-  YAP_Term arg1,arg2,out;
-  DdNode * node1,*node2;
+static YAP_Bool bdd_to_add(void) {
+  YAP_Term arg1, arg2, out;
+  DdNode *node1, *node2;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  node1=(DdNode *)YAP_IntOfTerm(arg1);
-  node2= Cudd_BddToAdd(mgr_ex[ex],node1);
-  out=YAP_MkIntTerm((YAP_Int) node2);
-  return(YAP_Unify(out,arg2));
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  node1 = (DdNode *)YAP_IntOfTerm(arg1);
+  node2 = Cudd_BddToAdd(mgr_ex[ex], node1);
+  out = YAP_MkIntTerm((YAP_Int)node2);
+  return (YAP_Unify(out, arg2));
 }
 
-static YAP_Bool create_dot(void)
-{
-  char * onames[]={"Out"};
-  char ** inames;
-   DdNode * array[1];
-  YAP_Term arg1,arg2;
-  int i,b,index;
+static YAP_Bool create_dot(void) {
+  const char *onames[] = {"Out"};
+  char **inames;
+  DdNode *array[1];
+  YAP_Term arg1, arg2;
+  int i, b, index;
   variable v;
-  char numberVar[10],numberBit[10],filename[1000];
-  FILE * file;
-  
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
+  char numberVar[10], numberBit[10], filename[1000];
+  FILE *file;
 
-  YAP_StringToBuffer(arg2,filename,1000);
-  inames= (char **) malloc(sizeof(char *)*(boolVars_ex[ex]));
-  index=0;
-  for (i=0;i<nVars_ex[ex];i++)
-  {
-    v=vars_ex[ex][i];
-    for (b=0;b<v.nVal-1;b++)
-    {  
-      inames[b+index]=(char *) malloc(sizeof(char)*20);
-      strcpy(inames[b+index],"X");
-      sprintf(numberVar,"%d",i);
-      strcat(inames[b+index],numberVar);
-      strcat(inames[b+index],"_");
-      sprintf(numberBit,"%d",b);
-      strcat(inames[b+index],numberBit);
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+
+  YAP_StringToBuffer(arg2, filename, 1000);
+  inames = (char **)malloc(sizeof(char *) * (boolVars_ex[ex]));
+  index = 0;
+  for (i = 0; i < nVars_ex[ex]; i++) {
+    v = vars_ex[ex][i];
+    for (b = 0; b < v.nVal - 1; b++) {
+      inames[b + index] = (char *)malloc(sizeof(char) * 20);
+      strcpy(inames[b + index], "X");
+      sprintf(numberVar, "%d", i);
+      strcat(inames[b + index], numberVar);
+      strcat(inames[b + index], "_");
+      sprintf(numberBit, "%d", b);
+      strcat(inames[b + index], numberBit);
     }
-    index=index+v.nVal-1;
+    index = index + v.nVal - 1;
   }
-  array[0]=(DdNode *)YAP_IntOfTerm(arg1);
+  array[0] = (DdNode *)YAP_IntOfTerm(arg1);
   file = open_file(filename, "w");
-  Cudd_DumpDot(mgr_ex[ex],1,array,inames,onames,file);
+  Cudd_DumpDot(mgr_ex[ex], 1, array, (const char **)inames, onames, file);
   fclose(file);
-  index=0;
-  for (i=0;i<nVars_ex[ex];i++)
-  {
-    v=vars_ex[ex][i];
-    for (b=0;b<v.nVal-1;b++)
-    {  
-      free(inames[b+index]);
+  index = 0;
+  for (i = 0; i < nVars_ex[ex]; i++) {
+    v = vars_ex[ex][i];
+    for (b = 0; b < v.nVal - 1; b++) {
+      free(inames[b + index]);
     }
-    index=index+v.nVal-1;
+    index = index + v.nVal - 1;
   }
   free(inames);
   return 1;
 }
 
-
-static YAP_Bool rec_deref(void)
-{
+static YAP_Bool rec_deref(void) {
   YAP_Term arg1;
-  DdNode * node;
+  DdNode *node;
 
-  arg1=YAP_ARG1;
-  node=(DdNode *) YAP_IntOfTerm(arg1);
+  arg1 = YAP_ARG1;
+  node = (DdNode *)YAP_IntOfTerm(arg1);
   Cudd_RecursiveDeref(mgr_ex[ex], node);
   return 1;
 }
 
-
-
-double ProbPath(DdNode *node,int comp_par, int nex)
-{
-  int index,mVarIndex,comp,pos,position,boolVarIndex;
+double ProbPath(DdNode *node, int comp_par, int nex) {
+  int index, mVarIndex, comp, pos, position, boolVarIndex;
   variable v;
   double res;
-  double value,p,pt,pf,BChild0,BChild1,e0,e1;
-  double * value_p,** eta_rule;
-  DdNode *nodekey,*T,*F;
+  double value, p, pt, pf, BChild0, BChild1, e0, e1;
+  double *value_p, **eta_rule;
+  DdNode *nodekey, *T, *F;
 
-  comp=Cudd_IsComplement(node);
-  comp=(comp && !comp_par) ||(!comp && comp_par);
-  if (Cudd_IsConstant(node))
-  {
-    value=Cudd_V(node);
-    if (comp)
-    {
+  comp = Cudd_IsComplement(node);
+  comp = (comp && !comp_par) || (!comp && comp_par);
+  if (Cudd_IsConstant(node)) {
+    value = Cudd_V(node);
+    if (comp) {
       return 0.0;
-    }
-    else
-    {
+    } else {
       return 1.0;
     }
-  }
-  else
-  {
-    nodekey=Cudd_Regular(node);
-    value_p=get_value(nodesB,nodekey);
-    if (value_p!=NULL)
-    {
+  } else {
+    nodekey = Cudd_Regular(node);
+    value_p = get_value(nodesB, nodekey);
+    if (value_p != NULL) {
       return *value_p;
-    }
-    else
-    {
-      index=Cudd_NodeReadIndex(node);
-      p=probs_ex[nex][index];
+    } else {
+      index = Cudd_NodeReadIndex(node);
+      p = probs_ex[nex][index];
       T = Cudd_T(node);
       F = Cudd_E(node);
-      pf=ProbPath(F,comp,nex);
-      pt=ProbPath(T,comp,nex);
-      BChild0=pf*(1-p);
-      BChild1=pt*p;
-      value_p=get_value(nodesF,nodekey);
-      e0 = (*value_p)*BChild0; 
-      e1 = (*value_p)*BChild1; 
-      mVarIndex=bVar2mVar_ex[nex][index];
-      v=vars_ex[nex][mVarIndex];
-      pos=index-v.firstBoolVar;
-      eta_rule=eta_temp[v.nRule];
-      eta_rule[pos][0]=eta_rule[pos][0]+e0;
-      eta_rule[pos][1]=eta_rule[pos][1]+e1;
-      res=BChild0+BChild1;
-      add_node(nodesB,nodekey,res);
-      position=Cudd_ReadPerm(mgr_ex[nex],index);
-      position=position+1;
-      boolVarIndex=Cudd_ReadInvPerm(mgr_ex[nex],position);//Returns the index of the variable currently in the i-th position of the order. 
-      if (position<boolVars_ex[nex])
-      {
-        sigma[position]=sigma[position]+e0+e1;
+      pf = ProbPath(F, comp, nex);
+      pt = ProbPath(T, comp, nex);
+      BChild0 = pf * (1 - p);
+      BChild1 = pt * p;
+      value_p = get_value(nodesF, nodekey);
+      e0 = (*value_p) * BChild0;
+      e1 = (*value_p) * BChild1;
+      mVarIndex = bVar2mVar_ex[nex][index];
+      v = vars_ex[nex][mVarIndex];
+      pos = index - v.firstBoolVar;
+      eta_rule = eta_temp[v.nRule];
+      eta_rule[pos][0] = eta_rule[pos][0] + e0;
+      eta_rule[pos][1] = eta_rule[pos][1] + e1;
+      res = BChild0 + BChild1;
+      add_node(nodesB, nodekey, res);
+      position = Cudd_ReadPerm(mgr_ex[nex], index);
+      position = position + 1;
+      boolVarIndex = Cudd_ReadInvPerm(
+          mgr_ex[nex], position); // Returns the index of the variable currently
+                                  // in the i-th position of the order.
+      if (position < boolVars_ex[nex]) {
+        sigma[position] = sigma[position] + e0 + e1;
       }
-      if(!Cudd_IsConstant(T))
-      {
-        index=Cudd_NodeReadIndex(T);  
-        position=Cudd_ReadPerm(mgr_ex[nex],index);
-        sigma[position]=sigma[position]-e1;
+      if (!Cudd_IsConstant(T)) {
+        index = Cudd_NodeReadIndex(T);
+        position = Cudd_ReadPerm(mgr_ex[nex], index);
+        sigma[position] = sigma[position] - e1;
       }
-      
-      if(!Cudd_IsConstant(F))
-      {
-        index=Cudd_NodeReadIndex(F);
-        position=Cudd_ReadPerm(mgr_ex[nex],index);
-        sigma[position]=sigma[position]-e0;
+
+      if (!Cudd_IsConstant(F)) {
+        index = Cudd_NodeReadIndex(F);
+        position = Cudd_ReadPerm(mgr_ex[nex], index);
+        sigma[position] = sigma[position] - e0;
       }
-    
+
       return res;
     }
   }
 }
 
+void Forward(DdNode *root, int nex) {
+  int i, j;
 
-
-
-void Forward(DdNode *root, int nex)
-{
-  int i,j;
-
-  if (boolVars_ex[nex])
-  {
-    nodesToVisit= (DdNode ***)malloc(sizeof(DdNode **)* boolVars_ex[nex]);
-    NnodesToVisit= (int *)malloc(sizeof(int)* boolVars_ex[nex]);
-    nodesToVisit[0]=(DdNode **)malloc(sizeof(DdNode *));
-    nodesToVisit[0][0]=root;
-    NnodesToVisit[0]=1;
-    for(i=1;i<boolVars_ex[nex];i++)
-    {
-      nodesToVisit[i]=NULL;
-      NnodesToVisit[i]=0;
+  if (boolVars_ex[nex]) {
+    nodesToVisit = (DdNode ***)malloc(sizeof(DdNode **) * boolVars_ex[nex]);
+    NnodesToVisit = (int *)malloc(sizeof(int) * boolVars_ex[nex]);
+    nodesToVisit[0] = (DdNode **)malloc(sizeof(DdNode *));
+    nodesToVisit[0][0] = root;
+    NnodesToVisit[0] = 1;
+    for (i = 1; i < boolVars_ex[nex]; i++) {
+      nodesToVisit[i] = NULL;
+      NnodesToVisit[i] = 0;
     }
-    add_node(nodesF,Cudd_Regular(root),1);
-    for(i=0;i<boolVars_ex[nex];i++)
-    {
-      for(j=0;j<NnodesToVisit[i];j++)
-      UpdateForward(nodesToVisit[i][j],nex);
+    add_node(nodesF, Cudd_Regular(root), 1);
+    for (i = 0; i < boolVars_ex[nex]; i++) {
+      for (j = 0; j < NnodesToVisit[i]; j++)
+        UpdateForward(nodesToVisit[i][j], nex);
     }
-    for(i=0;i<boolVars_ex[nex];i++)
-    {
+    for (i = 0; i < boolVars_ex[nex]; i++) {
       free(nodesToVisit[i]);
     }
     free(nodesToVisit);
     free(NnodesToVisit);
-  }
-  else
-  {
-    add_node(nodesF,Cudd_Regular(root),1);
+  } else {
+    add_node(nodesF, Cudd_Regular(root), 1);
   }
 }
 
-void UpdateForward(DdNode *node, int nex)
-{
-  int index,position,mVarIndex;
-  DdNode *T,*E,*nodereg;
+void UpdateForward(DdNode *node, int nex) {
+  int index, position, mVarIndex;
+  DdNode *T, *E, *nodereg;
   variable v;
-  double *value_p,*value_p_T,*value_p_F,p;
+  double *value_p, *value_p_T, *value_p_F, p;
 
-  if (Cudd_IsConstant(node)) 
-  {
+  if (Cudd_IsConstant(node)) {
     return;
-  }
-  else
-  {
-    index=Cudd_NodeReadIndex(node);
-    mVarIndex=bVar2mVar_ex[nex][index];
-    v=vars_ex[nex][mVarIndex];
-    p=probs_ex[nex][index];
-    nodereg=Cudd_Regular(node);
-    value_p=get_value(nodesF,nodereg);
-    if (value_p== NULL)
-    {
+  } else {
+    index = Cudd_NodeReadIndex(node);
+    mVarIndex = bVar2mVar_ex[nex][index];
+    v = vars_ex[nex][mVarIndex];
+    p = probs_ex[nex][index];
+    nodereg = Cudd_Regular(node);
+    value_p = get_value(nodesF, nodereg);
+    if (value_p == NULL) {
       printf("Error\n");
       return;
-    }
-    else
-    {
+    } else {
       T = Cudd_T(node);
       E = Cudd_E(node);
-      if (!Cudd_IsConstant(T)) 
-      {
-        value_p_T=get_value(nodesF,T);
-        if (value_p_T!= NULL)
-        {
-           *value_p_T= *value_p_T+*value_p*p;
-        }
-        else
-        {
-          add_or_replace_node(nodesF,Cudd_Regular(T),*value_p*p);
-          index=Cudd_NodeReadIndex(T);
-          position=Cudd_ReadPerm(mgr_ex[nex],index);
-          nodesToVisit[position]=(DdNode **)realloc(nodesToVisit[position],
-	    (NnodesToVisit[position]+1)* sizeof(DdNode *));
-          nodesToVisit[position][NnodesToVisit[position]]=T;
-          NnodesToVisit[position]=NnodesToVisit[position]+1;
+      if (!Cudd_IsConstant(T)) {
+        value_p_T = get_value(nodesF, T);
+        if (value_p_T != NULL) {
+          *value_p_T = *value_p_T + *value_p * p;
+        } else {
+          add_or_replace_node(nodesF, Cudd_Regular(T), *value_p * p);
+          index = Cudd_NodeReadIndex(T);
+          position = Cudd_ReadPerm(mgr_ex[nex], index);
+          nodesToVisit[position] = (DdNode **)realloc(
+              nodesToVisit[position],
+              (NnodesToVisit[position] + 1) * sizeof(DdNode *));
+          nodesToVisit[position][NnodesToVisit[position]] = T;
+          NnodesToVisit[position] = NnodesToVisit[position] + 1;
         }
       }
-      if (!Cudd_IsConstant(E)) 
-      {
-        value_p_F=get_value(nodesF,Cudd_Regular(E));
+      if (!Cudd_IsConstant(E)) {
+        value_p_F = get_value(nodesF, Cudd_Regular(E));
 
-        if (value_p_F!= NULL)
-        {
-          *value_p_F= *value_p_F+*value_p*(1-p);
-        }
-        else
-        {
-          add_or_replace_node(nodesF,Cudd_Regular(E),*value_p*(1-p));
-          index=Cudd_NodeReadIndex(E);
-          position=Cudd_ReadPerm(mgr_ex[nex],index);
-          nodesToVisit[position]=(DdNode **)realloc(nodesToVisit[position],
-	    (NnodesToVisit[position]+1)* sizeof(DdNode *));
-          nodesToVisit[position][NnodesToVisit[position]]=E;
-          NnodesToVisit[position]=NnodesToVisit[position]+1;
+        if (value_p_F != NULL) {
+          *value_p_F = *value_p_F + *value_p * (1 - p);
+        } else {
+          add_or_replace_node(nodesF, Cudd_Regular(E), *value_p * (1 - p));
+          index = Cudd_NodeReadIndex(E);
+          position = Cudd_ReadPerm(mgr_ex[nex], index);
+          nodesToVisit[position] = (DdNode **)realloc(
+              nodesToVisit[position],
+              (NnodesToVisit[position] + 1) * sizeof(DdNode *));
+          nodesToVisit[position][NnodesToVisit[position]] = E;
+          NnodesToVisit[position] = NnodesToVisit[position] + 1;
         }
       }
       return;
@@ -800,67 +711,52 @@ void UpdateForward(DdNode *node, int nex)
   }
 }
 
+int indexMvar(DdNode *node) {
+  int index, mVarIndex;
 
-int indexMvar(DdNode * node)
-{
-  int index,mVarIndex;
-
-  index=Cudd_NodeReadIndex(node);
-  mVarIndex=bVar2mVar_ex[ex][index];
+  index = Cudd_NodeReadIndex(node);
+  mVarIndex = bVar2mVar_ex[ex][index];
   return mVarIndex;
 }
 
-
-
-double GetOutsideExpe(DdNode *root,double ex_prob, int nex)
-{
-  int i,j,mVarIndex,bVarIndex;
+double GetOutsideExpe(DdNode *root, double ex_prob, int nex) {
+  int i, j, mVarIndex, bVarIndex;
   double **eta_rule;
-  double theta,rootProb, T=0;
+  double theta, rootProb, T = 0;
 
+  sigma = (double *)malloc(boolVars_ex[nex] * sizeof(double));
 
-  sigma=(double *)malloc(boolVars_ex[nex] * sizeof(double));
-
-  for (j=0; j<boolVars_ex[nex]; j++)
-  {
-    sigma[j]=0;
+  for (j = 0; j < boolVars_ex[nex]; j++) {
+    sigma[j] = 0;
   }
-  for (j=0; j<nRules; j++)
-  {
-    for (i=0; i<rules[j]-1; i++)
-    {
-      eta_temp[j][i][0]=0;
-      eta_temp[j][i][1]=0;
+  for (j = 0; j < nRules; j++) {
+    for (i = 0; i < rules[j] - 1; i++) {
+      eta_temp[j][i][0] = 0;
+      eta_temp[j][i][1] = 0;
     }
   }
-  rootProb=ProbPath(root,0,nex);
-  if (rootProb>0.0)
-  {
-    for (j=0; j<boolVars_ex[nex]; j++)
-    {
+  rootProb = ProbPath(root, 0, nex);
+  if (rootProb > 0.0) {
+    for (j = 0; j < boolVars_ex[nex]; j++) {
       T += sigma[j];
-      bVarIndex=Cudd_ReadInvPerm(mgr_ex[nex],j);
-      if (bVarIndex==-1)  
-      {
-        bVarIndex=j;
+      bVarIndex = Cudd_ReadInvPerm(mgr_ex[nex], j);
+      if (bVarIndex == -1) {
+        bVarIndex = j;
       }
 
-      mVarIndex=bVar2mVar_ex[nex][bVarIndex];
-      eta_rule=eta_temp[vars_ex[nex][mVarIndex].nRule];
-      for (i=0; i<vars_ex[nex][mVarIndex].nVal-1;i++)
-      {
-        theta=probs_ex[nex][bVarIndex];
-        eta_rule[i][0]=eta_rule[i][0]+T*(1-theta);
-        eta_rule[i][1]=eta_rule[i][1]+T*theta;
-      }   
+      mVarIndex = bVar2mVar_ex[nex][bVarIndex];
+      eta_rule = eta_temp[vars_ex[nex][mVarIndex].nRule];
+      for (i = 0; i < vars_ex[nex][mVarIndex].nVal - 1; i++) {
+        theta = probs_ex[nex][bVarIndex];
+        eta_rule[i][0] = eta_rule[i][0] + T * (1 - theta);
+        eta_rule[i][1] = eta_rule[i][1] + T * theta;
+      }
     }
 
-    for (j=0; j<nRules; j++)
-    {
-      for (i=0; i<rules[j]-1; i++)
-      {
-        eta[j][i][0]=eta[j][i][0]+eta_temp[j][i][0]*ex_prob/rootProb;
-        eta[j][i][1]=eta[j][i][1]+eta_temp[j][i][1]*ex_prob/rootProb;
+    for (j = 0; j < nRules; j++) {
+      for (i = 0; i < rules[j] - 1; i++) {
+        eta[j][i][0] = eta[j][i][0] + eta_temp[j][i][0] * ex_prob / rootProb;
+        eta[j][i][1] = eta[j][i][1] + eta_temp[j][i][1] * ex_prob / rootProb;
       }
     }
   }
@@ -868,404 +764,361 @@ double GetOutsideExpe(DdNode *root,double ex_prob, int nex)
   return rootProb;
 }
 
+void Maximization(void) {
+  int r, i, j, e;
+  double sum = 0;
+  double *probs_rule, **eta_rule;
 
-void Maximization(void)
-{
-  int r,i,j,e;
-  double sum=0;
-  double *probs_rule,**eta_rule;
-
-  for (r=0;r<nRules;r++)
-  {
-    eta_rule=eta[r];
-    for (i=0;i<rules[r]-1;i++)
-    {
-      sum=(eta_rule[i][0]+eta_rule[i][1]);
-      if (sum==0.0)
-      {
-        arrayprob[r][i]=0;
-      }
-      else 
-        arrayprob[r][i]=eta_rule[i][1]/sum;
+  for (r = 0; r < nRules; r++) {
+    eta_rule = eta[r];
+    for (i = 0; i < rules[r] - 1; i++) {
+      sum = (eta_rule[i][0] + eta_rule[i][1]);
+      if (sum == 0.0) {
+        arrayprob[r][i] = 0;
+      } else
+        arrayprob[r][i] = eta_rule[i][1] / sum;
     }
   }
 
-  for(e=0;e<ex;e++)
-  {
-    for (j=0;j<nVars_ex[e];j++)
-    {
-      r=vars_ex[e][j].nRule;
-      probs_rule=arrayprob[r];
-      for(i=0;i<rules[r]-1;i++)
-      {    
-        probs_ex[e][vars_ex[e][j].firstBoolVar+i]=probs_rule[i];
+  for (e = 0; e < ex; e++) {
+    for (j = 0; j < nVars_ex[e]; j++) {
+      r = vars_ex[e][j].nRule;
+      probs_rule = arrayprob[r];
+      for (i = 0; i < rules[r] - 1; i++) {
+        probs_ex[e][vars_ex[e][j].firstBoolVar + i] = probs_rule[i];
       }
     }
   }
 }
 
-static YAP_Bool randomize(void)
-{
-  int i,j,e,rule;
-  double * theta,p0;
-  double pmass,par;
+static YAP_Bool randomize(void) {
+  int i, j, e, rule;
+  double *theta, p0;
+  double pmass, par;
   double **Theta_rules;
-  
-  Theta_rules=(double **)malloc(nRules *sizeof(double *));
 
-  for (j=0;j<nRules;j++)
-  {
-    Theta_rules[j]=(double *)malloc(rules[j]*sizeof(double));
+  Theta_rules = (double **)malloc(nRules * sizeof(double *));
+
+  for (j = 0; j < nRules; j++) {
+    Theta_rules[j] = (double *)malloc(rules[j] * sizeof(double));
   }
 
-  for (j=0;j<nRules;j++)
-  {
-    theta=Theta_rules[j];
-    pmass=0;
-    for (i=0;i<rules[j]-1;i++)
-    {
-      par=((double)rand())/RAND_MAX*(1-pmass);
-      pmass=pmass+par;
-      theta[i]=par;
+  for (j = 0; j < nRules; j++) {
+    theta = Theta_rules[j];
+    pmass = 0;
+    for (i = 0; i < rules[j] - 1; i++) {
+      par = ((double)rand()) / RAND_MAX * (1 - pmass);
+      pmass = pmass + par;
+      theta[i] = par;
     }
-    theta[rules[j]-1]=1-pmass;
+    theta[rules[j] - 1] = 1 - pmass;
   }
-  for(e=0;e<ex;e++)
-  {
-    for (j=0; j<nVars_ex[e]; j++)
-    {
-      rule=vars_ex[e][j].nRule;
-      theta=Theta_rules[rule];
-      p0=1;
-      for (i=0; i<vars_ex[e][j].nVal-1;i++)
-      {    
-        probs_ex[e][vars_ex[e][j].firstBoolVar+i]=theta[i]/p0;
-        p0=p0*(1-theta[i]/p0);
+  for (e = 0; e < ex; e++) {
+    for (j = 0; j < nVars_ex[e]; j++) {
+      rule = vars_ex[e][j].nRule;
+      theta = Theta_rules[rule];
+      p0 = 1;
+      for (i = 0; i < vars_ex[e][j].nVal - 1; i++) {
+        probs_ex[e][vars_ex[e][j].firstBoolVar + i] = theta[i] / p0;
+        p0 = p0 * (1 - theta[i] / p0);
       }
     }
   }
-  for (j=0;j<nRules;j++)
-  {
+  for (j = 0; j < nRules; j++) {
     free(Theta_rules[j]);
   }
   free(Theta_rules);
   return 1;
 }
 
-static YAP_Bool EM(void)
-{
-  YAP_Term arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,
-    out1,out2,out3,nodesTerm,ruleTerm,tail,pair,compoundTerm;
-  DdNode * node1,**nodes_ex;
-  int r,lenNodes,i,iter;
+static YAP_Bool EM(void) {
+  YAP_Term arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, out1, out2, out3,
+      nodesTerm, ruleTerm, tail, pair, compoundTerm;
+  DdNode *node1, **nodes_ex;
+  int r, lenNodes, i, iter;
   long iter1;
-  double CLL0= -2.2*pow(10,10); //-inf
-  double CLL1= -1.7*pow(10,8);  //+inf   
-  double p,p0,**eta_rule,ea,er; 
-  double ratio,diff;
+  double CLL0 = -2.2 * pow(10, 10); //-inf
+  double CLL1 = -1.7 * pow(10, 8);  //+inf
+  double p, p0, **eta_rule, ea, er;
+  double ratio, diff;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  arg3=YAP_ARG3;
-  arg4=YAP_ARG4;
-  arg5=YAP_ARG5;
-  arg6=YAP_ARG6;
-  arg7=YAP_ARG7;
-  arg8=YAP_ARG8;
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  arg3 = YAP_ARG3;
+  arg4 = YAP_ARG4;
+  arg5 = YAP_ARG5;
+  arg6 = YAP_ARG6;
+  arg7 = YAP_ARG7;
+  arg8 = YAP_ARG8;
 
-  nodesTerm=arg1; 
-  ea=YAP_FloatOfTerm(arg2);
-  er=YAP_FloatOfTerm(arg3);
-  lenNodes=YAP_IntOfTerm(arg4);  
-  iter=YAP_IntOfTerm(arg5);  
+  nodesTerm = arg1;
+  ea = YAP_FloatOfTerm(arg2);
+  er = YAP_FloatOfTerm(arg3);
+  lenNodes = YAP_IntOfTerm(arg4);
+  iter = YAP_IntOfTerm(arg5);
 
-  nodes_ex=(DdNode **)malloc(lenNodes*sizeof(DdNode*));
-  nodes_probs_ex=(double *)malloc(lenNodes*sizeof(double));
-  example_prob=(double *)malloc(lenNodes*sizeof(double));
+  nodes_ex = (DdNode **)malloc(lenNodes * sizeof(DdNode *));
+  nodes_probs_ex = (double *)malloc(lenNodes * sizeof(double));
+  example_prob = (double *)malloc(lenNodes * sizeof(double));
 
-  for (i=0;i<lenNodes;i++)
-  {
-    pair=YAP_HeadOfTerm(nodesTerm);
-    node1=(DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
-    nodes_ex[i]=node1;
-    pair=YAP_TailOfTerm(pair);
-    example_prob[i]=YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
-    nodesTerm=YAP_TailOfTerm(nodesTerm);
+  for (i = 0; i < lenNodes; i++) {
+    pair = YAP_HeadOfTerm(nodesTerm);
+    node1 = (DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
+    nodes_ex[i] = node1;
+    pair = YAP_TailOfTerm(pair);
+    example_prob[i] = YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
+    nodesTerm = YAP_TailOfTerm(nodesTerm);
   }
-  diff=CLL1-CLL0;
-  ratio=diff/fabs(CLL0);
-  if (iter==-1)
-    iter1= 2147000000;
-  else iter1=iter;
-  
+  diff = CLL1 - CLL0;
+  ratio = diff / fabs(CLL0);
+  if (iter == -1)
+    iter1 = 2147000000;
+  else
+    iter1 = iter;
 
-  while  ( (diff>ea) && (ratio>er) && (cycle<iter1) )
-  {
+  while ((diff > ea) && (ratio > er) && (cycle < iter1)) {
     cycle++;
-    for (r=0;r<nRules;r++)
-    {
-      for (i=0;i<rules[r]-1;i++)
-      {
-        eta_rule=eta[r];
-        eta_rule[i][0]=0;
-        eta_rule[i][1]=0;
+    for (r = 0; r < nRules; r++) {
+      for (i = 0; i < rules[r] - 1; i++) {
+        eta_rule = eta[r];
+        eta_rule[i][0] = 0;
+        eta_rule[i][1] = 0;
       }
     }
     CLL0 = CLL1;
-    CLL1 = Expectation(nodes_ex,lenNodes);
+    CLL1 = Expectation(nodes_ex, lenNodes);
     Maximization();
-    diff=CLL1-CLL0;
-    ratio=diff/fabs(CLL0);
+    diff = CLL1 - CLL0;
+    ratio = diff / fabs(CLL0);
   }
-  out2= YAP_TermNil();
-  for (r=0; r<nRules; r++)
-  {
-    tail=YAP_TermNil();
-    p0=1;
-    for (i=0;i<rules[r]-1;i++)
-    {
-      p=arrayprob[r][i]*p0;
-      tail=YAP_MkPairTerm(YAP_MkFloatTerm(p),tail);
-      p0=p0*(1-arrayprob[r][i]);
+  out2 = YAP_TermNil();
+  for (r = 0; r < nRules; r++) {
+    tail = YAP_TermNil();
+    p0 = 1;
+    for (i = 0; i < rules[r] - 1; i++) {
+      p = arrayprob[r][i] * p0;
+      tail = YAP_MkPairTerm(YAP_MkFloatTerm(p), tail);
+      p0 = p0 * (1 - arrayprob[r][i]);
     }
-    tail=YAP_MkPairTerm(YAP_MkFloatTerm(p0),tail);
-    ruleTerm=YAP_MkIntTerm(r);
-    compoundTerm=YAP_MkPairTerm(ruleTerm,YAP_MkPairTerm(tail,YAP_TermNil()));
-    out2=YAP_MkPairTerm(compoundTerm,out2);
+    tail = YAP_MkPairTerm(YAP_MkFloatTerm(p0), tail);
+    ruleTerm = YAP_MkIntTerm(r);
+    compoundTerm =
+        YAP_MkPairTerm(ruleTerm, YAP_MkPairTerm(tail, YAP_TermNil()));
+    out2 = YAP_MkPairTerm(compoundTerm, out2);
   }
-  out3= YAP_TermNil();
-  for (i=0;i<lenNodes;i++)
-  {
-    out3=YAP_MkPairTerm(YAP_MkFloatTerm(nodes_probs_ex[i]),out3);
+  out3 = YAP_TermNil();
+  for (i = 0; i < lenNodes; i++) {
+    out3 = YAP_MkPairTerm(YAP_MkFloatTerm(nodes_probs_ex[i]), out3);
   }
-  YAP_Unify(out3,arg8);
+  YAP_Unify(out3, arg8);
 
-  out1=YAP_MkFloatTerm(CLL1);
-  YAP_Unify(out1,arg6);
+  out1 = YAP_MkFloatTerm(CLL1);
+  YAP_Unify(out1, arg6);
   free(nodes_ex);
   free(example_prob);
   free(nodes_probs_ex);
 
-  return (YAP_Unify(out2,arg7));
+  return (YAP_Unify(out2, arg7));
 }
 
+static YAP_Bool Q(void) {
+  YAP_Term arg1, arg2, arg3, arg4, out, out1, term, nodesTerm, ruleTerm, tail,
+      pair, compoundTerm;
+  DdNode *node1, **nodes_ex;
+  int r, lenNodes, i;
+  double p1, p0, **eta_rule, CLL;
 
-static YAP_Bool Q(void)
-{
-  YAP_Term arg1,arg2,arg3,arg4,out,out1,
-    term,nodesTerm,ruleTerm,tail,pair,compoundTerm;
-  DdNode * node1,**nodes_ex;
-  int r,lenNodes,i;
-  double p1,p0,**eta_rule,CLL; 
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  arg3 = YAP_ARG3;
+  arg4 = YAP_ARG4;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  arg3=YAP_ARG3;
-  arg4=YAP_ARG4;
+  nodesTerm = arg1;
+  lenNodes = YAP_IntOfTerm(arg2);
 
-  nodesTerm=arg1; 
-  lenNodes=YAP_IntOfTerm(arg2);  
+  nodes_ex = (DdNode **)malloc(lenNodes * sizeof(DdNode *));
+  example_prob = (double *)malloc(lenNodes * sizeof(double));
 
-  nodes_ex=(DdNode **)malloc(lenNodes*sizeof(DdNode*));
-  example_prob=(double *)malloc(lenNodes*sizeof(double));
-
-  for (i=0;i<lenNodes;i++)
-  {
-    pair=YAP_HeadOfTerm(nodesTerm);
-    node1=(DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
-    nodes_ex[i]=node1;
-    pair=YAP_TailOfTerm(pair);
-    example_prob[i]=YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
-    nodesTerm=YAP_TailOfTerm(nodesTerm);
+  for (i = 0; i < lenNodes; i++) {
+    pair = YAP_HeadOfTerm(nodesTerm);
+    node1 = (DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
+    nodes_ex[i] = node1;
+    pair = YAP_TailOfTerm(pair);
+    example_prob[i] = YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
+    nodesTerm = YAP_TailOfTerm(nodesTerm);
   }
 
-  for (r=0;r<nRules;r++)
-  {
-    for (i=0;i<rules[r]-1;i++)  
-    {
-      eta_rule=eta[r];
-      eta_rule[i][0]=0;
-      eta_rule[i][1]=0;
+  for (r = 0; r < nRules; r++) {
+    for (i = 0; i < rules[r] - 1; i++) {
+      eta_rule = eta[r];
+      eta_rule[i][0] = 0;
+      eta_rule[i][1] = 0;
     }
   }
-  CLL=Expectation(nodes_ex,lenNodes);
-  out= YAP_TermNil();
+  CLL = Expectation(nodes_ex, lenNodes);
+  out = YAP_TermNil();
 
-  for (r=0; r<nRules; r++)
-  {
-    tail=YAP_TermNil();
-    eta_rule=eta[r];
-    for (i=0;i<rules[r]-1;i++)
-    {
-      p0=eta_rule[i][0];
-      p1=eta_rule[i][1];
-      term=YAP_MkPairTerm(YAP_MkFloatTerm(p0),
-        YAP_MkPairTerm(YAP_MkFloatTerm(p1),YAP_TermNil()));
-      tail=YAP_MkPairTerm(term,tail);
+  for (r = 0; r < nRules; r++) {
+    tail = YAP_TermNil();
+    eta_rule = eta[r];
+    for (i = 0; i < rules[r] - 1; i++) {
+      p0 = eta_rule[i][0];
+      p1 = eta_rule[i][1];
+      term = YAP_MkPairTerm(YAP_MkFloatTerm(p0),
+                            YAP_MkPairTerm(YAP_MkFloatTerm(p1), YAP_TermNil()));
+      tail = YAP_MkPairTerm(term, tail);
     }
 
-    ruleTerm=YAP_MkIntTerm(r);
-    compoundTerm=YAP_MkPairTerm(ruleTerm,YAP_MkPairTerm(tail,YAP_TermNil()));
-    out=YAP_MkPairTerm(compoundTerm,out);
+    ruleTerm = YAP_MkIntTerm(r);
+    compoundTerm =
+        YAP_MkPairTerm(ruleTerm, YAP_MkPairTerm(tail, YAP_TermNil()));
+    out = YAP_MkPairTerm(compoundTerm, out);
   }
 
   free(nodes_ex);
   free(example_prob);
 
-  out1=YAP_MkFloatTerm(CLL);
-  YAP_Unify(out1,arg4);
-  return (YAP_Unify(out,arg3));
+  out1 = YAP_MkFloatTerm(CLL);
+  YAP_Unify(out1, arg4);
+  return (YAP_Unify(out, arg3));
 }
 
-static YAP_Bool paths_to_non_zero(void)
-{
+static YAP_Bool paths_to_non_zero(void) {
   double paths;
-  YAP_Term arg1,arg2,out;
-  DdNode * node;
+  YAP_Term arg1, arg2, out;
+  DdNode *node;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  node=(DdNode *)YAP_IntOfTerm(arg1);
-  paths=Cudd_CountPathsToNonZero(node);
-  out=YAP_MkFloatTerm(paths);
-  return(YAP_Unify(out,arg2));
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  node = (DdNode *)YAP_IntOfTerm(arg1);
+  paths = Cudd_CountPathsToNonZero(node);
+  out = YAP_MkFloatTerm(paths);
+  return (YAP_Unify(out, arg2));
 }
 
-static YAP_Bool paths(void)
-{
+static YAP_Bool paths(void) {
   double paths;
-  YAP_Term arg1,arg2,out;
-  DdNode * node;
+  YAP_Term arg1, arg2, out;
+  DdNode *node;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  node=(DdNode *)YAP_IntOfTerm(arg1);
-  paths=Cudd_CountPath(node);
-  out=YAP_MkFloatTerm(paths);
-  return(YAP_Unify(out,arg2));
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  node = (DdNode *)YAP_IntOfTerm(arg1);
+  paths = Cudd_CountPath(node);
+  out = YAP_MkFloatTerm(paths);
+  return (YAP_Unify(out, arg2));
 }
 
-static YAP_Bool dag_size(void)
-{
+static YAP_Bool dag_size(void) {
   int size;
-  YAP_Term arg1,arg2,out;
-  DdNode * node;
+  YAP_Term arg1, arg2, out;
+  DdNode *node;
 
-  arg1=YAP_ARG1;
-  arg2=YAP_ARG2;
-  node=(DdNode *)YAP_IntOfTerm(arg1);
-  size=Cudd_DagSize(node);
-  out=YAP_MkIntTerm(size);
-  return(YAP_Unify(out,arg2));
+  arg1 = YAP_ARG1;
+  arg2 = YAP_ARG2;
+  node = (DdNode *)YAP_IntOfTerm(arg1);
+  size = Cudd_DagSize(node);
+  out = YAP_MkIntTerm(size);
+  return (YAP_Unify(out, arg2));
 }
 
 void init_my_predicates()
-/* function required by YAP for intitializing the predicates defined by a C function*/
+/* function required by YAP for intitializing the predicates defined by a C
+   function*/
 {
   srand(10);
 
-  YAP_UserCPredicate("init",init,2);
-  YAP_UserCPredicate("init_bdd",init_bdd,0);
-  YAP_UserCPredicate("end",end,0);
-  YAP_UserCPredicate("end_bdd",end_bdd,0);
-  YAP_UserCPredicate("add_var",add_var,4);
-  YAP_UserCPredicate("equality",equality,3);
-  YAP_UserCPredicate("and",and,3);
-  YAP_UserCPredicate("one",one,1);
-  YAP_UserCPredicate("zero",zero,1);
-  YAP_UserCPredicate("or",or,3);
-  YAP_UserCPredicate("bdd_not",bdd_not,2);
-  YAP_UserCPredicate("create_dot",create_dot,2);
-  YAP_UserCPredicate("init_test",init_test,1);
-  YAP_UserCPredicate("end_test",end_test,0);
-  YAP_UserCPredicate("ret_prob",ret_prob,2);
-  YAP_UserCPredicate("em",EM,8);
-  YAP_UserCPredicate("q",Q,4);
-  YAP_UserCPredicate("randomize",randomize,0);
-  YAP_UserCPredicate("deref",rec_deref,1);
-  YAP_UserCPredicate("garbage_collect",garbage_collect,2);
-  YAP_UserCPredicate("bdd_to_add",bdd_to_add,2);
-  YAP_UserCPredicate("paths_to_non_zero",paths_to_non_zero,2);
-  YAP_UserCPredicate("paths",paths,2);
-  YAP_UserCPredicate("dag_size",dag_size,2);
+  YAP_UserCPredicate("init", init, 2);
+  YAP_UserCPredicate("init_bdd", init_bdd, 0);
+  YAP_UserCPredicate("end", end, 0);
+  YAP_UserCPredicate("end_bdd", end_bdd, 0);
+  YAP_UserCPredicate("add_var", add_var, 4);
+  YAP_UserCPredicate("equality", equality, 3);
+  YAP_UserCPredicate("and", and, 3);
+  YAP_UserCPredicate("one", one, 1);
+  YAP_UserCPredicate("zero", zero, 1);
+  YAP_UserCPredicate("or", or, 3);
+  YAP_UserCPredicate("bdd_not", bdd_not, 2);
+  YAP_UserCPredicate("create_dot", create_dot, 2);
+  YAP_UserCPredicate("init_test", init_test, 1);
+  YAP_UserCPredicate("end_test", end_test, 0);
+  YAP_UserCPredicate("ret_prob", ret_prob, 2);
+  YAP_UserCPredicate("em", EM, 8);
+  YAP_UserCPredicate("q", Q, 4);
+  YAP_UserCPredicate("randomize", randomize, 0);
+  YAP_UserCPredicate("deref", rec_deref, 1);
+  YAP_UserCPredicate("garbage_collect", garbage_collect, 2);
+  YAP_UserCPredicate("bdd_to_add", bdd_to_add, 2);
+  YAP_UserCPredicate("paths_to_non_zero", paths_to_non_zero, 2);
+  YAP_UserCPredicate("paths", paths, 2);
+  YAP_UserCPredicate("dag_size", dag_size, 2);
 }
-FILE * open_file(char *filename, const char *mode)
+FILE *open_file(char *filename, const char *mode)
 /* opens a file */
 {
   FILE *fp;
 
-  if ((fp = fopen(filename, mode)) == NULL) 
-  {
+  if ((fp = fopen(filename, mode)) == NULL) {
     perror(filename);
     exit(1);
   }
   return fp;
 }
 
-
-tablerow* init_table(int varcnt) {
+tablerow *init_table(int varcnt) {
   int i;
   tablerow *tab;
 
-  tab = (tablerow *) malloc(sizeof(rowel) * varcnt);
-  for (i = 0; i < varcnt; i++) 
-  {
+  tab = (tablerow *)malloc(sizeof(rowel) * varcnt);
+  for (i = 0; i < varcnt; i++) {
     tab[i].row = NULL;
     tab[i].cnt = 0;
   }
   return tab;
 }
 
-
 void add_node(tablerow *tab, DdNode *node, double value) {
   int index = Cudd_NodeReadIndex(node);
-  
-  tab[index].row = (rowel *) realloc(tab[index].row, 
-    (tab[index].cnt + 1) * sizeof(rowel));
+
+  tab[index].row =
+      (rowel *)realloc(tab[index].row, (tab[index].cnt + 1) * sizeof(rowel));
   tab[index].row[tab[index].cnt].key = node;
   tab[index].row[tab[index].cnt].value = value;
   tab[index].cnt += 1;
 }
 
-void add_or_replace_node(tablerow *tab, DdNode *node, double value)
-{
+void add_or_replace_node(tablerow *tab, DdNode *node, double value) {
   int i;
   int index = Cudd_NodeReadIndex(node);
-  for(i = 0; i < tab[index].cnt; i++) 
-  {
-    if (tab[index].row[i].key == node) 
-    {
-      tab[index].row[i].value=value;
+  for (i = 0; i < tab[index].cnt; i++) {
+    if (tab[index].row[i].key == node) {
+      tab[index].row[i].value = value;
       return;
     }
   }
-  tab[index].row = (rowel *) realloc(tab[index].row, 
-    (tab[index].cnt + 1) * sizeof(rowel));
+  tab[index].row =
+      (rowel *)realloc(tab[index].row, (tab[index].cnt + 1) * sizeof(rowel));
   tab[index].row[tab[index].cnt].key = node;
   tab[index].row[tab[index].cnt].value = value;
   tab[index].cnt += 1;
 }
 
-double * get_value(tablerow *tab,  DdNode *node) {
+double *get_value(tablerow *tab, DdNode *node) {
   int i;
   int index = Cudd_NodeReadIndex(node);
 
-  for(i = 0; i < tab[index].cnt; i++) 
-  {
-    if (tab[index].row[i].key == node)
-    {
+  for (i = 0; i < tab[index].cnt; i++) {
+    if (tab[index].row[i].key == node) {
       return &tab[index].row[i].value;
     }
   }
   return NULL;
 }
 
-void destroy_table(tablerow *tab,int varcnt)
-{
+void destroy_table(tablerow *tab, int varcnt) {
   int i;
 
-  for (i = 0; i < varcnt; i++) 
-  {
+  for (i = 0; i < varcnt; i++) {
     free(tab[i].row);
   }
   free(tab);