/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	/*                                                                           */
	/*                  This file is part of the program and library             */
	/*         SCIP --- Solving Constraint Integer Programs                      */
	/*                                                                           */
	/*    Copyright (C) 2002-2022 Konrad-Zuse-Zentrum                            */
	/*                            fuer Informationstechnik Berlin                */
	/*                                                                           */
	/*  SCIP is distributed under the terms of the ZIB Academic License.         */
	/*                                                                           */
	/*  You should have received a copy of the ZIB Academic License              */
	/*  along with SCIP; see the file COPYING. If not visit scipopt.org.         */
	/*                                                                           */
	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	
	/**@file   var.c
	 * @ingroup OTHER_CFILES
	 * @brief  methods for problem variables
	 * @author Tobias Achterberg
	 * @author Timo Berthold
	 * @author Gerald Gamrath
	 * @author Stefan Heinz
	 * @author Marc Pfetsch
	 * @author Michael Winkler
	 * @author Kati Wolter
	 * @author Stefan Vigerske
	 *
	 * @todo Possibly implement the access of bounds of multi-aggregated variables by accessing the
	 * corresponding linear constraint if it exists. This seems to require some work, since the linear
	 * constraint has to be stored. Moreover, it has even to be created in case the original constraint
	 * was deleted after multi-aggregation, but the bounds of the multi-aggregated variable should be
	 * changed. This has to be done with care in order to not loose the performance gains of
	 * multi-aggregation.
	 */
	
	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
	
	#include "scip/cons.h"
	#include "scip/event.h"
	#include "scip/history.h"
	#include "scip/implics.h"
	#include "scip/lp.h"
	#include "scip/primal.h"
	#include "scip/prob.h"
	#include "scip/pub_cons.h"
	#include "scip/pub_history.h"
	#include "scip/pub_implics.h"
	#include "scip/pub_lp.h"
	#include "scip/pub_message.h"
	#include "scip/pub_misc.h"
	#include "scip/pub_misc_sort.h"
	#include "scip/pub_prop.h"
	#include "scip/pub_var.h"
	#include "scip/relax.h"
	#include "scip/set.h"
	#include "scip/sol.h"
	#include "scip/stat.h"
	#include "scip/struct_event.h"
	#include "scip/struct_lp.h"
	#include "scip/struct_prob.h"
	#include "scip/struct_set.h"
	#include "scip/struct_stat.h"
	#include "scip/struct_var.h"
	#include "scip/tree.h"
	#include "scip/var.h"
	#include <string.h>
	
	#define MAXIMPLSCLOSURE 100  /**< maximal number of descendants of implied variable for building closure
	                              *   in implication graph */
	#define MAXABSVBCOEF    1e+5 /**< maximal absolute coefficient in variable bounds added due to implications */
	
	
	/*
	 * Debugging variable release and capture
	 *
	 * Define DEBUGUSES_VARNAME to the name of the variable for which to print
	 * a backtrace when it is captured and released.
	 * Optionally define DEBUGUSES_PROBNAME to the name of a SCIP problem to consider.
	 * Have DEBUGUSES_NOADDR2LINE defined if you do not have addr2line installed on your system.
	 */
	/* #define DEBUGUSES_VARNAME "t_t_b7" */
	/* #define DEBUGUSES_PROBNAME "t_st_e35_rens" */
	/* #define DEBUGUSES_NOADDR2LINE */
	
	#ifdef DEBUGUSES_VARNAME
	#include <execinfo.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include "scip/struct_scip.h"
	
	/** obtains a backtrace and prints it to stdout. */
	static
	void print_backtrace(void)
	{
	   void* array[10];
	   char** strings;
	   int size;
	   int i;
	
	   size = backtrace(array, 10);
	   strings = backtrace_symbols(array, size);
	   if( strings == NULL )
	      return;
	
	   /* skip first entry, which is the print_backtrace function */
	   for( i = 1; i < size; ++i )
	   {
	      /* if string is something like
	       *  /path/to/scip/bin/../lib/shared/libscip-7.0.1.3.linux.x86_64.gnu.dbg.so(+0x2675dd3)
	       * (that is, no function name because it is a inlined function), then call
	       * addr2line -e <libname> <addr> to get func and code line
	       * dladdr() may be an alternative
	       */
	      char* openpar;
	      char* closepar = NULL;
	#ifndef DEBUGUSES_NOADDR2LINE
	      openpar = strchr(strings[i], '(');
	      if( openpar != NULL && openpar[1] == '+' )
	         closepar = strchr(openpar+2, ')');
	#endif
	      if( closepar != NULL )
	      {
	         char cmd[SCIP_MAXSTRLEN];
	         (void) SCIPsnprintf(cmd, SCIP_MAXSTRLEN, "addr2line -f -p -e \"%.*s\" %.*s", openpar - strings[i], strings[i], closepar-openpar-1, openpar+1);
	         printf("  ");
	         fflush(stdout);
	         system(cmd);
	      }
	      else
	         printf("  %s\n", strings[i]);
	    }
	
	  free(strings);
	}
	#endif
	
	/*
	 * hole, holelist, and domain methods
	 */
	
	/** creates a new holelist element */
	static
	SCIP_RETCODE holelistCreate(
	   SCIP_HOLELIST**       holelist,           /**< pointer to holelist to create */
	   BMS_BLKMEM*           blkmem,             /**< block memory for target holelist */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_Real             left,               /**< left bound of open interval in new hole */
	   SCIP_Real             right               /**< right bound of open interval in new hole */
	   )
	{
	   assert(holelist != NULL);
	   assert(blkmem != NULL);
	   assert(SCIPsetIsLT(set, left, right));
	
	   SCIPsetDebugMsg(set, "create hole list element (%.15g,%.15g) in blkmem %p\n", left, right, (void*)blkmem);
	
	   SCIP_ALLOC( BMSallocBlockMemory(blkmem, holelist) );
	   (*holelist)->hole.left = left;
	   (*holelist)->hole.right = right;
	   (*holelist)->next = NULL;
	
	   return SCIP_OKAY;
	}
	
	/** frees all elements in the holelist */
	static
	void holelistFree(
	   SCIP_HOLELIST**       holelist,           /**< pointer to holelist to free */
	   BMS_BLKMEM*           blkmem              /**< block memory for target holelist */
	   )
	{
	   assert(holelist != NULL);
	   assert(blkmem != NULL);
	
	   while( *holelist != NULL )
	   {
	      SCIP_HOLELIST* next;
	
	      SCIPdebugMessage("free hole list element (%.15g,%.15g) in blkmem %p\n", 
	         (*holelist)->hole.left, (*holelist)->hole.right, (void*)blkmem);
	
	      next = (*holelist)->next;
	      BMSfreeBlockMemory(blkmem, holelist);
	      assert(*holelist == NULL);
	
	      *holelist = next;
	   }
	   assert(*holelist == NULL);
	}
	
	/** duplicates a list of holes */
	static
	SCIP_RETCODE holelistDuplicate(
	   SCIP_HOLELIST**       target,             /**< pointer to target holelist */
	   BMS_BLKMEM*           blkmem,             /**< block memory for target holelist */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_HOLELIST*        source              /**< holelist to duplicate */
	   )
	{
	   assert(target != NULL);
	
	   while( source != NULL )
	   {
	      assert(source->next == NULL || SCIPsetIsGE(set, source->next->hole.left, source->hole.right));
	      SCIP_CALL( holelistCreate(target, blkmem, set, source->hole.left, source->hole.right) );
	      source = source->next;
	      target = &(*target)->next;
	   }
	
	   return SCIP_OKAY;
	}
	
	/** adds a hole to the domain */
	static
	SCIP_RETCODE domAddHole(
	   SCIP_DOM*             dom,                /**< domain to add hole to */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_Real             left,               /**< left bound of open interval in new hole */
	   SCIP_Real             right,              /**< right bound of open interval in new hole */
	   SCIP_Bool*            added               /**< pointer to store whether the hole was added (variable didn't had that hole before), or NULL */
	   )
	{
	   SCIP_HOLELIST** insertpos;
	   SCIP_HOLELIST* next;
	
	   assert(dom != NULL);
	   assert(added != NULL);
	
	   /* search for the position of the new hole */
	   insertpos = &dom->holelist;
	   while( *insertpos != NULL && (*insertpos)->hole.left < left )
	      insertpos = &(*insertpos)->next;
	
	   /* check if new hole already exists in the hole list or is a sub hole of an existing one */
	   if( *insertpos != NULL && (*insertpos)->hole.left == left && (*insertpos)->hole.right >= right )  /*lint !e777 */
	   {
	      SCIPsetDebugMsg(set, "new hole (%.15g,%.15g) is redundant through known hole (%.15g,%.15g)\n",
	         left, right, (*insertpos)->hole.left, (*insertpos)->hole.right);
	      *added = FALSE;
	      return SCIP_OKAY;
	   }
	
	   /* add hole */
	   *added = TRUE;
	
	   next = *insertpos;
	   SCIP_CALL( holelistCreate(insertpos, blkmem, set, left, right) );
	   (*insertpos)->next = next;
	
	   return SCIP_OKAY;
	}
	
	/** merges overlapping holes into single holes, computes and moves lower and upper bound, respectively */
	/**@todo  the domMerge() method is currently called if a lower or an upper bound locally or globally changed; this could
	 *        be more efficient if performed with the knowledge if it was a lower or an upper bound which triggered this
	 *        merge */
	static
	void domMerge(
	   SCIP_DOM*             dom,                /**< domain to merge */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_Real*            newlb,              /**< pointer to store new lower bound */
	   SCIP_Real*            newub               /**< pointer to store new upper bound */
	   )
	{
	   SCIP_HOLELIST** holelistptr;
	   SCIP_HOLELIST** lastnextptr;
	   SCIP_Real* lastrightptr;
	
	   assert(dom != NULL);
	   assert(SCIPsetIsLE(set, dom->lb, dom->ub));
	
	#ifndef NDEBUG
	   {
	      /* check if the holelist is sorted w.r.t. to the left interval bounds */
	      SCIP_Real lastleft;
	
	      holelistptr = &dom->holelist;
	
	      lastleft = -SCIPsetInfinity(set);
	
	      while( *holelistptr != NULL )
	      {
	         if( (*holelistptr)->next != NULL )
	         {
	            assert( SCIPsetIsLE(set, lastleft, (*holelistptr)->hole.left) );
	            lastleft = (*holelistptr)->hole.left;
	         }
	
	         holelistptr = &(*holelistptr)->next;
	      }   
	   }
	#endif
	
	   SCIPsetDebugMsg(set, "merge hole list\n");
	
	   holelistptr = &dom->holelist;
	   lastrightptr = &dom->lb;  /* lower bound is the right bound of the hole (-infinity,lb) */
	   lastnextptr = holelistptr;
	
	   while( *holelistptr != NULL )
	   {
	      SCIPsetDebugMsg(set, "check hole (%.15g,%.15g) last right interval was <%.15g>\n", (*holelistptr)->hole.left, (*holelistptr)->hole.right, *lastrightptr);
	
	      /* check that the hole is not empty */
	      assert(SCIPsetIsLT(set, (*holelistptr)->hole.left, (*holelistptr)->hole.right));
	
	      if( SCIPsetIsGE(set, (*holelistptr)->hole.left, dom->ub) )
	      {
	         /* the remaining holes start behind the upper bound: remove them */
	         SCIPsetDebugMsg(set, "remove remaining hole since upper bound <%.15g> is less then the left hand side of the current hole\n", dom->ub);
	         holelistFree(holelistptr, blkmem);
	         assert(*holelistptr == NULL);
	
	         /* unlink this hole from the previous hole */
	         *lastnextptr = NULL;
	      }
	      else if( SCIPsetIsGT(set, (*holelistptr)->hole.right, dom->ub) )
	      {
	         /* the hole overlaps the upper bound: decrease upper bound, remove this hole and all remaining holes */
	         SCIPsetDebugMsg(set, "upper bound <%.15g> lays in current hole; store new upper bound and remove this and all remaining holes\n", dom->ub);
	
	         assert(SCIPsetIsLT(set, (*holelistptr)->hole.left, dom->ub));
	
	         /* adjust upper bound */
	         dom->ub = (*holelistptr)->hole.left;
	
	         if(newub != NULL )
	            *newub = (*holelistptr)->hole.left;
	
	         /* remove remaining hole list */
	         holelistFree(holelistptr, blkmem);
	         assert(*holelistptr == NULL);
	
	         /* unlink this hole from the previous hole */
	         *lastnextptr = NULL;
	      }
	      else if( SCIPsetIsGT(set, *lastrightptr, (*holelistptr)->hole.left) )
	      {
	         /* the right bound of the last hole is greater than the left bound of this hole: increase the right bound of
	          * the last hole, delete this hole */
	         SCIP_HOLELIST* nextholelist;
	
	         if( SCIPsetIsEQ(set, *lastrightptr, dom->lb ) )
	         {
	            /* the reason for the overlap results from the lower bound hole (-infinity,lb); therefore, we can increase
	             * the lower bound */
	            SCIPsetDebugMsg(set, "lower bound <%.15g> lays in current hole; store new lower bound and remove hole\n", dom->lb);
	            *lastrightptr = MAX(*lastrightptr, (*holelistptr)->hole.right);
	
	            /* adjust lower bound */
	            dom->lb = *lastrightptr;
	
	            if(newlb != NULL )
	               *newlb = *lastrightptr;
	         }
	         else
	         {
	            SCIPsetDebugMsg(set, "current hole overlaps with the previous one (...,%.15g); merge to (...,%.15g)\n",
	               *lastrightptr, MAX(*lastrightptr, (*holelistptr)->hole.right) );
	            *lastrightptr = MAX(*lastrightptr, (*holelistptr)->hole.right);
	         }
	         nextholelist = (*holelistptr)->next;
	         (*holelistptr)->next = NULL;
	         holelistFree(holelistptr, blkmem);
	
	         /* connect the linked list after removing the hole */
	         *lastnextptr = nextholelist;
	
	         /* get next hole */
	         *holelistptr = nextholelist;
	      }
	      else
	      {
	         /* the holes do not overlap: update lastholelist and lastrightptr */
	         lastrightptr = &(*holelistptr)->hole.right;
	         lastnextptr = &(*holelistptr)->next;
	
	         /* get next hole */
	         holelistptr = &(*holelistptr)->next;
	      }
	   }
	
	#ifndef NDEBUG
	   {
	      /* check that holes are merged */
	      SCIP_Real lastright;
	
	      lastright = dom->lb; /* lower bound is the right bound of the hole (-infinity,lb) */
	      holelistptr = &dom->holelist;
	
	      while( *holelistptr != NULL )
	      {
	         /* check the the last right interval is smaller or equal to the current left interval (none overlapping) */
	         assert( SCIPsetIsLE(set, lastright, (*holelistptr)->hole.left) );
	
	         /* check the hole property (check that the hole is not empty) */
	         assert( SCIPsetIsLT(set, (*holelistptr)->hole.left, (*holelistptr)->hole.right) );
	         lastright = (*holelistptr)->hole.right;
	
	         /* get next hole */
	         holelistptr = &(*holelistptr)->next;
	      }   
	
	      /* check the the last right interval is smaller or equal to the upper bound (none overlapping) */     
	      assert( SCIPsetIsLE(set, lastright, dom->ub) );
	   }
	#endif
	}
	
	/*
	 * domain change methods
	 */
	
	/** ensures, that bound change info array for lower bound changes can store at least num entries */
	static
	SCIP_RETCODE varEnsureLbchginfosSize(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   int                   num                 /**< minimum number of entries to store */
	   )
	{
	   assert(var != NULL);
	   assert(var->nlbchginfos <= var->lbchginfossize);
	   assert(SCIPvarIsTransformed(var));
	
	   if( num > var->lbchginfossize )
	   {
	      int newsize;
	
	      newsize = SCIPsetCalcMemGrowSize(set, num);
	      SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &var->lbchginfos, var->lbchginfossize, newsize) );
	      var->lbchginfossize = newsize;
	   }
	   assert(num <= var->lbchginfossize);
	
	   return SCIP_OKAY;
	}
	
	/** ensures, that bound change info array for upper bound changes can store at least num entries */
	static
	SCIP_RETCODE varEnsureUbchginfosSize(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   int                   num                 /**< minimum number of entries to store */
	   )
	{
	   assert(var != NULL);
	   assert(var->nubchginfos <= var->ubchginfossize);
	   assert(SCIPvarIsTransformed(var));
	
	   if( num > var->ubchginfossize )
	   {
	      int newsize;
	
	      newsize = SCIPsetCalcMemGrowSize(set, num);
	      SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &var->ubchginfos, var->ubchginfossize, newsize) );
	      var->ubchginfossize = newsize;
	   }
	   assert(num <= var->ubchginfossize);
	
	   return SCIP_OKAY;
	}
	
	/** adds domain change info to the variable's lower bound change info array */
	static
	SCIP_RETCODE varAddLbchginfo(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_Real             oldbound,           /**< old value for bound */
	   SCIP_Real             newbound,           /**< new value for bound */
	   int                   depth,              /**< depth in the tree, where the bound change takes place */
	   int                   pos,                /**< position of the bound change in its bound change array */
	   SCIP_VAR*             infervar,           /**< variable that was changed (parent of var, or var itself) */
	   SCIP_CONS*            infercons,          /**< constraint that infered this bound change, or NULL */
	   SCIP_PROP*            inferprop,          /**< propagator that deduced the bound change, or NULL */
	   int                   inferinfo,          /**< user information for inference to help resolving the conflict */
	   SCIP_BOUNDTYPE        inferboundtype,     /**< type of bound for inference var: lower or upper bound */
	   SCIP_BOUNDCHGTYPE     boundchgtype        /**< bound change type: branching decision or infered bound change */
	   )
	{
	   assert(var != NULL);
	   assert(SCIPsetIsLT(set, oldbound, newbound));
	   assert(SCIPvarGetType(var) == SCIP_VARTYPE_CONTINUOUS || SCIPsetIsFeasIntegral(set, oldbound));
	   assert(SCIPvarGetType(var) == SCIP_VARTYPE_CONTINUOUS || SCIPsetIsFeasIntegral(set, newbound));
	   assert(!SCIPvarIsBinary(var) || SCIPsetIsEQ(set, oldbound, 0.0));
	   assert(!SCIPvarIsBinary(var) || SCIPsetIsEQ(set, newbound, 1.0));
	   assert(boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING || infervar != NULL);
	   assert((boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) == (infercons != NULL));
	   assert(boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER || inferprop == NULL);
	
	   SCIPsetDebugMsg(set, "adding lower bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n",
	      SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, depth, pos, infercons != NULL ? "cons" : "prop",
	      infercons != NULL ? SCIPconsGetName(infercons) : (inferprop != NULL ? SCIPpropGetName(inferprop) : "-"), inferinfo,
	      oldbound, newbound);
	
	   SCIP_CALL( varEnsureLbchginfosSize(var, blkmem, set, var->nlbchginfos+1) );
	   var->lbchginfos[var->nlbchginfos].oldbound = oldbound;
	   var->lbchginfos[var->nlbchginfos].newbound = newbound;
	   var->lbchginfos[var->nlbchginfos].var = var;
	   var->lbchginfos[var->nlbchginfos].bdchgidx.depth = depth;
	   var->lbchginfos[var->nlbchginfos].bdchgidx.pos = pos;
	   var->lbchginfos[var->nlbchginfos].pos = var->nlbchginfos; /*lint !e732*/
	   var->lbchginfos[var->nlbchginfos].boundchgtype = boundchgtype; /*lint !e641*/
	   var->lbchginfos[var->nlbchginfos].boundtype = SCIP_BOUNDTYPE_LOWER; /*lint !e641*/
	   var->lbchginfos[var->nlbchginfos].redundant = FALSE;
	   var->lbchginfos[var->nlbchginfos].inferboundtype = inferboundtype; /*lint !e641*/
	   var->lbchginfos[var->nlbchginfos].inferencedata.var = infervar;
	   var->lbchginfos[var->nlbchginfos].inferencedata.info = inferinfo;
	
	   /**@note The "pos" data member of the bound change info has a size of 27 bits */
	   assert(var->nlbchginfos < 1 << 27);
	
	   switch( boundchgtype )
	   {
	   case SCIP_BOUNDCHGTYPE_BRANCHING:
	      break;
	   case SCIP_BOUNDCHGTYPE_CONSINFER:
	      assert(infercons != NULL);
	      var->lbchginfos[var->nlbchginfos].inferencedata.reason.cons = infercons;
	      break;
	   case SCIP_BOUNDCHGTYPE_PROPINFER:
	      var->lbchginfos[var->nlbchginfos].inferencedata.reason.prop = inferprop;
	      break;
	   default:
	      SCIPerrorMessage("invalid bound change type %d\n", boundchgtype);
	      return SCIP_INVALIDDATA;
	   }
	
	   var->nlbchginfos++;
	
	   assert(var->nlbchginfos < 2
	      || SCIPbdchgidxIsEarlier(&var->lbchginfos[var->nlbchginfos-2].bdchgidx,
	         &var->lbchginfos[var->nlbchginfos-1].bdchgidx));
	
	   return SCIP_OKAY;
	}
	
	/** adds domain change info to the variable's upper bound change info array */
	static
	SCIP_RETCODE varAddUbchginfo(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_Real             oldbound,           /**< old value for bound */
	   SCIP_Real             newbound,           /**< new value for bound */
	   int                   depth,              /**< depth in the tree, where the bound change takes place */
	   int                   pos,                /**< position of the bound change in its bound change array */
	   SCIP_VAR*             infervar,           /**< variable that was changed (parent of var, or var itself) */
	   SCIP_CONS*            infercons,          /**< constraint that infered this bound change, or NULL */
	   SCIP_PROP*            inferprop,          /**< propagator that deduced the bound change, or NULL */
	   int                   inferinfo,          /**< user information for inference to help resolving the conflict */
	   SCIP_BOUNDTYPE        inferboundtype,     /**< type of bound for inference var: lower or upper bound */
	   SCIP_BOUNDCHGTYPE     boundchgtype        /**< bound change type: branching decision or infered bound change */
	   )
	{
	   assert(var != NULL);
	   assert(SCIPsetIsGT(set, oldbound, newbound));
	   assert(SCIPvarGetType(var) == SCIP_VARTYPE_CONTINUOUS || SCIPsetIsFeasIntegral(set, oldbound));
	   assert(SCIPvarGetType(var) == SCIP_VARTYPE_CONTINUOUS || SCIPsetIsFeasIntegral(set, newbound));
	   assert(!SCIPvarIsBinary(var) || SCIPsetIsEQ(set, oldbound, 1.0));
	   assert(!SCIPvarIsBinary(var) || SCIPsetIsEQ(set, newbound, 0.0));
	   assert(boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING || infervar != NULL);
	   assert((boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) == (infercons != NULL));
	   assert(boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER || inferprop == NULL);
	
	   SCIPsetDebugMsg(set, "adding upper bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n",
	      SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, depth, pos, infercons != NULL ? "cons" : "prop",
	      infercons != NULL ? SCIPconsGetName(infercons) : (inferprop != NULL ? SCIPpropGetName(inferprop) : "-"), inferinfo,
	      oldbound, newbound);
	
	   SCIP_CALL( varEnsureUbchginfosSize(var, blkmem, set, var->nubchginfos+1) );
	   var->ubchginfos[var->nubchginfos].oldbound = oldbound;
	   var->ubchginfos[var->nubchginfos].newbound = newbound;
	   var->ubchginfos[var->nubchginfos].var = var;
	   var->ubchginfos[var->nubchginfos].bdchgidx.depth = depth;
	   var->ubchginfos[var->nubchginfos].bdchgidx.pos = pos;
	   var->ubchginfos[var->nubchginfos].pos = var->nubchginfos; /*lint !e732*/
	   var->ubchginfos[var->nubchginfos].boundchgtype = boundchgtype; /*lint !e641*/
	   var->ubchginfos[var->nubchginfos].boundtype = SCIP_BOUNDTYPE_UPPER; /*lint !e641*/
	   var->ubchginfos[var->nubchginfos].redundant = FALSE;
	   var->ubchginfos[var->nubchginfos].inferboundtype = inferboundtype; /*lint !e641*/
	   var->ubchginfos[var->nubchginfos].inferencedata.var = infervar;
	   var->ubchginfos[var->nubchginfos].inferencedata.info = inferinfo;
	
	   /**@note The "pos" data member of the bound change info has a size of 27 bits */
	   assert(var->nubchginfos < 1 << 27);
	
	   switch( boundchgtype )
	   {
	   case SCIP_BOUNDCHGTYPE_BRANCHING:
	      break;
	   case SCIP_BOUNDCHGTYPE_CONSINFER:
	      assert(infercons != NULL);
	      var->ubchginfos[var->nubchginfos].inferencedata.reason.cons = infercons;
	      break;
	   case SCIP_BOUNDCHGTYPE_PROPINFER:
	      var->ubchginfos[var->nubchginfos].inferencedata.reason.prop = inferprop;
	      break;
	   default:
	      SCIPerrorMessage("invalid bound change type %d\n", boundchgtype);
	      return SCIP_INVALIDDATA;
	   }
	
	   var->nubchginfos++;
	
	   assert(var->nubchginfos < 2
	      || SCIPbdchgidxIsEarlier(&var->ubchginfos[var->nubchginfos-2].bdchgidx,
	         &var->ubchginfos[var->nubchginfos-1].bdchgidx));
	
	   return SCIP_OKAY;
	}
	
	/** applies single bound change */
	SCIP_RETCODE SCIPboundchgApply(
	   SCIP_BOUNDCHG*        boundchg,           /**< bound change to apply */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   int                   depth,              /**< depth in the tree, where the bound change takes place */
	   int                   pos,                /**< position of the bound change in its bound change array */
	   SCIP_Bool*            cutoff              /**< pointer to store whether an infeasible bound change was detected */
	   )
	{
	   SCIP_VAR* var;
	
	   assert(boundchg != NULL);
	   assert(stat != NULL);
	   assert(depth > 0);
	   assert(pos >= 0);
	   assert(cutoff != NULL);
	
	   *cutoff = FALSE;
	
	   /* ignore redundant bound changes */
	   if( boundchg->redundant )
	      return SCIP_OKAY;
	
	   var = boundchg->var;
	   assert(var != NULL);
	   assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE || SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
	   assert(!SCIPvarIsIntegral(var) || SCIPsetIsFeasIntegral(set, boundchg->newbound));
	
	   /* apply bound change */
	   switch( boundchg->boundtype )
	   {
	   case SCIP_BOUNDTYPE_LOWER:
	      /* check, if the bound change is still active (could be replaced by inference due to repropagation of higher node) */
	      if( SCIPsetIsGT(set, boundchg->newbound, var->locdom.lb) )
	      {
	         if( SCIPsetIsLE(set, boundchg->newbound, var->locdom.ub) )
	         {
	            /* add the bound change info to the variable's bound change info array */
	            switch( boundchg->boundchgtype )
	            {
	            case SCIP_BOUNDCHGTYPE_BRANCHING:
	               SCIPsetDebugMsg(set, " -> branching: new lower bound of <%s>[%g,%g]: %g\n",
	                  SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	               SCIP_CALL( varAddLbchginfo(var, blkmem, set, var->locdom.lb, boundchg->newbound, depth, pos,
	                     NULL, NULL, NULL, 0, SCIP_BOUNDTYPE_LOWER, SCIP_BOUNDCHGTYPE_BRANCHING) );
	               stat->lastbranchvar = var;
	               stat->lastbranchdir = SCIP_BRANCHDIR_UPWARDS;
	               stat->lastbranchvalue = boundchg->newbound;
	               break;
	
	            case SCIP_BOUNDCHGTYPE_CONSINFER:
	               assert(boundchg->data.inferencedata.reason.cons != NULL);
	               SCIPsetDebugMsg(set, " -> constraint <%s> inference: new lower bound of <%s>[%g,%g]: %g\n",
	                  SCIPconsGetName(boundchg->data.inferencedata.reason.cons),
	                  SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	               SCIP_CALL( varAddLbchginfo(var, blkmem, set, var->locdom.lb, boundchg->newbound, depth, pos,
	                     boundchg->data.inferencedata.var, boundchg->data.inferencedata.reason.cons, NULL,
	                     boundchg->data.inferencedata.info,
	                     (SCIP_BOUNDTYPE)(boundchg->inferboundtype), SCIP_BOUNDCHGTYPE_CONSINFER) );
	               break;
	
	            case SCIP_BOUNDCHGTYPE_PROPINFER:
	               SCIPsetDebugMsg(set, " -> propagator <%s> inference: new lower bound of <%s>[%g,%g]: %g\n",
	                  boundchg->data.inferencedata.reason.prop != NULL
	                  ? SCIPpropGetName(boundchg->data.inferencedata.reason.prop) : "-",
	                  SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	               SCIP_CALL( varAddLbchginfo(var, blkmem, set, var->locdom.lb, boundchg->newbound, depth, pos,
	                     boundchg->data.inferencedata.var, NULL, boundchg->data.inferencedata.reason.prop,
	                     boundchg->data.inferencedata.info,
	                     (SCIP_BOUNDTYPE)(boundchg->inferboundtype), SCIP_BOUNDCHGTYPE_PROPINFER) );
	               break;
	
	            default:
	               SCIPerrorMessage("invalid bound change type %d\n", boundchg->boundchgtype);
	               return SCIP_INVALIDDATA;
	            }
	
	            /* change local bound of variable */
	            SCIP_CALL( SCIPvarChgLbLocal(var, blkmem, set, stat, lp, branchcand, eventqueue, boundchg->newbound) );
	         }
	         else
	         {
	            SCIPsetDebugMsg(set, " -> cutoff: new lower bound of <%s>[%g,%g]: %g\n",
	               SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	            *cutoff = TRUE;
	            boundchg->redundant = TRUE; /* bound change has not entered the lbchginfos array of the variable! */
	         }
	      }
	      else
	      {
	         /* mark bound change to be inactive */
	         SCIPsetDebugMsg(set, " -> inactive %s: new lower bound of <%s>[%g,%g]: %g\n",
	            (SCIP_BOUNDCHGTYPE)boundchg->boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING ? "branching" : "inference",
	            SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	         boundchg->redundant = TRUE;
	      }
	      break;
	
	   case SCIP_BOUNDTYPE_UPPER:
	      /* check, if the bound change is still active (could be replaced by inference due to repropagation of higher node) */
	      if( SCIPsetIsLT(set, boundchg->newbound, var->locdom.ub) )
	      {
	         if( SCIPsetIsGE(set, boundchg->newbound, var->locdom.lb) )
	         {
	            /* add the bound change info to the variable's bound change info array */
	            switch( boundchg->boundchgtype )
	            {
	            case SCIP_BOUNDCHGTYPE_BRANCHING:
	               SCIPsetDebugMsg(set, " -> branching: new upper bound of <%s>[%g,%g]: %g\n",
	                  SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	               SCIP_CALL( varAddUbchginfo(var, blkmem, set, var->locdom.ub, boundchg->newbound, depth, pos,
	                     NULL, NULL, NULL, 0, SCIP_BOUNDTYPE_UPPER, SCIP_BOUNDCHGTYPE_BRANCHING) );
	               stat->lastbranchvar = var;
	               stat->lastbranchdir = SCIP_BRANCHDIR_DOWNWARDS;
	               stat->lastbranchvalue = boundchg->newbound;
	               break;
	
	            case SCIP_BOUNDCHGTYPE_CONSINFER:
	               assert(boundchg->data.inferencedata.reason.cons != NULL);
	               SCIPsetDebugMsg(set, " -> constraint <%s> inference: new upper bound of <%s>[%g,%g]: %g\n",
	                  SCIPconsGetName(boundchg->data.inferencedata.reason.cons),
	                  SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	               SCIP_CALL( varAddUbchginfo(var, blkmem, set, var->locdom.ub, boundchg->newbound, depth, pos,
	                     boundchg->data.inferencedata.var, boundchg->data.inferencedata.reason.cons, NULL,
	                     boundchg->data.inferencedata.info,
	                     (SCIP_BOUNDTYPE)(boundchg->inferboundtype), SCIP_BOUNDCHGTYPE_CONSINFER) );
	               break;
	
	            case SCIP_BOUNDCHGTYPE_PROPINFER:
	               SCIPsetDebugMsg(set, " -> propagator <%s> inference: new upper bound of <%s>[%g,%g]: %g\n",
	                  boundchg->data.inferencedata.reason.prop != NULL
	                  ? SCIPpropGetName(boundchg->data.inferencedata.reason.prop) : "-",
	                  SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	               SCIP_CALL( varAddUbchginfo(var, blkmem, set, var->locdom.ub, boundchg->newbound, depth, pos,
	                     boundchg->data.inferencedata.var, NULL, boundchg->data.inferencedata.reason.prop,
	                     boundchg->data.inferencedata.info,
	                     (SCIP_BOUNDTYPE)(boundchg->inferboundtype), SCIP_BOUNDCHGTYPE_PROPINFER) );
	               break;
	
	            default:
	               SCIPerrorMessage("invalid bound change type %d\n", boundchg->boundchgtype);
	               return SCIP_INVALIDDATA;
	            }
	
	            /* change local bound of variable */
	            SCIP_CALL( SCIPvarChgUbLocal(var, blkmem, set, stat, lp, branchcand, eventqueue, boundchg->newbound) );
	         }
	         else
	         {
	            SCIPsetDebugMsg(set, " -> cutoff: new upper bound of <%s>[%g,%g]: %g\n",
	               SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	            *cutoff = TRUE;
	            boundchg->redundant = TRUE; /* bound change has not entered the ubchginfos array of the variable! */
	         }
	      }
	      else
	      {
	         /* mark bound change to be inactive */
	         SCIPsetDebugMsg(set, " -> inactive %s: new upper bound of <%s>[%g,%g]: %g\n",
	            (SCIP_BOUNDCHGTYPE)boundchg->boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING ? "branching" : "inference",
	            SCIPvarGetName(var), var->locdom.lb, var->locdom.ub, boundchg->newbound);
	         boundchg->redundant = TRUE;
	      }
	      break;
	
	   default:
	      SCIPerrorMessage("unknown bound type\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   /* update the branching and inference history */
	   if( !boundchg->applied && !boundchg->redundant )
	   {
	      assert(var == boundchg->var);
	
	      if( (SCIP_BOUNDCHGTYPE)boundchg->boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING )
	      {
	         SCIP_CALL( SCIPvarIncNBranchings(var, blkmem, set, stat,
	               (SCIP_BOUNDTYPE)boundchg->boundtype == SCIP_BOUNDTYPE_LOWER
	               ? SCIP_BRANCHDIR_UPWARDS : SCIP_BRANCHDIR_DOWNWARDS, boundchg->newbound, depth) );
	      }
	      else if( stat->lastbranchvar != NULL )
	      {
	         /**@todo if last branching variable is unknown, retrieve it from the nodes' boundchg arrays */
	         SCIP_CALL( SCIPvarIncInferenceSum(stat->lastbranchvar, blkmem, set, stat, stat->lastbranchdir, stat->lastbranchvalue, 1.0) );
	      }
	      boundchg->applied = TRUE;
	   }
	
	   return SCIP_OKAY;
	}
	
	/** undoes single bound change */
	SCIP_RETCODE SCIPboundchgUndo(
	   SCIP_BOUNDCHG*        boundchg,           /**< bound change to remove */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTQUEUE*      eventqueue          /**< event queue */
	   )
	{
	   SCIP_VAR* var;
	
	   assert(boundchg != NULL);
	   assert(stat != NULL);
	
	   /* ignore redundant bound changes */
	   if( boundchg->redundant )
	      return SCIP_OKAY;
	
	   var = boundchg->var;
	   assert(var != NULL);
	   assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE || SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
	
	   /* undo bound change: apply the previous bound change of variable */
	   switch( boundchg->boundtype )
	   {
	   case SCIP_BOUNDTYPE_LOWER:
	      var->nlbchginfos--;
	      assert(var->nlbchginfos >= 0);
	      assert(var->lbchginfos != NULL);
	      assert( SCIPsetIsFeasEQ(set, var->lbchginfos[var->nlbchginfos].newbound, var->locdom.lb) ); /*lint !e777*/
	      assert( SCIPsetIsFeasLE(set, boundchg->newbound, var->locdom.lb) ); /* current lb might be larger to intermediate global bound change */
	
	      SCIPsetDebugMsg(set, "removed lower bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
	         SCIPvarGetName(var), var->locdom.lb, var->locdom.ub,
	         var->lbchginfos[var->nlbchginfos].bdchgidx.depth, var->lbchginfos[var->nlbchginfos].bdchgidx.pos,
	         var->lbchginfos[var->nlbchginfos].oldbound, var->lbchginfos[var->nlbchginfos].newbound);
	
	      /* reinstall the previous local bound */
	      SCIP_CALL( SCIPvarChgLbLocal(boundchg->var, blkmem, set, stat, lp, branchcand, eventqueue,
	            var->lbchginfos[var->nlbchginfos].oldbound) );
	
	      /* in case all bound changes are removed the local bound should match the global bound */
	      assert(var->nlbchginfos > 0 || SCIPsetIsFeasEQ(set, var->locdom.lb, var->glbdom.lb));
	
	      break;
	
	   case SCIP_BOUNDTYPE_UPPER:
	      var->nubchginfos--;
	      assert(var->nubchginfos >= 0);
	      assert(var->ubchginfos != NULL);
	      assert( SCIPsetIsFeasEQ(set, var->ubchginfos[var->nubchginfos].newbound, var->locdom.ub) ); /*lint !e777*/
	      assert( SCIPsetIsFeasGE(set, boundchg->newbound, var->locdom.ub) ); /* current ub might be smaller to intermediate global bound change */
	
	      SCIPsetDebugMsg(set, "removed upper bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
	         SCIPvarGetName(var), var->locdom.lb, var->locdom.ub,
	         var->ubchginfos[var->nubchginfos].bdchgidx.depth, var->ubchginfos[var->nubchginfos].bdchgidx.pos,
	         var->ubchginfos[var->nubchginfos].oldbound, var->ubchginfos[var->nubchginfos].newbound);
	
	      /* reinstall the previous local bound */
	      SCIP_CALL( SCIPvarChgUbLocal(boundchg->var, blkmem, set, stat, lp, branchcand, eventqueue,
	            var->ubchginfos[var->nubchginfos].oldbound) );
	
	      /* in case all bound changes are removed the local bound should match the global bound */
	      assert(var->nubchginfos > 0 || SCIPsetIsFeasEQ(set, var->locdom.ub, var->glbdom.ub));
	
	      break;
	
	   default:
	      SCIPerrorMessage("unknown bound type\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   /* update last branching variable */
	   if( (SCIP_BOUNDCHGTYPE)boundchg->boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING )
	   {
	      stat->lastbranchvar = NULL;
	      stat->lastbranchvalue = SCIP_UNKNOWN;
	   }
	
	   return SCIP_OKAY;
	}
	
	/** applies single bound change to the global problem by changing the global bound of the corresponding variable */
	static
	SCIP_RETCODE boundchgApplyGlobal(
	   SCIP_BOUNDCHG*        boundchg,           /**< bound change to apply */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
	   SCIP_Bool*            cutoff              /**< pointer to store whether an infeasible bound change was detected */
	   )
	{
	   SCIP_VAR* var;
	   SCIP_Real newbound;
	   SCIP_BOUNDTYPE boundtype;
	
	   assert(boundchg != NULL);
	   assert(cutoff != NULL);
	
	   *cutoff = FALSE;
	
	   /* ignore redundant bound changes */
	   if( boundchg->redundant )
	      return SCIP_OKAY;
	
	   var = SCIPboundchgGetVar(boundchg);
	   newbound = SCIPboundchgGetNewbound(boundchg);
	   boundtype = SCIPboundchgGetBoundtype(boundchg);
	
	   /* check if the bound change is redundant which can happen due to a (better) global bound change which was performed
	    * after that bound change was applied
	    *
	    * @note a global bound change is not captured by the redundant member of the bound change data structure
	    */
	   if( (boundtype == SCIP_BOUNDTYPE_LOWER && SCIPsetIsFeasLE(set, newbound, SCIPvarGetLbGlobal(var)))
	      || (boundtype == SCIP_BOUNDTYPE_UPPER && SCIPsetIsFeasGE(set, newbound, SCIPvarGetUbGlobal(var))) )
	   {
	      return SCIP_OKAY;
	   }
	
	   SCIPsetDebugMsg(set, "applying global bound change: <%s>[%g,%g] %s %g\n",
	      SCIPvarGetName(var), SCIPvarGetLbGlobal(var), SCIPvarGetUbGlobal(var),
	      boundtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", newbound);
	
	   /* check for cutoff */
	   if( (boundtype == SCIP_BOUNDTYPE_LOWER && SCIPsetIsFeasGT(set, newbound, SCIPvarGetUbGlobal(var)))
	      || (boundtype == SCIP_BOUNDTYPE_UPPER && SCIPsetIsFeasLT(set, newbound, SCIPvarGetLbGlobal(var))) )
	   {
	      *cutoff = TRUE;
	      return SCIP_OKAY;
	   }
	
	   /* apply bound change */
	   SCIP_CALL( SCIPvarChgBdGlobal(var, blkmem, set, stat, lp, branchcand, eventqueue, cliquetable, newbound, boundtype) );
	
	   return SCIP_OKAY;
	}
	
	/** captures branching and inference data of bound change */
	static
	SCIP_RETCODE boundchgCaptureData(
	   SCIP_BOUNDCHG*        boundchg            /**< bound change to remove */
	   )
	{
	   assert(boundchg != NULL);
	
	   /* capture variable associated with the bound change */
	   assert(boundchg->var != NULL);
	   SCIPvarCapture(boundchg->var);
	
	   switch( boundchg->boundchgtype )
	   {
	   case SCIP_BOUNDCHGTYPE_BRANCHING:
	   case SCIP_BOUNDCHGTYPE_PROPINFER:
	      break;
	
	   case SCIP_BOUNDCHGTYPE_CONSINFER:
	      assert(boundchg->data.inferencedata.var != NULL);
	      assert(boundchg->data.inferencedata.reason.cons != NULL);
	      SCIPconsCapture(boundchg->data.inferencedata.reason.cons);
	      break;
	
	   default:
	      SCIPerrorMessage("invalid bound change type\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   return SCIP_OKAY;
	}
	
	/** releases branching and inference data of bound change */
	static
	SCIP_RETCODE boundchgReleaseData(
	   SCIP_BOUNDCHG*        boundchg,           /**< bound change to remove */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_LP*              lp                  /**< current LP data */
	
	   )
	{
	   assert(boundchg != NULL);
	
	   switch( boundchg->boundchgtype )
	   {
	   case SCIP_BOUNDCHGTYPE_BRANCHING:
	   case SCIP_BOUNDCHGTYPE_PROPINFER:
	      break;
	
	   case SCIP_BOUNDCHGTYPE_CONSINFER:
	      assert(boundchg->data.inferencedata.var != NULL);
	      assert(boundchg->data.inferencedata.reason.cons != NULL);
	      SCIP_CALL( SCIPconsRelease(&boundchg->data.inferencedata.reason.cons, blkmem, set) );
	      break;
	
	   default:
	      SCIPerrorMessage("invalid bound change type\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   /* release variable */
	   assert(boundchg->var != NULL);
	   SCIP_CALL( SCIPvarRelease(&boundchg->var, blkmem, set, eventqueue, lp) );
	
	   return SCIP_OKAY;
	}
	
	/** creates empty domain change data with dynamic arrays */
	static
	SCIP_RETCODE domchgCreate(
	   SCIP_DOMCHG**         domchg,             /**< pointer to domain change data */
	   BMS_BLKMEM*           blkmem              /**< block memory */
	   )
	{
	   assert(domchg != NULL);
	   assert(blkmem != NULL);
	
	   SCIP_ALLOC( BMSallocBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGDYN)) );
	   (*domchg)->domchgdyn.domchgtype = SCIP_DOMCHGTYPE_DYNAMIC; /*lint !e641*/
	   (*domchg)->domchgdyn.nboundchgs = 0;
	   (*domchg)->domchgdyn.boundchgs = NULL;
	   (*domchg)->domchgdyn.nholechgs = 0;
	   (*domchg)->domchgdyn.holechgs = NULL;
	   (*domchg)->domchgdyn.boundchgssize = 0;
	   (*domchg)->domchgdyn.holechgssize = 0;
	
	   return SCIP_OKAY;
	}
	
	/** frees domain change data */
	SCIP_RETCODE SCIPdomchgFree(
	   SCIP_DOMCHG**         domchg,             /**< pointer to domain change */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_LP*              lp                  /**< current LP data */
	   )
	{
	   assert(domchg != NULL);
	   assert(blkmem != NULL);
	
	   if( *domchg != NULL )
	   {
	      int i;
	
	      /* release variables, branching and inference data associated with the bound changes */
	      for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
	      {
	         SCIP_CALL( boundchgReleaseData(&(*domchg)->domchgbound.boundchgs[i], blkmem, set, eventqueue, lp) );
	      }
	
	      /* free memory for bound and hole changes */
	      switch( (*domchg)->domchgdyn.domchgtype )
	      {
	      case SCIP_DOMCHGTYPE_BOUND:
	         BMSfreeBlockMemoryArrayNull(blkmem, &(*domchg)->domchgbound.boundchgs, (*domchg)->domchgbound.nboundchgs);
	         BMSfreeBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGBOUND));
	         break;
	      case SCIP_DOMCHGTYPE_BOTH:
	         BMSfreeBlockMemoryArrayNull(blkmem, &(*domchg)->domchgboth.boundchgs, (*domchg)->domchgboth.nboundchgs);
	         BMSfreeBlockMemoryArrayNull(blkmem, &(*domchg)->domchgboth.holechgs, (*domchg)->domchgboth.nholechgs);
	         BMSfreeBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGBOTH));
	         break;
	      case SCIP_DOMCHGTYPE_DYNAMIC:
	         BMSfreeBlockMemoryArrayNull(blkmem, &(*domchg)->domchgdyn.boundchgs, (*domchg)->domchgdyn.boundchgssize);
	         BMSfreeBlockMemoryArrayNull(blkmem, &(*domchg)->domchgdyn.holechgs, (*domchg)->domchgdyn.holechgssize);
	         BMSfreeBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGDYN));
	         break;
	      default:
	         SCIPerrorMessage("invalid domain change type\n");
	         return SCIP_INVALIDDATA;
	      }
	   }
	
	   return SCIP_OKAY;
	}
	
	/** converts a static domain change data into a dynamic one */
	static
	SCIP_RETCODE domchgMakeDynamic(
	   SCIP_DOMCHG**         domchg,             /**< pointer to domain change data */
	   BMS_BLKMEM*           blkmem              /**< block memory */
	   )
	{
	   assert(domchg != NULL);
	   assert(blkmem != NULL);
	
	   SCIPdebugMessage("making domain change data %p pointing to %p dynamic\n", (void*)domchg, (void*)*domchg);
	
	   if( *domchg == NULL )
	   {
	      SCIP_CALL( domchgCreate(domchg, blkmem) );
	   }
	   else
	   {
	      switch( (*domchg)->domchgdyn.domchgtype )
	      {
	      case SCIP_DOMCHGTYPE_BOUND:
	         SCIP_ALLOC( BMSreallocBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGBOUND), sizeof(SCIP_DOMCHGDYN)) );
	         (*domchg)->domchgdyn.nholechgs = 0;
	         (*domchg)->domchgdyn.holechgs = NULL;
	         (*domchg)->domchgdyn.boundchgssize = (int) (*domchg)->domchgdyn.nboundchgs;
	         (*domchg)->domchgdyn.holechgssize = 0;
	         (*domchg)->domchgdyn.domchgtype = SCIP_DOMCHGTYPE_DYNAMIC; /*lint !e641*/
	         break;
	      case SCIP_DOMCHGTYPE_BOTH:
	         SCIP_ALLOC( BMSreallocBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGBOTH), sizeof(SCIP_DOMCHGDYN)) );
	         (*domchg)->domchgdyn.boundchgssize = (int) (*domchg)->domchgdyn.nboundchgs;
	         (*domchg)->domchgdyn.holechgssize = (*domchg)->domchgdyn.nholechgs;
	         (*domchg)->domchgdyn.domchgtype = SCIP_DOMCHGTYPE_DYNAMIC; /*lint !e641*/
	         break;
	      case SCIP_DOMCHGTYPE_DYNAMIC:
	         break;
	      default:
	         SCIPerrorMessage("invalid domain change type\n");
	         return SCIP_INVALIDDATA;
	      }
	   }
	#ifndef NDEBUG
	   {
	      int i;
	      for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
	         assert(SCIPvarGetType((*domchg)->domchgbound.boundchgs[i].var) == SCIP_VARTYPE_CONTINUOUS
	            || EPSISINT((*domchg)->domchgbound.boundchgs[i].newbound, 1e-06));
	   }
	#endif
	
	   return SCIP_OKAY;
	}
	
	/** converts a dynamic domain change data into a static one, using less memory than for a dynamic one */
	SCIP_RETCODE SCIPdomchgMakeStatic(
	   SCIP_DOMCHG**         domchg,             /**< pointer to domain change data */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_LP*              lp                  /**< current LP data */
	   )
	{
	   assert(domchg != NULL);
	   assert(blkmem != NULL);
	
	   SCIPsetDebugMsg(set, "making domain change data %p pointing to %p static\n", (void*)domchg, (void*)*domchg);
	
	   if( *domchg != NULL )
	   {
	      switch( (*domchg)->domchgdyn.domchgtype )
	      {
	      case SCIP_DOMCHGTYPE_BOUND:
	         if( (*domchg)->domchgbound.nboundchgs == 0 )
	         {
	            SCIP_CALL( SCIPdomchgFree(domchg, blkmem, set, eventqueue, lp) );
	         }
	         break;
	      case SCIP_DOMCHGTYPE_BOTH:
	         if( (*domchg)->domchgboth.nholechgs == 0 )
	         {
	            if( (*domchg)->domchgbound.nboundchgs == 0 )
	            {
	               SCIP_CALL( SCIPdomchgFree(domchg, blkmem, set, eventqueue, lp) );
	            }
	            else
	            {
	               SCIP_ALLOC( BMSreallocBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGBOTH), sizeof(SCIP_DOMCHGBOUND)) );
	               (*domchg)->domchgdyn.domchgtype = SCIP_DOMCHGTYPE_BOUND; /*lint !e641*/
	            }
	         }
	         break;
	      case SCIP_DOMCHGTYPE_DYNAMIC:
	         if( (*domchg)->domchgboth.nholechgs == 0 )
	         {
	            if( (*domchg)->domchgbound.nboundchgs == 0 )
	            {
	               SCIP_CALL( SCIPdomchgFree(domchg, blkmem, set, eventqueue, lp) );
	            }
	            else
	            {
	               /* shrink dynamic size arrays to their minimal sizes */
	               SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &(*domchg)->domchgdyn.boundchgs, \
	                     (*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) ); /*lint !e571*/
	               BMSfreeBlockMemoryArrayNull(blkmem, &(*domchg)->domchgdyn.holechgs, (*domchg)->domchgdyn.holechgssize);
	
	               /* convert into static domain change */
	               SCIP_ALLOC( BMSreallocBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGDYN), sizeof(SCIP_DOMCHGBOUND)) );
	               (*domchg)->domchgdyn.domchgtype = SCIP_DOMCHGTYPE_BOUND; /*lint !e641*/
	            }
	         }
	         else
	         {
	            /* shrink dynamic size arrays to their minimal sizes */
	            SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &(*domchg)->domchgdyn.boundchgs, \
	                  (*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) ); /*lint !e571*/
	            SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &(*domchg)->domchgdyn.holechgs, \
	                  (*domchg)->domchgdyn.holechgssize, (*domchg)->domchgdyn.nholechgs) );
	
	            /* convert into static domain change */
	            SCIP_ALLOC( BMSreallocBlockMemorySize(blkmem, domchg, sizeof(SCIP_DOMCHGDYN), sizeof(SCIP_DOMCHGBOTH)) );
	            (*domchg)->domchgdyn.domchgtype = SCIP_DOMCHGTYPE_BOTH; /*lint !e641*/
	         }
	         break;
	      default:
	         SCIPerrorMessage("invalid domain change type\n");
	         return SCIP_INVALIDDATA;
	      }
	#ifndef NDEBUG
	      if( *domchg != NULL )
	      {
	         int i;
	         for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
	            assert(SCIPvarGetType((*domchg)->domchgbound.boundchgs[i].var) == SCIP_VARTYPE_CONTINUOUS
	               || SCIPsetIsFeasIntegral(set, (*domchg)->domchgbound.boundchgs[i].newbound));
	      }
	#endif
	   }
	
	   return SCIP_OKAY;
	}
	
	/** ensures, that boundchgs array can store at least num entries */
	static
	SCIP_RETCODE domchgEnsureBoundchgsSize(
	   SCIP_DOMCHG*          domchg,             /**< domain change data structure */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   int                   num                 /**< minimum number of entries to store */
	   )
	{
	   assert(domchg != NULL);
	   assert(domchg->domchgdyn.domchgtype == SCIP_DOMCHGTYPE_DYNAMIC); /*lint !e641*/
	
	   if( num > domchg->domchgdyn.boundchgssize )
	   {
	      int newsize;
	
	      newsize = SCIPsetCalcMemGrowSize(set, num);
	      SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &domchg->domchgdyn.boundchgs, domchg->domchgdyn.boundchgssize, newsize) );
	      domchg->domchgdyn.boundchgssize = newsize;
	   }
	   assert(num <= domchg->domchgdyn.boundchgssize);
	
	   return SCIP_OKAY;
	}
	
	/** ensures, that holechgs array can store at least num additional entries */
	static
	SCIP_RETCODE domchgEnsureHolechgsSize(
	   SCIP_DOMCHG*          domchg,             /**< domain change data structure */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   int                   num                 /**< minimum number of additional entries to store */
	   )
	{
	   assert(domchg != NULL);
	   assert(domchg->domchgdyn.domchgtype == SCIP_DOMCHGTYPE_DYNAMIC); /*lint !e641*/
	
	   if( num > domchg->domchgdyn.holechgssize )
	   {
	      int newsize;
	
	      newsize = SCIPsetCalcMemGrowSize(set, num);
	      SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &domchg->domchgdyn.holechgs, domchg->domchgdyn.holechgssize, newsize) );
	      domchg->domchgdyn.holechgssize = newsize;
	   }
	   assert(num <= domchg->domchgdyn.holechgssize);
	
	   return SCIP_OKAY;
	}
	
	/** applies domain change */
	SCIP_RETCODE SCIPdomchgApply(
	   SCIP_DOMCHG*          domchg,             /**< domain change to apply */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   int                   depth,              /**< depth in the tree, where the domain change takes place */
	   SCIP_Bool*            cutoff              /**< pointer to store whether an infeasible domain change was detected */
	   )
	{
	   int i;
	
	   assert(cutoff != NULL);
	
	   *cutoff = FALSE;
	
	   SCIPsetDebugMsg(set, "applying domain changes at %p in depth %d\n", (void*)domchg, depth);
	
	   if( domchg == NULL )
	      return SCIP_OKAY;
	
	   /* apply bound changes */
	   for( i = 0; i < (int)domchg->domchgbound.nboundchgs; ++i )
	   {
	      SCIP_CALL( SCIPboundchgApply(&domchg->domchgbound.boundchgs[i], blkmem, set, stat, lp,
	            branchcand, eventqueue, depth, i, cutoff) );
	      if( *cutoff )
	         break;
	   }
	   SCIPsetDebugMsg(set, " -> %u bound changes (cutoff %u)\n", domchg->domchgbound.nboundchgs, *cutoff);
	
	   /* mark all bound changes after a cutoff redundant */
	   for( ; i < (int)domchg->domchgbound.nboundchgs; ++i )
	      domchg->domchgbound.boundchgs[i].redundant = TRUE;
	
	   /* apply holelist changes */
	   if( domchg->domchgdyn.domchgtype != SCIP_DOMCHGTYPE_BOUND ) /*lint !e641*/
	   {
	      for( i = 0; i < domchg->domchgboth.nholechgs; ++i )
	         *(domchg->domchgboth.holechgs[i].ptr) = domchg->domchgboth.holechgs[i].newlist;
	      SCIPsetDebugMsg(set, " -> %d hole changes\n", domchg->domchgboth.nholechgs);
	   }
	
	   return SCIP_OKAY;
	}
	
	/** undoes domain change */
	SCIP_RETCODE SCIPdomchgUndo(
	   SCIP_DOMCHG*          domchg,             /**< domain change to remove */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTQUEUE*      eventqueue          /**< event queue */
	   )
	{
	   int i;
	
	   SCIPsetDebugMsg(set, "undoing domain changes at %p\n", (void*)domchg);
	   if( domchg == NULL )
	      return SCIP_OKAY;
	
	   /* undo holelist changes */
	   if( domchg->domchgdyn.domchgtype != SCIP_DOMCHGTYPE_BOUND ) /*lint !e641*/
	   {
	      for( i = domchg->domchgboth.nholechgs-1; i >= 0; --i )
	         *(domchg->domchgboth.holechgs[i].ptr) = domchg->domchgboth.holechgs[i].oldlist;
	      SCIPsetDebugMsg(set, " -> %d hole changes\n", domchg->domchgboth.nholechgs);
	   }
	
	   /* undo bound changes */
	   for( i = domchg->domchgbound.nboundchgs-1; i >= 0; --i )
	   {
	      SCIP_CALL( SCIPboundchgUndo(&domchg->domchgbound.boundchgs[i], blkmem, set, stat, lp, branchcand, eventqueue) );
	   }
	   SCIPsetDebugMsg(set, " -> %u bound changes\n", domchg->domchgbound.nboundchgs);
	
	   return SCIP_OKAY;
	}
	
	/** applies domain change to the global problem */
	SCIP_RETCODE SCIPdomchgApplyGlobal(
	   SCIP_DOMCHG*          domchg,             /**< domain change to apply */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
	   SCIP_Bool*            cutoff              /**< pointer to store whether an infeasible domain change was detected */
	   )
	{
	   int i;
	
	   assert(cutoff != NULL);
	
	   *cutoff = FALSE;
	
	   if( domchg == NULL )
	      return SCIP_OKAY;
	
	   SCIPsetDebugMsg(set, "applying domain changes at %p to the global problem\n", (void*)domchg);
	
	   /* apply bound changes */
	   for( i = 0; i < (int)domchg->domchgbound.nboundchgs; ++i )
	   {
	      SCIP_CALL( boundchgApplyGlobal(&domchg->domchgbound.boundchgs[i], blkmem, set, stat, lp,
	            branchcand, eventqueue, cliquetable, cutoff) );
	      if( *cutoff )
	         break;
	   }
	   SCIPsetDebugMsg(set, " -> %u global bound changes\n", domchg->domchgbound.nboundchgs);
	
	   /**@todo globally apply holelist changes - how can this be done without confusing pointer updates? */
	
	   return SCIP_OKAY;
	}
	
	/** adds bound change to domain changes */
	SCIP_RETCODE SCIPdomchgAddBoundchg(
	   SCIP_DOMCHG**         domchg,             /**< pointer to domain change data structure */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_VAR*             var,                /**< variable to change the bounds for */
	   SCIP_Real             newbound,           /**< new value for bound */
	   SCIP_BOUNDTYPE        boundtype,          /**< type of bound for var: lower or upper bound */
	   SCIP_BOUNDCHGTYPE     boundchgtype,       /**< type of bound change: branching decision or inference */
	   SCIP_Real             lpsolval,           /**< solval of variable in last LP on path to node, or SCIP_INVALID if unknown */
	   SCIP_VAR*             infervar,           /**< variable that was changed (parent of var, or var itself), or NULL */
	   SCIP_CONS*            infercons,          /**< constraint that deduced the bound change, or NULL */
	   SCIP_PROP*            inferprop,          /**< propagator that deduced the bound change, or NULL */
	   int                   inferinfo,          /**< user information for inference to help resolving the conflict */
	   SCIP_BOUNDTYPE        inferboundtype      /**< type of bound for inference var: lower or upper bound */
	   )
	{
	   SCIP_BOUNDCHG* boundchg;
	
	   assert(domchg != NULL);
	   assert(var != NULL);
	   assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE || SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
	   assert(SCIPvarGetType(var) == SCIP_VARTYPE_CONTINUOUS || SCIPsetIsFeasIntegral(set, newbound));
	   assert(!SCIPvarIsBinary(var) || SCIPsetIsEQ(set, newbound, boundtype == SCIP_BOUNDTYPE_LOWER ? 1.0 : 0.0));
	   assert(boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING || infervar != NULL);
	   assert((boundchgtype == SCIP_BOUNDCHGTYPE_CONSINFER) == (infercons != NULL));
	   assert(boundchgtype == SCIP_BOUNDCHGTYPE_PROPINFER || inferprop == NULL);
	
	   SCIPsetDebugMsg(set, "adding %s bound change <%s: %g> of variable <%s> to domain change at %p pointing to %p\n",
	      boundtype == SCIP_BOUNDTYPE_LOWER ? "lower" : "upper", boundchgtype == SCIP_BOUNDCHGTYPE_BRANCHING ? "branching" : "inference",
	      newbound, var->name, (void*)domchg, (void*)*domchg);
	
	   /* if domain change data doesn't exist, create it;
	    * if domain change is static, convert it into dynamic change
	    */
	   if( *domchg == NULL )
	   {
	      SCIP_CALL( domchgCreate(domchg, blkmem) );
	   }
	   else if( (*domchg)->domchgdyn.domchgtype != SCIP_DOMCHGTYPE_DYNAMIC ) /*lint !e641*/
	   {
	      SCIP_CALL( domchgMakeDynamic(domchg, blkmem) );
	   }
	   assert(*domchg != NULL && (*domchg)->domchgdyn.domchgtype == SCIP_DOMCHGTYPE_DYNAMIC); /*lint !e641*/
	
	   /* get memory for additional bound change */
	   SCIP_CALL( domchgEnsureBoundchgsSize(*domchg, blkmem, set, (*domchg)->domchgdyn.nboundchgs+1) );
	
	   /* fill in the bound change data */
	   boundchg = &(*domchg)->domchgdyn.boundchgs[(*domchg)->domchgdyn.nboundchgs];
	   boundchg->var = var;
	   switch( boundchgtype )
	   {
	   case SCIP_BOUNDCHGTYPE_BRANCHING:
	      boundchg->data.branchingdata.lpsolval = lpsolval;
	      break;
	   case SCIP_BOUNDCHGTYPE_CONSINFER:
	      assert(infercons != NULL);
	      boundchg->data.inferencedata.var = infervar;
	      boundchg->data.inferencedata.reason.cons = infercons;
	      boundchg->data.inferencedata.info = inferinfo; 
	      break;
	   case SCIP_BOUNDCHGTYPE_PROPINFER:
	      boundchg->data.inferencedata.var = infervar;
	      boundchg->data.inferencedata.reason.prop = inferprop;
	      boundchg->data.inferencedata.info = inferinfo; 
	      break;
	   default:
	      SCIPerrorMessage("invalid bound change type %d\n", boundchgtype);
	      return SCIP_INVALIDDATA;
	   }
	
	   boundchg->newbound = newbound;
	   boundchg->boundchgtype = boundchgtype; /*lint !e641*/
	   boundchg->boundtype = boundtype; /*lint !e641*/
	   boundchg->inferboundtype = inferboundtype; /*lint !e641*/
	   boundchg->applied = FALSE;
	   boundchg->redundant = FALSE;
	   (*domchg)->domchgdyn.nboundchgs++;
	
	   /* capture branching and inference data associated with the bound changes */
	   SCIP_CALL( boundchgCaptureData(boundchg) );
	
	#ifdef SCIP_DISABLED_CODE /* expensive debug check */
	#ifdef SCIP_MORE_DEBUG
	   {
	      int i;
	      for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
	         assert(SCIPvarGetType((*domchg)->domchgbound.boundchgs[i].var) == SCIP_VARTYPE_CONTINUOUS
	            || SCIPsetIsFeasIntegral(set, (*domchg)->domchgbound.boundchgs[i].newbound));
	   }
	#endif
	#endif
	
	   return SCIP_OKAY;
	}
	
	/** adds hole change to domain changes */
	SCIP_RETCODE SCIPdomchgAddHolechg(
	   SCIP_DOMCHG**         domchg,             /**< pointer to domain change data structure */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_HOLELIST**       ptr,                /**< changed list pointer */
	   SCIP_HOLELIST*        newlist,            /**< new value of list pointer */
	   SCIP_HOLELIST*        oldlist             /**< old value of list pointer */
	   )
	{
	   SCIP_HOLECHG* holechg;
	
	   assert(domchg != NULL);
	   assert(ptr != NULL);
	
	   /* if domain change data doesn't exist, create it;
	    * if domain change is static, convert it into dynamic change
	    */
	   if( *domchg == NULL )
	   {
	      SCIP_CALL( domchgCreate(domchg, blkmem) );
	   }
	   else if( (*domchg)->domchgdyn.domchgtype != SCIP_DOMCHGTYPE_DYNAMIC ) /*lint !e641*/
	   {
	      SCIP_CALL( domchgMakeDynamic(domchg, blkmem) );
	   }
	   assert(*domchg != NULL && (*domchg)->domchgdyn.domchgtype == SCIP_DOMCHGTYPE_DYNAMIC); /*lint !e641*/
	
	   /* get memory for additional hole change */
	   SCIP_CALL( domchgEnsureHolechgsSize(*domchg, blkmem, set, (*domchg)->domchgdyn.nholechgs+1) );
	
	   /* fill in the hole change data */
	   holechg = &(*domchg)->domchgdyn.holechgs[(*domchg)->domchgdyn.nholechgs];
	   holechg->ptr = ptr;
	   holechg->newlist = newlist;
	   holechg->oldlist = oldlist;
	   (*domchg)->domchgdyn.nholechgs++;
	
	   return SCIP_OKAY;
	}
	
	
	
	
	/*
	 * methods for variables 
	 */
	
	/** returns adjusted lower bound value, which is rounded for integral variable types */
	static
	SCIP_Real adjustedLb(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_VARTYPE          vartype,            /**< type of variable */
	   SCIP_Real             lb                  /**< lower bound to adjust */
	   )
	{
	   if( lb < 0.0 && SCIPsetIsInfinity(set, -lb) )
	      return -SCIPsetInfinity(set);
	   else if( lb > 0.0 && SCIPsetIsInfinity(set, lb) )
	      return SCIPsetInfinity(set);
	   else if( vartype != SCIP_VARTYPE_CONTINUOUS )
	      return SCIPsetFeasCeil(set, lb);
	   else if( lb > 0.0 && lb < SCIPsetEpsilon(set) )
	      return 0.0;
	   else
	      return lb;
	}
	
	/** returns adjusted upper bound value, which is rounded for integral variable types */
	static
	SCIP_Real adjustedUb(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_VARTYPE          vartype,            /**< type of variable */
	   SCIP_Real             ub                  /**< upper bound to adjust */
	   )
	{
	   if( ub > 0.0 && SCIPsetIsInfinity(set, ub) )
	      return SCIPsetInfinity(set);
	   else if( ub < 0.0 && SCIPsetIsInfinity(set, -ub) )
	      return -SCIPsetInfinity(set);
	   else if( vartype != SCIP_VARTYPE_CONTINUOUS )
	      return SCIPsetFeasFloor(set, ub);
	   else if( ub < 0.0 && ub > -SCIPsetEpsilon(set) )
	      return 0.0;
	   else
	      return ub;
	}
	
	/** removes (redundant) cliques, implications and variable bounds of variable from all other variables' implications and variable
	 *  bounds arrays, and optionally removes them also from the variable itself
	 */
	SCIP_RETCODE SCIPvarRemoveCliquesImplicsVbs(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_Bool             irrelevantvar,      /**< has the variable become irrelevant? */
	   SCIP_Bool             onlyredundant,      /**< should only the redundant implications and variable bounds be removed? */
	   SCIP_Bool             removefromvar       /**< should the implications and variable bounds be removed from the var itself? */
	   )
	{
	   SCIP_Real lb;
	   SCIP_Real ub;
	
	   assert(var != NULL);
	   assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE || SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
	   assert(SCIPvarIsActive(var) || SCIPvarGetType(var) != SCIP_VARTYPE_BINARY);
	
	   lb = SCIPvarGetLbGlobal(var);
	   ub = SCIPvarGetUbGlobal(var);
	
	   SCIPsetDebugMsg(set, "removing %s implications and vbounds of %s<%s>[%g,%g]\n",
	      onlyredundant ? "redundant" : "all", irrelevantvar ? "irrelevant " : "", SCIPvarGetName(var), lb, ub);
	
	   /* remove implications of (fixed) binary variable */
	   if( var->implics != NULL && (!onlyredundant || lb > 0.5 || ub < 0.5) )
	   {
	      SCIP_Bool varfixing;
	
	      assert(SCIPvarIsBinary(var));
	
	      varfixing = FALSE;
	      do
	      {
	         SCIP_VAR** implvars;
	         SCIP_BOUNDTYPE* impltypes;
	         int nimpls;
	         int i;
	
	         nimpls = SCIPimplicsGetNImpls(var->implics, varfixing);
	         implvars = SCIPimplicsGetVars(var->implics, varfixing);
	         impltypes = SCIPimplicsGetTypes(var->implics, varfixing);
	
	         for( i = 0; i < nimpls; i++ )
	         {
	            SCIP_VAR* implvar;
	            SCIP_BOUNDTYPE impltype;
	
	            implvar = implvars[i];
	            impltype = impltypes[i];
	            assert(implvar != var);
	
	            /* remove for all implications z == 0 / 1  ==>  x <= p / x >= p (x not binary)
	             * the following variable bound from x's variable bounds 
	             *   x <= b*z+d (z in vubs of x)            , for z == 0 / 1  ==>  x <= p
	             *   x >= b*z+d (z in vlbs of x)            , for z == 0 / 1  ==>  x >= p
	             */
	            if( impltype == SCIP_BOUNDTYPE_UPPER )
	            {
	               if( implvar->vubs != NULL ) /* implvar may have been aggregated in the mean time */
	               {
	                  SCIPsetDebugMsg(set, "deleting variable bound: <%s> == %u  ==>  <%s> <= %g\n",
	                     SCIPvarGetName(var), varfixing, SCIPvarGetName(implvar),
	                     SCIPimplicsGetBounds(var->implics, varfixing)[i]);
	                  SCIP_CALL( SCIPvboundsDel(&implvar->vubs, blkmem, var, varfixing) );
	                  implvar->closestvblpcount = -1;
	                  var->closestvblpcount = -1;
	               }
	            }
	            else
	            {
	               if( implvar->vlbs != NULL ) /* implvar may have been aggregated in the mean time */
	               {
	                  SCIPsetDebugMsg(set, "deleting variable bound: <%s> == %u  ==>  <%s> >= %g\n",
	                     SCIPvarGetName(var), varfixing, SCIPvarGetName(implvar),
	                     SCIPimplicsGetBounds(var->implics, varfixing)[i]);
	                  SCIP_CALL( SCIPvboundsDel(&implvar->vlbs, blkmem, var, !varfixing) );
	                  implvar->closestvblpcount = -1;
	                  var->closestvblpcount = -1;
	               }
	            }
	         }
	         varfixing = !varfixing;
	      }
	      while( varfixing == TRUE );
	
	      if( removefromvar )
	      {
	         /* free the implications data structures */
	         SCIPimplicsFree(&var->implics, blkmem);
	      }
	   }
	
	   /* remove the (redundant) variable lower bounds */
	   if( var->vlbs != NULL )
	   {
	      SCIP_VAR** vars;
	      SCIP_Real* coefs;
	      SCIP_Real* constants;
	      int nvbds;
	      int newnvbds;
	      int i;
	
	      nvbds = SCIPvboundsGetNVbds(var->vlbs);
	      vars = SCIPvboundsGetVars(var->vlbs);
	      coefs = SCIPvboundsGetCoefs(var->vlbs);
	      constants = SCIPvboundsGetConstants(var->vlbs);
	
	      /* remove for all variable bounds x >= b*z+d the following implication from z's implications 
	       *   z == ub  ==>  x >= b*ub + d           , if b > 0
	       *   z == lb  ==>  x >= b*lb + d           , if b < 0
	       */
	      newnvbds = 0;
	      for( i = 0; i < nvbds; i++ )
	      {
	         SCIP_VAR* implvar;
	         SCIP_Real coef;
	
	         assert(newnvbds <= i);
	
	         implvar = vars[i];
	         assert(implvar != NULL);
	
	         coef = coefs[i];
	         assert(!SCIPsetIsZero(set, coef));
	
	         /* check, if we want to remove the variable bound */
	         if( onlyredundant )
	         {
	            SCIP_Real vbound;
	
	            vbound = MAX(coef * SCIPvarGetUbGlobal(implvar), coef * SCIPvarGetLbGlobal(implvar)) + constants[i];  /*lint !e666*/
	            if( SCIPsetIsFeasGT(set, vbound, lb) )
	            {
	               /* the variable bound is not redundant: keep it */
	               if( removefromvar )
	               {
	                  if( newnvbds < i )
	                  {
	                     vars[newnvbds] = implvar;
	                     coefs[newnvbds] = coef;
	                     constants[newnvbds] = constants[i];
	                  }
	                  newnvbds++;
	               }
	               continue;
	            }
	         }
	
	         /* remove the corresponding implication */
	         if( implvar->implics != NULL ) /* variable may have been aggregated in the mean time */
	         {
	            SCIPsetDebugMsg(set, "deleting implication: <%s> == %d  ==>  <%s> >= %g\n",
	               SCIPvarGetName(implvar), (coef > 0.0), SCIPvarGetName(var), MAX(coef, 0.0) + constants[i]);
	            SCIP_CALL( SCIPimplicsDel(&implvar->implics, blkmem, set, (coef > 0.0), var, SCIP_BOUNDTYPE_LOWER) );
	         }
	         if( coef > 0.0 && implvar->vubs != NULL ) /* implvar may have been aggregated in the mean time */
	         {
	            SCIPsetDebugMsg(set, "deleting variable upper bound from <%s> involving variable %s\n",
	               SCIPvarGetName(implvar), SCIPvarGetName(var));
	            SCIP_CALL( SCIPvboundsDel(&implvar->vubs, blkmem, var, FALSE) );
	            implvar->closestvblpcount = -1;
	            var->closestvblpcount = -1;
	         }
	         else if( coef < 0.0 && implvar->vlbs != NULL ) /* implvar may have been aggregated in the mean time */
	         {
	            SCIPsetDebugMsg(set, "deleting variable lower bound from <%s> involving variable %s\n",
	               SCIPvarGetName(implvar), SCIPvarGetName(var));
	            SCIP_CALL( SCIPvboundsDel(&implvar->vlbs, blkmem, var, TRUE) );
	            implvar->closestvblpcount = -1;
	            var->closestvblpcount = -1;
	         }
	      }
	
	      if( removefromvar )
	      {
	         /* update the number of variable bounds */
	         SCIPvboundsShrink(&var->vlbs, blkmem, newnvbds);
	         var->closestvblpcount = -1;
	      }
	   }
	
	   /**@todo in general, variable bounds like x >= b*z + d corresponding to an implication like z = ub ==> x >= b*ub + d 
	    *       might be missing because we only add variable bounds with reasonably small value of b. thus, we currently 
	    *       cannot remove such variables x from z's implications.
	    */
	
	   /* remove the (redundant) variable upper bounds */
	   if( var->vubs != NULL )
	   {
	      SCIP_VAR** vars;
	      SCIP_Real* coefs;
	      SCIP_Real* constants;
	      int nvbds;
	      int newnvbds;
	      int i;
	
	      nvbds = SCIPvboundsGetNVbds(var->vubs);
	      vars = SCIPvboundsGetVars(var->vubs);
	      coefs = SCIPvboundsGetCoefs(var->vubs);
	      constants = SCIPvboundsGetConstants(var->vubs);
	
	      /* remove for all variable bounds x <= b*z+d the following implication from z's implications 
	       *   z == lb  ==>  x <= b*lb + d           , if b > 0
	       *   z == ub  ==>  x <= b*ub + d           , if b < 0
	       */
	      newnvbds = 0;
	      for( i = 0; i < nvbds; i++ )
	      {
	         SCIP_VAR* implvar;
	         SCIP_Real coef;
	
	         assert(newnvbds <= i);
	
	         implvar = vars[i];
	         assert(implvar != NULL);
	
	         coef = coefs[i];
	         assert(!SCIPsetIsZero(set, coef));
	
	         /* check, if we want to remove the variable bound */
	         if( onlyredundant )
	         {
	            SCIP_Real vbound;
	
	            vbound = MIN(coef * SCIPvarGetUbGlobal(implvar), coef * SCIPvarGetLbGlobal(implvar)) + constants[i];  /*lint !e666*/
	            if( SCIPsetIsFeasLT(set, vbound, ub) )
	            {
	               /* the variable bound is not redundant: keep it */
	               if( removefromvar )
	               {
	                  if( newnvbds < i )
	                  {
	                     vars[newnvbds] = implvar;
	                     coefs[newnvbds] = coefs[i];
	                     constants[newnvbds] = constants[i];
	                  }
	                  newnvbds++;
	               }
	               continue;
	            }
	         }
	
	         /* remove the corresponding implication */
	         if( implvar->implics != NULL ) /* variable may have been aggregated in the mean time */
	         {
	            SCIPsetDebugMsg(set, "deleting implication: <%s> == %d  ==>  <%s> <= %g\n",
	               SCIPvarGetName(implvar), (coef < 0.0), SCIPvarGetName(var), MIN(coef, 0.0) + constants[i]);
	            SCIP_CALL( SCIPimplicsDel(&implvar->implics, blkmem, set, (coef < 0.0), var, SCIP_BOUNDTYPE_UPPER) );
	         }
	         if( coef < 0.0 && implvar->vubs != NULL ) /* implvar may have been aggregated in the mean time */
	         {
	            SCIPsetDebugMsg(set, "deleting variable upper bound from <%s> involving variable %s\n",
	               SCIPvarGetName(implvar), SCIPvarGetName(var));
	            SCIP_CALL( SCIPvboundsDel(&implvar->vubs, blkmem, var, TRUE) );
	            implvar->closestvblpcount = -1;
	            var->closestvblpcount = -1;
	         }
	         else if( coef > 0.0 && implvar->vlbs != NULL ) /* implvar may have been aggregated in the mean time */
	         {
	            SCIPsetDebugMsg(set, "deleting variable lower bound from <%s> involving variable %s\n",
	               SCIPvarGetName(implvar), SCIPvarGetName(var));
	            SCIP_CALL( SCIPvboundsDel(&implvar->vlbs, blkmem, var, FALSE) );
	            implvar->closestvblpcount = -1;
	            var->closestvblpcount = -1;
	         }
	      }
	
	      if( removefromvar )
	      {
	         /* update the number of variable bounds */
	         SCIPvboundsShrink(&var->vubs, blkmem, newnvbds);
	         var->closestvblpcount = -1;
	      }
	   }
	
	   /* remove the variable from all cliques */
	   if( SCIPvarIsBinary(var) )
	   {
	      SCIPcliquelistRemoveFromCliques(var->cliquelist, cliquetable, var, irrelevantvar);
	      SCIPcliquelistFree(&var->cliquelist, blkmem);
	   }
	
	   /**@todo variable bounds like x <= b*z + d with z general integer are not removed from x's vbd arrays, because
	    *       z has no link (like in the binary case) to x
	    */
	
	   return SCIP_OKAY;
	}
	
	/** sets the variable name */
	static
	SCIP_RETCODE varSetName(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_STAT*            stat,               /**< problem statistics, or NULL */
	   const char*           name                /**< name of variable, or NULL for automatic name creation */
	   )
	{
	   assert(blkmem != NULL);
	   assert(var != NULL);
	
	   if( name == NULL )
	   {
	      char s[SCIP_MAXSTRLEN];
	
	      assert(stat != NULL);
	
	      (void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "_var%d_", stat->nvaridx);
	      SCIP_ALLOC( BMSduplicateBlockMemoryArray(blkmem, &var->name, s, strlen(s)+1) );
	   }
	   else
	   {
	      SCIP_ALLOC( BMSduplicateBlockMemoryArray(blkmem, &var->name, name, strlen(name)+1) );
	   }
	
	   return SCIP_OKAY;
	}
	
	
	/** creates variable; if variable is of integral type, fractional bounds are automatically rounded; an integer variable
	 *  with bounds zero and one is automatically converted into a binary variable
	 */
	static
	SCIP_RETCODE varCreate(
	   SCIP_VAR**            var,                /**< pointer to variable data */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   const char*           name,               /**< name of variable, or NULL for automatic name creation */
	   SCIP_Real             lb,                 /**< lower bound of variable */
	   SCIP_Real             ub,                 /**< upper bound of variable */
	   SCIP_Real             obj,                /**< objective function value */
	   SCIP_VARTYPE          vartype,            /**< type of variable */
	   SCIP_Bool             initial,            /**< should var's column be present in the initial root LP? */
	   SCIP_Bool             removable,          /**< is var's column removable from the LP (due to aging or cleanup)? */
	   SCIP_DECL_VARCOPY     ((*varcopy)),       /**< copies variable data if wanted to subscip, or NULL */
	   SCIP_DECL_VARDELORIG  ((*vardelorig)),    /**< frees user data of original variable, or NULL */
	   SCIP_DECL_VARTRANS    ((*vartrans)),      /**< creates transformed user data by transforming original user data, or NULL */
	   SCIP_DECL_VARDELTRANS ((*vardeltrans)),   /**< frees user data of transformed variable, or NULL */
	   SCIP_VARDATA*         vardata             /**< user data for this specific variable */
	   )
	{
	   int i;
	
	   assert(var != NULL);
	   assert(blkmem != NULL);
	   assert(stat != NULL);
	
	   /* adjust bounds of variable */
	   lb = adjustedLb(set, vartype, lb);
	   ub = adjustedUb(set, vartype, ub);
	
	   /* convert [0,1]-integers into binary variables and check that binary variables have correct bounds */
	   if( (SCIPsetIsEQ(set, lb, 0.0) || SCIPsetIsEQ(set, lb, 1.0))
	      && (SCIPsetIsEQ(set, ub, 0.0) || SCIPsetIsEQ(set, ub, 1.0)) )
	   {
	      if( vartype == SCIP_VARTYPE_INTEGER )
	         vartype = SCIP_VARTYPE_BINARY;
	   }
	   else
	   {
	      if( vartype == SCIP_VARTYPE_BINARY )
	      {
	         SCIPerrorMessage("invalid bounds [%.2g,%.2g] for binary variable <%s>\n", lb, ub, name);
	         return SCIP_INVALIDDATA;
	      }
	   }
	
	   assert(vartype != SCIP_VARTYPE_BINARY || SCIPsetIsEQ(set, lb, 0.0) || SCIPsetIsEQ(set, lb, 1.0));
	   assert(vartype != SCIP_VARTYPE_BINARY || SCIPsetIsEQ(set, ub, 0.0) || SCIPsetIsEQ(set, ub, 1.0));
	
	   SCIP_ALLOC( BMSallocBlockMemory(blkmem, var) );
	
	   /* set variable's name */
	   SCIP_CALL( varSetName(*var, blkmem, stat, name) );
	
	#ifndef NDEBUG
	   (*var)->scip = set->scip;
	#endif
	   (*var)->obj = obj;
	   (*var)->unchangedobj = obj;
	   (*var)->branchfactor = 1.0;
	   (*var)->rootsol = 0.0;
	   (*var)->bestrootsol = 0.0;
	   (*var)->bestrootredcost = 0.0;
	   (*var)->bestrootlpobjval = SCIP_INVALID;
	   (*var)->relaxsol = 0.0;
	   (*var)->nlpsol = 0.0;
	   (*var)->primsolavg = 0.5 * (lb + ub);
	   (*var)->conflictlb = SCIP_REAL_MIN;
	   (*var)->conflictub = SCIP_REAL_MAX;
	   (*var)->conflictrelaxedlb = (*var)->conflictlb;
	   (*var)->conflictrelaxedub = (*var)->conflictub;
	   (*var)->lazylb = -SCIPsetInfinity(set);
	   (*var)->lazyub = SCIPsetInfinity(set);
	   (*var)->glbdom.holelist = NULL;
	   (*var)->glbdom.lb = lb;
	   (*var)->glbdom.ub = ub;
	   (*var)->locdom.holelist = NULL;
	   (*var)->locdom.lb = lb;
	   (*var)->locdom.ub = ub;
	   (*var)->varcopy = varcopy;
	   (*var)->vardelorig = vardelorig;
	   (*var)->vartrans = vartrans;
	   (*var)->vardeltrans = vardeltrans;
	   (*var)->vardata = vardata;
	   (*var)->parentvars = NULL;
	   (*var)->negatedvar = NULL;
	   (*var)->vlbs = NULL;
	   (*var)->vubs = NULL;
	   (*var)->implics = NULL;
	   (*var)->cliquelist = NULL;
	   (*var)->eventfilter = NULL;
	   (*var)->lbchginfos = NULL;
	   (*var)->ubchginfos = NULL;
	   (*var)->index = stat->nvaridx;
	   (*var)->probindex = -1;
	   (*var)->pseudocandindex = -1;
	   (*var)->eventqueueindexobj = -1;
	   (*var)->eventqueueindexlb = -1;
	   (*var)->eventqueueindexub = -1;
	   (*var)->parentvarssize = 0;
	   (*var)->nparentvars = 0;
	   (*var)->nuses = 0;
	   (*var)->branchpriority = 0;
	   (*var)->branchdirection = SCIP_BRANCHDIR_AUTO; /*lint !e641*/
	   (*var)->lbchginfossize = 0;
	   (*var)->nlbchginfos = 0;
	   (*var)->ubchginfossize = 0;
	   (*var)->nubchginfos = 0;
	   (*var)->conflictlbcount = 0;
	   (*var)->conflictubcount = 0;
	   (*var)->closestvlbidx = -1;
	   (*var)->closestvubidx = -1;
	   (*var)->closestvblpcount = -1;
	   (*var)->initial = initial;
	   (*var)->removable = removable;
	   (*var)->deleted = FALSE;
	   (*var)->donotaggr = FALSE;
	   (*var)->donotmultaggr = FALSE;
	   (*var)->vartype = vartype; /*lint !e641*/
	   (*var)->pseudocostflag = FALSE;
	   (*var)->eventqueueimpl = FALSE;
	   (*var)->deletable = FALSE;
	   (*var)->delglobalstructs = FALSE;
	   (*var)->relaxationonly = FALSE;
	
	   for( i = 0; i < NLOCKTYPES; i++ )
	   {
	      (*var)->nlocksdown[i] = 0;
	      (*var)->nlocksup[i] = 0;
	   }
	
	   stat->nvaridx++;
	
	   /* create branching and inference history entries */
	   SCIP_CALL( SCIPhistoryCreate(&(*var)->history, blkmem) );
	   SCIP_CALL( SCIPhistoryCreate(&(*var)->historycrun, blkmem) );
	
	   /* the value based history is only created on demand */
	   (*var)->valuehistory = NULL;
	
	   return SCIP_OKAY;
	}
	
	/** creates and captures an original problem variable; an integer variable with bounds
	 *  zero and one is automatically converted into a binary variable
	 */
	SCIP_RETCODE SCIPvarCreateOriginal(
	   SCIP_VAR**            var,                /**< pointer to variable data */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   const char*           name,               /**< name of variable, or NULL for automatic name creation */
	   SCIP_Real             lb,                 /**< lower bound of variable */
	   SCIP_Real             ub,                 /**< upper bound of variable */
	   SCIP_Real             obj,                /**< objective function value */
	   SCIP_VARTYPE          vartype,            /**< type of variable */
	   SCIP_Bool             initial,            /**< should var's column be present in the initial root LP? */
	   SCIP_Bool             removable,          /**< is var's column removable from the LP (due to aging or cleanup)? */
	   SCIP_DECL_VARDELORIG  ((*vardelorig)),    /**< frees user data of original variable, or NULL */
	   SCIP_DECL_VARTRANS    ((*vartrans)),      /**< creates transformed user data by transforming original user data, or NULL */
	   SCIP_DECL_VARDELTRANS ((*vardeltrans)),   /**< frees user data of transformed variable, or NULL */
	   SCIP_DECL_VARCOPY     ((*varcopy)),       /**< copies variable data if wanted to subscip, or NULL */
	   SCIP_VARDATA*         vardata             /**< user data for this specific variable */
	   )
	{
	   assert(var != NULL);
	   assert(blkmem != NULL);
	   assert(stat != NULL);
	
	   /* create variable */
	   SCIP_CALL( varCreate(var, blkmem, set, stat, name, lb, ub, obj, vartype, initial, removable,
	         varcopy, vardelorig, vartrans, vardeltrans, vardata) );
	
	   /* set variable status and data */
	   (*var)->varstatus = SCIP_VARSTATUS_ORIGINAL; /*lint !e641*/
	   (*var)->data.original.origdom.holelist = NULL;
	   (*var)->data.original.origdom.lb = lb;
	   (*var)->data.original.origdom.ub = ub;
	   (*var)->data.original.transvar = NULL;
	
	   /* capture variable */
	   SCIPvarCapture(*var);
	
	   return SCIP_OKAY;
	}
	
	/** creates and captures a loose variable belonging to the transformed problem; an integer variable with bounds
	 *  zero and one is automatically converted into a binary variable
	 */
	SCIP_RETCODE SCIPvarCreateTransformed(
	   SCIP_VAR**            var,                /**< pointer to variable data */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   const char*           name,               /**< name of variable, or NULL for automatic name creation */
	   SCIP_Real             lb,                 /**< lower bound of variable */
	   SCIP_Real             ub,                 /**< upper bound of variable */
	   SCIP_Real             obj,                /**< objective function value */
	   SCIP_VARTYPE          vartype,            /**< type of variable */
	   SCIP_Bool             initial,            /**< should var's column be present in the initial root LP? */
	   SCIP_Bool             removable,          /**< is var's column removable from the LP (due to aging or cleanup)? */
	   SCIP_DECL_VARDELORIG  ((*vardelorig)),    /**< frees user data of original variable, or NULL */
	   SCIP_DECL_VARTRANS    ((*vartrans)),      /**< creates transformed user data by transforming original user data, or NULL */
	   SCIP_DECL_VARDELTRANS ((*vardeltrans)),   /**< frees user data of transformed variable, or NULL */
	   SCIP_DECL_VARCOPY     ((*varcopy)),       /**< copies variable data if wanted to subscip, or NULL */
	   SCIP_VARDATA*         vardata             /**< user data for this specific variable */
	   )
	{
	   assert(var != NULL);
	   assert(blkmem != NULL);
	
	   /* create variable */
	   SCIP_CALL( varCreate(var, blkmem, set, stat, name, lb, ub, obj, vartype, initial, removable,
	         varcopy, vardelorig, vartrans, vardeltrans, vardata) );
	
	   /* create event filter for transformed variable */
	   SCIP_CALL( SCIPeventfilterCreate(&(*var)->eventfilter, blkmem) );
	
	   /* set variable status and data */
	   (*var)->varstatus = SCIP_VARSTATUS_LOOSE; /*lint !e641*/
	
	   /* capture variable */
	   SCIPvarCapture(*var);
	
	   return SCIP_OKAY;   
	}
	
	/** copies and captures a variable from source to target SCIP; an integer variable with bounds zero and one is
	 *  automatically converted into a binary variable; in case the variable data cannot be copied the variable is not
	 *  copied at all
	 */
	SCIP_RETCODE SCIPvarCopy(
	   SCIP_VAR**            var,                /**< pointer to store the target variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP*                 sourcescip,         /**< source SCIP data structure */
	   SCIP_VAR*             sourcevar,          /**< source variable */
	   SCIP_HASHMAP*         varmap,             /**< a hashmap to store the mapping of source variables corresponding
	                                              *   target variables */
	   SCIP_HASHMAP*         consmap,            /**< a hashmap to store the mapping of source constraints to the corresponding
	                                              *   target constraints */
	   SCIP_Bool             global              /**< should global or local bounds be used? */
	   )
	{
	   SCIP_VARDATA* targetdata;
	   SCIP_RESULT result;
	   SCIP_Real lb;
	   SCIP_Real ub;
	
	   assert(set != NULL);
	   assert(blkmem != NULL);
	   assert(stat != NULL);
	   assert(sourcescip != NULL);
	   assert(sourcevar != NULL);
	   assert(var != NULL);
	   assert(set->stage == SCIP_STAGE_PROBLEM);
	   assert(varmap != NULL);
	   assert(consmap != NULL);
	
	   /** @todo copy hole lists */
	   assert(global || SCIPvarGetHolelistLocal(sourcevar) == NULL);
	   assert(!global || SCIPvarGetHolelistGlobal(sourcevar) == NULL);
	
	   result = SCIP_DIDNOTRUN;
	   targetdata = NULL;
	
	   if( SCIPvarGetStatus(sourcevar) == SCIP_VARSTATUS_ORIGINAL )
	   {
	      lb = SCIPvarGetLbOriginal(sourcevar);
	      ub = SCIPvarGetUbOriginal(sourcevar);
	   }
	   else
	   {
	      lb = global ? SCIPvarGetLbGlobal(sourcevar) : SCIPvarGetLbLocal(sourcevar);
	      ub = global ? SCIPvarGetUbGlobal(sourcevar) : SCIPvarGetUbLocal(sourcevar);
	   }
	
	   /* creates and captures the variable in the target SCIP and initialize callback methods and variable data to NULL */
	   SCIP_CALL( SCIPvarCreateOriginal(var, blkmem, set, stat, SCIPvarGetName(sourcevar), 
	         lb, ub, SCIPvarGetObj(sourcevar), SCIPvarGetType(sourcevar),
	         SCIPvarIsInitial(sourcevar), SCIPvarIsRemovable(sourcevar), 
	         NULL, NULL, NULL, NULL, NULL) );
	   assert(*var != NULL);
	
	   /* directly copy donot(mult)aggr flag */
	   (*var)->donotaggr = sourcevar->donotaggr;
	   (*var)->donotmultaggr = sourcevar->donotmultaggr;
	
	   /* insert variable into mapping between source SCIP and the target SCIP */
	   assert(!SCIPhashmapExists(varmap, sourcevar));
	   SCIP_CALL( SCIPhashmapInsert(varmap, sourcevar, *var) );
	
	   /* in case there exists variable data and the variable data copy callback, try to copy variable data */
	   if( sourcevar->vardata != NULL && sourcevar->varcopy != NULL )
	   {
	      SCIP_CALL( sourcevar->varcopy(set->scip, sourcescip, sourcevar, sourcevar->vardata, 
	            varmap, consmap, (*var), &targetdata, &result) );
	
	      /* evaluate result */
	      if( result != SCIP_DIDNOTRUN && result != SCIP_SUCCESS )
	      {
	         SCIPerrorMessage("variable data copying method returned invalid result <%d>\n", result);
	         return SCIP_INVALIDRESULT;
	      }
	
	      assert(targetdata == NULL || result == SCIP_SUCCESS);
	
	      /* if copying was successful, add the created variable data to the variable as well as all callback methods */
	      if( result == SCIP_SUCCESS )
	      {
	         (*var)->varcopy = sourcevar->varcopy;
	         (*var)->vardelorig = sourcevar->vardelorig;
	         (*var)->vartrans = sourcevar->vartrans;
	         (*var)->vardeltrans = sourcevar->vardeltrans;
	         (*var)->vardata = targetdata;
	      }
	   }
	
	   /* we initialize histories of the variables by copying the source variable-information */
	   if( set->history_allowtransfer )
	   {
	      SCIPvarMergeHistories((*var), sourcevar, stat);
	   }
	
	   /* in case the copying was successfully, add the created variable data to the variable as well as all callback
	    * methods 
	    */
	   if( result == SCIP_SUCCESS )
	   {
	      (*var)->varcopy = sourcevar->varcopy;
	      (*var)->vardelorig = sourcevar->vardelorig;
	      (*var)->vartrans = sourcevar->vartrans;
	      (*var)->vardeltrans = sourcevar->vardeltrans;
	      (*var)->vardata = targetdata;
	   }
	
	   SCIPsetDebugMsg(set, "created copy <%s> of variable <%s>\n", SCIPvarGetName(*var), SCIPvarGetName(sourcevar));
	
	   return SCIP_OKAY;
	}
	
	/** parse given string for a SCIP_Real bound */
	static
	SCIP_RETCODE parseValue(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   const char*           str,                /**< string to parse */
	   SCIP_Real*            value,              /**< pointer to store the parsed value */
	   char**                endptr              /**< pointer to store the final string position if successfully parsed */
	   )
	{
	   /* first check for infinity value */
	   if( strncmp(str, "+inf", 4) == 0 )
	   {
	      *value = SCIPsetInfinity(set);
	      (*endptr) = (char*)str + 4;
	   }
	   else if( strncmp(str, "-inf", 4) == 0 )
	   {
	      *value = -SCIPsetInfinity(set);
	      (*endptr) = (char*)str + 4;
	   }
	   else
	   {
	      if( !SCIPstrToRealValue(str, value, endptr) )
	      {
	         SCIPerrorMessage("expected value: %s.\n", str);
	         return SCIP_READERROR;
	      }
	   }
	
	   return SCIP_OKAY;
	}
	
	/** parse the characters as bounds */
	static
	SCIP_RETCODE parseBounds(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   const char*           str,                /**< string to parse */
	   char*                 type,               /**< bound type (global, local, or lazy) */
	   SCIP_Real*            lb,                 /**< pointer to store the lower bound */
	   SCIP_Real*            ub,                 /**< pointer to store the upper bound */
	   char**                endptr              /**< pointer to store the final string position if successfully parsed (or NULL if an error occured) */
	   )
	{
	   char token[SCIP_MAXSTRLEN];
	   char* tmpend;
	
	   SCIPsetDebugMsg(set, "parsing bounds: '%s'\n", str);
	
	   /* get bound type */
	   SCIPstrCopySection(str, ' ', ' ', type, SCIP_MAXSTRLEN, endptr);
	   if ( strncmp(type, "original", 8) != 0 && strncmp(type, "global", 6) != 0 && strncmp(type, "local", 5) != 0 && strncmp(type, "lazy", 4) != 0 )
	   {
	      SCIPsetDebugMsg(set, "unkown bound type <%s>\n", type);
	      *endptr = NULL;
	      return SCIP_OKAY;
	   }
	
	   SCIPsetDebugMsg(set, "parsed bound type <%s>\n", type);
	
	   /* get lower bound */
	   SCIPstrCopySection(str, '[', ',', token, SCIP_MAXSTRLEN, endptr);
	   str = *endptr;
	   SCIP_CALL( parseValue(set, token, lb, &tmpend) );
	
	   /* get upper bound */
	   SCIP_CALL( parseValue(set, str, ub, endptr) );
	
	   SCIPsetDebugMsg(set, "parsed bounds: [%g,%g]\n", *lb, *ub);
	
	   /* skip end of bounds */
	   while ( **endptr != '\0' && (**endptr == ']' || **endptr == ',') )
	      ++(*endptr);
	
	   return SCIP_OKAY;
	}
	
	/** parses a given string for a variable informations */
	static
	SCIP_RETCODE varParse(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
	   const char*           str,                /**< string to parse */
	   char*                 name,               /**< pointer to store the variable name */
	   SCIP_Real*            lb,                 /**< pointer to store the lower bound */
	   SCIP_Real*            ub,                 /**< pointer to store the upper bound */
	   SCIP_Real*            obj,                /**< pointer to store the objective coefficient */
	   SCIP_VARTYPE*         vartype,            /**< pointer to store the variable type */
	   SCIP_Real*            lazylb,             /**< pointer to store if the lower bound is lazy */
	   SCIP_Real*            lazyub,             /**< pointer to store if the upper bound is lazy */
	   SCIP_Bool             local,              /**< should the local bound be applied */
	   char**                endptr,             /**< pointer to store the final string position if successfully */
	   SCIP_Bool*            success             /**< pointer store if the paring process was successful */
	   )
	{
	   SCIP_Real parsedlb;
	   SCIP_Real parsedub;
	   char token[SCIP_MAXSTRLEN];
	   char* strptr;
	   int i;
	
	   assert(lb != NULL);
	   assert(ub != NULL);
	   assert(obj != NULL);
	   assert(vartype != NULL);
	   assert(lazylb != NULL);
	   assert(lazyub != NULL);
	   assert(success != NULL);
	
	   (*success) = TRUE;
	
	   /* copy variable type */
	   SCIPstrCopySection(str, '[', ']', token, SCIP_MAXSTRLEN, endptr);
	   assert(str != *endptr);
	   SCIPsetDebugMsg(set, "parsed variable type <%s>\n", token);
	
	   /* get variable type */
	   if( strncmp(token, "binary", 3) == 0 )
	      (*vartype) = SCIP_VARTYPE_BINARY;
	   else if( strncmp(token, "integer", 3) == 0 )
	      (*vartype) = SCIP_VARTYPE_INTEGER;
	   else if( strncmp(token, "implicit", 3) == 0 )
	      (*vartype) = SCIP_VARTYPE_IMPLINT;
	   else if( strncmp(token, "continuous", 3) == 0 )
	      (*vartype) = SCIP_VARTYPE_CONTINUOUS;
	   else
	   {
	      SCIPmessagePrintWarning(messagehdlr, "unknown variable type\n");
	      (*success) = FALSE;
	      return SCIP_OKAY;
	   }
	
	   /* move string pointer behind variable type */
	   str = *endptr;
	
	   /* get variable name */
	   SCIPstrCopySection(str, '<', '>', name, SCIP_MAXSTRLEN, endptr);
	   assert(endptr != NULL);
	   SCIPsetDebugMsg(set, "parsed variable name <%s>\n", name);
	
	   /* move string pointer behind variable name */
	   str = *endptr;
	
	   /* cut out objective coefficient */
	   SCIPstrCopySection(str, '=', ',', token, SCIP_MAXSTRLEN, endptr);
	
	   /* move string pointer behind objective coefficient */
	   str = *endptr;
	
	   /* get objective coefficient */
	   if( !SCIPstrToRealValue(token, obj, endptr) )
	   {
	      *endptr = NULL;
	      return SCIP_READERROR;
	   }
	
	   SCIPsetDebugMsg(set, "parsed objective coefficient <%g>\n", *obj);
	
	   /* parse global/original bounds */
	   SCIP_CALL( parseBounds(set, str, token, lb, ub, endptr) );
	   if ( *endptr == NULL )
	   {
	      SCIPerrorMessage("Expected bound type: %s.\n", token);
	      return SCIP_READERROR;
	   }
	   assert(strncmp(token, "global", 6) == 0 || strncmp(token, "original", 8) == 0);
	
	   /* initialize the lazy bound */
	   *lazylb = -SCIPsetInfinity(set);
	   *lazyub =  SCIPsetInfinity(set);
	
	   /* store pointer */
	   strptr = *endptr;
	
	   /* possibly parse optional local and lazy bounds */
	   for( i = 0; i < 2 && *endptr != NULL && **endptr != '\0'; ++i )
	   {
	      /* start after previous bounds */
	      strptr = *endptr;
	
	      /* parse global bounds */
	      SCIP_CALL( parseBounds(set, strptr, token, &parsedlb, &parsedub, endptr) );
	
	      /* stop if parsing of bounds failed */
	      if( *endptr == NULL )
	         break;
	
	      if( strncmp(token, "local", 5) == 0 && local )
	      {
	         *lb = parsedlb;
	         *ub = parsedub;
	      }
	      else if( strncmp(token, "lazy", 4) == 0 )
	      {
	         *lazylb = parsedlb;
	         *lazyub = parsedub;
	      }
	   }
	
	   /* restore pointer */
	   if ( *endptr == NULL )
	      *endptr = strptr;
	
	   /* check bounds for binary variables */
	   if ( (*vartype) == SCIP_VARTYPE_BINARY )
	   {
	      if ( SCIPsetIsLT(set, *lb, 0.0) || SCIPsetIsGT(set, *ub, 1.0) )
	      {
	         SCIPerrorMessage("Parsed invalid bounds for binary variable <%s>: [%f, %f].\n", name, *lb, *ub);
	         return SCIP_READERROR;
	      }
	      if ( !SCIPsetIsInfinity(set, -(*lazylb)) && !SCIPsetIsInfinity(set, *lazyub) && 
	           ( SCIPsetIsLT(set, *lazylb, 0.0) || SCIPsetIsGT(set, *lazyub, 1.0) ) )
	      {
	         SCIPerrorMessage("Parsed invalid lazy bounds for binary variable <%s>: [%f, %f].\n", name, *lazylb, *lazyub);
	         return SCIP_READERROR;
	      }
	   }
	
	   return SCIP_OKAY;
	}
	
	/** parses variable information (in cip format) out of a string; if the parsing process was successful an original
	 *  variable is created and captured; if variable is of integral type, fractional bounds are automatically rounded; an
	 *  integer variable with bounds zero and one is automatically converted into a binary variable
	 */
	SCIP_RETCODE SCIPvarParseOriginal(
	   SCIP_VAR**            var,                /**< pointer to variable data */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   const char*           str,                /**< string to parse */
	   SCIP_Bool             initial,            /**< should var's column be present in the initial root LP? */
	   SCIP_Bool             removable,          /**< is var's column removable from the LP (due to aging or cleanup)? */
	   SCIP_DECL_VARCOPY     ((*varcopy)),       /**< copies variable data if wanted to subscip, or NULL */
	   SCIP_DECL_VARDELORIG  ((*vardelorig)),    /**< frees user data of original variable */
	   SCIP_DECL_VARTRANS    ((*vartrans)),      /**< creates transformed user data by transforming original user data */
	   SCIP_DECL_VARDELTRANS ((*vardeltrans)),   /**< frees user data of transformed variable */
	   SCIP_VARDATA*         vardata,            /**< user data for this specific variable */
	   char**                endptr,             /**< pointer to store the final string position if successfully */
	   SCIP_Bool*            success             /**< pointer store if the paring process was successful */
	   )
	{
	   char name[SCIP_MAXSTRLEN];
	   SCIP_Real lb;
	   SCIP_Real ub;
	   SCIP_Real obj;
	   SCIP_VARTYPE vartype;
	   SCIP_Real lazylb;
	   SCIP_Real lazyub;
	
	   assert(var != NULL);
	   assert(blkmem != NULL);
	   assert(stat != NULL);
	   assert(endptr != NULL);
	   assert(success != NULL);
	
	   /* parse string in cip format for variable information */
	   SCIP_CALL( varParse(set, messagehdlr, str, name, &lb, &ub, &obj, &vartype, &lazylb, &lazyub, FALSE, endptr, success) );
	
	   if( *success ) /*lint !e774*/
	   {
	      /* create variable */
	      SCIP_CALL( varCreate(var, blkmem, set, stat, name, lb, ub, obj, vartype, initial, removable,
	            varcopy, vardelorig, vartrans, vardeltrans, vardata) );
	
	      /* set variable status and data */
	      (*var)->varstatus = SCIP_VARSTATUS_ORIGINAL; /*lint !e641*/
	      (*var)->data.original.origdom.holelist = NULL;
	      (*var)->data.original.origdom.lb = lb;
	      (*var)->data.original.origdom.ub = ub;
	      (*var)->data.original.transvar = NULL;
	
	      /* set lazy status of variable bounds */
	      (*var)->lazylb = lazylb;
	      (*var)->lazyub = lazyub;
	
	      /* capture variable */
	      SCIPvarCapture(*var);
	   }
	
	   return SCIP_OKAY;
	}
	
	/** parses variable information (in cip format) out of a string; if the parsing process was successful a loose variable
	 *  belonging to the transformed problem is created and captured; if variable is of integral type, fractional bounds are
	 *  automatically rounded; an integer variable with bounds zero and one is automatically converted into a binary
	 *  variable
	 */
	SCIP_RETCODE SCIPvarParseTransformed(
	   SCIP_VAR**            var,                /**< pointer to variable data */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   const char*           str,                /**< string to parse */
	   SCIP_Bool             initial,            /**< should var's column be present in the initial root LP? */
	   SCIP_Bool             removable,          /**< is var's column removable from the LP (due to aging or cleanup)? */
	   SCIP_DECL_VARCOPY     ((*varcopy)),       /**< copies variable data if wanted to subscip, or NULL */
	   SCIP_DECL_VARDELORIG  ((*vardelorig)),    /**< frees user data of original variable */
	   SCIP_DECL_VARTRANS    ((*vartrans)),      /**< creates transformed user data by transforming original user data */
	   SCIP_DECL_VARDELTRANS ((*vardeltrans)),   /**< frees user data of transformed variable */
	   SCIP_VARDATA*         vardata,            /**< user data for this specific variable */
	   char**                endptr,             /**< pointer to store the final string position if successfully */
	   SCIP_Bool*            success             /**< pointer store if the paring process was successful */
	   )
	{
	   char name[SCIP_MAXSTRLEN];
	   SCIP_Real lb;
	   SCIP_Real ub;
	   SCIP_Real obj;
	   SCIP_VARTYPE vartype;
	   SCIP_Real lazylb;
	   SCIP_Real lazyub;
	
	   assert(var != NULL);
	   assert(blkmem != NULL);
	   assert(endptr != NULL);
	   assert(success != NULL);
	
	   /* parse string in cip format for variable information */
	   SCIP_CALL( varParse(set, messagehdlr, str, name, &lb, &ub, &obj, &vartype, &lazylb, &lazyub, TRUE, endptr, success) );
	
	   if( *success ) /*lint !e774*/
	   {
	      /* create variable */
	      SCIP_CALL( varCreate(var, blkmem, set, stat, name, lb, ub, obj, vartype, initial, removable,
	            varcopy, vardelorig, vartrans, vardeltrans, vardata) );
	
	      /* create event filter for transformed variable */
	      SCIP_CALL( SCIPeventfilterCreate(&(*var)->eventfilter, blkmem) );
	
	      /* set variable status and data */
	      (*var)->varstatus = SCIP_VARSTATUS_LOOSE; /*lint !e641*/
	
	      /* set lazy status of variable bounds */
	      (*var)->lazylb = lazylb;
	      (*var)->lazyub = lazyub;
	
	      /* capture variable */
	      SCIPvarCapture(*var);
	   }
	
	   return SCIP_OKAY;   
	}
	
	/** ensures, that parentvars array of var can store at least num entries */
	static
	SCIP_RETCODE varEnsureParentvarsSize(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   int                   num                 /**< minimum number of entries to store */
	   )
	{
	   assert(var->nparentvars <= var->parentvarssize);
	
	   if( num > var->parentvarssize )
	   {
	      int newsize;
	
	      newsize = SCIPsetCalcMemGrowSize(set, num);
	      SCIP_ALLOC( BMSreallocBlockMemoryArray(blkmem, &var->parentvars, var->parentvarssize, newsize) );
	      var->parentvarssize = newsize;
	   }
	   assert(num <= var->parentvarssize);
	
	   return SCIP_OKAY;
	}
	
	/** adds variable to parent list of a variable and captures parent variable */
	static
	SCIP_RETCODE varAddParent(
	   SCIP_VAR*             var,                /**< variable to add parent to */
	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_VAR*             parentvar           /**< parent variable to add */
	   )
	{
	   assert(var != NULL);
	   assert(parentvar != NULL);
	
	   /* the direct original counterpart must be stored as first parent */
	   assert(var->nparentvars == 0 || SCIPvarGetStatus(parentvar) != SCIP_VARSTATUS_ORIGINAL);
	
	   SCIPsetDebugMsg(set, "adding parent <%s>[%p] to variable <%s>[%p] in slot %d\n",
	      parentvar->name, (void*)parentvar, var->name, (void*)var, var->nparentvars);
	
	   SCIP_CALL( varEnsureParentvarsSize(var, blkmem, set, var->nparentvars+1) );
	
	   var->parentvars[var->nparentvars] = parentvar;
	   var->nparentvars++;
	
	   SCIPvarCapture(parentvar);
	
	   return SCIP_OKAY;
	}
	
	/** deletes and releases all variables from the parent list of a variable, frees the memory of parents array */
	static
	SCIP_RETCODE varFreeParents(
	   SCIP_VAR**            var,                /**< pointer to variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue (or NULL, if it's an original variable) */
	   SCIP_LP*              lp                  /**< current LP data (or NULL, if it's an original variable) */
	   )
	{
	   SCIP_VAR* parentvar;
	   int i;
	
	   SCIPsetDebugMsg(set, "free parents of <%s>\n", (*var)->name);
	
	   /* release the parent variables and remove the link from the parent variable to the child */
	   for( i = 0; i < (*var)->nparentvars; ++i )
	   {
	      assert((*var)->parentvars != NULL);
	      parentvar = (*var)->parentvars[i];
	      assert(parentvar != NULL);
	
	      switch( SCIPvarGetStatus(parentvar) )
	      {
	      case SCIP_VARSTATUS_ORIGINAL:
	         assert(parentvar->data.original.transvar == *var);
	         assert(&parentvar->data.original.transvar != var);
	         parentvar->data.original.transvar = NULL;
	         break;
	
	      case SCIP_VARSTATUS_AGGREGATED:
	         assert(parentvar->data.aggregate.var == *var);
	         assert(&parentvar->data.aggregate.var != var);
	         parentvar->data.aggregate.var = NULL;
	         break;
	
	#if 0
	      /* The following code is unclear: should the current variable be removed from its parents? */
	      case SCIP_VARSTATUS_MULTAGGR:
	         assert(parentvar->data.multaggr.vars != NULL);
	         for( v = 0; v < parentvar->data.multaggr.nvars && parentvar->data.multaggr.vars[v] != *var; ++v )
	         {}
	         assert(v < parentvar->data.multaggr.nvars && parentvar->data.multaggr.vars[v] == *var);
	         if( v < parentvar->data.multaggr.nvars-1 )
	         {
	            parentvar->data.multaggr.vars[v] = parentvar->data.multaggr.vars[parentvar->data.multaggr.nvars-1];
	            parentvar->data.multaggr.scalars[v] = parentvar->data.multaggr.scalars[parentvar->data.multaggr.nvars-1];
	         }
	         parentvar->data.multaggr.nvars--;
	         break;
	#endif
	
	      case SCIP_VARSTATUS_NEGATED:
	         assert(parentvar->negatedvar == *var);
	         assert((*var)->negatedvar == parentvar);
	         parentvar->negatedvar = NULL;
	         (*var)->negatedvar = NULL;
	         break;
	
	      default:
	         SCIPerrorMessage("parent variable is neither ORIGINAL, AGGREGATED nor NEGATED\n");
	         return SCIP_INVALIDDATA;
	      }  /*lint !e788*/
	
	      SCIP_CALL( SCIPvarRelease(&(*var)->parentvars[i], blkmem, set, eventqueue, lp) );
	   }
	
	   /* free parentvars array */
	   BMSfreeBlockMemoryArrayNull(blkmem, &(*var)->parentvars, (*var)->parentvarssize);
	
	   return SCIP_OKAY;
	}
	
	/** frees a variable */
	static
	SCIP_RETCODE varFree(
	   SCIP_VAR**            var,                /**< pointer to variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue (may be NULL, if it's not a column variable) */
	   SCIP_LP*              lp                  /**< current LP data (may be NULL, if it's not a column variable) */
	   )
	{
	   assert(var != NULL);
	   assert(*var != NULL);
	   assert(SCIPvarGetStatus(*var) != SCIP_VARSTATUS_COLUMN || &(*var)->data.col->var != var);
	   assert((*var)->nuses == 0);
	   assert((*var)->probindex == -1);
	   assert((*var)->nlocksup[SCIP_LOCKTYPE_MODEL] == 0);
	   assert((*var)->nlocksdown[SCIP_LOCKTYPE_MODEL] == 0);
	
	   SCIPsetDebugMsg(set, "free variable <%s> with status=%d\n", (*var)->name, SCIPvarGetStatus(*var));
	
	   switch( SCIPvarGetStatus(*var) )
	   {
	   case SCIP_VARSTATUS_ORIGINAL:
	      assert((*var)->data.original.transvar == NULL); /* cannot free variable, if transformed variable is still existing */
	      holelistFree(&(*var)->data.original.origdom.holelist, blkmem);
	      assert((*var)->data.original.origdom.holelist == NULL);
	      break;
	   case SCIP_VARSTATUS_LOOSE:
	      break;
	   case SCIP_VARSTATUS_COLUMN:
	      SCIP_CALL( SCIPcolFree(&(*var)->data.col, blkmem, set, eventqueue, lp) );  /* free corresponding LP column */
	      break;
	   case SCIP_VARSTATUS_FIXED:
	   case SCIP_VARSTATUS_AGGREGATED:
	      break;
	   case SCIP_VARSTATUS_MULTAGGR:
	      BMSfreeBlockMemoryArray(blkmem, &(*var)->data.multaggr.vars, (*var)->data.multaggr.varssize);
	      BMSfreeBlockMemoryArray(blkmem, &(*var)->data.multaggr.scalars, (*var)->data.multaggr.varssize);
	      break;
	   case SCIP_VARSTATUS_NEGATED:
	      break;
	   default:
	      SCIPerrorMessage("unknown variable status\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   /* release all parent variables and free the parentvars array */
	   SCIP_CALL( varFreeParents(var, blkmem, set, eventqueue, lp) );
	
	   /* free user data */
	   if( SCIPvarGetStatus(*var) == SCIP_VARSTATUS_ORIGINAL )
	   {
	      if( (*var)->vardelorig != NULL )
	      {
	         SCIP_CALL( (*var)->vardelorig(set->scip, *var, &(*var)->vardata) );
	      }
	   }
	   else
	   {
	      if( (*var)->vardeltrans != NULL )
	      {
	         SCIP_CALL( (*var)->vardeltrans(set->scip, *var, &(*var)->vardata) );
	      }
	   }
	
	   /* free event filter */
	   if( (*var)->eventfilter != NULL )
	   {
	      SCIP_CALL( SCIPeventfilterFree(&(*var)->eventfilter, blkmem, set) );
	   }
	   assert((*var)->eventfilter == NULL);
	
	   /* free hole lists */
	   holelistFree(&(*var)->glbdom.holelist, blkmem);
	   holelistFree(&(*var)->locdom.holelist, blkmem);
	   assert((*var)->glbdom.holelist == NULL);
	   assert((*var)->locdom.holelist == NULL);
	
	   /* free variable bounds data structures */
	   SCIPvboundsFree(&(*var)->vlbs, blkmem);
	   SCIPvboundsFree(&(*var)->vubs, blkmem);
	
	   /* free implications data structures */
	   SCIPimplicsFree(&(*var)->implics, blkmem);
	
	   /* free clique list data structures */
	   SCIPcliquelistFree(&(*var)->cliquelist, blkmem);
	
	   /* free bound change information arrays */
	   BMSfreeBlockMemoryArrayNull(blkmem, &(*var)->lbchginfos, (*var)->lbchginfossize);
	   BMSfreeBlockMemoryArrayNull(blkmem, &(*var)->ubchginfos, (*var)->ubchginfossize);
	
	   /* free branching and inference history entries */
	   SCIPhistoryFree(&(*var)->history, blkmem);
	   SCIPhistoryFree(&(*var)->historycrun, blkmem);
	   SCIPvaluehistoryFree(&(*var)->valuehistory, blkmem);
	
	   /* free variable data structure */
	   BMSfreeBlockMemoryArray(blkmem, &(*var)->name, strlen((*var)->name)+1);
	   BMSfreeBlockMemory(blkmem, var);
	
	   return SCIP_OKAY;
	}
	
	/** increases usage counter of variable */
	void SCIPvarCapture(
	   SCIP_VAR*             var                 /**< variable */
	   )
	{
	   assert(var != NULL);
	   assert(var->nuses >= 0);
	
	   SCIPdebugMessage("capture variable <%s> with nuses=%d\n", var->name, var->nuses);
	   var->nuses++;
	
	#ifdef DEBUGUSES_VARNAME
	   if( strcmp(var->name, DEBUGUSES_VARNAME) == 0
	#ifdef DEBUGUSES_PROBNAME
	      && ((var->scip->transprob != NULL && strcmp(SCIPprobGetName(var->scip->transprob), DEBUGUSES_PROBNAME) == 0) ||
	          strcmp(SCIPprobGetName(var->scip->origprob), DEBUGUSES_PROBNAME) == 0)
	#endif
	   )
	   {
	      printf("Captured variable " DEBUGUSES_VARNAME " in SCIP %p, now %d uses; captured at\n", (void*)var->scip, var->nuses);
	      print_backtrace();
	   }
	#endif
	}
	
	/** decreases usage counter of variable, and frees memory if necessary */
	SCIP_RETCODE SCIPvarRelease(
	   SCIP_VAR**            var,                /**< pointer to variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_LP*              lp                  /**< current LP data (or NULL, if it's an original variable) */
	   )
	{
	   assert(var != NULL);
	   assert(*var != NULL);
	   assert((*var)->nuses >= 1);
	   assert(blkmem != NULL);
	   assert((*var)->scip == set->scip);
	
	   SCIPsetDebugMsg(set, "release variable <%s> with nuses=%d\n", (*var)->name, (*var)->nuses);
	   (*var)->nuses--;
	
	#ifdef DEBUGUSES_VARNAME
	   if( strcmp((*var)->name, DEBUGUSES_VARNAME) == 0
	#ifdef DEBUGUSES_PROBNAME
	      && (((*var)->scip->transprob != NULL && strcmp(SCIPprobGetName((*var)->scip->transprob), DEBUGUSES_PROBNAME) == 0) ||
	          strcmp(SCIPprobGetName((*var)->scip->origprob), DEBUGUSES_PROBNAME) == 0)
	#endif
	   )
	   {
	      printf("Released variable " DEBUGUSES_VARNAME " in SCIP %p, now %d uses; released at\n", (void*)(*var)->scip, (*var)->nuses);
	      print_backtrace();
	   }
	#endif
	
	   if( (*var)->nuses == 0 )
	   {
	      SCIP_CALL( varFree(var, blkmem, set, eventqueue, lp) );
	   }
	
	   *var = NULL;
	
	   return SCIP_OKAY;
	}
	
	/** change variable name */
	SCIP_RETCODE SCIPvarChgName(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   const char*           name                /**< name of variable */
	   )
	{
	   assert(name != NULL);
	
	   /* remove old variable name */
	   BMSfreeBlockMemoryArray(blkmem, &var->name, strlen(var->name)+1);
	
	   /* set new variable name */
	   SCIP_CALL( varSetName(var, blkmem, NULL, name) );
	
	   return SCIP_OKAY;
	}
	
	/** initializes variable data structure for solving */
	void SCIPvarInitSolve(
	   SCIP_VAR*             var                 /**< problem variable */
	   )
	{
	   assert(var != NULL);
	
	   SCIPhistoryReset(var->historycrun);
	   var->conflictlbcount = 0;
	   var->conflictubcount = 0;
	}
	
	/** outputs the given bounds into the file stream */
	static
	void printBounds(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
	   FILE*                 file,               /**< output file (or NULL for standard output) */
	   SCIP_Real             lb,                 /**< lower bound */
	   SCIP_Real             ub,                 /**< upper bound */
	   const char*           name                /**< bound type name */
	   )
	{
	   assert(set != NULL);
	
	   SCIPmessageFPrintInfo(messagehdlr, file, ", %s=", name);
	   if( SCIPsetIsInfinity(set, lb) )
	      SCIPmessageFPrintInfo(messagehdlr, file, "[+inf,");
	   else if( SCIPsetIsInfinity(set, -lb) )
	      SCIPmessageFPrintInfo(messagehdlr, file, "[-inf,");
	   else
	      SCIPmessageFPrintInfo(messagehdlr, file, "[%.15g,", lb);
	   if( SCIPsetIsInfinity(set, ub) )
	      SCIPmessageFPrintInfo(messagehdlr, file, "+inf]");
	   else if( SCIPsetIsInfinity(set, -ub) )
	      SCIPmessageFPrintInfo(messagehdlr, file, "-inf]");
	   else
	      SCIPmessageFPrintInfo(messagehdlr, file, "%.15g]", ub);
	}
	
	/** prints hole list to file stream */
	static
	void printHolelist(
	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
	   FILE*                 file,               /**< output file (or NULL for standard output) */
	   SCIP_HOLELIST*        holelist,           /**< hole list pointer to hole of interest */
	   const char*           name                /**< hole type name */
	   )
	{  /*lint --e{715}*/
	   SCIP_Real left;
	   SCIP_Real right;
	
	   if( holelist == NULL )
	      return;
	
	   left = SCIPholelistGetLeft(holelist);
	   right = SCIPholelistGetRight(holelist);
	
	   /* display first hole */
	   SCIPmessageFPrintInfo(messagehdlr, file, ", %s=(%g,%g)", name, left, right);
	   holelist = SCIPholelistGetNext(holelist);
	
	   while(holelist != NULL  )
	   {
	      left = SCIPholelistGetLeft(holelist);
	      right = SCIPholelistGetRight(holelist);
	
	      /* display hole */
	      SCIPmessageFPrintInfo(messagehdlr, file, "(%g,%g)", left, right);
	
	      /* get next hole */
	      holelist = SCIPholelistGetNext(holelist);
	   }
	}
	
	/** outputs variable information into file stream */
	SCIP_RETCODE SCIPvarPrint(
	   SCIP_VAR*             var,                /**< problem variable */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
	   FILE*                 file                /**< output file (or NULL for standard output) */
	   )
	{
	   SCIP_HOLELIST* holelist;
	   SCIP_Real lb;
	   SCIP_Real ub;
	   int i;
	
	   assert(var != NULL);
	   assert(var->scip == set->scip);
	
	   /* type of variable */
	   switch( SCIPvarGetType(var) )
	   {
	   case SCIP_VARTYPE_BINARY:
	      SCIPmessageFPrintInfo(messagehdlr, file, "  [binary]");
	      break;
	   case SCIP_VARTYPE_INTEGER:
	      SCIPmessageFPrintInfo(messagehdlr, file, "  [integer]");
	      break;
	   case SCIP_VARTYPE_IMPLINT:
	      SCIPmessageFPrintInfo(messagehdlr, file, "  [implicit]");
	      break;
	   case SCIP_VARTYPE_CONTINUOUS:
	      SCIPmessageFPrintInfo(messagehdlr, file, "  [continuous]");
	      break;
	   default:
	      SCIPerrorMessage("unknown variable type\n");
	      SCIPABORT();
	      return SCIP_ERROR; /*lint !e527*/
	   }
	
	   /* name */
	   SCIPmessageFPrintInfo(messagehdlr, file, " <%s>:", var->name);
	
	   /* objective value */
	   SCIPmessageFPrintInfo(messagehdlr, file, " obj=%.15g", var->obj);
	
	   /* bounds (global bounds for transformed variables, original bounds for original variables) */
	   if( !SCIPvarIsTransformed(var) )
	   {
	      /* output original bound */
	      lb = SCIPvarGetLbOriginal(var);
	      ub = SCIPvarGetUbOriginal(var);
	      printBounds(set, messagehdlr, file, lb, ub, "original bounds");
	
	      /* output lazy bound */
	      lb = SCIPvarGetLbLazy(var);
	      ub = SCIPvarGetUbLazy(var);
	
	      /* only display the lazy bounds if they are different from [-infinity,infinity] */
	      if( !SCIPsetIsInfinity(set, -lb) || !SCIPsetIsInfinity(set, ub) )
	         printBounds(set, messagehdlr, file, lb, ub, "lazy bounds");
	
	      holelist = SCIPvarGetHolelistOriginal(var);
	      printHolelist(messagehdlr, file, holelist, "original holes");
	   }
	   else
	   {
	      /* output global bound */
	      lb = SCIPvarGetLbGlobal(var);
	      ub = SCIPvarGetUbGlobal(var);
	      printBounds(set, messagehdlr, file, lb, ub, "global bounds");
	
	      /* output local bound */
	      lb = SCIPvarGetLbLocal(var);
	      ub = SCIPvarGetUbLocal(var);
	      printBounds(set, messagehdlr, file, lb, ub, "local bounds");
	
	      /* output lazy bound */
	      lb = SCIPvarGetLbLazy(var);
	      ub = SCIPvarGetUbLazy(var);
	
	      /* only display the lazy bounds if they are different from [-infinity,infinity] */
	      if( !SCIPsetIsInfinity(set, -lb) || !SCIPsetIsInfinity(set, ub) )
	         printBounds(set, messagehdlr, file, lb, ub, "lazy bounds");
	
	      /* global hole list */
	      holelist = SCIPvarGetHolelistGlobal(var);
	      printHolelist(messagehdlr, file, holelist, "global holes");
	
	      /* local hole list */
	      holelist = SCIPvarGetHolelistLocal(var);
	      printHolelist(messagehdlr, file, holelist, "local holes");
	   }
	
	   /* fixings and aggregations */
	   switch( SCIPvarGetStatus(var) )
	   {
	   case SCIP_VARSTATUS_ORIGINAL:
	   case SCIP_VARSTATUS_LOOSE:
	   case SCIP_VARSTATUS_COLUMN:
	      break;
	
	   case SCIP_VARSTATUS_FIXED:
	      SCIPmessageFPrintInfo(messagehdlr, file, ", fixed:");
	      if( SCIPsetIsInfinity(set, var->glbdom.lb) )
	         SCIPmessageFPrintInfo(messagehdlr, file, "+inf");
	      else if( SCIPsetIsInfinity(set, -var->glbdom.lb) )
	         SCIPmessageFPrintInfo(messagehdlr, file, "-inf");
	      else
	         SCIPmessageFPrintInfo(messagehdlr, file, "%.15g", var->glbdom.lb);
	      break;
	
	   case SCIP_VARSTATUS_AGGREGATED:
	      SCIPmessageFPrintInfo(messagehdlr, file, ", aggregated:");
	      if( !SCIPsetIsZero(set, var->data.aggregate.constant) )
	         SCIPmessageFPrintInfo(messagehdlr, file, " %.15g", var->data.aggregate.constant);
	      SCIPmessageFPrintInfo(messagehdlr, file, " %+.15g<%s>", var->data.aggregate.scalar, SCIPvarGetName(var->data.aggregate.var));
	      break;
	
	   case SCIP_VARSTATUS_MULTAGGR:
	      SCIPmessageFPrintInfo(messagehdlr, file, ", aggregated:");
	      if( var->data.multaggr.nvars == 0 || !SCIPsetIsZero(set, var->data.multaggr.constant) )
	         SCIPmessageFPrintInfo(messagehdlr, file, " %.15g", var->data.multaggr.constant);
	      for( i = 0; i < var->data.multaggr.nvars; ++i )
	         SCIPmessageFPrintInfo(messagehdlr, file, " %+.15g<%s>", var->data.multaggr.scalars[i], SCIPvarGetName(var->data.multaggr.vars[i]));
	      break;
	
	   case SCIP_VARSTATUS_NEGATED:
	      SCIPmessageFPrintInfo(messagehdlr, file, ", negated: %.15g - <%s>", var->data.negate.constant, SCIPvarGetName(var->negatedvar));
	      break;
	
	   default:
	      SCIPerrorMessage("unknown variable status\n");
	      SCIPABORT();
	      return SCIP_ERROR; /*lint !e527*/
	   }
	
	   SCIPmessageFPrintInfo(messagehdlr, file, "\n");
	
	   return SCIP_OKAY;
	}
	
	/** issues a VARUNLOCKED event on the given variable */
	static
	SCIP_RETCODE varEventVarUnlocked(
	   SCIP_VAR*             var,                /**< problem variable to change */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue          /**< event queue */
	   )
	{
	   SCIP_EVENT* event;
	
	   assert(var != NULL);
	   assert(var->nlocksdown[SCIP_LOCKTYPE_MODEL] <= 1 && var->nlocksup[SCIP_LOCKTYPE_MODEL] <= 1);
	   assert(var->scip == set->scip);
	
	   /* issue VARUNLOCKED event on variable */
	   SCIP_CALL( SCIPeventCreateVarUnlocked(&event, blkmem, var) );
	   SCIP_CALL( SCIPeventqueueAdd(eventqueue, blkmem, set, NULL, NULL, NULL, NULL, &event) );
	
	   return SCIP_OKAY;
	}
	
	/** modifies lock numbers for rounding */
	SCIP_RETCODE SCIPvarAddLocks(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_LOCKTYPE         locktype,           /**< type of the variable locks */
	   int                   addnlocksdown,      /**< increase in number of rounding down locks */
	   int                   addnlocksup         /**< increase in number of rounding up locks */
	   )
	{
	   SCIP_VAR* lockvar;
	
	   assert(var != NULL);
	   assert((int)locktype >= 0 && (int)locktype < (int)NLOCKTYPES); /*lint !e685 !e568 !e587 !e650*/
	   assert(var->nlocksup[locktype] >= 0);
	   assert(var->nlocksdown[locktype] >= 0);
	   assert(var->scip == set->scip);
	
	   if( addnlocksdown == 0 && addnlocksup == 0 )
	      return SCIP_OKAY;
	
	#ifdef SCIP_DEBUG
	   SCIPsetDebugMsg(set, "add rounding locks %d/%d to variable <%s> (locks=%d/%d, type=%u)\n",
	         addnlocksdown, addnlocksup, var->name, var->nlocksdown[locktype], var->nlocksup[locktype], locktype);
	#endif
	
	   lockvar = var;
	
	   while( TRUE ) /*lint !e716 */
	   {
	      assert(lockvar != NULL);
	
	      switch( SCIPvarGetStatus(lockvar) )
	      {
	      case SCIP_VARSTATUS_ORIGINAL:
	         if( lockvar->data.original.transvar != NULL )
	         {
	            lockvar = lockvar->data.original.transvar;
	            break;
	         }
	         else
	         {
	            lockvar->nlocksdown[locktype] += addnlocksdown;
	            lockvar->nlocksup[locktype] += addnlocksup;
	
	            assert(lockvar->nlocksdown[locktype] >= 0);
	            assert(lockvar->nlocksup[locktype] >= 0);
	
	            return SCIP_OKAY;
	         }
	      case SCIP_VARSTATUS_LOOSE:
	      case SCIP_VARSTATUS_COLUMN:
	      case SCIP_VARSTATUS_FIXED:
	         lockvar->nlocksdown[locktype] += addnlocksdown;
	         lockvar->nlocksup[locktype] += addnlocksup;
	
	         assert(lockvar->nlocksdown[locktype] >= 0);
	         assert(lockvar->nlocksup[locktype] >= 0);
	
	         if( locktype == SCIP_LOCKTYPE_MODEL && lockvar->nlocksdown[locktype] <= 1
	            && lockvar->nlocksup[locktype] <= 1 )
	         {
	            SCIP_CALL( varEventVarUnlocked(lockvar, blkmem, set, eventqueue) );
	         }
	
	         return SCIP_OKAY;
	      case SCIP_VARSTATUS_AGGREGATED:
	         assert(!lockvar->donotaggr);
	
	         if( lockvar->data.aggregate.scalar < 0.0 )
	         {
	            int tmp = addnlocksup;
	
	            addnlocksup = addnlocksdown;
	            addnlocksdown = tmp;
	         }
	
	         lockvar = lockvar->data.aggregate.var;
	         break;
	      case SCIP_VARSTATUS_MULTAGGR:
	      {
	         int v;
	
	         assert(!lockvar->donotmultaggr);
	
	         lockvar->nlocksdown[locktype] += addnlocksdown;
	         lockvar->nlocksup[locktype] += addnlocksup;
	
	         assert(lockvar->nlocksdown[locktype] >= 0);
	         assert(lockvar->nlocksup[locktype] >= 0);
	
	         for( v = lockvar->data.multaggr.nvars - 1; v >= 0; --v )
	         {
	            if( lockvar->data.multaggr.scalars[v] > 0.0 )
	            {
	               SCIP_CALL( SCIPvarAddLocks(lockvar->data.multaggr.vars[v], blkmem, set, eventqueue, locktype, addnlocksdown,
	                     addnlocksup) );
	            }
	            else
	            {
	               SCIP_CALL( SCIPvarAddLocks(lockvar->data.multaggr.vars[v], blkmem, set, eventqueue, locktype, addnlocksup,
	                     addnlocksdown) );
	            }
	         }
	         return SCIP_OKAY;
	      }
	      case SCIP_VARSTATUS_NEGATED:
	      {
	         int tmp = addnlocksup;
	
	         assert(lockvar->negatedvar != NULL);
	         assert(SCIPvarGetStatus(lockvar->negatedvar) != SCIP_VARSTATUS_NEGATED);
	         assert(lockvar->negatedvar->negatedvar == lockvar);
	
	         addnlocksup = addnlocksdown;
	         addnlocksdown = tmp;
	
	         lockvar = lockvar->negatedvar;
	         break;
	      }
	      default:
	         SCIPerrorMessage("unknown variable status\n");
	         return SCIP_INVALIDDATA;
	      }
	   }
	}
	
	/** gets number of locks for rounding down of a special type */
	int SCIPvarGetNLocksDownType(
	   SCIP_VAR*             var,                /**< problem variable */
	   SCIP_LOCKTYPE         locktype            /**< type of variable locks */
	   )
	{
	   int nlocks;
	   int i;
	
	   assert(var != NULL);
	   assert((int)locktype >= 0 && (int)locktype < (int)NLOCKTYPES); /*lint !e685 !e568 !e587 !e650*/
	   assert(var->nlocksdown[locktype] >= 0);
	
	   switch( SCIPvarGetStatus(var) )
	   {
	   case SCIP_VARSTATUS_ORIGINAL:
	      if( var->data.original.transvar != NULL )
	         return SCIPvarGetNLocksDownType(var->data.original.transvar, locktype);
	      else
	         return var->nlocksdown[locktype];
	
	   case SCIP_VARSTATUS_LOOSE:
	   case SCIP_VARSTATUS_COLUMN:
	   case SCIP_VARSTATUS_FIXED:
	      return var->nlocksdown[locktype];
	
	   case SCIP_VARSTATUS_AGGREGATED:
	      assert(!var->donotaggr);
	      if( var->data.aggregate.scalar > 0.0 )
	         return SCIPvarGetNLocksDownType(var->data.aggregate.var, locktype);
	      else
	         return SCIPvarGetNLocksUpType(var->data.aggregate.var, locktype);
	
	   case SCIP_VARSTATUS_MULTAGGR:
	      assert(!var->donotmultaggr);
	      nlocks = 0;
	      for( i = 0; i < var->data.multaggr.nvars; ++i )
	      {
	         if( var->data.multaggr.scalars[i] > 0.0 )
	            nlocks += SCIPvarGetNLocksDownType(var->data.multaggr.vars[i], locktype);
	         else
	            nlocks += SCIPvarGetNLocksUpType(var->data.multaggr.vars[i], locktype);
	      }
	      return nlocks;
	
	   case SCIP_VARSTATUS_NEGATED:
	      assert(var->negatedvar != NULL);
	      assert(SCIPvarGetStatus(var->negatedvar) != SCIP_VARSTATUS_NEGATED);
	      assert(var->negatedvar->negatedvar == var);
	      return SCIPvarGetNLocksUpType(var->negatedvar, locktype);
	
	   default:
	      SCIPerrorMessage("unknown variable status\n");
	      SCIPABORT();
	      return INT_MAX; /*lint !e527*/
	   }
	}
	
	/** gets number of locks for rounding up of a special type */
	int SCIPvarGetNLocksUpType(
	   SCIP_VAR*             var,                /**< problem variable */
	   SCIP_LOCKTYPE         locktype            /**< type of variable locks */
	   )
	{
	   int nlocks;
	   int i;
	
	   assert(var != NULL);
	   assert((int)locktype >= 0 && (int)locktype < (int)NLOCKTYPES); /*lint !e685 !e568 !e587 !e650*/
	   assert(var->nlocksup[locktype] >= 0);
	
	   switch( SCIPvarGetStatus(var) )
	   {
	   case SCIP_VARSTATUS_ORIGINAL:
	      if( var->data.original.transvar != NULL )
	         return SCIPvarGetNLocksUpType(var->data.original.transvar, locktype);
	      else
	         return var->nlocksup[locktype];
	
	   case SCIP_VARSTATUS_LOOSE:
	   case SCIP_VARSTATUS_COLUMN:
	   case SCIP_VARSTATUS_FIXED:
	      return var->nlocksup[locktype];
	
	   case SCIP_VARSTATUS_AGGREGATED:
	      assert(!var->donotaggr);
	      if( var->data.aggregate.scalar > 0.0 )
	         return SCIPvarGetNLocksUpType(var->data.aggregate.var, locktype);
	      else
	         return SCIPvarGetNLocksDownType(var->data.aggregate.var, locktype);
	
	   case SCIP_VARSTATUS_MULTAGGR:
	      assert(!var->donotmultaggr);
	      nlocks = 0;
	      for( i = 0; i < var->data.multaggr.nvars; ++i )
	      {
	         if( var->data.multaggr.scalars[i] > 0.0 )
	            nlocks += SCIPvarGetNLocksUpType(var->data.multaggr.vars[i], locktype);
	         else
	            nlocks += SCIPvarGetNLocksDownType(var->data.multaggr.vars[i], locktype);
	      }
	      return nlocks;
	
	   case SCIP_VARSTATUS_NEGATED:
	      assert(var->negatedvar != NULL);
	      assert(SCIPvarGetStatus(var->negatedvar) != SCIP_VARSTATUS_NEGATED);
	      assert(var->negatedvar->negatedvar == var);
	      return SCIPvarGetNLocksDownType(var->negatedvar, locktype);
	
	   default:
	      SCIPerrorMessage("unknown variable status\n");
	      SCIPABORT();
	      return INT_MAX; /*lint !e527*/
	   }
	}
	
	/** gets number of locks for rounding down
	 *
	 *  @note This method will always return variable locks of type model
	 *
	 *  @note It is recommented to use SCIPvarGetNLocksDownType()
	 */
	int SCIPvarGetNLocksDown(
	   SCIP_VAR*             var                 /**< problem variable */
	   )
	{
	   return SCIPvarGetNLocksDownType(var, SCIP_LOCKTYPE_MODEL);
	}
	
	/** gets number of locks for rounding up
	 *
	 *  @note This method will always return variable locks of type model
	 *
	 *  @note It is recommented to use SCIPvarGetNLocksUpType()
	 */
	int SCIPvarGetNLocksUp(
	   SCIP_VAR*             var                 /**< problem variable */
	   )
	{
	   return SCIPvarGetNLocksUpType(var, SCIP_LOCKTYPE_MODEL);
	}
	
	/** is it possible, to round variable down and stay feasible?
	 *
	 *  @note This method will always check w.r.t variable locks of type model
	 */
	SCIP_Bool SCIPvarMayRoundDown(
	   SCIP_VAR*             var                 /**< problem variable */
	   )
	{
	   return (SCIPvarGetNLocksDownType(var, SCIP_LOCKTYPE_MODEL) == 0);
	}
	
	/** is it possible, to round variable up and stay feasible?
	 *
	 *  @note This method will always check w.r.t. variable locks of type model
	 */
	SCIP_Bool SCIPvarMayRoundUp(
	   SCIP_VAR*             var                 /**< problem variable */
	   )
	{
	   return (SCIPvarGetNLocksUpType(var, SCIP_LOCKTYPE_MODEL) == 0);
	}
	
	/** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
	 *  a new transformed variable for this variable is created
	 */
	SCIP_RETCODE SCIPvarTransform(
	   SCIP_VAR*             origvar,            /**< original problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_OBJSENSE         objsense,           /**< objective sense of original problem; transformed is always MINIMIZE */
	   SCIP_VAR**            transvar            /**< pointer to store the transformed variable */
	   )
	{
	   char name[SCIP_MAXSTRLEN];
	
	   assert(origvar != NULL);
	   assert(origvar->scip == set->scip);
	   assert(SCIPvarGetStatus(origvar) == SCIP_VARSTATUS_ORIGINAL);
	   assert(SCIPsetIsEQ(set, origvar->glbdom.lb, origvar->locdom.lb));
	   assert(SCIPsetIsEQ(set, origvar->glbdom.ub, origvar->locdom.ub));
	   assert(origvar->vlbs == NULL);
	   assert(origvar->vubs == NULL);
	   assert(transvar != NULL);
	
	   /* check if variable is already transformed */
	   if( origvar->data.original.transvar != NULL )
	   {
	      *transvar = origvar->data.original.transvar;
	      SCIPvarCapture(*transvar);
	   }
	   else
	   {
	      int i;
	
	      /* create transformed variable */
	      (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "t_%s", origvar->name);
	      SCIP_CALL( SCIPvarCreateTransformed(transvar, blkmem, set, stat, name,
	            origvar->glbdom.lb, origvar->glbdom.ub, (SCIP_Real)objsense * origvar->obj,
	            SCIPvarGetType(origvar), origvar->initial, origvar->removable,
	            origvar->vardelorig, origvar->vartrans, origvar->vardeltrans, origvar->varcopy, NULL) );
	
	      /* copy the branch factor and priority */
	      (*transvar)->branchfactor = origvar->branchfactor;
	      (*transvar)->branchpriority = origvar->branchpriority;
	      (*transvar)->branchdirection = origvar->branchdirection; /*lint !e732*/
	
	      /* duplicate hole lists */
	      SCIP_CALL( holelistDuplicate(&(*transvar)->glbdom.holelist, blkmem, set, origvar->glbdom.holelist) );
	      SCIP_CALL( holelistDuplicate(&(*transvar)->locdom.holelist, blkmem, set, origvar->locdom.holelist) );
	
	      /* link original and transformed variable */
	      origvar->data.original.transvar = *transvar;
	      SCIP_CALL( varAddParent(*transvar, blkmem, set, origvar) );
	
	      /* copy rounding locks */
	      for( i = 0; i < NLOCKTYPES; i++ )
	      {
	         (*transvar)->nlocksdown[i] = origvar->nlocksdown[i];
	         (*transvar)->nlocksup[i] = origvar->nlocksup[i];
	         assert((*transvar)->nlocksdown[i] >= 0);
	         assert((*transvar)->nlocksup[i] >= 0);
	      }
	
	      /* copy donot(mult)aggr status */
	      (*transvar)->donotaggr = origvar->donotaggr;
	      (*transvar)->donotmultaggr = origvar->donotmultaggr;
	
	      /* copy lazy bounds */
	      (*transvar)->lazylb = origvar->lazylb;
	      (*transvar)->lazyub = origvar->lazyub;
	
	      /* transfer eventual variable statistics; do not update global statistics, because this has been done
	       * when original variable was created
	       */
	      SCIPhistoryUnite((*transvar)->history, origvar->history, FALSE);
	
	      /* transform user data */
	      if( origvar->vartrans != NULL )
	      {
	         SCIP_CALL( origvar->vartrans(set->scip, origvar, origvar->vardata, *transvar, &(*transvar)->vardata) );
	      }
	      else
	         (*transvar)->vardata = origvar->vardata;
	   }
	
	   SCIPsetDebugMsg(set, "transformed variable: <%s>[%p] -> <%s>[%p]\n", origvar->name, (void*)origvar, (*transvar)->name, (void*)*transvar);
	
	   return SCIP_OKAY;
	}
	
	/** gets corresponding transformed variable of an original or negated original variable */
	SCIP_RETCODE SCIPvarGetTransformed(
	   SCIP_VAR*             origvar,            /**< original problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_VAR**            transvar            /**< pointer to store the transformed variable, or NULL if not existing yet */
	   )
	{
	   assert(origvar != NULL);
	   assert(SCIPvarGetStatus(origvar) == SCIP_VARSTATUS_ORIGINAL || SCIPvarGetStatus(origvar) == SCIP_VARSTATUS_NEGATED);
	   assert(origvar->scip == set->scip);
	
	   if( SCIPvarGetStatus(origvar) == SCIP_VARSTATUS_NEGATED )
	   {
	      assert(origvar->negatedvar != NULL);
	      assert(SCIPvarGetStatus(origvar->negatedvar) == SCIP_VARSTATUS_ORIGINAL);
	
	      if( origvar->negatedvar->data.original.transvar == NULL )
	         *transvar = NULL;
	      else
	      {
	         SCIP_CALL( SCIPvarNegate(origvar->negatedvar->data.original.transvar, blkmem, set, stat, transvar) );
	      }
	   }
	   else 
	      *transvar = origvar->data.original.transvar;
	
	   return SCIP_OKAY;
	}
	
	/** converts loose transformed variable into column variable, creates LP column */
	SCIP_RETCODE SCIPvarColumn(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_PROB*            prob,               /**< problem data */
	   SCIP_LP*              lp                  /**< current LP data */
	   )
	{
	   assert(var != NULL);
	   assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_LOOSE);
	   assert(var->scip == set->scip);
	
	   SCIPsetDebugMsg(set, "creating column for variable <%s>\n", var->name);
	
	   /* switch variable status */
	   var->varstatus = SCIP_VARSTATUS_COLUMN; /*lint !e641*/
	
	   /* create column of variable */
	   SCIP_CALL( SCIPcolCreate(&var->data.col, blkmem, set, stat, var, 0, NULL, NULL, var->removable) );
	
	   if( var->probindex != -1 )
	   {
	      /* inform problem about the variable's status change */
	      SCIP_CALL( SCIPprobVarChangedStatus(prob, blkmem, set, NULL, NULL, var) );
	
	      /* inform LP, that problem variable is now a column variable and no longer loose */
	      SCIP_CALL( SCIPlpUpdateVarColumn(lp, set, var) );
	   }
	
	   return SCIP_OKAY;
	}
	
	/** converts column transformed variable back into loose variable, frees LP column */
	SCIP_RETCODE SCIPvarLoose(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_PROB*            prob,               /**< problem data */
	   SCIP_LP*              lp                  /**< current LP data */
	   )
	{
	   assert(var != NULL);
	   assert(SCIPvarGetStatus(var) == SCIP_VARSTATUS_COLUMN);
	   assert(var->scip == set->scip);
	   assert(var->data.col != NULL);
	   assert(var->data.col->lppos == -1);
	   assert(var->data.col->lpipos == -1);
	
	   SCIPsetDebugMsg(set, "deleting column for variable <%s>\n", var->name);
	
	   /* free column of variable */
	   SCIP_CALL( SCIPcolFree(&var->data.col, blkmem, set, eventqueue, lp) );
	
	   /* switch variable status */
	   var->varstatus = SCIP_VARSTATUS_LOOSE; /*lint !e641*/
	
	   if( var->probindex != -1 )
	   {
	      /* inform problem about the variable's status change */
	      SCIP_CALL( SCIPprobVarChangedStatus(prob, blkmem, set, NULL, NULL, var) );
	
	      /* inform LP, that problem variable is now a loose variable and no longer a column */
	      SCIP_CALL( SCIPlpUpdateVarLoose(lp, set, var) );
	   }
	
	   return SCIP_OKAY;
	}
	
	/** issues a VARFIXED event on the given variable and all its parents (except ORIGINAL parents);
	 *  the event issuing on the parents is necessary, because unlike with bound changes, the parent variables
	 *  are not informed about a fixing of an active variable they are pointing to
	 */
	static
	SCIP_RETCODE varEventVarFixed(
	   SCIP_VAR*             var,                /**< problem variable to change */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   int                   fixeventtype        /**< is this event a fixation(0), an aggregation(1), or a
						      *   multi-aggregation(2)
						      */
	   )
	{
	   SCIP_EVENT* event;
	   SCIP_VARSTATUS varstatus;
	   int i;
	
	   assert(var != NULL);
	   assert(var->scip == set->scip);
	   assert(0 <= fixeventtype && fixeventtype <= 2);
	
	   /* issue VARFIXED event on variable */
	   SCIP_CALL( SCIPeventCreateVarFixed(&event, blkmem, var) );
	   SCIP_CALL( SCIPeventqueueAdd(eventqueue, blkmem, set, NULL, NULL, NULL, NULL, &event) );
	
	#ifndef NDEBUG
	   for( i = var->nparentvars -1; i >= 0; --i )
	   {
	      assert(SCIPvarGetStatus(var->parentvars[i]) != SCIP_VARSTATUS_MULTAGGR);
	   }
	#endif
	
	   switch( fixeventtype )
	   {
	   case 0:
	      /* process all parents of a fixed variable */
	      for( i = var->nparentvars - 1; i >= 0; --i )
	      {
		 varstatus = SCIPvarGetStatus(var->parentvars[i]);
	
		 assert(varstatus != SCIP_VARSTATUS_FIXED);
	
		 /* issue event on all not yet fixed parent variables, (that should already issued this event) except the original
		  * one
		  */
		 if( varstatus != SCIP_VARSTATUS_ORIGINAL )
		 {
		    SCIP_CALL( varEventVarFixed(var->parentvars[i], blkmem, set, eventqueue, fixeventtype) );
		 }
	      }
	      break;
	   case 1:
	      /* process all parents of a aggregated variable */
	      for( i = var->nparentvars - 1; i >= 0; --i )
	      {
		 varstatus = SCIPvarGetStatus(var->parentvars[i]);
	
		 assert(varstatus != SCIP_VARSTATUS_FIXED);
	
		 /* issue event for not aggregated parent variable, because for these and its parents the var event was already
	          * issued(, except the original one)
	          *
	          * @note that even before an aggregated parent variable, there might be variables, for which the vent was not
	          *       yet issued
		  */
	         if( varstatus == SCIP_VARSTATUS_AGGREGATED )
	            continue;
	
		 if( varstatus != SCIP_VARSTATUS_ORIGINAL )
		 {
		    SCIP_CALL( varEventVarFixed(var->parentvars[i], blkmem, set, eventqueue, fixeventtype) );
		 }
	      }
	      break;
	   case 2:
	      /* process all parents of a aggregated variable */
	      for( i = var->nparentvars - 1; i >= 0; --i )
	      {
		 varstatus = SCIPvarGetStatus(var->parentvars[i]);
	
		 assert(varstatus != SCIP_VARSTATUS_FIXED);
	
		 /* issue event on all parent variables except the original one */
		 if( varstatus != SCIP_VARSTATUS_ORIGINAL )
		 {
		    SCIP_CALL( varEventVarFixed(var->parentvars[i], blkmem, set, eventqueue, fixeventtype) );
		 }
	      }
	      break;
	   default:
	      SCIPerrorMessage("unknown variable fixation event origin\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   return SCIP_OKAY;
	}
	
	/** converts variable into fixed variable */
	SCIP_RETCODE SCIPvarFix(
	   SCIP_VAR*             var,                /**< problem variable */
	   BMS_BLKMEM*           blkmem,             /**< block memory */
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_STAT*            stat,               /**< problem statistics */
	   SCIP_PROB*            transprob,          /**< tranformed problem data */
	   SCIP_PROB*            origprob,           /**< original problem data */
	   SCIP_PRIMAL*          primal,             /**< primal data */
	   SCIP_TREE*            tree,               /**< branch and bound tree */
	   SCIP_REOPT*           reopt,              /**< reoptimization data structure */
	   SCIP_LP*              lp,                 /**< current LP data */
	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
	   SCIP_EVENTFILTER*     eventfilter,        /**< event filter for global (not variable dependent) events */
	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
	   SCIP_Real             fixedval,           /**< value to fix variable at */
	   SCIP_Bool*            infeasible,         /**< pointer to store whether the fixing is infeasible */
	   SCIP_Bool*            fixed               /**< pointer to store whether the fixing was performed (variable was unfixed) */
	   )
	{
	   SCIP_Real obj;
	   SCIP_Real childfixedval;
	
	   assert(var != NULL);
	   assert(var->scip == set->scip);
	   assert(SCIPsetIsEQ(set, var->glbdom.lb, var->locdom.lb));
	   assert(SCIPsetIsEQ(set, var->glbdom.ub, var->locdom.ub));
	   assert(infeasible != NULL);
	   assert(fixed != NULL);
	
	   SCIPsetDebugMsg(set, "fix variable <%s>[%g,%g] to %g\n", var->name, var->glbdom.lb, var->glbdom.ub, fixedval);
	
	   *infeasible = FALSE;
	   *fixed = FALSE;
	
	   if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_FIXED )
	   {
	      *infeasible = !SCIPsetIsFeasEQ(set, fixedval, var->locdom.lb);
	      SCIPsetDebugMsg(set, " -> variable already fixed to %g (fixedval=%g): infeasible=%u\n", var->locdom.lb, fixedval, *infeasible);
	      return SCIP_OKAY;
	   }
	   else if( (SCIPvarGetType(var) != SCIP_VARTYPE_CONTINUOUS && !SCIPsetIsFeasIntegral(set, fixedval))
	      || SCIPsetIsFeasLT(set, fixedval, var->locdom.lb)
	      || SCIPsetIsFeasGT(set, fixedval, var->locdom.ub) )
	   {
	      SCIPsetDebugMsg(set, " -> fixing infeasible: locdom=[%g,%g], fixedval=%g\n", var->locdom.lb, var->locdom.ub, fixedval);
	      *infeasible = TRUE;
	      return SCIP_OKAY;
	   }
	
	   switch( SCIPvarGetStatus(var) )
	   {
	   case SCIP_VARSTATUS_ORIGINAL:
	      if( var->data.original.transvar == NULL )
	      {
	         SCIPerrorMessage("cannot fix an untransformed original variable\n");
	         return SCIP_INVALIDDATA;
	      }
	      SCIP_CALL( SCIPvarFix(var->data.original.transvar, blkmem, set, stat, transprob, origprob, primal, tree, reopt,
	            lp, branchcand, eventfilter, eventqueue, cliquetable, fixedval, infeasible, fixed) );
	      break;
	
	   case SCIP_VARSTATUS_LOOSE:
	      assert(!SCIPeventqueueIsDelayed(eventqueue)); /* otherwise, the pseudo objective value update gets confused */
	
	      /* set the fixed variable's objective value to 0.0 */
	      obj = var->obj;
	      SCIP_CALL( SCIPvarChgObj(var, blkmem, set, transprob, primal, lp, eventqueue, 0.0) );
	
	      /* since we change the variable type form loose to fixed, we have to adjust the number of loose
	       * variables in the LP data structure; the loose objective value (looseobjval) in the LP data structure, however,
	       * gets adjusted automatically, due to the event SCIP_EVENTTYPE_OBJCHANGED which dropped in the moment where the
	       * objective of this variable is set to zero
	       */
	      SCIPlpDecNLoosevars(lp);
	
	      /* change variable's bounds to fixed value (thereby removing redundant implications and variable bounds) */
	      holelistFree(&var->glbdom.holelist, blkmem);
	      holelistFree(&var->locdom.holelist, blkmem);
	      SCIP_CALL( SCIPvarChgLbGlobal(var, blkmem, set, stat, lp, branchcand, eventqueue, cliquetable, fixedval) );
	      SCIP_CALL( SCIPvarChgUbGlobal(var, blkmem, set, stat, lp, branchcand, eventqueue, cliquetable, fixedval) );
	
	      /* explicitly set variable's bounds, even if the fixed value is in epsilon range of the old bound */
	      var->glbdom.lb = fixedval;
	      var->glbdom.ub = fixedval;
	      var->locdom.lb = fixedval;
	      var->locdom.ub = fixedval;
	
	      /* delete implications and variable bounds information */
	      SCIP_CALL( SCIPvarRemoveCliquesImplicsVbs(var, blkmem, cliquetable, set, FALSE, FALSE, TRUE) );
	      assert(var->vlbs == NULL);
	      assert(var->vubs == NULL);
	      assert(var->implics == NULL);
	      assert(var->cliquelist == NULL);
	
	      /* clear the history of the variable */
	      SCIPhistoryReset(var->history);
	      SCIPhistoryReset(var->historycrun);
	
	      /* convert variable into fixed variable */
	      var->varstatus = SCIP_VARSTATUS_FIXED; /*lint !e641*/
	
	      /* inform problem about the variable's status change */
	      if( var->probindex != -1 )
	      {
	         SCIP_CALL( SCIPprobVarChangedStatus(transprob, blkmem, set, branchcand, cliquetable, var) );
	      }
	
	      /* reset the objective value of the fixed variable, thus adjusting the problem's objective offset */
	      SCIP_CALL( SCIPvarAddObj(var, blkmem, set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue, obj) );
	
	      /* issue VARFIXED event */
	      SCIP_CALL( varEventVarFixed(var, blkmem, set, eventqueue, 0) );
	
	      *fixed = TRUE;
	      break;
	
	   case SCIP_VARSTATUS_COLUMN:
	      SCIPerrorMessage("cannot fix a column variable\n");
	      return SCIP_INVALIDDATA;
	
	   case SCIP_VARSTATUS_FIXED:
	      SCIPerrorMessage("cannot fix a fixed variable again\n");  /*lint !e527*/
	      SCIPABORT(); /* case is already handled in earlier if condition */
	      return SCIP_INVALIDDATA;  /*lint !e527*/
	
	   case SCIP_VARSTATUS_AGGREGATED:
	      /* fix aggregation variable y in x = a*y + c, instead of fixing x directly */
	      assert(SCIPsetIsZero(set, var->obj));
	      assert(!SCIPsetIsZero(set, var->data.aggregate.scalar));
	      if( SCIPsetIsInfinity(set, fixedval) || SCIPsetIsInfinity(set, -fixedval) )
	         childfixedval = (var->data.aggregate.scalar < 0.0 ? -fixedval : fixedval);
	      else
	         childfixedval = (fixedval - var->data.aggregate.constant)/var->data.aggregate.scalar;
	      SCIP_CALL( SCIPvarFix(var->data.aggregate.var, blkmem, set, stat, transprob, origprob, primal, tree, reopt, lp,
	            branchcand, eventfilter, eventqueue, cliquetable, childfixedval, infeasible, fixed) );
	      break;
	
	   case SCIP_VARSTATUS_MULTAGGR:
	      SCIPerrorMessage("cannot fix a multiple aggregated variable\n");
	      SCIPABORT();
	      return SCIP_INVALIDDATA;  /*lint !e527*/
	
	   case SCIP_VARSTATUS_NEGATED:
	      /* fix negation variable x in x' = offset - x, instead of fixing x' directly */
	      assert(SCIPsetIsZero(set, var->obj));
	      assert(var->negatedvar != NULL);
	      assert(SCIPvarGetStatus(var->negatedvar) != SCIP_VARSTATUS_NEGATED);
	      assert(var->negatedvar->negatedvar == var);
	      SCIP_CALL( SCIPvarFix(var->negatedvar, blkmem, set, stat, transprob, origprob, primal, tree, reopt, lp,
	            branchcand, eventfilter, eventqueue, cliquetable, var->data.negate.constant - fixedval, infeasible, fixed) );
	      break;
	
	   default:
	      SCIPerrorMessage("unknown variable status\n");
	      return SCIP_INVALIDDATA;
	   }
	
	   return SCIP_OKAY;
	}
	
	/** transforms given variables, scalars and constant to the corresponding active variables, scalars and constant
	 *
	 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens except
	 * that the required size is stored in the corresponding variable; hence, if afterwards the required size is greater than the
	 * available slots (varssize), nothing happens; otherwise, the active variable representation is stored in the arrays.
	 *
	 * The reason for this approach is that we cannot reallocate memory, since we do not know how the
	 * memory has been allocated (e.g., by a C++ 'new' or SCIP functions).
	 */
	SCIP_RETCODE SCIPvarGetActiveRepresentatives(
	   SCIP_SET*             set,                /**< global SCIP settings */
	   SCIP_VAR**            vars,               /**< variable array to get active variables */
	   SCIP_Real*            scalars,            /**< scalars a_1, ..., a_n in linear sum a_1*x_1 + ... + a_n*x_n + c */
	   int*                  nvars,              /**< pointer to number of variables and values in vars and scalars array */
	   int                   varssize,           /**< available slots in vars and scalars array */
	   SCIP_Real*            constant,           /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c  */
	   int*                  requiredsize,       /**< pointer to store the required array size for the active variables */
	   SCIP_Bool             mergemultiples      /**< should multiple occurrences of a var be replaced by a single coeff? */
	   )
	{
	   SCIP_VAR** activevars;
	   SCIP_Real* activescalars;
	   int nactivevars;
	   SCIP_Real activeconstant;
	   SCIP_Bool activeconstantinf;
	   int activevarssize;
	
	   SCIP_VAR* var;
	   SCIP_Real scalar;
	   int v;
	   int k;
	
	   SCIP_VAR** tmpvars;
	   SCIP_VAR** multvars;
	   SCIP_Real* tmpscalars;
	   SCIP_Real* multscalars;
	   int tmpvarssize;
	   int ntmpvars;
	   int nmultvars;
	
	   SCIP_VAR* multvar;
	   SCIP_Real multscalar;
	   SCIP_Real multconstant;
	   int pos;
	
	   int noldtmpvars;
	
	   SCIP_VAR** tmpvars2;
	   SCIP_Real* tmpscalars2;
	   int tmpvarssize2;
	   int ntmpvars2;
	
	   SCIP_Bool sortagain = FALSE;
	
	   assert(set != NULL);
	   assert(nvars != NULL);
	   assert(scalars != NULL || *nvars == 0);
	   assert(constant != NULL);
	   assert(requiredsize != NULL);
	   assert(*nvars <= varssize);
	
	   *requiredsize = 0;