diff --git a/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2 b/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2
index 5de2111efa9b4b4b065bfeda9947ca99f073c13c..640df855bbe42bbe113daebb918cc7c5e1f7589e 100755
Binary files a/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2 and b/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2 differ
diff --git a/src/relax_lagr.cpp b/src/relax_lagr.cpp
index 7e76e5bcf8576a10363f9af2a0a48cf54207a7b4..f7e1679b0fbbd4632329f993b0ffe0db023ae647 100644
--- a/src/relax_lagr.cpp
+++ b/src/relax_lagr.cpp
@@ -97,29 +97,29 @@ SCIP_DECL_RELAXFREE(relaxFreelagr)
 static
 SCIP_DECL_RELAXINIT(relaxInitlagr)
 {  /*lint --e{715}*/
-   // printf("hellow\n");
+   printf("hellow\n");
 
-   // using std::cout;
-   // SCIP*                                  relaxscip;                   //a copy of the scip we can work on
-   // SCIP_HASHMAP*                          varmap;                      //to map the variables from scip to relaxscip
-   // SCIP_HASHMAP*                          consmap;                     //to map the constraints from scip to relaxscip
+   using std::cout;
+   SCIP*                                  relaxscip;                   //a copy of the scip we can work on
+   SCIP_HASHMAP*                          varmap;                      //to map the variables from scip to relaxscip
+   SCIP_HASHMAP*                          consmap;                     //to map the constraints from scip to relaxscip
 
-   // SCIP_VARDATA*                           vardata;                     //contains variable data, including in which constraints it's found
-   // SCIP_PROBDATA*                          probdata;                    //contains constraint data, identify slot vs start conss, and also which variables it contains
-   // SCIP_RELAXDATA*                         relaxdata;                   // not yet used, but can be part of the struct SCIP_RelaxData
+   SCIP_VARDATA*                           vardata;                     //contains variable data, including in which constraints it's found
+   SCIP_PROBDATA*                          probdata;                    //contains constraint data, identify slot vs start conss, and also which variables it contains
+   SCIP_RELAXDATA*                         relaxdata;                   // not yet used, but can be part of the struct SCIP_RelaxData
 
-   // SCIP_CLOCK*                             varslottime;                 //to help us record the time
+   SCIP_CLOCK*                             varslottime;                 //to help us record the time
 
-   // FILE*                                   file;                        
+   FILE*                                   file;                        
    
-   // SCIP_Bool                               success;
-   // SCIP_Bool                               valid;
+   SCIP_Bool                               success;
+   SCIP_Bool                               valid;
 
-   // SCIP_SOL**                              sols;
+   SCIP_SOL**                              sols;
 
-   // relaxdata = SCIPrelaxGetData(relax);
-   // SCIP_CALL(SCIPallocBlockMemory(scip , &relaxdata));
-   // assert(relaxdata != NULL);
+   relaxdata = SCIPrelaxGetData(relax);
+   SCIP_CALL(SCIPallocBlockMemory(scip , &relaxdata));
+   assert(relaxdata != NULL);
 
 
 
@@ -128,21 +128,21 @@ SCIP_DECL_RELAXINIT(relaxInitlagr)
    /*************************************************************************************************/
    /*we start with creating our relaxed scip instance, where the variable and constraints are mapped*/
    /*************************************************************************************************/
-   // SCIP_CALL( SCIPcreate(&relaxscip));
-   // valid=FALSE;
-   // SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(relaxscip), SCIPgetNVars(scip)) );
-   // SCIP_CALL(SCIPcopy(scip,relaxscip,varmap,consmap,"relaxscip",FALSE,FALSE,FALSE,FALSE,&valid));
+   SCIP_CALL( SCIPcreate(&relaxscip));
+   valid=FALSE;
+   SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(relaxscip), SCIPgetNVars(scip)) );
+   SCIP_CALL(SCIPcopy(scip,relaxscip,varmap,consmap,"relaxscip",FALSE,FALSE,FALSE,FALSE,&valid));
    
-   // SCIP_VAR** origvars = SCIPgetVars(scip);
-   // SCIP_VAR** vars = SCIPgetVars(relaxscip);
-   // SCIP_CONS** conss = SCIPgetConss(relaxscip);
-   // int nconss = SCIPgetNConss(relaxscip);
-   // int nvars = SCIPgetNVars(relaxscip);
-   // SCIP_Real upperbound = 0;
-   // // printf("**************%f***********",SCIPgetNCountedFeasSubtrees(relaxscip));
+   SCIP_VAR** origvars = SCIPgetVars(scip);
+   SCIP_VAR** vars = SCIPgetVars(relaxscip);
+   SCIP_CONS** conss = SCIPgetConss(relaxscip);
+   int nconss = SCIPgetNConss(relaxscip);
+   int nvars = SCIPgetNVars(relaxscip);
+   SCIP_Real upperbound = 0;
+   // printf("**************%f***********",SCIPgetNCountedFeasSubtrees(relaxscip));
 
-   // SCIP_CALL( SCIPcreateClock(relaxscip, &varslottime) );                     //* start time counting*  
-   // SCIP_CALL(SCIPstartClock(relaxscip,varslottime));
+   SCIP_CALL( SCIPcreateClock(relaxscip, &varslottime) );                     //* start time counting*  
+   SCIP_CALL(SCIPstartClock(relaxscip,varslottime));
 
    /**************************************************************************************************************/
    /*First,                                                                                                      */
@@ -151,174 +151,174 @@ SCIP_DECL_RELAXINIT(relaxInitlagr)
    /*--along with the quotient of the obj to the nVarSlotConss                                                    */
    /***************************************************************************************************************/
                                      
-   // SCIPcreateprobdata(relaxscip,&probdata);     //*will be used to identify the #of slot constraints 
-   // printf("%d", SCIPgetNConss(relaxscip));
-   // int nSlotConss = SCIPgetNSlotConss(probdata);
-   // printf("%d", SCIPgetNSlotConss(probdata));
-
-   // SCIP_Real* origobj;
-   // SCIP_CALL(SCIPallocBufferArray(relaxscip,&origobj,nvars));
-
-
-   // for (int v = 0; v < nvars; v++)
-   // {
-   //    SCIP_VAR* var = vars[v];
-   //    origobj[v]= SCIPvarGetObj(var);
-
-   //    vardata=NULL;
-   //    SCIPvardataCreateLagrangian(relaxscip,vardata,&var,nSlotConss,v);        //*we create the vardata, containing the ids of the constraints containing the variable
-   //    vardata=SCIPvarGetData(var);  
-   //    if(upperbound<=SCIPvarGetObj(var))
-   //    {
-   //       upperbound = SCIPvarGetObj(var);
-   //    }
-   // } 
-   // upperbound = upperbound * (nconss - nSlotConss);
-   // printf("%f",upperbound);  
-   // // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
-   // // SCIPinfoMessage(relaxscip, NULL, "Solving Time (sec) : %6f\n", SCIPgetClockTime(relaxscip, varslottime));
-
-
-   // SCIP_SOL* bestsol ;
-   // SCIP_Real* dualmultipliers;
-   // SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));   
+   SCIPcreateprobdata(relaxscip,&probdata);     //*will be used to identify the #of slot constraints 
+   printf("%d", SCIPgetNConss(relaxscip));
+   int nSlotConss = SCIPgetNSlotConss(probdata);
+   printf("%d", SCIPgetNSlotConss(probdata));
+
+   SCIP_Real* origobj;
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&origobj,nvars));
+
+
+   for (int v = 0; v < nvars; v++)
+   {
+      SCIP_VAR* var = vars[v];
+      origobj[v]= SCIPvarGetObj(var);
+
+      vardata=NULL;
+      SCIPvardataCreateLagrangian(relaxscip,vardata,&var,nSlotConss,v);        //*we create the vardata, containing the ids of the constraints containing the variable
+      vardata=SCIPvarGetData(var);  
+      if(upperbound<=SCIPvarGetObj(var))
+      {
+         upperbound = SCIPvarGetObj(var);
+      }
+   } 
+   upperbound = upperbound * (nconss - nSlotConss);
+   printf("%f",upperbound);  
+   // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
+   // SCIPinfoMessage(relaxscip, NULL, "Solving Time (sec) : %6f\n", SCIPgetClockTime(relaxscip, varslottime));
+
+
+   SCIP_SOL* bestsol ;
+   SCIP_Real* dualmultipliers;
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));   
                                            
-   // SCIP_Real sumofduals = 0;   
-   // SCIP_Real stepsize = 0.0000;
-   // SCIP_Real sqsum = 0;
-   // SCIP_Real sqrtsum = 0;
-   // SCIP_Real C = 2;
+   SCIP_Real sumofduals = 0;   
+   SCIP_Real stepsize = 0.0000;
+   SCIP_Real sqsum = 0;
+   SCIP_Real sqrtsum = 0;
+   SCIP_Real C = 2;
 
 
-   // SCIP_Real* subgradients;
-   // SCIP_CALL(SCIPallocBufferArray(relaxscip,&subgradients,nSlotConss));
+   SCIP_Real* subgradients;
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&subgradients,nSlotConss));
 
-   // /******************************************************************************************************************/
-   // /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */ 
-   // /* In the end, we will subtract this sum from the objective of the function.                                      */
-   // /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation       */
-   // /******************************************************************************************************************/
+   /******************************************************************************************************************/
+   /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */ 
+   /* In the end, we will subtract this sum from the objective of the function.                                      */
+   /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation       */
+   /******************************************************************************************************************/
   
-   // for ( int r = 0; r < nSlotConss; ++r)
-   // {
-   //          // printf("*******************%f\n",subgradients[r]);
-   //    SCIP_CONS* cons = conss[r]; 
+   for ( int r = 0; r < nSlotConss; ++r)
+   {
+            // printf("*******************%f\n",subgradients[r]);
+      SCIP_CONS* cons = conss[r]; 
    
-   //    dualmultipliers[r]=SCIPconsGetMultiplier(relaxscip,&cons, 0,0,0,true,0);           //returns the minumum
-   //    dualmultipliers[r] = 0;
-   //    sumofduals+=dualmultipliers[r];                    //adds the negative of the minimum in each iteration
-   //    // printf("(%s,%f) \n",SCIPconsGetName(cons), dualmultipliers[r]);
+      dualmultipliers[r]=SCIPconsGetMultiplier(relaxscip,&cons, 0,0,0,true,0);           //returns the minumum
+      dualmultipliers[r] = 0;
+      sumofduals+=dualmultipliers[r];                    //adds the negative of the minimum in each iteration
+      // printf("(%s,%f) \n",SCIPconsGetName(cons), dualmultipliers[r]);
         
-   // }
+   }
 
    
-   // int niters = 2250;
-   // int stoppingiter=0;
+   int niters = 2250;
+   int stoppingiter=0;
    
-   // /**solvals is used for storing solutions in an iteration. where as bestsolvals will store the solution with the best objective value*/
-   // SCIP_Real* solvals;
-   // SCIP_Real* bestsolvals;
-   // SCIP_CALL(SCIPallocBufferArray(relaxscip,&solvals,nvars+1));
-   // SCIP_CALL(SCIPallocBufferArray(relaxscip,&bestsolvals,nvars+1+niters));
-
-   // bestsolvals[nvars] = -10000000000000000;
-   // // printf("%f",bestsolvals[nvars+1]);
+   /**solvals is used for storing solutions in an iteration. where as bestsolvals will store the solution with the best objective value*/
+   SCIP_Real* solvals;
+   SCIP_Real* bestsolvals;
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&solvals,nvars+1));
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&bestsolvals,nvars+1+niters));
+
+   bestsolvals[nvars] = -10000000000000000;
+   // printf("%f",bestsolvals[nvars+1]);
    
-   // // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
-   // // SCIPinfoMessage(relaxscip, NULL, "Solving Time (sec) : %6f\n", SCIPgetClockTime(relaxscip, varslottime));
+   // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
+   // SCIPinfoMessage(relaxscip, NULL, "Solving Time (sec) : %6f\n", SCIPgetClockTime(relaxscip, varslottime));
     
-   // /*add all the duals that are added onto the variabls under sumofaddonvars*/
-   // SCIP_Real sumofaddonvars=0;
-   // SCIP_Real percent;
-   // SCIP_Real percent2;
-   // int counter=0;
+   /*add all the duals that are added onto the variabls under sumofaddonvars*/
+   SCIP_Real sumofaddonvars=0;
+   SCIP_Real percent;
+   SCIP_Real percent2;
+   int counter=0;
 
-   // SCIP_Real sumofsqsubgrad=0;
+   SCIP_Real sumofsqsubgrad=0;
 
    
-   // stepsize; 
-   // /*Now we can start with our interation to maximize the dualmultipliers while minimizing the reformulated SCIP instance*/
-   // for(int k =  0; k < niters; ++k)
-   // {  
-   //    stepsize = 0.1;
-   //    printf("%f\n\n",stepsize);
-   //    sumofaddonvars = 0;       
-   //    SCIP_CALL(SCIPfreeTransform(relaxscip));
-   //    /*******************************************************************************************************/
-   //    /* The reformulation of the problem can be written as follows                                          */
-   //    //*>>>>>>>>>>>>>>>>>> min sum { (w[i]+sum{dual[j]})}x[i]-sum{dual[r]} <<<<<<<<<<<<                     */
-   //    /*where i is nvars, j is nVarSlotConss, and r is nSlotConss for our case *******************************/
-   //    /*******************************************************************************************************/
-   //    SCIPvarchangeDuals(relaxscip,&vars,dualmultipliers,origobj);
-   //    SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,-1*sumofduals));
-   //    // printf("*****************************upperbound*********************---> %f",SCIPgetUpperbound(relaxscip));
-   //    // SCIP_CALL(SCIPprintOrigProblem(relaxscip, file, "lp", FALSE));
+   stepsize; 
+   /*Now we can start with our interation to maximize the dualmultipliers while minimizing the reformulated SCIP instance*/
+   for(int k =  0; k < niters; ++k)
+   {  
+      stepsize = 0.1;
+      printf("%f\n\n",stepsize);
+      sumofaddonvars = 0;       
+      SCIP_CALL(SCIPfreeTransform(relaxscip));
+      /*******************************************************************************************************/
+      /* The reformulation of the problem can be written as follows                                          */
+      //*>>>>>>>>>>>>>>>>>> min sum { (w[i]+sum{dual[j]})}x[i]-sum{dual[r]} <<<<<<<<<<<<                     */
+      /*where i is nvars, j is nVarSlotConss, and r is nSlotConss for our case *******************************/
+      /*******************************************************************************************************/
+      SCIPvarchangeDuals(relaxscip,&vars,dualmultipliers,origobj);
+      SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,-1*sumofduals));
+      // printf("*****************************upperbound*********************---> %f",SCIPgetUpperbound(relaxscip));
+      // SCIP_CALL(SCIPprintOrigProblem(relaxscip, file, "lp", FALSE));
       
-   //    SCIPsolveiteration(relaxscip,nSlotConss,&subgradients,2,&stepsize,&bestsolvals,&upperbound, k);
-   //    //prinf("\t\t\t\t%fUpperbound \n",upperbound);
+      SCIPsolveiteration(relaxscip,nSlotConss,&subgradients,2,&stepsize,&bestsolvals,&upperbound, k);
+      //prinf("\t\t\t\t%fUpperbound \n",upperbound);
            
-   //    SCIP_CALL(SCIPduplicateBlockMemoryArray(scip, &(relaxdata->bestsolvals), bestsolvals, nvars+1));
-   //    // printf("\n best obj = %f \n",bestsolvals[nvars]);
+      SCIP_CALL(SCIPduplicateBlockMemoryArray(scip, &(relaxdata->bestsolvals), bestsolvals, nvars+1));
+      // printf("\n best obj = %f \n",bestsolvals[nvars]);
 
 
-   //    SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,sumofduals));
+      SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,sumofduals));
     
-   //    sumofduals = 0;
-   //    for ( int r = 0; r < nSlotConss; ++r)
-   //    {  
-   //       SCIP_CONS* cons = conss[r]; 
-   //       // printf("--subgrad %f--",subgradients[r]);
-   //       SCIP_Real subgradient = subgradients[r];
-   //       sumofsqsubgrad += subgradients[r]*subgradients[r];
-   //    } 
-
-   //    for ( int r = 0; r < nSlotConss; ++r)
-   //    {  
-   //       SCIP_CONS* cons = conss[r]; 
-   //       // printf("--subgrad %f--",subgradients[r]);
-   //       SCIP_Real subgradient = subgradients[r];
-   //       dualmultipliers[r]=SCIPconsGetMultiplier(relaxscip,&cons,subgradient,C,stepsize,false,dualmultipliers[r]);           //returns the minumum
-   //       sumofduals+=dualmultipliers[r];                    //adds the negative of the minimum in each iteration
-   //       //prinf("(%s,%f, sumofduals %f) \n",SCIPconsGetName(cons), dualmultipliers[r],sumofduals);
-   //    }
+      sumofduals = 0;
+      for ( int r = 0; r < nSlotConss; ++r)
+      {  
+         SCIP_CONS* cons = conss[r]; 
+         // printf("--subgrad %f--",subgradients[r]);
+         SCIP_Real subgradient = subgradients[r];
+         sumofsqsubgrad += subgradients[r]*subgradients[r];
+      } 
+
+      for ( int r = 0; r < nSlotConss; ++r)
+      {  
+         SCIP_CONS* cons = conss[r]; 
+         // printf("--subgrad %f--",subgradients[r]);
+         SCIP_Real subgradient = subgradients[r];
+         dualmultipliers[r]=SCIPconsGetMultiplier(relaxscip,&cons,subgradient,C,stepsize,false,dualmultipliers[r]);           //returns the minumum
+         sumofduals+=dualmultipliers[r];                    //adds the negative of the minimum in each iteration
+         //prinf("(%s,%f, sumofduals %f) \n",SCIPconsGetName(cons), dualmultipliers[r],sumofduals);
+      }
 
       
       
 
-   //    ++stoppingiter;
-   //    if(bestsolvals[nvars]!=bestsolvals[nvars+k+1]){++counter;}
-   //    else{counter=0;}
-   //    if(counter==10){ break; }   
-   // }
+      ++stoppingiter;
+      if(bestsolvals[nvars]!=bestsolvals[nvars+k+1]){++counter;}
+      else{counter=0;}
+      if(counter==10){ break; }   
+   }
 
-   // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
-   // SCIPinfoMessage(relaxscip, NULL, "Solving Time (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
-
-   // FILE* saveniter;
-   // saveniter = fopen("values.txt","w");
-   // fprintf(saveniter,"%d\n",stoppingiter);
-   // fclose(saveniter);
-
-   // FILE* savebestsols;
-   // for(int v=nvars+1; v<nvars+1+stoppingiter; ++v)
-   // {
-   //    // prinf("(%s bsv= %f\n", SCIPvarGetName(vars[v]),bestsolvals[v]);
-   //    savebestsols = fopen("values.txt","a");
-   //    fprintf(savebestsols,"%f\n", bestsolvals[v]);
-   //    // fputs("This is testing for fputs...\n",were);
-   //    fclose(savebestsols);
-   // }
+   SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
+   SCIPinfoMessage(relaxscip, NULL, "Solving Time (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
+
+   FILE* saveniter;
+   saveniter = fopen("values.txt","w");
+   fprintf(saveniter,"%d\n",stoppingiter);
+   fclose(saveniter);
+
+   FILE* savebestsols;
+   for(int v=nvars+1; v<nvars+1+stoppingiter; ++v)
+   {
+      // prinf("(%s bsv= %f\n", SCIPvarGetName(vars[v]),bestsolvals[v]);
+      savebestsols = fopen("values.txt","a");
+      fprintf(savebestsols,"%f\n", bestsolvals[v]);
+      // fputs("This is testing for fputs...\n",were);
+      fclose(savebestsols);
+   }
 
    
-   // for(int v=0; v<nvars; ++v)
-   // {
-   //    SCIP_VAR* var = vars[v];
-   //    // printf("orobj %f|",origobj[v]);
-   //    // vardata = SCIPvarGetData(var);
-   //    // SCIP_CALL(SCIPVaraddDualMultiplier(relaxscip,&var,dualmultipliers));
-   //    // printf("%f",SCIPvarGetQuotient(vardata));
-   //    // vardataDelete(relaxscip,&vardata);
-   // }
+   for(int v=0; v<nvars; ++v)
+   {
+      SCIP_VAR* var = vars[v];
+      // printf("orobj %f|",origobj[v]);
+      // vardata = SCIPvarGetData(var);
+      // SCIP_CALL(SCIPVaraddDualMultiplier(relaxscip,&var,dualmultipliers));
+      // printf("%f",SCIPvarGetQuotient(vardata));
+      // vardataDelete(relaxscip,&vardata);
+   }
 
 
    
@@ -444,7 +444,7 @@ SCIP* relaxscip;
       if(SCIPconsGetLhs(relaxscip,cons,&valid)==-SCIPinfinity(relaxscip))                        /*<We get the slot constraints based on the inquality*/
       {
          badconss[counter]=t;
-         // printf("(%d,%d)--%s\t",counter, t,SCIPconsGetName(cons));
+         printf("(%d,%d)--%s\t",counter, t,SCIPconsGetName(cons));
          counter++; 
       }
    }
@@ -471,6 +471,7 @@ SCIP* relaxscip;
       SCIP_CALL(SCIPgetConsNVars(relaxscip,cons,&nconsvars,&valid));
       if(maxnconsvars<nconsvars){maxnconsvars=nconsvars;}   //get the max number of variables found at each constraint
       consids[r]=0;
+      // printf("%s\n",SCIPconsGetName(cons));
    }
 
    SCIP_VAR** varbuffers;
@@ -479,14 +480,16 @@ SCIP* relaxscip;
    {
       varbuffers[v] =vars[v];
    }
-   
 
+   SCIP_Real* origobj;
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&origobj,nvars)); 
    for (int v = 0; v < nvars; v++)
    { 
       int* varid;
       int nVarSlotConss=0;
       nconsvars = 0;
       SCIP_VAR* var = vars[v];
+      origobj[v]= SCIPvarGetObj(var);
       
       int varindex = SCIPvarGetIndex(var);                                    /* (2) */
       assert(varindex!= NULL);
@@ -537,10 +540,40 @@ SCIP* relaxscip;
       // /**set the variable data to the variable*/
       SCIPvarSetData(var,vardata);  
    }
-      
+
 
    // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
    SCIPinfoMessage(relaxscip, NULL, "\n row and column identified in (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
+   /******************************************************************************************************************/
+   /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */
+   /* In the end, we will subtract this sum from the objective of the function.                                      */
+   /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation       */
+   /******************************************************************************************************************/
+   SCIP_Real* dualmultipliers;
+   SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));
+   int sumofduals=0;
+
+   for ( int r = 0; r < nSlotConss; ++r)
+   {
+      id = badconss[r];
+      SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
+      
+
+      // dualmultipliers[r]=SCIPconsGetMultiplier(relaxscip,&cons, 0,0,0,true,0);           //returns the minumum
+      dualmultipliers[r] = 0;
+      sumofduals+=dualmultipliers[r];                    //adds the negative of the minimum in each iteration
+      
+   }
+
+   /*******************************************************************************************************/
+   /* The reformulation of the problem can be written as follows                                          */
+   //*>>>>>>>>>>>>>>>>>> min sum { (w[i]+sum{dual[j]})}x[i]-sum{dual[r]} <<<<<<<<<<<<                     */
+   /*where i is nvars, j is nVarSlotConss, and r is nSlotConss for our case *******************************/
+   /****************************************************************************************************************/
+   /* The following function will add the following to the obj(weight) of the variable,                            */
+   //*  the obj(weight) of var + the sum of the dualmultipliers of bad constraints which contains this variable    */
+   /****************************************************************************************************************/
+  
 
 
    /* change variable types */
@@ -556,10 +589,14 @@ SCIP* relaxscip;
       assert(!infeasible);
    }
 
-   // SCIP_CALL(SCIPprintOrigProblem(relaxscip, NULL, "lp", FALSE));
-   SCIPsetMessagehdlrQuiet(relaxscip, TRUE);
    SCIP_CALL( SCIPtransformProb(relaxscip) );
 
+   FILE* saveniter;
+   saveniter = fopen("time.txt","w");
+
+   SCIP_CALL(SCIPprintOrigProblem(relaxscip, saveniter, "lp", FALSE));
+   SCIPsetMessagehdlrQuiet(relaxscip, TRUE);
+   fclose(saveniter);
 
    SCIP_CALL( SCIPsolve(relaxscip) );
    relaxval = SCIPgetPrimalbound(relaxscip);
diff --git a/time.txt b/time.txt
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..4e649a39a1f38c4ccbcb466bd687f4540a08c40b 100644
--- a/time.txt
+++ b/time.txt
@@ -0,0 +1,119 @@
+\ SCIP STATISTICS
+\   Problem name     : data/6f4s.lp_relaxscip
+\   Variables        : 54 (27 binary, 0 integer, 0 implicit integer, 27 continuous)
+\   Constraints      : 36
+Minimize
+ Obj: +120 t_x_{6}_{120} +105 t_x_{6}_{105} +90 t_x_{6}_{90} +75 t_x_{6}_{75} +60 t_x_{6}_{60} +45 t_x_{6}_{45}
+      +30 t_x_{6}_{30} +15 t_x_{6}_{15} +120 t_x_{5}_{120} +105 t_x_{5}_{105} +90 t_x_{5}_{90} +75 t_x_{5}_{75}
+      +60 t_x_{5}_{60} +45 t_x_{5}_{45} +30 t_x_{5}_{30} +15 t_x_{5}_{15} +120 t_x_{4}_{120} +105 t_x_{4}_{105}
+      +90 t_x_{4}_{90} +75 t_x_{4}_{75} +60 t_x_{4}_{60} +45 t_x_{4}_{45} +30 t_x_{4}_{30} +15 t_x_{4}_{15}
+      +105 t_x_{3}_{105} +90 t_x_{3}_{90} +75 t_x_{3}_{75} +60 t_x_{3}_{60} +45 t_x_{3}_{45} +30 t_x_{3}_{30}
+      +15 t_x_{3}_{15} +120 t_x_{2}_{120} +105 t_x_{2}_{105} +90 t_x_{2}_{90} +75 t_x_{2}_{75} +60 t_x_{2}_{60}
+      +45 t_x_{2}_{45} +30 t_x_{2}_{30} +15 t_x_{2}_{15} +120 t_x_{1}_{120} +105 t_x_{1}_{105} +90 t_x_{1}_{90}
+      +75 t_x_{1}_{75} +60 t_x_{1}_{60} +45 t_x_{1}_{45} +30 t_x_{1}_{30} +15 t_x_{1}_{15} +1 t_x_{1}_{0}
+      +120 t_x_{3}_{120}
+Subject to
+ slot1: +1 t_x_{1}_{0} +1 t_x_{2}_{0} <= +1
+ slot2: +1 t_x_{1}_{15} +1 t_x_{2}_{15} <= +1
+ slot3: +1 t_x_{1}_{30} +1 t_x_{2}_{30} <= +1
+ slot4: +1 t_x_{1}_{45} +1 t_x_{2}_{45} <= +1
+ slot5: +1 t_x_{1}_{60} +1 t_x_{2}_{60} <= +1
+ slot6: +1 t_x_{1}_{75} +1 t_x_{2}_{75} <= +1
+ slot7: +1 t_x_{1}_{90} +1 t_x_{2}_{90} <= +1
+ slot8: +1 t_x_{1}_{105} +1 t_x_{2}_{105} <= +1
+ F_6: +1 t_x_{6}_{0} +1 t_x_{6}_{15} +1 t_x_{6}_{30} +1 t_x_{6}_{45} +1 t_x_{6}_{60} +1 t_x_{6}_{75} +1 t_x_{6}_{90}
+  +1 t_x_{6}_{105} +1 t_x_{6}_{120} = +1
+ slot10: +1 t_x_{2}_{0} +1 t_x_{3}_{0} +1 t_x_{4}_{0} <= +1
+ slot11: +1 t_x_{2}_{15} +1 t_x_{3}_{15} +1 t_x_{4}_{15} <= +1
+ slot12: +1 t_x_{2}_{30} +1 t_x_{3}_{30} +1 t_x_{4}_{30} <= +1
+ slot13: +1 t_x_{2}_{45} +1 t_x_{3}_{45} +1 t_x_{4}_{45} <= +1
+ slot14: +1 t_x_{2}_{60} +1 t_x_{3}_{60} +1 t_x_{4}_{60} <= +1
+ slot15: +1 t_x_{2}_{75} +1 t_x_{3}_{75} +1 t_x_{4}_{75} <= +1
+ slot16: +1 t_x_{2}_{90} +1 t_x_{3}_{90} +1 t_x_{4}_{90} <= +1
+ F_4: +1 t_x_{4}_{0} +1 t_x_{4}_{15} +1 t_x_{4}_{30} +1 t_x_{4}_{45} +1 t_x_{4}_{60} +1 t_x_{4}_{75} +1 t_x_{4}_{90}
+  +1 t_x_{4}_{105} +1 t_x_{4}_{120} = +1
+ F_2: +1 t_x_{2}_{0} +1 t_x_{2}_{15} +1 t_x_{2}_{30} +1 t_x_{2}_{45} +1 t_x_{2}_{60} +1 t_x_{2}_{75} +1 t_x_{2}_{90}
+  +1 t_x_{2}_{105} +1 t_x_{2}_{120} = +1
+ slot19: +1 t_x_{1}_{0} +1 t_x_{3}_{0} +1 t_x_{5}_{0} <= +1
+ slot20: +1 t_x_{1}_{15} +1 t_x_{3}_{15} +1 t_x_{5}_{15} <= +1
+ slot21: +1 t_x_{1}_{30} +1 t_x_{3}_{30} +1 t_x_{5}_{30} <= +1
+ slot22: +1 t_x_{1}_{45} +1 t_x_{3}_{45} +1 t_x_{5}_{45} <= +1
+ slot23: +1 t_x_{1}_{60} +1 t_x_{3}_{60} +1 t_x_{5}_{60} <= +1
+ slot24: +1 t_x_{1}_{75} +1 t_x_{3}_{75} +1 t_x_{5}_{75} <= +1
+ F_1: +1 t_x_{1}_{0} +1 t_x_{1}_{15} +1 t_x_{1}_{30} +1 t_x_{1}_{45} +1 t_x_{1}_{60} +1 t_x_{1}_{75} +1 t_x_{1}_{90}
+  +1 t_x_{1}_{105} +1 t_x_{1}_{120} = +1
+ F_3: +1 t_x_{3}_{0} +1 t_x_{3}_{15} +1 t_x_{3}_{30} +1 t_x_{3}_{45} +1 t_x_{3}_{60} +1 t_x_{3}_{75} +1 t_x_{3}_{90}
+  +1 t_x_{3}_{105} +1 t_x_{3}_{120} = +1
+ F_5: +1 t_x_{5}_{0} +1 t_x_{5}_{15} +1 t_x_{5}_{30} +1 t_x_{5}_{45} +1 t_x_{5}_{60} +1 t_x_{5}_{75} +1 t_x_{5}_{90}
+  +1 t_x_{5}_{105} +1 t_x_{5}_{120} = +1
+ slot28: +1 t_x_{4}_{0} +1 t_x_{5}_{0} +1 t_x_{6}_{0} <= +1
+ slot29: +1 t_x_{4}_{15} +1 t_x_{5}_{15} +1 t_x_{6}_{15} <= +1
+ slot30: +1 t_x_{4}_{30} +1 t_x_{5}_{30} +1 t_x_{6}_{30} <= +1
+ slot31: +1 t_x_{4}_{45} +1 t_x_{5}_{45} +1 t_x_{6}_{45} <= +1
+ slot32: +1 t_x_{4}_{60} +1 t_x_{5}_{60} +1 t_x_{6}_{60} <= +1
+ slot33: +1 t_x_{4}_{75} +1 t_x_{5}_{75} +1 t_x_{6}_{75} <= +1
+ slot35: +1 t_x_{4}_{105} +1 t_x_{5}_{105} +1 t_x_{6}_{105} <= +1
+ cf1_0: -1 t_x_{2}_{60} +1 t_x_{3}_{0} +1 t_x_{3}_{15} +1 t_x_{3}_{30} +1 t_x_{3}_{45} +1 t_x_{3}_{75}
+  >= +0
+ cf1_1: -1 t_x_{1}_{15} -1 t_x_{3}_{30} -1 t_x_{4}_{15} -1 t_x_{6}_{30} >= -3
+Bounds
+ 0 <= t_x_{6}_{120} <= 0
+ 0 <= t_x_{6}_{105} <= 0
+ 0 <= t_x_{6}_{90} <= 0
+ 0 <= t_x_{6}_{75} <= 1
+ 0 <= t_x_{6}_{60} <= 1
+ 0 <= t_x_{6}_{45} <= 1
+ 0 <= t_x_{6}_{30} <= 1
+ 0 <= t_x_{6}_{15} <= 1
+ 0 <= t_x_{6}_{0} <= 1
+ 0 <= t_x_{5}_{120} <= 0
+ 0 <= t_x_{5}_{105} <= 0
+ 0 <= t_x_{5}_{90} <= 0
+ 0 <= t_x_{5}_{75} <= 1
+ 0 <= t_x_{5}_{60} <= 1
+ 0 <= t_x_{5}_{45} <= 1
+ 0 <= t_x_{5}_{30} <= 1
+ 0 <= t_x_{5}_{15} <= 1
+ 0 <= t_x_{5}_{0} <= 1
+ 0 <= t_x_{4}_{120} <= 0
+ 0 <= t_x_{4}_{105} <= 0
+ 0 <= t_x_{4}_{90} <= 0
+ 0 <= t_x_{4}_{75} <= 1
+ 0 <= t_x_{4}_{60} <= 1
+ 0 <= t_x_{4}_{45} <= 1
+ 0 <= t_x_{4}_{30} <= 1
+ 0 <= t_x_{4}_{15} <= 1
+ 0 <= t_x_{4}_{0} <= 1
+ 0 <= t_x_{3}_{105} <= 0
+ 0 <= t_x_{3}_{90} <= 0
+ 0 <= t_x_{3}_{75} <= 1
+ 0 <= t_x_{3}_{60} <= 1
+ 0 <= t_x_{3}_{45} <= 1
+ 0 <= t_x_{3}_{30} <= 1
+ 0 <= t_x_{3}_{15} <= 1
+ 0 <= t_x_{3}_{0} <= 1
+ 0 <= t_x_{2}_{120} <= 0
+ 0 <= t_x_{2}_{105} <= 0
+ 0 <= t_x_{2}_{90} <= 0
+ 0 <= t_x_{2}_{75} <= 1
+ 0 <= t_x_{2}_{60} <= 1
+ 0 <= t_x_{2}_{45} <= 1
+ 0 <= t_x_{2}_{30} <= 1
+ 0 <= t_x_{2}_{15} <= 1
+ 0 <= t_x_{2}_{0} <= 1
+ 0 <= t_x_{1}_{120} <= 0
+ 0 <= t_x_{1}_{105} <= 0
+ 0 <= t_x_{1}_{90} <= 0
+ 0 <= t_x_{1}_{75} <= 0
+ 0 <= t_x_{1}_{60} <= 1
+ 0 <= t_x_{1}_{45} <= 1
+ 0 <= t_x_{1}_{30} <= 1
+ 0 <= t_x_{1}_{15} <= 1
+ 0 <= t_x_{1}_{0} <= 1
+ 0 <= t_x_{3}_{120} <= 0
+Binaries
+ t_x_{6}_{120} t_x_{6}_{105} t_x_{6}_{90} t_x_{6}_{75} t_x_{6}_{60} t_x_{6}_{45} t_x_{6}_{30} t_x_{6}_{15}
+ t_x_{6}_{0} t_x_{5}_{120} t_x_{5}_{105} t_x_{5}_{90} t_x_{5}_{75} t_x_{5}_{60} t_x_{5}_{45} t_x_{5}_{30}
+ t_x_{5}_{15} t_x_{5}_{0} t_x_{4}_{120} t_x_{4}_{105} t_x_{4}_{90} t_x_{4}_{75} t_x_{4}_{60} t_x_{4}_{45}
+ t_x_{4}_{30} t_x_{4}_{15} t_x_{4}_{0}
+End