diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp
index c1efb98..5c23454 100644
--- a/lib/Analysis/BasicStore.cpp
+++ b/lib/Analysis/BasicStore.cpp
@@ -40,7 +40,7 @@
   
 public:
   BasicStoreManager(GRStateManager& mgr)
-    : StoreManager(mgr.getAllocator()),
+    : StoreManager(mgr.getValueManager()),
       VBFactory(mgr.getAllocator()), 
       StateMgr(mgr), 
       SelfRegion(0) {}
@@ -478,11 +478,8 @@
       if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Base)) {
         if (DR->getDecl() == SelfDecl) {
           const MemRegion *IVR = MRMgr.getObjCIvarRegion(IV->getDecl(),
-                                                         SelfRegion);
-          
-          SVal X = SVal::GetRValueSymbolVal(StateMgr.getSymbolManager(),
-                                            MRMgr, IVR);
-          
+                                                         SelfRegion);          
+          SVal X = ValMgr.getRValueSymbolVal(IVR);          
           St = BindInternal(St, Loc::MakeVal(IVR), X);
         }
       }
@@ -538,7 +535,7 @@
       const MemRegion *R = StateMgr.getRegion(VD);
       SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
                 isa<ImplicitParamDecl>(VD))
-            ? SVal::GetRValueSymbolVal(StateMgr.getSymbolManager(), MRMgr,R)
+            ? ValMgr.getRValueSymbolVal(R)
             : UndefinedVal();
 
       St = BindInternal(St, Loc::MakeVal(R), X);
diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index 0a68ee4..cfeabd0 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -1760,8 +1760,8 @@
             QualType T = R->getRValueType(Ctx);
           
             if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())){
-              SVal V = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
-                        Eng.getStoreManager().getRegionManager(), *I, T, Count);
+              ValueManager &ValMgr = Eng.getValueManager();
+              SVal V = ValMgr.getConjuredSymbolVal(*I, T, Count);
               state = state.BindLoc(Loc::MakeVal(R), V);
             }
             else if (const RecordType *RT = T->getAsStructureType()) {
@@ -1787,13 +1787,10 @@
                 QualType FT = FD->getType();
                 
                 if (Loc::IsLocType(FT) || 
-                    (FT->isIntegerType() && FT->isScalarType())) {
-                  
+                    (FT->isIntegerType() && FT->isScalarType())) {                  
                   const FieldRegion* FR = MRMgr.getFieldRegion(FD, R);
-
-                  SVal V = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
-                       Eng.getStoreManager().getRegionManager(), *I, FT, Count);
-
+                  ValueManager &ValMgr = Eng.getValueManager();
+                  SVal V = ValMgr.getConjuredSymbolVal(*I, FT, Count);
                   state = state.BindLoc(Loc::MakeVal(FR), V);
                 }                
               }
@@ -1857,8 +1854,8 @@
       
       if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
         unsigned Count = Builder.getCurrentBlockCount();
-        SVal X = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
-                       Eng.getStoreManager().getRegionManager(), Ex, T, Count);
+        ValueManager &ValMgr = Eng.getValueManager();
+        SVal X = ValMgr.getConjuredSymbolVal(Ex, T, Count);
         state = state.BindExpr(Ex, X, false);
       }      
       
diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index 2a43b9a..c7ff0ae 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -2139,8 +2139,7 @@
       // UnknownVal.
       if (InitVal.isUnknown() || 
           !getConstraintManager().canReasonAbout(InitVal)) {
-        InitVal = SVal::GetConjuredSymbolVal(SymMgr, 
-                          getStoreManager().getRegionManager(), InitEx, Count);
+        InitVal = ValMgr.getConjuredSymbolVal(InitEx, Count);
       }        
       
       state = StateMgr.BindDecl(state, VD, InitVal);
@@ -2531,9 +2530,8 @@
       
       // Conjure a new symbol if necessary to recover precision.
       if (Result.isUnknown() || !getConstraintManager().canReasonAbout(Result))
-        Result = SVal::GetConjuredSymbolVal(SymMgr, 
-                                       getStoreManager().getRegionManager(),Ex,
-                                            Builder->getCurrentBlockCount());
+        Result = ValMgr.getConjuredSymbolVal(Ex,
+                                             Builder->getCurrentBlockCount());
       
       state = BindExpr(state, U, U->isPostfix() ? V2 : Result);
 
@@ -2758,10 +2756,8 @@
                !getConstraintManager().canReasonAbout(RightV))              
               && (Loc::IsLocType(T) || 
                   (T->isScalarType() && T->isIntegerType()))) {
-            unsigned Count = Builder->getCurrentBlockCount();
-            
-            RightV = SVal::GetConjuredSymbolVal(SymMgr, 
-                      getStoreManager().getRegionManager(), B->getRHS(), Count);
+            unsigned Count = Builder->getCurrentBlockCount();            
+            RightV = ValMgr.getConjuredSymbolVal(B->getRHS(), Count);
           }
           
           // Simulate the effects of a "store":  bind the value of the RHS
@@ -2932,8 +2928,7 @@
           // The symbolic value is actually for the type of the left-hand side
           // expression, not the computation type, as this is the value the
           // LValue on the LHS will bind to.
-          LHSVal = SVal::GetConjuredSymbolVal(SymMgr, 
-                getStoreManager().getRegionManager(), B->getRHS(), LTy, Count);
+          LHSVal = ValMgr.getConjuredSymbolVal(B->getRHS(), LTy, Count);
           
           // However, we need to convert the symbol to the computation type.
           Result = (LTy == CTy) ? LHSVal : EvalCast(LHSVal,CTy);
diff --git a/lib/Analysis/GRSimpleVals.cpp b/lib/Analysis/GRSimpleVals.cpp
index 44e7655..8d59695 100644
--- a/lib/Analysis/GRSimpleVals.cpp
+++ b/lib/Analysis/GRSimpleVals.cpp
@@ -449,10 +449,7 @@
   QualType T = CE->getType();  
   if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {    
     unsigned Count = Builder.getCurrentBlockCount();
-        
-    SVal X = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
-                          Eng.getStoreManager().getRegionManager(), CE, Count);
-    
+    SVal X = Eng.getValueManager().getConjuredSymbolVal(CE, Count);
     St = StateMgr.BindExpr(St, CE, X, Eng.getCFG().isBlkExpr(CE), false);
   }  
     
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 5e60363..4088158 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -148,7 +148,7 @@
 
 public:
   RegionStoreManager(GRStateManager& mgr) 
-    : StoreManager(mgr.getAllocator()),
+    : StoreManager(mgr.getValueManager()),
       RBFactory(mgr.getAllocator()),
       RVFactory(mgr.getAllocator()),
       StateMgr(mgr), SelfRegion(0), SelfDecl(0) {
@@ -159,8 +159,6 @@
 
   virtual ~RegionStoreManager() {}
 
-  MemRegionManager& getRegionManager() { return MRMgr; }
-  
   SubRegionMap* getSubRegionMap(const GRState *state);
   
   const GRState* BindCompoundLiteral(const GRState* St, 
@@ -756,7 +754,7 @@
     if (SR == SelfRegion) {
       // FIXME: Do we need to handle the case where the super region
       // has a view?  We want to canonicalize the bindings.
-      return SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, R);
+      return ValMgr.getRValueSymbolVal(R);
     }
     
     // Otherwise, we need a new symbol.  For now return Unknown.
@@ -778,7 +776,7 @@
         VD->hasGlobalStorage()) {
       QualType VTy = VD->getType();
       if (Loc::IsLocType(VTy) || VTy->isIntegerType())
-        return SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, VR);
+        return ValMgr.getRValueSymbolVal(VR);
       else
         return UnknownVal();
     }
@@ -794,7 +792,7 @@
 
   // All other integer values are symbolic.
   if (Loc::IsLocType(RTy) || RTy->isIntegerType())
-    return SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, R);
+    return ValMgr.getRValueSymbolVal(R);
   else
     return UnknownVal();
 }
@@ -833,7 +831,7 @@
       if (MRMgr.onStack(FR) || MRMgr.onHeap(FR))
         FieldValue = UndefinedVal();
       else
-        FieldValue = SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, FR);
+        FieldValue = ValMgr.getRValueSymbolVal(FR);
     }
 
     StructVal = getBasicVals().consVals(FieldValue, StructVal);
diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp
index 8fdc37f..acc4111 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -280,15 +280,14 @@
   return nonloc::CompoundVal(BasicVals.getCompoundValData(T, Vals));
 }
 
-SVal SVal::GetRValueSymbolVal(SymbolManager& SymMgr, MemRegionManager& MRMgr,
-                              const MemRegion* R) {
+SVal ValueManager::getRValueSymbolVal(const MemRegion* R) {
   SymbolRef sym = SymMgr.getRegionRValueSymbol(R);
                                 
   if (const TypedRegion* TR = dyn_cast<TypedRegion>(R)) {
     QualType T = TR->getRValueType(SymMgr.getContext());
     
     if (Loc::IsLocType(T))
-      return Loc::MakeVal(MRMgr.getSymbolicRegion(sym));
+      return Loc::MakeVal(MemMgr.getSymbolicRegion(sym));
   
     // Only handle integers for now.
     if (T->isIntegerType() && T->isScalarType())
@@ -298,13 +297,12 @@
   return UnknownVal();
 }
 
-SVal SVal::GetConjuredSymbolVal(SymbolManager &SymMgr, MemRegionManager& MRMgr,
-                                const Expr* E, unsigned Count) {
+SVal ValueManager::getConjuredSymbolVal(const Expr* E, unsigned Count) {
   QualType T = E->getType();
   SymbolRef sym = SymMgr.getConjuredSymbol(E, Count);
 
   if (Loc::IsLocType(T))
-    return Loc::MakeVal(MRMgr.getSymbolicRegion(sym));
+    return Loc::MakeVal(MemMgr.getSymbolicRegion(sym));
 
   if (T->isIntegerType() && T->isScalarType())
     return NonLoc::MakeVal(sym);
@@ -312,12 +310,13 @@
   return UnknownVal();
 }
 
-SVal SVal::GetConjuredSymbolVal(SymbolManager &SymMgr, MemRegionManager& MRMgr,
-                                const Expr* E, QualType T, unsigned Count) {
+SVal ValueManager::getConjuredSymbolVal(const Expr* E, QualType T,
+                                        unsigned Count) {
+
   SymbolRef sym = SymMgr.getConjuredSymbol(E, T, Count);
 
   if (Loc::IsLocType(T))
-    return Loc::MakeVal(MRMgr.getSymbolicRegion(sym));
+    return Loc::MakeVal(MemMgr.getSymbolicRegion(sym));
 
   if (T->isIntegerType() && T->isScalarType())
     return NonLoc::MakeVal(sym);