diff --git a/src/bin/libint/algebra.cc b/src/bin/libint/algebra.cc
index a80c7da05..34419475b 100644
--- a/src/bin/libint/algebra.cc
+++ b/src/bin/libint/algebra.cc
@@ -25,7 +25,7 @@ namespace libint2 {
 
   template <>
   void
-  AlgebraicOperator<DGVertex>::add_exit_arc(const SafePtr<DGArc>& a)
+  AlgebraicOperator<DGVertex>::add_exit_arc(const std::shared_ptr<DGArc>& a)
   {
     DGVertex::add_exit_arc(a);
 #if CHECK_SAFETY
diff --git a/src/bin/libint/algebra.h b/src/bin/libint/algebra.h
index e4af9e079..8d374a175 100644
--- a/src/bin/libint/algebra.h
+++ b/src/bin/libint/algebra.h
@@ -54,8 +54,8 @@ namespace libint2 {
       typedef algebra::OperatorTypes::OperatorType OperatorType;
 
       AlgebraicOperator(OperatorType OT,
-                        const SafePtr<T>& left,
-                        const SafePtr<T>& right) :
+                        const std::shared_ptr<T>& left,
+                        const std::shared_ptr<T>& right) :
         DGVertex(ClassInfo<AlgebraicOperator>::Instance().id()), OT_(OT), left_(left), right_(right),
         label_(algebra::OperatorSymbol[OT_])
         {
@@ -63,9 +63,9 @@ namespace libint2 {
       virtual ~AlgebraicOperator() {}
 
       /// Clone A but replace operands with left and right
-      AlgebraicOperator(const SafePtr<AlgebraicOperator>& A,
-                        const SafePtr<T>& left,
-                        const SafePtr<T>& right) :
+      AlgebraicOperator(const std::shared_ptr<AlgebraicOperator>& A,
+                        const std::shared_ptr<T>& left,
+                        const std::shared_ptr<T>& right) :
         DGVertex(static_cast<DGVertex&>(*A)), OT_(A->OT_),
         left_(left), right_(right), label_(A->label_)
         {
@@ -90,16 +90,16 @@ namespace libint2 {
       /// Returns the OperatorType
       OperatorType type() const { return OT_; }
       /// Returns the left argument
-      const SafePtr<T>& left() const { return left_; }
+      const std::shared_ptr<T>& left() const { return left_; }
       /// Returns the right argument
-      const SafePtr<T>& right() const { return right_; }
+      const std::shared_ptr<T>& right() const { return right_; }
 
       /// Overloads DGVertex::add_exit_arc(). The default definition is used unless T = DGVertex (see algebra.cc)
-      void add_exit_arc(const SafePtr<DGArc>& a) override;
+      void add_exit_arc(const std::shared_ptr<DGArc>& a) override;
       /// Implements DGVertex::size()
       unsigned int size() const override { return 1; }
       /// Implements DGVertex::equiv()
-      bool equiv(const SafePtr<DGVertex>& a) const override
+      bool equiv(const std::shared_ptr<DGVertex>& a) const override
       {
         if (typeid_ == a->typeid_) {
 #if ALGEBRAICOPERATOR_USE_KEY_TO_COMPARE
@@ -120,7 +120,7 @@ namespace libint2 {
       }
 
       /// laboriously compare 2 operators element by element
-      bool operator==(const SafePtr<AlgebraicOperator>& a) const {
+      bool operator==(const std::shared_ptr<AlgebraicOperator>& a) const {
 #if ALGEBRAICOPERATOR_USE_SAFEPTR
         // Find out why sometimes equivalent left_ and a->left_ have non-equivalent pointers
         if (left_->equiv(a->left()) && left_ != a->left_) {
@@ -189,8 +189,8 @@ namespace libint2 {
 
     private:
       OperatorType OT_;
-      SafePtr<T> left_;
-      SafePtr<T> right_;
+      std::shared_ptr<T> left_;
+      std::shared_ptr<T> right_;
 
       /// Implements DGVertex::this_precomputed()
       bool this_precomputed() const override
@@ -204,7 +204,7 @@ namespace libint2 {
   /*
   template <>
     void
-    AlgebraicOperator<DGVertex>::add_exit_arc(const SafePtr<DGArc>& a)
+    AlgebraicOperator<DGVertex>::add_exit_arc(const std::shared_ptr<DGArc>& a)
     {
       DGVertex::add_exit_arc(a);
       if (left_->equiv(a->dest()))
diff --git a/src/bin/libint/bfset.h b/src/bin/libint/bfset.h
index 51a9f4545..7b619adde 100644
--- a/src/bin/libint/bfset.h
+++ b/src/bin/libint/bfset.h
@@ -37,7 +37,7 @@
 namespace libint2 {
 
   /** Set of basis functions. Sets must be constructable using
-      SafePtr<BFSet> or SafePtr<ConstructablePolymorphically>.
+      std::shared_ptr<BFSet> or std::shared_ptr<ConstructablePolymorphically>.
   */
   class BFSet : public ConstructablePolymorphically {
 
@@ -52,7 +52,7 @@ namespace libint2 {
   };
 
   /** Set of basis functions with incrementable/decrementable quantum numbers.
-      Sets must be constructable using SafePtr<BFSet> or SafePtr<ConstructablePolymorphically>.
+      Sets must be constructable using std::shared_ptr<BFSet> or std::shared_ptr<ConstructablePolymorphically>.
 
       Call to dec() may invalidate the object. No further
       modification of such object's state is possible.
diff --git a/src/bin/libint/build_libint.cc b/src/bin/libint/build_libint.cc
index 448350e3b..dda36e7d7 100644
--- a/src/bin/libint/build_libint.cc
+++ b/src/bin/libint/build_libint.cc
@@ -194,39 +194,39 @@ int main(int argc, char* argv[])
 static void print_header(std::ostream& os);
 static void print_config(std::ostream& os);
 // Put all configuration-specific API elements in here
-static void config_to_api(const SafePtr<CompilationParameters>& cparams, SafePtr<Libint2Iface>& iface);
+static void config_to_api(const std::shared_ptr<CompilationParameters>& cparams, std::shared_ptr<Libint2Iface>& iface);
 
 #ifdef INCLUDE_ERI
 #define USE_GENERIC_ERI_BUILD 1
 # if !USE_GENERIC_ERI_BUILD
-static void build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                SafePtr<Libint2Iface>& iface);
+static void build_TwoPRep_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                std::shared_ptr<Libint2Iface>& iface);
 # else
-static void build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                SafePtr<Libint2Iface>& iface, unsigned int deriv_level);
+static void build_TwoPRep_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level);
 # endif
 #endif
 
 #ifdef INCLUDE_ERI3
-static void build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                SafePtr<Libint2Iface>& iface, unsigned int deriv_level);
+static void build_TwoPRep_1b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level);
 #endif
 
 #ifdef INCLUDE_ERI2
-static void build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                SafePtr<Libint2Iface>& iface, unsigned int deriv_level);
+static void build_TwoPRep_1b_1k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level);
 #endif
 
 #ifdef INCLUDE_G12
-static void build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                SafePtr<Libint2Iface>& iface);
-static void build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                         SafePtr<Libint2Iface>& iface);
+static void build_R12kG12_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                std::shared_ptr<Libint2Iface>& iface);
+static void build_R12kG12_2b_2k_separate(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                         std::shared_ptr<Libint2Iface>& iface);
 #endif
 
 #ifdef INCLUDE_G12DKH
-static void build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                                SafePtr<Libint2Iface>& iface);
+static void build_G12DKH_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                                std::shared_ptr<Libint2Iface>& iface);
 #endif
 
 #ifdef INCLUDE_ONEBODY
@@ -263,8 +263,8 @@ namespace {
 
 template <typename _OperType>
 void
-build_onebody_1b_1k(std::ostream& os, std::string label, const SafePtr<CompilationParameters>& cparams,
-                    SafePtr<Libint2Iface>& iface, unsigned int deriv_level)
+build_onebody_1b_1k(std::ostream& os, std::string label, const std::shared_ptr<CompilationParameters>& cparams,
+                    std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level)
 {
   // implement overlap as a special case of cartesian emultipole
   using OperType = typename std::conditional<std::is_same<_OperType,OverlapOper>::value,CartesianMultipoleOper<3u>,_OperType>::type;
@@ -310,10 +310,10 @@ build_onebody_1b_1k(std::ostream& os, std::string label, const SafePtr<Compilati
   // 3) at the end, for each unresolved recurrence relation generate
   //    explicit source code
   //
-  SafePtr<DirectedGraph> dg(new DirectedGraph);
-  SafePtr<Strategy> strat(new Strategy());
-  SafePtr<CodeContext> context(new CppCodeContext(cparams));
-  SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+  std::shared_ptr<DirectedGraph> dg(new DirectedGraph);
+  std::shared_ptr<Strategy> strat(new Strategy());
+  std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+  std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
 
   for(unsigned int la=0; la<=lmax; la++) {
     for(unsigned int lb=0; lb<=lmax; lb++) {
@@ -325,10 +325,10 @@ build_onebody_1b_1k(std::ostream& os, std::string label, const SafePtr<Compilati
              )
             continue;
 
-          SafePtr<Tactic> tactic(new TwoCenter_OS_Tactic(la,lb));
+          std::shared_ptr<Tactic> tactic(new TwoCenter_OS_Tactic(la,lb));
 
           // this will hold all target shell sets
-          std::vector< SafePtr<Onebody_sh_1_1> > targets;
+          std::vector< std::shared_ptr<Onebody_sh_1_1> > targets;
 
           /////////////////////////////////
           // loop over operator components
@@ -397,7 +397,7 @@ build_onebody_1b_1k(std::ostream& os, std::string label, const SafePtr<Compilati
             for(unsigned int op=0; op!=descrs.size(); ++op) {
               OperType oper(descrs[op]);
 
-              SafePtr<Onebody_sh_1_1> target = Onebody_sh_1_1::Instance(a,b,nullaux,oper);
+              std::shared_ptr<Onebody_sh_1_1> target = Onebody_sh_1_1::Instance(a,b,nullaux,oper);
               targets.push_back(target);
             } // loop over operator components
             
@@ -422,7 +422,7 @@ build_onebody_1b_1k(std::ostream& os, std::string label, const SafePtr<Compilati
 
           // shove all targets on the graph, IN ORDER
           for(auto t = targets.begin(); t!=targets.end(); ++t) {
-            SafePtr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,Onebody_sh_1_1>(*t);
+            std::shared_ptr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,Onebody_sh_1_1>(*t);
             dg->append_target(t_ptr);
           }
 
@@ -451,7 +451,7 @@ build_onebody_1b_1k(std::ostream& os, std::string label, const SafePtr<Compilati
                        prefix, eval_label, false);
 
           // update max stack size and # of targets
-          const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+          const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
           tparams->max_stack_size(max_am, memman->max_memory_used());
           tparams->max_ntarget(targets.size());
           //os << " Max memory used = " << memman->max_memory_used() << std::endl;
@@ -557,7 +557,7 @@ BOOST_PP_LIST_FOR_EACH ( BOOST_PP_ONEBODY_MCR1, _, BOOST_PP_ONEBODY_TASK_LIST)
 #endif
 
   // use default parameters
-  SafePtr<CompilationParameters> cparams(new CompilationParameters);
+  std::shared_ptr<CompilationParameters> cparams(new CompilationParameters);
 
   cparams->max_am("default",LIBINT_MAX_AM);
   cparams->max_am_opt("default",LIBINT_OPT_AM);
@@ -750,9 +750,9 @@ BOOST_PP_LIST_FOR_EACH ( BOOST_PP_ONEBODY_MCR1, _, BOOST_PP_ONEBODY_TASK_LIST)
 #endif
 
   // initialize code context to produce library API
-  SafePtr<CodeContext> icontext(new CppCodeContext(cparams));
+  std::shared_ptr<CodeContext> icontext(new CppCodeContext(cparams));
   // initialize object to generate interface
-  SafePtr<Libint2Iface> iface(new Libint2Iface(cparams,icontext));
+  std::shared_ptr<Libint2Iface> iface(new Libint2Iface(cparams,icontext));
 
   print_header(os);
   print_config(os);
@@ -860,7 +860,7 @@ BOOST_PP_LIST_FOR_EACH ( BOOST_PP_ONEBODY_MCR1, _, BOOST_PP_ONEBODY_TASK_LIST)
   typedef LibraryTaskManager::TasksCIter tciter;
   const tciter tend = taskmgr.plast();
   for(tciter t=taskmgr.first(); t!=tend; ++t) {
-    const SafePtr<TaskExternSymbols> tsymbols = t->symbols();
+    const std::shared_ptr<TaskExternSymbols> tsymbols = t->symbols();
     typedef TaskExternSymbols::SymbolList SymbolList;
     const SymbolList& symbols = tsymbols->symbols();
     // print out the labels
@@ -933,8 +933,8 @@ print_config(std::ostream& os)
 
 #ifdef INCLUDE_ERI
 void
-build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                    SafePtr<Libint2Iface>& iface, unsigned int deriv_level)
+build_TwoPRep_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                    std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level)
 {
   const std::string task = task_label("eri", deriv_level);
   typedef TwoPRep_11_11_sq TwoPRep_sh_11_11;
@@ -958,10 +958,10 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
   // 3) at the end, for each unresolved recurrence relation generate
   //    explicit source code
   //
-  SafePtr<DirectedGraph> dg_xxxx(new DirectedGraph);
-  SafePtr<Strategy> strat(new Strategy());
-  SafePtr<CodeContext> context(new CppCodeContext(cparams));
-  SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+  std::shared_ptr<DirectedGraph> dg_xxxx(new DirectedGraph);
+  std::shared_ptr<Strategy> strat(new Strategy());
+  std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+  std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
 
   for(unsigned int la=0; la<=lmax; la++) {
     for(unsigned int lb=0; lb<=lmax; lb++) {
@@ -971,8 +971,8 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
           if (!ShellQuartetSetPredicate<static_cast<ShellSetType>(LIBINT_SHELL_SET)>::value(la,lb,lc,ld))
             continue;
 
-          //SafePtr<Tactic> tactic(new ParticleDirectionTactic(la+lb > lc+ld ? false : true));
-          SafePtr<Tactic> tactic(new FourCenter_OS_Tactic(la, lb, lc, ld));
+          //std::shared_ptr<Tactic> tactic(new ParticleDirectionTactic(la+lb > lc+ld ? false : true));
+          std::shared_ptr<Tactic> tactic(new FourCenter_OS_Tactic(la, lb, lc, ld));
 
 #if STUDY_MEMORY_USAGE
           const int lim = 1;
@@ -1003,7 +1003,7 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
           ////////////
           // NB translational invariance is now handled by CR_DerivGauss
           CartesianDerivIterator<4> diter(deriv_level);
-          std::vector< SafePtr<TwoPRep_sh_11_11> > targets;
+          std::vector< std::shared_ptr<TwoPRep_sh_11_11> > targets;
           bool last_deriv = false;
           do {
             CGShell a(la);
@@ -1020,16 +1020,16 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
               }
             }
 
-            SafePtr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
+            std::shared_ptr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
             targets.push_back(abcd);
             last_deriv = diter.last();
             if (!last_deriv) diter.next();
           } while (!last_deriv);
           // append all derivatives as targets to the graph
-          for(std::vector< SafePtr<TwoPRep_sh_11_11> >::const_iterator t=targets.begin();
+          for(std::vector< std::shared_ptr<TwoPRep_sh_11_11> >::const_iterator t=targets.begin();
               t != targets.end();
               ++t) {
-            SafePtr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_sh_11_11>(*t);
+            std::shared_ptr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_sh_11_11>(*t);
             dg_xxxx->append_target(t_ptr);
           }
 
@@ -1041,7 +1041,7 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
             CGShell b(lb);
             CGShell c(lc);
             CGShell d(ld);
-            SafePtr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
+            std::shared_ptr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
             abcd_label = abcd->label();
           }
           // + derivative level (if deriv_level > 0)
@@ -1068,7 +1068,7 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
                        prefix, label, false);
 
           // update max stack size and # of targets
-          const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+          const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
           tparams->max_stack_size(max_am, memman->max_memory_used());
           tparams->max_ntarget(targets.size());
           //os << " Max memory used = " << memman->max_memory_used() << std::endl;
@@ -1108,8 +1108,8 @@ build_TwoPRep_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #ifdef INCLUDE_ERI3
 
 void
-build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                    SafePtr<Libint2Iface>& iface, unsigned int deriv_level)
+build_TwoPRep_1b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                    std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level)
 {
   const std::string task = task_label("3eri", deriv_level);
   typedef TwoPRep_11_11_sq TwoPRep_sh_11_11;
@@ -1137,10 +1137,10 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
   // 3) at the end, for each unresolved recurrence relation generate
   //    explicit source code
   //
-  SafePtr<DirectedGraph> dg_xxx(new DirectedGraph);
-  SafePtr<Strategy> strat(new Strategy());
-  SafePtr<CodeContext> context(new CppCodeContext(cparams));
-  SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+  std::shared_ptr<DirectedGraph> dg_xxx(new DirectedGraph);
+  std::shared_ptr<Strategy> strat(new Strategy());
+  std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+  std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
 
   for(unsigned int lbra=0; lbra<=lmax; lbra++) {
     for(unsigned int lc=0; lc<=lmax_default; lc++) {
@@ -1154,8 +1154,8 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
           // unfortunately, depending on the direction in which the build goes it must be A(0) or B(1)
           const unsigned int dummy_center = (LIBINT_SHELL_SET == LIBINT_SHELL_SET_ORCA) ? 0 : 1;
 
-          //SafePtr<Tactic> tactic(new ParticleDirectionTactic(lbra > lc+ld ? false : true));
-          SafePtr<Tactic> tactic(new FourCenter_OS_Tactic(dummy_center==0?0:lbra,
+          //std::shared_ptr<Tactic> tactic(new ParticleDirectionTactic(lbra > lc+ld ? false : true));
+          std::shared_ptr<Tactic> tactic(new FourCenter_OS_Tactic(dummy_center==0?0:lbra,
               dummy_center==1?0:lbra, lc, ld));
 
 #if STUDY_MEMORY_USAGE
@@ -1184,7 +1184,7 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
           ////////////
           // NB translational invariance is now handled by CR_DerivGauss
           CartesianDerivIterator<3> diter(deriv_level);
-          std::vector< SafePtr<TwoPRep_sh_11_11> > targets;
+          std::vector< std::shared_ptr<TwoPRep_sh_11_11> > targets;
           bool last_deriv = false;
           do {
             CGShell a = (dummy_center == 0) ? CGShell::unit() : CGShell(lbra);
@@ -1210,16 +1210,16 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
             }
 
             // use 4-center integrals
-            SafePtr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
+            std::shared_ptr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
             targets.push_back(abcd);
             last_deriv = diter.last();
             if (!last_deriv) diter.next();
           } while (!last_deriv);
           // append all derivatives as targets to the graph
-          for(std::vector< SafePtr<TwoPRep_sh_11_11> >::const_iterator t=targets.begin();
+          for(std::vector< std::shared_ptr<TwoPRep_sh_11_11> >::const_iterator t=targets.begin();
               t != targets.end();
               ++t) {
-            SafePtr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_sh_11_11>(*t);
+            std::shared_ptr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_sh_11_11>(*t);
             dg_xxx->append_target(t_ptr);
           }
 
@@ -1235,7 +1235,7 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
             if (dummy_center == 1 && deriv_level == 0) a.pure_sh(true);
             if (dummy_center == 0 && deriv_level == 0) b.pure_sh(true);
 #endif
-            SafePtr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
+            std::shared_ptr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
             abcd_label = abcd->label();
           }
           // + derivative level (if deriv_level > 0)
@@ -1263,7 +1263,7 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
                        prefix, label, false);
 
           // update max stack size and # of targets
-          const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+          const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
           tparams->max_stack_size(max_am, memman->max_memory_used());
           tparams->max_ntarget(targets.size());
           //os << " Max memory used = " << memman->max_memory_used() << std::endl;
@@ -1299,8 +1299,8 @@ build_TwoPRep_1b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #ifdef INCLUDE_ERI2
 
 void
-build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                    SafePtr<Libint2Iface>& iface, unsigned int deriv_level)
+build_TwoPRep_1b_1k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                    std::shared_ptr<Libint2Iface>& iface, unsigned int deriv_level)
 {
   const std::string task = task_label("2eri", deriv_level);
   typedef TwoPRep_11_11_sq TwoPRep_sh_11_11;
@@ -1324,10 +1324,10 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
   // 3) at the end, for each unresolved recurrence relation generate
   //    explicit source code
   //
-  SafePtr<DirectedGraph> dg_xxx(new DirectedGraph);
-  SafePtr<Strategy> strat(new Strategy());
-  SafePtr<CodeContext> context(new CppCodeContext(cparams));
-  SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+  std::shared_ptr<DirectedGraph> dg_xxx(new DirectedGraph);
+  std::shared_ptr<Strategy> strat(new Strategy());
+  std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+  std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
 
   for(unsigned int lbra=0; lbra<=lmax; lbra++) {
     for(unsigned int lket=0; lket<=lmax; lket++) {
@@ -1337,8 +1337,8 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
           const unsigned int dummy_center1 = (LIBINT_SHELL_SET == LIBINT_SHELL_SET_ORCA) ? 0 : 1;
           const unsigned int dummy_center2 = (LIBINT_SHELL_SET == LIBINT_SHELL_SET_ORCA) ? 2 : 3;
 
-          //SafePtr<Tactic> tactic(new ParticleDirectionTactic(lbra > lket ? false : true));
-          SafePtr<Tactic> tactic(new FourCenter_OS_Tactic(dummy_center1==0?0:lbra,
+          //std::shared_ptr<Tactic> tactic(new ParticleDirectionTactic(lbra > lket ? false : true));
+          std::shared_ptr<Tactic> tactic(new FourCenter_OS_Tactic(dummy_center1==0?0:lbra,
                                                           dummy_center1==1?0:lbra,
                                                           dummy_center2==2?0:lket,
                                                           dummy_center2==3?0:lket));
@@ -1367,7 +1367,7 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
           ////////////
           // NB translational invariance is now handled by CR_DerivGauss
           CartesianDerivIterator<2> diter(deriv_level);
-          std::vector< SafePtr<TwoPRep_sh_11_11> > targets;
+          std::vector< std::shared_ptr<TwoPRep_sh_11_11> > targets;
           bool last_deriv = false;
           do {
             CGShell a = (dummy_center1 == 0) ? CGShell::unit() : CGShell(lbra);
@@ -1395,16 +1395,16 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
             }
 
             // use 4-center integrals
-            SafePtr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
+            std::shared_ptr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
             targets.push_back(abcd);
             last_deriv = diter.last();
             if (!last_deriv) diter.next();
           } while (!last_deriv);
           // append all derivatives as targets to the graph
-          for(std::vector< SafePtr<TwoPRep_sh_11_11> >::const_iterator t=targets.begin();
+          for(std::vector< std::shared_ptr<TwoPRep_sh_11_11> >::const_iterator t=targets.begin();
               t != targets.end();
               ++t) {
-            SafePtr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_sh_11_11>(*t);
+            std::shared_ptr<DGVertex> t_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_sh_11_11>(*t);
             dg_xxx->append_target(t_ptr);
           }
 
@@ -1422,7 +1422,7 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
             if (dummy_center2 == 3 && deriv_level == 0) c.pure_sh(true);
             if (dummy_center2 == 2 && deriv_level == 0) d.pure_sh(true);
 #endif
-            SafePtr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
+            std::shared_ptr<TwoPRep_sh_11_11> abcd = TwoPRep_sh_11_11::Instance(a,b,c,d,mType(0u));
             abcd_label = abcd->label();
           }
           // + derivative level (if deriv_level > 0)
@@ -1450,7 +1450,7 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
                        prefix, label, false);
 
           // update max stack size and # of targets
-          const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+          const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
           tparams->max_stack_size(max_am, memman->max_memory_used());
           tparams->max_ntarget(targets.size());
           //os << " Max memory used = " << memman->max_memory_used() << std::endl;
@@ -1485,8 +1485,8 @@ build_TwoPRep_1b_1k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 
 #ifdef INCLUDE_G12
 void
-build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                    SafePtr<Libint2Iface>& iface)
+build_R12kG12_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                    std::shared_ptr<Libint2Iface>& iface)
 {
   const std::string task("r12kg12");
   vector<CGShell*> shells;
@@ -1514,13 +1514,13 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
   // 3) at the end, for each unresolved recurrence relation generate
   //    explicit source code
   //
-  SafePtr<DirectedGraph> dg_xxxx(new DirectedGraph);
-  SafePtr<Strategy> strat(new Strategy);
-  SafePtr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
-  //SafePtr<Tactic> tactic(new RandomChoiceTactic());
-  //SafePtr<Tactic> tactic(new FewestNewVerticesTactic(dg_xxxx));
-  SafePtr<CodeContext> context(new CppCodeContext(cparams));
-  SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+  std::shared_ptr<DirectedGraph> dg_xxxx(new DirectedGraph);
+  std::shared_ptr<Strategy> strat(new Strategy);
+  std::shared_ptr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
+  //std::shared_ptr<Tactic> tactic(new RandomChoiceTactic());
+  //std::shared_ptr<Tactic> tactic(new FewestNewVerticesTactic(dg_xxxx));
+  std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+  std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
 
   for(unsigned int la=0; la<=lmax; la++) {
     for(unsigned int lb=0; lb<=lmax; lb++) {
@@ -1556,9 +1556,9 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #if LIBINT_CONTRACTED_INTS
             oper.descr().contract();
 #endif
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
 
@@ -1569,9 +1569,9 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #if LIBINT_CONTRACTED_INTS
             oper.descr().contract();
 #endif
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
 
@@ -1585,9 +1585,9 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #if LIBINT_CONTRACTED_INTS
             oper.descr().contract();
 #endif
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
 
@@ -1600,9 +1600,9 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #if LIBINT_CONTRACTED_INTS
             oper.descr().contract();
 #endif
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
 #endif
@@ -1616,9 +1616,9 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 #if LIBINT_CONTRACTED_INTS
             oper.descr().contract();
 #endif
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
 
@@ -1644,7 +1644,7 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
                        prefix, label, false);
 
           // update max stack size
-          const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+          const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
           tparams->max_stack_size(max_am, memman->max_memory_used());
           tparams->max_ntarget(5);
 
@@ -1678,8 +1678,8 @@ build_R12kG12_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpar
 
 #ifdef INCLUDE_G12
 void
-build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                             SafePtr<Libint2Iface>& iface)
+build_R12kG12_2b_2k_separate(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                             std::shared_ptr<Libint2Iface>& iface)
 {
   // do not support this if the commutator integrals are needed
 #if SUPPORT_T1G12
@@ -1707,11 +1707,11 @@ build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParamete
     iface->to_params(iface->macro_define(std::string("MAX_AM_") + task_NAMES[task],lmax));
     iface->to_params(iface->macro_define("SUPPORT_T1G12",0));
 
-    SafePtr<DirectedGraph> dg_xxxx(new DirectedGraph);
-    SafePtr<Strategy> strat(new Strategy);
-    SafePtr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
-    SafePtr<CodeContext> context(new CppCodeContext(cparams));
-    SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+    std::shared_ptr<DirectedGraph> dg_xxxx(new DirectedGraph);
+    std::shared_ptr<Strategy> strat(new Strategy);
+    std::shared_ptr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
+    std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+    std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
 
     for(unsigned int la=0; la<=lmax; la++) {
       for(unsigned int lb=0; lb<=lmax; lb++) {
@@ -1744,9 +1744,9 @@ build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParamete
 #if LIBINT_CONTRACTED_INTS
               oper.descr().contract();
 #endif
-              SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+              std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
               os << "building " << abcd->description() << endl;
-              SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+              std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
               dg_xxxx->append_target(abcd_ptr);
               _label = abcd_ptr->label();
             }
@@ -1760,9 +1760,9 @@ build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParamete
 #if LIBINT_CONTRACTED_INTS
               oper.descr().contract();
 #endif
-              SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
+              std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper);
               os << "building " << abcd->description() << endl;
-              SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+              std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
               dg_xxxx->append_target(abcd_ptr);
               _label = abcd_ptr->label();
             }
@@ -1778,7 +1778,7 @@ build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParamete
                          prefix, label, false);
 
             // update max stack size
-            const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+            const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
             tparams->max_stack_size(max_am, memman->max_memory_used());
             tparams->max_ntarget(1);
 
@@ -1814,8 +1814,8 @@ build_R12kG12_2b_2k_separate(std::ostream& os, const SafePtr<CompilationParamete
 
 #ifdef INCLUDE_G12DKH
 void
-build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
-                    SafePtr<Libint2Iface>& iface)
+build_G12DKH_2b_2k(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
+                    std::shared_ptr<Libint2Iface>& iface)
 {
   const std::string task("g12dkh");
   vector<CGShell*> shells;
@@ -1838,9 +1838,9 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
   // 3) at the end, for each unresolved recurrence relation generate
   //    explicit source code
   //
-  SafePtr<DirectedGraph> dg_xxxx(new DirectedGraph);
-  SafePtr<Strategy> strat(new Strategy);
-  SafePtr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
+  std::shared_ptr<DirectedGraph> dg_xxxx(new DirectedGraph);
+  std::shared_ptr<Strategy> strat(new Strategy);
+  std::shared_ptr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
   for(int la=0; la<=lmax; la++) {
     for(int lb=0; lb<=lmax; lb++) {
       for(int lc=0; lc<=lmax; lc++) {
@@ -1874,9 +1874,9 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
             typedef R12kG12_11_11_sq int_type;
             typedef R12kG12 oper_type;
             typedef oper_type::Descriptor oper_descr;
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(0)));
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(0)));
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
           // k=2
@@ -1884,9 +1884,9 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
             typedef R12kG12_11_11_sq int_type;
             typedef R12kG12 oper_type;
             typedef oper_type::Descriptor oper_descr;
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(2)));
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(2)));
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
           // k=4
@@ -1894,9 +1894,9 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
             typedef R12kG12_11_11_sq int_type;
             typedef R12kG12 oper_type;
             typedef oper_type::Descriptor oper_descr;
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(4)));
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(4)));
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
           // (G12prime.Div1)^2
@@ -1904,9 +1904,9 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
             typedef DivG12prime_xTx_11_11_sq int_type;
             typedef int_type::OperType oper_type;
             typedef oper_type::Descriptor oper_descr;
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(0)));
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(0)));
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
           // (G12prime.Div2)^2
@@ -1914,14 +1914,14 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
             typedef DivG12prime_xTx_11_11_sq int_type;
             typedef int_type::OperType oper_type;
             typedef oper_type::Descriptor oper_descr;
-            SafePtr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(1)));
+            std::shared_ptr<int_type> abcd = int_type::Instance(*shells[la],*shells[lb],*shells[lc],*shells[ld],0u,oper_type(oper_descr(1)));
             os << "building " << abcd->description() << endl;
-            SafePtr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
+            std::shared_ptr<DGVertex> abcd_ptr = dynamic_pointer_cast<DGVertex,int_type>(abcd);
             dg_xxxx->append_target(abcd_ptr);
           }
 
-          SafePtr<CodeContext> context(new CppCodeContext(cparams));
-          SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
+          std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+          std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
           dg_xxxx->apply(strat,tactic);
           dg_xxxx->optimize_rr_out(context);
           dg_xxxx->traverse();
@@ -1944,10 +1944,10 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
           std::string src_filename(prefix + context->label_to_name(label));  src_filename += ".cc";
           std::basic_ofstream<char> declfile(decl_filename.c_str());
           std::basic_ofstream<char> srcfile(src_filename.c_str());
-          dg_xxxx->generate_code(context,memman,ImplicitDimensions::default_dims(),SafePtr<CodeSymbols>(new CodeSymbols),label,declfile,srcfile);
+          dg_xxxx->generate_code(context,memman,ImplicitDimensions::default_dims(),std::shared_ptr<CodeSymbols>(new CodeSymbols),label,declfile,srcfile);
 
           // update max stack size
-          const SafePtr<TaskParameters>& tparams = taskmgr.current().params();
+          const std::shared_ptr<TaskParameters>& tparams = taskmgr.current().params();
           tparams->max_stack_size(max_am, memman->max_memory_used());
           tparams->max_ntarget(3);
 
@@ -1984,7 +1984,7 @@ build_G12DKH_2b_2k(std::ostream& os, const SafePtr<CompilationParameters>& cpara
 #endif // INCLUDE_G12DKH
 
 void
-config_to_api(const SafePtr<CompilationParameters>& cparams, SafePtr<Libint2Iface>& iface)
+config_to_api(const std::shared_ptr<CompilationParameters>& cparams, std::shared_ptr<Libint2Iface>& iface)
 {
   int max_deriv_order = 0;
 #ifdef INCLUDE_ONEBODY
diff --git a/src/bin/libint/buildtest.cc b/src/bin/libint/buildtest.cc
index 2130d1a32..d7fc443c7 100644
--- a/src/bin/libint/buildtest.cc
+++ b/src/bin/libint/buildtest.cc
@@ -34,15 +34,15 @@ namespace libint2 {
 
   void
   generate_rr_code(std::ostream& os,
-                   const SafePtr<CompilationParameters>& cparams,
+                   const std::shared_ptr<CompilationParameters>& cparams,
                    std::deque<std::string>& decl_filenames,
                    std::deque<std::string>& def_filenames)
   {
-    SafePtr<CodeContext> context(new CppCodeContext(cparams));
+    std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
     ImplicitDimensions::set_default_dims(cparams);
     std::string prefix(cparams->source_directory());
 
-    SafePtr<RRStack> rrstack = RRStack::Instance();
+    std::shared_ptr<RRStack> rrstack = RRStack::Instance();
 
 #define GENERATE_ALL_RRS 0
 #if GENERATE_ALL_RRS
@@ -51,7 +51,7 @@ namespace libint2 {
     //
     RRStack::citer_type it = rrstack->begin();
     while (it != rrstack->end()) {
-      SafePtr<RecurrenceRelation> rr = (*it).second.second;
+      std::shared_ptr<RecurrenceRelation> rr = (*it).second.second;
 #else
     //
     // generate code for all recurrence relation actually used
@@ -62,7 +62,7 @@ namespace libint2 {
     const tciter tend = taskmgr.plast();
     std::set<TaskExternSymbols::RRList::value_type> aggregate_rrlist;
     for(tciter t=taskmgr.first(); t!=tend; ++t) {
-      const SafePtr<TaskExternSymbols> tsymbols = t->symbols();
+      const std::shared_ptr<TaskExternSymbols> tsymbols = t->symbols();
       typedef TaskExternSymbols::SymbolList SymbolList;
       auto rrlist = tsymbols->rrlist();
       aggregate_rrlist.insert(rrlist.begin(), rrlist.end());
diff --git a/src/bin/libint/buildtest.h b/src/bin/libint/buildtest.h
index 3ce60c542..665e91105 100644
--- a/src/bin/libint/buildtest.h
+++ b/src/bin/libint/buildtest.h
@@ -37,18 +37,18 @@
 namespace libint2 {
 
   // defined in buildtest.cc
-  void generate_rr_code(std::ostream& os, const SafePtr<CompilationParameters>& cparams,
+  void generate_rr_code(std::ostream& os, const std::shared_ptr<CompilationParameters>& cparams,
                         std::deque<std::string>& decl_filenames,
                         std::deque<std::string>& def_filenames);
 
   /// defined below generates code for dg; dg and memman are reset at the end
   void
-    GenerateCode(const SafePtr<DirectedGraph>& dg,
-                 const SafePtr<CodeContext>& context,
-                 const SafePtr<CompilationParameters>& cparams,
-                 const SafePtr<Strategy>& strat,
-                 const SafePtr<Tactic>& tactic,
-                 const SafePtr<MemoryManager>& memman,
+    GenerateCode(const std::shared_ptr<DirectedGraph>& dg,
+                 const std::shared_ptr<CodeContext>& context,
+                 const std::shared_ptr<CompilationParameters>& cparams,
+                 const std::shared_ptr<Strategy>& strat,
+                 const std::shared_ptr<Tactic>& tactic,
+                 const std::shared_ptr<MemoryManager>& memman,
                  std::deque<std::string>& decl_filenames,
                  std::deque<std::string>& def_filenames,
                  const std::string& prefix,
@@ -82,7 +82,7 @@ namespace libint2 {
       to be produced (i.e. include header files + set-level recurrence relations code)
    */
   template <class Integral, bool GenAllCode>
-    void BuildTest(const std::vector< SafePtr<Integral> >& targets, unsigned int size_to_unroll, unsigned int veclen,
+    void BuildTest(const std::vector< std::shared_ptr<Integral> >& targets, unsigned int size_to_unroll, unsigned int veclen,
 		   bool vec_by_line, bool do_cse, const std::string& complabel = "buildtest",
 		   std::ostream& os = std::cout);
 
@@ -91,23 +91,23 @@ namespace libint2 {
       to be produced (i.e. include header files + set-level recurrence relations code)
    */
   template <class Integral, bool GenAllCode>
-    void __BuildTest(const std::vector< SafePtr<Integral> >& targets, const SafePtr<CompilationParameters>& cparams,
+    void __BuildTest(const std::vector< std::shared_ptr<Integral> >& targets, const std::shared_ptr<CompilationParameters>& cparams,
 		     unsigned int size_to_unroll, std::ostream& os = std::cout,
-		     const SafePtr<Tactic>& tactic = SafePtr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
-		     const SafePtr<MemoryManager>& memman = SafePtr<MemoryManager>(new WorstFitMemoryManager),
+		     const std::shared_ptr<Tactic>& tactic = std::shared_ptr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
+		     const std::shared_ptr<MemoryManager>& memman = std::shared_ptr<MemoryManager>(new WorstFitMemoryManager),
 		     const std::string& complabel = "general_integral");
 
   template <class Integral, bool GenAllCode>
     void
-    __BuildTest(const std::vector< SafePtr<Integral> >& targets, const SafePtr<CompilationParameters>& cparams,
+    __BuildTest(const std::vector< std::shared_ptr<Integral> >& targets, const std::shared_ptr<CompilationParameters>& cparams,
 		unsigned int size_to_unroll, std::ostream& os,
-		const SafePtr<Tactic>& tactic, const SafePtr<MemoryManager>& memman,
+		const std::shared_ptr<Tactic>& tactic, const std::shared_ptr<MemoryManager>& memman,
 		const std::string& complabel)
     {
       const std::string prefix("");
       const std::string label = cparams->api_prefix() + complabel;
-      SafePtr<Strategy> strat(new Strategy);
-      SafePtr<CodeContext> context(new CppCodeContext(cparams));
+      std::shared_ptr<Strategy> strat(new Strategy);
+      std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
 
       LibraryTaskManager& taskmgr = LibraryTaskManager::Instance();
       taskmgr.add(complabel);
@@ -118,7 +118,7 @@ namespace libint2 {
       //
       unsigned int max_am = 0;
       for(unsigned int t=0; t<targets.size(); ++t) {
-        const SafePtr<Integral>& target = targets[t];
+        const std::shared_ptr<Integral>& target = targets[t];
         const unsigned int np = target->bra().num_part();
         // bra
         for(unsigned int p=0; p<np; p++) {
@@ -148,7 +148,7 @@ namespace libint2 {
 
       os << "Building " << complabel << std::endl;
 
-      SafePtr<DirectedGraph> dg_xxxx(new DirectedGraph);
+      std::shared_ptr<DirectedGraph> dg_xxxx(new DirectedGraph);
       dg_xxxx->set_label(complabel);
 
       // configure the graph
@@ -159,8 +159,8 @@ namespace libint2 {
       dg_xxxx->registry()->unroll_threshold(size_to_unroll);
 
       for(unsigned int t=0; t<targets.size(); ++t) {
-        const SafePtr<Integral>& target = targets[t];
-        SafePtr<DGVertex> target_ptr = dynamic_pointer_cast<DGVertex,Integral>(target);
+        const std::shared_ptr<Integral>& target = targets[t];
+        std::shared_ptr<DGVertex> target_ptr = dynamic_pointer_cast<DGVertex,Integral>(target);
         assert(target_ptr != 0);
         dg_xxxx->append_target(target_ptr);
       }
@@ -177,9 +177,9 @@ namespace libint2 {
 
       if (GenAllCode) {
         // initialize code context to produce library API
-        SafePtr<CodeContext> icontext(new CppCodeContext(cparams));
+        std::shared_ptr<CodeContext> icontext(new CppCodeContext(cparams));
         // initialize object to generate interface
-        SafePtr<Libint2Iface> iface(new Libint2Iface(cparams,icontext));
+        std::shared_ptr<Libint2Iface> iface(new Libint2Iface(cparams,icontext));
 
         // generate interface
         std::ostringstream oss;
@@ -215,12 +215,12 @@ namespace libint2 {
     }
 
   void
-  GenerateCode(const SafePtr<DirectedGraph>& dg,
-               const SafePtr<CodeContext>& context,
-               const SafePtr<CompilationParameters>& cparams,
-               const SafePtr<Strategy>& strat,
-               const SafePtr<Tactic>& tactic,
-               const SafePtr<MemoryManager>& memman,
+  GenerateCode(const std::shared_ptr<DirectedGraph>& dg,
+               const std::shared_ptr<CodeContext>& context,
+               const std::shared_ptr<CompilationParameters>& cparams,
+               const std::shared_ptr<Strategy>& strat,
+               const std::shared_ptr<Tactic>& tactic,
+               const std::shared_ptr<MemoryManager>& memman,
                std::deque<std::string>& decl_filenames,
                std::deque<std::string>& def_filenames,
                const std::string& prefix,
@@ -245,7 +245,7 @@ namespace libint2 {
       //std::cout << "missing some prerequisites!" << std::endl;
       dg->foreach(pe);
     }
-    std::deque< SafePtr<DGVertex> > prereq_list = pe.vertices;
+    std::deque< std::shared_ptr<DGVertex> > prereq_list = pe.vertices;
 
     dg->traverse();
     //dg->debug_print_traversal(cout);
@@ -262,7 +262,7 @@ namespace libint2 {
     std::basic_ofstream<char> declfile(decl_filename.c_str());
     std::basic_ofstream<char> deffile(def_filename.c_str());
     // if have parent graph, it will pass its stack where this graph will put its results
-    SafePtr<CodeSymbols> args(new CodeSymbols);
+    std::shared_ptr<CodeSymbols> args(new CodeSymbols);
     if (have_parent)
       args->append_symbol("parent_stack");
     dg->generate_code(context,memman,ImplicitDimensions::default_dims(),args,
@@ -286,9 +286,9 @@ namespace libint2 {
     // last: missing prerequisites? create new graph computing prereqs and move them onto it
     if (dg->missing_prerequisites()) {
 
-      SafePtr<DirectedGraph> dg_prereq(new DirectedGraph);
+      std::shared_ptr<DirectedGraph> dg_prereq(new DirectedGraph);
       // configure identically
-      dg_prereq->registry() = SafePtr<GraphRegistry>(dg->registry()->clone());
+      dg_prereq->registry() = std::shared_ptr<GraphRegistry>(dg->registry()->clone());
       // except:
       // - allow uncontraction
       // - no need to return targets via inteval->targets_ -- their locations are known by the parent graph (see allocate_mem)
@@ -324,7 +324,7 @@ namespace libint2 {
   }
 
   template <class Integral, bool GenAllCode>
-    void BuildTest(const std::vector< SafePtr<Integral> >& targets, unsigned int size_to_unroll, unsigned int veclen,
+    void BuildTest(const std::vector< std::shared_ptr<Integral> >& targets, unsigned int size_to_unroll, unsigned int veclen,
 		   bool vec_by_line, bool do_cse, const std::string& complabel,
 		   std::ostream& os)
   {
@@ -336,7 +336,7 @@ namespace libint2 {
     taskmgr.current(complabel);
 
     // initialize cparams
-    SafePtr<CompilationParameters> cparams(new CompilationParameters);
+    std::shared_ptr<CompilationParameters> cparams(new CompilationParameters);
     cparams->max_am(complabel,max_am);
     cparams->num_bf(complabel,4u);
     cparams->max_vector_length(veclen);
@@ -379,26 +379,26 @@ namespace libint2 {
     // set default dims
     ImplicitDimensions::set_default_dims(cparams);
 
-    SafePtr<StdRandomizePolicy> rpolicy(new StdRandomizePolicy(0.00));
+    std::shared_ptr<StdRandomizePolicy> rpolicy(new StdRandomizePolicy(0.00));
     // use 4-center OS if the target is a 4-center integral
-    SafePtr<Tactic> tactic;
+    std::shared_ptr<Tactic> tactic;
     {
       typedef GenIntegralSet_11_11<typename Integral::BasisFunctionType,
       typename Integral::OperatorType,
       typename Integral::AuxIndexType> genint_11_11_t;
-      SafePtr< genint_11_11_t > cast_ptr = dynamic_pointer_cast<genint_11_11_t>(targets.front());
+      std::shared_ptr< genint_11_11_t > cast_ptr = dynamic_pointer_cast<genint_11_11_t>(targets.front());
       if (cast_ptr) {
         const unsigned int la = cast_ptr->bra(0, 0).norm();
         const unsigned int lb = cast_ptr->ket(0, 0).norm();
         const unsigned int lc = cast_ptr->bra(1, 0).norm();
         const unsigned int ld = cast_ptr->ket(1, 0).norm();
-        tactic = SafePtr<Tactic>(new FourCenter_OS_Tactic(la, lb, lc, ld));
+        tactic = std::shared_ptr<Tactic>(new FourCenter_OS_Tactic(la, lb, lc, ld));
       }
       else {
-        tactic = SafePtr<Tactic>(new FirstChoiceTactic<StdRandomizePolicy>(rpolicy));
+        tactic = std::shared_ptr<Tactic>(new FirstChoiceTactic<StdRandomizePolicy>(rpolicy));
       }
     }
-    const SafePtr<MemoryManager> memman(new WorstFitMemoryManager);
+    const std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager);
     __BuildTest<Integral,true>(targets,cparams,size_to_unroll,os,tactic,memman,complabel);
   }
 
diff --git a/src/bin/libint/codeblock.cc b/src/bin/libint/codeblock.cc
index ecd1d3c7b..c012ace04 100644
--- a/src/bin/libint/codeblock.cc
+++ b/src/bin/libint/codeblock.cc
@@ -24,8 +24,8 @@
 using namespace std;
 using namespace libint2;
 
-ForLoop::ForLoop(const SafePtr<CodeContext>& context, std::string& varname,
-                 const SafePtr<Entity>& less_than, const SafePtr<Entity>& start_at) :
+ForLoop::ForLoop(const std::shared_ptr<CodeContext>& context, std::string& varname,
+                 const std::shared_ptr<Entity>& less_than, const std::shared_ptr<Entity>& start_at) :
   CodeBlock(context), varname_(varname), less_than_(less_than), start_at_(start_at)
 {
   init_();
@@ -38,11 +38,11 @@ ForLoop::~ForLoop()
 void
 ForLoop::init_()
 {
-  SafePtr<CodeContext> ctext = context();
-  SafePtr< CTimeEntity<int> > lt_cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(less_than_);
-  SafePtr< CTimeEntity<int> > sa_cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(start_at_);
-  SafePtr< RTimeEntity<EntityTypes::Int> > lt_rptr = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(less_than_);
-  SafePtr< RTimeEntity<EntityTypes::Int> > sa_rptr = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(start_at_);
+  std::shared_ptr<CodeContext> ctext = context();
+  std::shared_ptr< CTimeEntity<int> > lt_cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(less_than_);
+  std::shared_ptr< CTimeEntity<int> > sa_cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(start_at_);
+  std::shared_ptr< RTimeEntity<EntityTypes::Int> > lt_rptr = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(less_than_);
+  std::shared_ptr< RTimeEntity<EntityTypes::Int> > sa_rptr = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(start_at_);
   
   if (lt_cptr != 0) {
     ostringstream oss;
@@ -75,7 +75,7 @@ ForLoop::init_()
 std::string
 ForLoop::open()
 {
-  SafePtr<CodeContext> ctext = context();
+  std::shared_ptr<CodeContext> ctext = context();
   ostringstream oss;
 
   if (dummy_loop_) {
diff --git a/src/bin/libint/codeblock.h b/src/bin/libint/codeblock.h
index 8c3cee173..a52716314 100644
--- a/src/bin/libint/codeblock.h
+++ b/src/bin/libint/codeblock.h
@@ -30,11 +30,11 @@ namespace libint2 {
 
   class CodeBlock {
     public:
-    CodeBlock(const SafePtr<CodeContext>& context) :
+    CodeBlock(const std::shared_ptr<CodeContext>& context) :
       context_(context) {}
     virtual ~CodeBlock() {}
 
-    SafePtr<CodeContext> context() const { return context_; }
+    std::shared_ptr<CodeContext> context() const { return context_; }
 
     /// Opens a code block
     virtual std::string open() =0;
@@ -42,13 +42,13 @@ namespace libint2 {
     virtual std::string close() =0;
 
     private:
-    SafePtr<CodeContext> context_;
+    std::shared_ptr<CodeContext> context_;
   };
 
   class ForLoop : public CodeBlock {
     public:
-    ForLoop(const SafePtr<CodeContext>& context, std::string& varname,
-            const SafePtr<Entity>& less_than, const SafePtr<Entity>& start_at);
+    ForLoop(const std::shared_ptr<CodeContext>& context, std::string& varname,
+            const std::shared_ptr<Entity>& less_than, const std::shared_ptr<Entity>& start_at);
     virtual ~ForLoop();
 
     /// Implementation of CodeBlock::open()
@@ -58,8 +58,8 @@ namespace libint2 {
 
     private:
     std::string varname_;
-    SafePtr<Entity> less_than_;
-    SafePtr<Entity> start_at_;
+    std::shared_ptr<Entity> less_than_;
+    std::shared_ptr<Entity> start_at_;
 
     // checks less_than_ and start_at_ and initializes
     // lt_expr_, sa_expr_, and dummy_loop_
diff --git a/src/bin/libint/comp_11_DivG12prime_xTx_11.h b/src/bin/libint/comp_11_DivG12prime_xTx_11.h
index ffdeda11b..5a1830626 100644
--- a/src/bin/libint/comp_11_DivG12prime_xTx_11.h
+++ b/src/bin/libint/comp_11_DivG12prime_xTx_11.h
@@ -56,14 +56,14 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_11_DivG12prime_xTx_11(const SafePtr<TargetType>&, unsigned int dir);
+      CR_11_DivG12prime_xTx_11(const std::shared_ptr<TargetType>&, unsigned int dir);
       static std::string descr() { return "CR"; }
 
       template<class RR, class C> friend class ChildFactory;
     };
 
   template <class F>
-    CR_11_DivG12prime_xTx_11<F>::CR_11_DivG12prime_xTx_11(const SafePtr<TargetType>& Tint,
+    CR_11_DivG12prime_xTx_11<F>::CR_11_DivG12prime_xTx_11(const std::shared_ptr<TargetType>& Tint,
                                       unsigned int dir) :
     ParentType(Tint,dir)
     {
diff --git a/src/bin/libint/comp_11_g12tig12_11.h b/src/bin/libint/comp_11_g12tig12_11.h
index 313b3a1f5..f6ff88d46 100644
--- a/src/bin/libint/comp_11_g12tig12_11.h
+++ b/src/bin/libint/comp_11_g12tig12_11.h
@@ -53,21 +53,21 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_11_G12TiG12_11(const SafePtr<TargetType>&, unsigned int dir);
+      CR_11_G12TiG12_11(const std::shared_ptr<TargetType>&, unsigned int dir);
       static std::string descr() { return "CR"; }
 
 #if LIBINT_ENABLE_GENERIC_CODE
     /// Implementation of RecurrenceRelation::has_generic()
-    bool has_generic(const SafePtr<CompilationParameters>& cparams) const override;
+    bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const override;
     /// Implementation of RecurrenceRelation::generic_header()
     std::string generic_header() const override { return "GenericScale.h"; }
     /// Implementation of RecurrenceRelation::generic_instance()
-    std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const override;
+    std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const override;
 #endif
     };
 
   template <class F>
-    CR_11_G12TiG12_11<F>::CR_11_G12TiG12_11(const SafePtr<TargetType>& Tint,
+    CR_11_G12TiG12_11<F>::CR_11_G12TiG12_11(const std::shared_ptr<TargetType>& Tint,
                                             unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -104,7 +104,7 @@ namespace libint2 {
 #if LIBINT_ENABLE_GENERIC_CODE
   template <class F>
   bool
-  CR_11_G12TiG12_11<F>::has_generic(const SafePtr<CompilationParameters>& cparams) const
+  CR_11_G12TiG12_11<F>::has_generic(const std::shared_ptr<CompilationParameters>& cparams) const
   {
     F sh_a(target_->bra(0,0));
     F sh_b(target_->ket(0,0));
@@ -125,7 +125,7 @@ namespace libint2 {
 
   template <class F>
   std::string
-  CR_11_G12TiG12_11<F>::generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const {
+  CR_11_G12TiG12_11<F>::generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const {
       std::ostringstream oss;
 
       const bool vec = (context->cparams()->max_vector_length() != 1);
diff --git a/src/bin/libint/comp_11_gtg_11_1d.h b/src/bin/libint/comp_11_gtg_11_1d.h
index 824427895..0a20f0a9d 100644
--- a/src/bin/libint/comp_11_gtg_11_1d.h
+++ b/src/bin/libint/comp_11_gtg_11_1d.h
@@ -53,21 +53,21 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_11_GTG_11_1d(const SafePtr<TargetType>&, unsigned int dir);
+      CR_11_GTG_11_1d(const std::shared_ptr<TargetType>&, unsigned int dir);
       static std::string descr() { return "CR"; }
 
 #if LIBINT_ENABLE_GENERIC_CODE
     /// Implementation of RecurrenceRelation::has_generic()
-    bool has_generic(const SafePtr<CompilationParameters>& cparams) const override { return true; }
+    bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const override { return true; }
     /// Implementation of RecurrenceRelation::generic_header()
     std::string generic_header() const override { return "VRR_GTG_1d_xx_xx.h"; }
     /// Implementation of RecurrenceRelation::generic_instance()
-    std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const override;
+    std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const override;
 #endif
     };
 
   template <CartesianAxis Axis>
-  CR_11_GTG_11_1d<Axis>::CR_11_GTG_11_1d(const SafePtr<TargetType>& Tint,
+  CR_11_GTG_11_1d<Axis>::CR_11_GTG_11_1d(const std::shared_ptr<TargetType>& Tint,
                                          unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -88,7 +88,7 @@ namespace libint2 {
 #if LIBINT_ENABLE_GENERIC_CODE
   template <CartesianAxis Axis>
   std::string
-  CR_11_GTG_11_1d<Axis>::generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const {
+  CR_11_GTG_11_1d<Axis>::generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const {
 
       std::ostringstream oss;
       auto a = target_->bra(0,0);
diff --git a/src/bin/libint/comp_11_r12kr12lg12_11.h b/src/bin/libint/comp_11_r12kr12lg12_11.h
index 181d74481..3fd03a47c 100644
--- a/src/bin/libint/comp_11_r12kr12lg12_11.h
+++ b/src/bin/libint/comp_11_r12kr12lg12_11.h
@@ -58,13 +58,13 @@ namespace libint2 {
       template<class RR, class C> friend class ChildFactory;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_11_R12kR12lG12_11(const SafePtr<TargetType>&, unsigned int dir);
+      CR_11_R12kR12lG12_11(const std::shared_ptr<TargetType>&, unsigned int dir);
       static std::string descr() { return "CR"; }
 
     };
 
   template <class F>
-    CR_11_R12kR12lG12_11<F>::CR_11_R12kR12lG12_11(const SafePtr<TargetType>& Tint,
+    CR_11_R12kR12lG12_11<F>::CR_11_R12kR12lG12_11(const std::shared_ptr<TargetType>& Tint,
                                                   unsigned int dir) :
     ParentType(Tint,dir)
     {
diff --git a/src/bin/libint/comp_11_r1dotr1g12_11.h b/src/bin/libint/comp_11_r1dotr1g12_11.h
index 86e11ae7f..394893ad3 100644
--- a/src/bin/libint/comp_11_r1dotr1g12_11.h
+++ b/src/bin/libint/comp_11_r1dotr1g12_11.h
@@ -58,21 +58,21 @@ namespace libint2 {
     typedef RecurrenceRelation::ExprType ExprType;
 
     /** Use Instance() to obtain an instance of RR. This function is provided to avoid
-        issues with getting a SafePtr from constructor (as needed for registry to work).
+        issues with getting a std::shared_ptr from constructor (as needed for registry to work).
     */
-    static SafePtr<ThisType> Instance(const SafePtr<TargetType>&);
+    static std::shared_ptr<ThisType> Instance(const std::shared_ptr<TargetType>&);
     virtual ~CR_11_R1dotR1G12_11() {}
 
     /// Implementation of RecurrenceRelation::num_children()
     unsigned int num_children() const override { return nchildren_; }
     /// target() returns pointer to the i-th child
-    SafePtr<TargetType> target() const { return target_; };
+    std::shared_ptr<TargetType> target() const { return target_; };
     /// child(i) returns pointer to the i-th child
-    SafePtr<ChildType> child(unsigned int i) const;
+    std::shared_ptr<ChildType> child(unsigned int i) const;
     /// Implementation of RecurrenceRelation::rr_target()
-    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
+    std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
     /// Implementation of RecurrenceRelation::rr_child()
-    SafePtr<DGVertex> rr_child(unsigned int i) const override { return dynamic_pointer_cast<DGVertex,ChildType>(child(i)); }
+    std::shared_ptr<DGVertex> rr_child(unsigned int i) const override { return dynamic_pointer_cast<DGVertex,ChildType>(child(i)); }
     /// Implementation of RecurrenceRelation::is_simple()
     bool is_simple() const override {
       return TrivialBFSet<BFSet>::result;
@@ -84,7 +84,7 @@ namespace libint2 {
       For example, dir can be 0 (x), 1(y), or 2(z) if BFSet is
       a Cartesian Gaussian.
      */
-    CR_11_R1dotR1G12_11(const SafePtr<TargetType>&);
+    CR_11_R1dotR1G12_11(const std::shared_ptr<TargetType>&);
 
 #if 0
     /// registers this RR with the stack, if needed
@@ -92,8 +92,8 @@ namespace libint2 {
 #endif
 
     static const unsigned int max_nchildren_ = 18;
-    SafePtr<TargetType> target_;
-    SafePtr<ChildType> children_[max_nchildren_];
+    std::shared_ptr<TargetType> target_;
+    std::shared_ptr<ChildType> children_[max_nchildren_];
     unsigned int nchildren_;
 
     std::string generate_label() const override
@@ -107,20 +107,20 @@ namespace libint2 {
   };
 
   template <template <class> class I, class F>
-    SafePtr< CR_11_R1dotR1G12_11<I,F> >
-    CR_11_R1dotR1G12_11<I,F>::Instance(const SafePtr<TargetType>& Tint)
+    std::shared_ptr< CR_11_R1dotR1G12_11<I,F> >
+    CR_11_R1dotR1G12_11<I,F>::Instance(const std::shared_ptr<TargetType>& Tint)
     {
-      SafePtr<ThisType> this_ptr(new ThisType(Tint));
+      std::shared_ptr<ThisType> this_ptr(new ThisType(Tint));
       // Do post-construction duties
       if (this_ptr->num_children() != 0) {
         this_ptr->register_with_rrstack<ThisType>();
         return this_ptr;
       }
-      return SafePtr<ThisType>();
+      return std::shared_ptr<ThisType>();
     }
 
   template <template <class> class I, class F>
-    CR_11_R1dotR1G12_11<I,F>::CR_11_R1dotR1G12_11(const SafePtr<I<F> >& Tint) :
+    CR_11_R1dotR1G12_11<I,F>::CR_11_R1dotR1G12_11(const std::shared_ptr<I<F> >& Tint) :
     ParentType(), target_(Tint), nchildren_(0)
     {
       F sh_a(Tint->bra(0,0));
@@ -149,7 +149,7 @@ namespace libint2 {
 	++nchildren_;
 
 	if (is_simple()) {
-	  SafePtr<ExprType> expr0_ptr(new ExprType(ExprType::OperatorTypes::Times,Scalar(1.0),rr_child(next_child)));
+	  std::shared_ptr<ExprType> expr0_ptr(new ExprType(ExprType::OperatorTypes::Times,Scalar(1.0),rr_child(next_child)));
 	  add_expr(expr0_ptr);
 	  nflops_ += 1;
 	}
@@ -159,7 +159,7 @@ namespace libint2 {
     }
 
   template <template <class> class I, class F>
-    SafePtr< typename CR_11_R1dotR1G12_11<I,F>::ChildType >
+    std::shared_ptr< typename CR_11_R1dotR1G12_11<I,F>::ChildType >
     CR_11_R1dotR1G12_11<I,F>::child(unsigned int i) const
     {
       assert(i>=0 && i<nchildren_);
diff --git a/src/bin/libint/comp_11_r1dotr2g12_11.h b/src/bin/libint/comp_11_r1dotr2g12_11.h
index a5d617c9a..15da3b019 100644
--- a/src/bin/libint/comp_11_r1dotr2g12_11.h
+++ b/src/bin/libint/comp_11_r1dotr2g12_11.h
@@ -58,21 +58,21 @@ namespace libint2 {
     typedef RecurrenceRelation::ExprType ExprType;
 
     /** Use Instance() to obtain an instance of RR. This function is provided to avoid
-        issues with getting a SafePtr from constructor (as needed for registry to work).
+        issues with getting a std::shared_ptr from constructor (as needed for registry to work).
     */
-    static SafePtr<ThisType> Instance(const SafePtr<TargetType>&);
+    static std::shared_ptr<ThisType> Instance(const std::shared_ptr<TargetType>&);
     virtual ~CR_11_R1dotR2G12_11() {}
 
     /// Implementation of RecurrenceRelation::num_children()
     unsigned int num_children() const override { return nchildren_; }
     /// target() returns pointer to the i-th child
-    SafePtr<TargetType> target() const { return target_; };
+    std::shared_ptr<TargetType> target() const { return target_; };
     /// child(i) returns pointer to the i-th child
-    SafePtr<ChildType> child(unsigned int i) const;
+    std::shared_ptr<ChildType> child(unsigned int i) const;
     /// Implementation of RecurrenceRelation::rr_target()
-    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
+    std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
     /// Implementation of RecurrenceRelation::rr_child()
-    SafePtr<DGVertex> rr_child(unsigned int i) const override { return dynamic_pointer_cast<DGVertex,ChildType>(child(i)); }
+    std::shared_ptr<DGVertex> rr_child(unsigned int i) const override { return dynamic_pointer_cast<DGVertex,ChildType>(child(i)); }
     /// Implementation of RecurrenceRelation::is_simple()
     bool is_simple() const override {
       return TrivialBFSet<BFSet>::result;
@@ -84,7 +84,7 @@ namespace libint2 {
       For example, dir can be 0 (x), 1(y), or 2(z) if BFSet is
       a Cartesian Gaussian.
      */
-    CR_11_R1dotR2G12_11(const SafePtr<TargetType>&);
+    CR_11_R1dotR2G12_11(const std::shared_ptr<TargetType>&);
 
 #if 0
     /// registers this RR with the stack, if needed
@@ -92,8 +92,8 @@ namespace libint2 {
 #endif
 
     static const unsigned int max_nchildren_ = 18;
-    SafePtr<TargetType> target_;
-    SafePtr<ChildType> children_[max_nchildren_];
+    std::shared_ptr<TargetType> target_;
+    std::shared_ptr<ChildType> children_[max_nchildren_];
     unsigned int nchildren_;
 
     std::string generate_label() const override
@@ -107,20 +107,20 @@ namespace libint2 {
   };
 
   template <template <typename,typename,typename> class I, class F>
-    SafePtr< CR_11_R1dotR2G12_11<I,F> >
-    CR_11_R1dotR2G12_11<I,F>::Instance(const SafePtr<TargetType>& Tint)
+    std::shared_ptr< CR_11_R1dotR2G12_11<I,F> >
+    CR_11_R1dotR2G12_11<I,F>::Instance(const std::shared_ptr<TargetType>& Tint)
     {
-      SafePtr<ThisType> this_ptr(new ThisType(Tint));
+      std::shared_ptr<ThisType> this_ptr(new ThisType(Tint));
       // Do post-construction duties
       if (this_ptr->num_children() != 0) {
         this_ptr->register_with_rrstack<ThisType>();
         return this_ptr;
       }
-      return SafePtr<ThisType>();
+      return std::shared_ptr<ThisType>();
     }
 
   template <template <typename,typename,typename> class I, class F>
-    CR_11_R1dotR2G12_11<I,F>::CR_11_R1dotR2G12_11(const SafePtr<TargetType>& Tint) :
+    CR_11_R1dotR2G12_11<I,F>::CR_11_R1dotR2G12_11(const std::shared_ptr<TargetType>& Tint) :
     ParentType(), target_(Tint), nchildren_(0)
     {
       F sh_a(Tint->bra(0,0));
@@ -149,7 +149,7 @@ namespace libint2 {
 	++nchildren_;
 
 	if (is_simple()) {
-	  SafePtr<ExprType> expr0_ptr(new ExprType(ExprType::OperatorTypes::Times,Scalar(1.0),rr_child(next_child)));
+	  std::shared_ptr<ExprType> expr0_ptr(new ExprType(ExprType::OperatorTypes::Times,Scalar(1.0),rr_child(next_child)));
 	  add_expr(expr0_ptr);
 	  nflops_ += 1;
 	}
@@ -159,7 +159,7 @@ namespace libint2 {
     }
 
   template <template <typename,typename,typename> class I, class F>
-    SafePtr< typename CR_11_R1dotR2G12_11<I,F>::ChildType >
+    std::shared_ptr< typename CR_11_R1dotR2G12_11<I,F>::ChildType >
     CR_11_R1dotR2G12_11<I,F>::child(unsigned int i) const
     {
       assert(i>=0 && i<nchildren_);
diff --git a/src/bin/libint/comp_11_r2dotr2g12_11.h b/src/bin/libint/comp_11_r2dotr2g12_11.h
index fad6d5241..f442ff4fb 100644
--- a/src/bin/libint/comp_11_r2dotr2g12_11.h
+++ b/src/bin/libint/comp_11_r2dotr2g12_11.h
@@ -58,21 +58,21 @@ namespace libint2 {
     typedef RecurrenceRelation::ExprType ExprType;
 
     /** Use Instance() to obtain an instance of RR. This function is provided to avoid
-        issues with getting a SafePtr from constructor (as needed for registry to work).
+        issues with getting a std::shared_ptr from constructor (as needed for registry to work).
     */
-    static SafePtr<ThisType> Instance(const SafePtr<TargetType>&);
+    static std::shared_ptr<ThisType> Instance(const std::shared_ptr<TargetType>&);
     virtual ~CR_11_R2dotR2G12_11() {}
 
     /// Implementation of RecurrenceRelation::num_children()
     unsigned int num_children() const override { return nchildren_; }
     /// target() returns pointer to the i-th child
-    SafePtr<TargetType> target() const { return target_; };
+    std::shared_ptr<TargetType> target() const { return target_; };
     /// child(i) returns pointer to the i-th child
-    SafePtr<ChildType> child(unsigned int i) const;
+    std::shared_ptr<ChildType> child(unsigned int i) const;
     /// Implementation of RecurrenceRelation::rr_target()
-    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
+    std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
     /// Implementation of RecurrenceRelation::rr_child()
-    SafePtr<DGVertex> rr_child(unsigned int i) const override { return dynamic_pointer_cast<DGVertex,ChildType>(child(i)); }
+    std::shared_ptr<DGVertex> rr_child(unsigned int i) const override { return dynamic_pointer_cast<DGVertex,ChildType>(child(i)); }
     /// Implementation of RecurrenceRelation::is_simple()
     bool is_simple() const override {
       return TrivialBFSet<BFSet>::result;
@@ -84,7 +84,7 @@ namespace libint2 {
       For example, dir can be 0 (x), 1(y), or 2(z) if BFSet is
       a Cartesian Gaussian.
      */
-    CR_11_R2dotR2G12_11(const SafePtr<TargetType>&);
+    CR_11_R2dotR2G12_11(const std::shared_ptr<TargetType>&);
 
 #if 0
     /// registers this RR with the stack, if needed
@@ -92,8 +92,8 @@ namespace libint2 {
 #endif
 
     static const unsigned int max_nchildren_ = 3;
-    SafePtr<TargetType> target_;
-    SafePtr<ChildType> children_[max_nchildren_];
+    std::shared_ptr<TargetType> target_;
+    std::shared_ptr<ChildType> children_[max_nchildren_];
     unsigned int nchildren_;
 
     std::string generate_label() const override
@@ -107,20 +107,20 @@ namespace libint2 {
   };
 
   template <template <class> class I, class F>
-    SafePtr< CR_11_R2dotR2G12_11<I,F> >
-    CR_11_R2dotR2G12_11<I,F>::Instance(const SafePtr<TargetType>& Tint)
+    std::shared_ptr< CR_11_R2dotR2G12_11<I,F> >
+    CR_11_R2dotR2G12_11<I,F>::Instance(const std::shared_ptr<TargetType>& Tint)
     {
-      SafePtr<ThisType> this_ptr(new ThisType(Tint));
+      std::shared_ptr<ThisType> this_ptr(new ThisType(Tint));
       // Do post-construction duties
       if (this_ptr->num_children() != 0) {
         this_ptr->register_with_rrstack<ThisType>();
         return this_ptr;
       }
-      return SafePtr<ThisType>();
+      return std::shared_ptr<ThisType>();
     }
 
   template <template <class> class I, class F>
-    CR_11_R2dotR2G12_11<I,F>::CR_11_R2dotR2G12_11(const SafePtr<I<F> >& Tint) :
+    CR_11_R2dotR2G12_11<I,F>::CR_11_R2dotR2G12_11(const std::shared_ptr<I<F> >& Tint) :
     ParentType(), target_(Tint), nchildren_(0)
     {
       F sh_a(Tint->bra(0,0));
@@ -149,7 +149,7 @@ namespace libint2 {
 	++nchildren_;
 
 	if (is_simple()) {
-	  SafePtr<ExprType> expr0_ptr(new ExprType(ExprType::OperatorTypes::Times,Scalar(1.0),rr_child(next_child)));
+	  std::shared_ptr<ExprType> expr0_ptr(new ExprType(ExprType::OperatorTypes::Times,Scalar(1.0),rr_child(next_child)));
 	  add_expr(expr0_ptr);
 	  nflops_ += 1;
 	}
@@ -159,7 +159,7 @@ namespace libint2 {
     }
 
   template <template <class> class I, class F>
-    SafePtr< typename CR_11_R2dotR2G12_11<I,F>::ChildType >
+    std::shared_ptr< typename CR_11_R2dotR2G12_11<I,F>::ChildType >
     CR_11_R2dotR2G12_11<I,F>::child(unsigned int i) const
     {
       assert(i>=0 && i<nchildren_);
diff --git a/src/bin/libint/comp_11_tig12_11.h b/src/bin/libint/comp_11_tig12_11.h
index f8fc46947..fab48b5ab 100644
--- a/src/bin/libint/comp_11_tig12_11.h
+++ b/src/bin/libint/comp_11_tig12_11.h
@@ -55,13 +55,13 @@ namespace libint2 {
       template<class RR, class C> friend class ChildFactory;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_11_TiG12_11(const SafePtr<TargetType>&, unsigned int dir);
+      CR_11_TiG12_11(const std::shared_ptr<TargetType>&, unsigned int dir);
       static std::string descr() { return "CR"; }
 
     };
 
   template <class F>
-    CR_11_TiG12_11<F>::CR_11_TiG12_11(const SafePtr<TargetType>& Tint,
+    CR_11_TiG12_11<F>::CR_11_TiG12_11(const std::shared_ptr<TargetType>& Tint,
                                       unsigned int dir) :
     ParentType(Tint,dir)
     {
diff --git a/src/bin/libint/comp_deriv_gauss.h b/src/bin/libint/comp_deriv_gauss.h
index 97e0dacb4..6e71efd65 100644
--- a/src/bin/libint/comp_deriv_gauss.h
+++ b/src/bin/libint/comp_deriv_gauss.h
@@ -95,7 +95,7 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_DerivGauss(const SafePtr<TargetType>&, unsigned int dir);
+      CR_DerivGauss(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return "CR_DerivGauss"; }
       /** Re-Implementation of GenericRecurrenceRelation::generate_label():
@@ -104,7 +104,7 @@ namespace libint2 {
       std::string generate_label() const override
       {
         typedef typename TargetType::AuxIndexType mType;
-        static SafePtr<mType> aux0(new mType(0u));
+        static std::shared_ptr<mType> aux0(new mType(0u));
         std::ostringstream os;
         os << descr() << "P" << part << to_string(where)
            << genintegralset_label(target_->bra(),target_->ket(),aux0,target_->oper());
@@ -113,18 +113,18 @@ namespace libint2 {
 
 #if LIBINT_ENABLE_GENERIC_CODE
       /// Implementation of RecurrenceRelation::has_generic()
-      bool has_generic(const SafePtr<CompilationParameters>& cparams) const override;
+      bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const override;
       /// Implementation of RecurrenceRelation::generic_header()
       std::string generic_header() const override;
       /// Implementation of RecurrenceRelation::generic_instance()
-      std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const override;
+      std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const override;
 #endif
     };
 
   template <class IntType, int part, FunctionPosition where,
             int trans_inv_part, FunctionPosition trans_inv_where>
   CR_DerivGauss<IntType,part,where,trans_inv_part,trans_inv_where>::CR_DerivGauss(
-      const SafePtr< TargetType >& Tint,
+      const std::shared_ptr< TargetType >& Tint,
       unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -279,7 +279,7 @@ namespace libint2 {
             int trans_inv_part, FunctionPosition trans_inv_where>
   bool
   CR_DerivGauss<IntType,part,where,trans_inv_part,trans_inv_where>::has_generic(
-      const SafePtr<CompilationParameters>& cparams
+      const std::shared_ptr<CompilationParameters>& cparams
       ) const
     {
       // not implemented generic relation for translational invariance yet
@@ -324,7 +324,7 @@ namespace libint2 {
             int trans_inv_part, FunctionPosition trans_inv_where>
       std::string
       CR_DerivGauss<IntType,part,where,trans_inv_part,trans_inv_where>::generic_instance(
-          const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args
+          const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args
         ) const
     {
       std::ostringstream oss;
diff --git a/src/bin/libint/comp_xyz.h b/src/bin/libint/comp_xyz.h
index cf177b5e3..1f917ab3e 100644
--- a/src/bin/libint/comp_xyz.h
+++ b/src/bin/libint/comp_xyz.h
@@ -54,7 +54,7 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      CR_XYZ_1_1(const SafePtr<TargetType>&, unsigned int dir = 0);
+      CR_XYZ_1_1(const std::shared_ptr<TargetType>&, unsigned int dir = 0);
 
       static std::string descr() { return "CR"; }
 
@@ -63,7 +63,7 @@ namespace libint2 {
   };
 
   template <typename F, typename Oper, typename AuxQuanta>
-  CR_XYZ_1_1<F,Oper,AuxQuanta>::CR_XYZ_1_1(const SafePtr< TargetType >& Tint,
+  CR_XYZ_1_1<F,Oper,AuxQuanta>::CR_XYZ_1_1(const std::shared_ptr< TargetType >& Tint,
                                            unsigned int dir) :
     ParentType(Tint,dir)
     {
diff --git a/src/bin/libint/context.cc b/src/bin/libint/context.cc
index 2c7b3b18e..0d6cb67f4 100644
--- a/src/bin/libint/context.cc
+++ b/src/bin/libint/context.cc
@@ -82,14 +82,14 @@ namespace libint2 {
   }
 };
 
-CodeContext::CodeContext(const SafePtr<CompilationParameters>& cparams) :
+CodeContext::CodeContext(const std::shared_ptr<CompilationParameters>& cparams) :
   cparams_(cparams),
   comments_on_(false)
 {
   zero_out_counters();
 }
 
-const SafePtr<CompilationParameters>&
+const std::shared_ptr<CompilationParameters>&
 CodeContext::cparams() const
 {
   return cparams_;
@@ -185,7 +185,7 @@ namespace ForbiddenCppCharacters {
   };
 };
 
-CppCodeContext::CppCodeContext(const SafePtr<CompilationParameters>& cparams, bool vectorize) :
+CppCodeContext::CppCodeContext(const std::shared_ptr<CompilationParameters>& cparams, bool vectorize) :
   CodeContext(cparams), vectorize_(vectorize)
 {
 }
@@ -660,9 +660,9 @@ CppCodeContext::value_to_pointer(const std::string& val) const
   }
 }
 
-SafePtr<ForLoop>
-CppCodeContext::for_loop(std::string& varname, const SafePtr<Entity>& less_than,
-                         const SafePtr<Entity>& start_at) const
+std::shared_ptr<ForLoop>
+CppCodeContext::for_loop(std::string& varname, const std::shared_ptr<Entity>& less_than,
+                         const std::shared_ptr<Entity>& start_at) const
 {
   // not implemented
   abort();
diff --git a/src/bin/libint/context.h b/src/bin/libint/context.h
index bfca8cc7b..824a58d1d 100644
--- a/src/bin/libint/context.h
+++ b/src/bin/libint/context.h
@@ -36,7 +36,7 @@ namespace libint2 {
     virtual ~CodeContext() {}
 
     /// Returns the CompilationParameters used to create this context
-    const SafePtr<CompilationParameters>& cparams() const;
+    const std::shared_ptr<CompilationParameters>& cparams() const;
 
     /// turn comments on and off (the default is on)
     void turn_comments(bool on);
@@ -144,8 +144,8 @@ namespace libint2 {
 
     /** returns a ForLoop object.
       */
-    virtual SafePtr<ForLoop> for_loop(std::string& varname, const SafePtr<Entity>& less_than,
-                                      const SafePtr<Entity>& start_at = SafePtr<Entity>(new CTimeEntity<int>(0))) const =0;
+    virtual std::shared_ptr<ForLoop> for_loop(std::string& varname, const std::shared_ptr<Entity>& less_than,
+                                      const std::shared_ptr<Entity>& start_at = std::shared_ptr<Entity>(new CTimeEntity<int>(0))) const =0;
 
     /// unique_name<T> returns a unique name for a variable of type T
     template <typename T>
@@ -166,7 +166,7 @@ namespace libint2 {
 
   protected:
     /// Lone constructor takes CompilationParams
-    CodeContext(const SafePtr<CompilationParameters>& cparams);
+    CodeContext(const std::shared_ptr<CompilationParameters>& cparams);
     /// generates a unique name for a floating-point variable
     virtual std::string unique_fp_name() const =0;
     /// generates a unique name for an integer
@@ -193,7 +193,7 @@ namespace libint2 {
     virtual std::string ptr_fp_type() const =0;
 
   private:
-    SafePtr<CompilationParameters> cparams_;
+    std::shared_ptr<CompilationParameters> cparams_;
     mutable unsigned int next_index_[EntityTypes::ntypes];
     void zero_out_counters() const;
     bool comments_on_;
@@ -206,7 +206,7 @@ namespace libint2 {
   */
   class CppCodeContext : public CodeContext, public std::enable_shared_from_this<CppCodeContext> {
   public:
-    CppCodeContext(const SafePtr<CompilationParameters>& cparams, bool vectorize = false);
+    CppCodeContext(const std::shared_ptr<CompilationParameters>& cparams, bool vectorize = false);
     virtual ~CppCodeContext();
 
     /// Implementation of CodeContext::code_prefix()
@@ -287,8 +287,8 @@ namespace libint2 {
     /// Implementation of CodeContext::value_to_pointer()
     std::string value_to_pointer(const std::string& val) const override;
     /// Implementation of CodeContext::for_loop()
-    SafePtr<ForLoop> for_loop(std::string& varname, const SafePtr<Entity>& less_than,
-                              const SafePtr<Entity>& start_at) const override;
+    std::shared_ptr<ForLoop> for_loop(std::string& varname, const std::shared_ptr<Entity>& less_than,
+                              const std::shared_ptr<Entity>& start_at) const override;
 
     /// Implementation of CodeContext::inteval_type_name()
     std::string inteval_type_name(const std::string& task) const override;
diff --git a/src/bin/libint/dg.cc b/src/bin/libint/dg.cc
index 713a6df90..7cbc7380e 100644
--- a/src/bin/libint/dg.cc
+++ b/src/bin/libint/dg.cc
@@ -58,8 +58,8 @@ namespace {
 
 DirectedGraph::DirectedGraph() :
   stack_(), targets_(), target_accums_(), label_("graph"), func_names_(),
-  registry_(SafePtr<GraphRegistry>(new GraphRegistry)),
-  iregistry_(SafePtr<InternalGraphRegistry>(new InternalGraphRegistry)),
+  registry_(std::shared_ptr<GraphRegistry>(new GraphRegistry)),
+  iregistry_(std::shared_ptr<InternalGraphRegistry>(new InternalGraphRegistry)),
   first_to_compute_()
 {
   stack_.clear();
@@ -72,15 +72,15 @@ DirectedGraph::~DirectedGraph()
 }
 
 void
-DirectedGraph::append_target(const SafePtr<DGVertex>& target)
+DirectedGraph::append_target(const std::shared_ptr<DGVertex>& target)
 {
   target->make_a_target();
   append_vertex(target);
   push(targets_,target);
 }
 
-SafePtr<DGVertex>
-DirectedGraph::append_vertex(const SafePtr<DGVertex>& vertex)
+std::shared_ptr<DGVertex>
+DirectedGraph::append_vertex(const std::shared_ptr<DGVertex>& vertex)
 {
   // If this vertex is owned by this graph, return it immediately
   if (vertex->dg() == this) {
@@ -96,13 +96,13 @@ DirectedGraph::append_vertex(const SafePtr<DGVertex>& vertex)
   return vcopy_on_graph;
 }
 
-SafePtr<DGVertex>
-DirectedGraph::add_vertex(const SafePtr<DGVertex>& vertex)
+std::shared_ptr<DGVertex>
+DirectedGraph::add_vertex(const std::shared_ptr<DGVertex>& vertex)
 {
   // if vertex is precomputed -- can replicate it without consequences
   // else check if it's on already
   if (!vertex->precomputed()) {
-    SafePtr<DGVertex> vcopy_on_graph = vertex_is_on(vertex);
+    std::shared_ptr<DGVertex> vcopy_on_graph = vertex_is_on(vertex);
     if (vcopy_on_graph)
       return vcopy_on_graph;
   }
@@ -111,7 +111,7 @@ DirectedGraph::add_vertex(const SafePtr<DGVertex>& vertex)
 }
 
 void
-DirectedGraph::add_new_vertex(const SafePtr<DGVertex>& vertex)
+DirectedGraph::add_new_vertex(const std::shared_ptr<DGVertex>& vertex)
 {
 #if 0
   // Resize if using std::vector
@@ -138,13 +138,13 @@ DirectedGraph::add_new_vertex(const SafePtr<DGVertex>& vertex)
   return;
 }
 
-const SafePtr<DGVertex>&
-DirectedGraph::vertex_is_on(const SafePtr<DGVertex>& vertex) const
+const std::shared_ptr<DGVertex>&
+DirectedGraph::vertex_is_on(const std::shared_ptr<DGVertex>& vertex) const
 {
   if (vertex->dg() == this)
     return vertex;
 
-  static SafePtr<DGVertex> null_ptr;
+  static std::shared_ptr<DGVertex> null_ptr;
 #if USE_ASSOCCONTAINER_BASED_DIRECTEDGRAPH
   typedef vertices::const_iterator citer;
   typedef vertices::value_type value_type;
@@ -187,7 +187,7 @@ DirectedGraph::vertex_is_on(const SafePtr<DGVertex>& vertex) const
 
 namespace {
   struct __reset_dgvertex {
-    void operator()(SafePtr<DGVertex>& v) {
+    void operator()(std::shared_ptr<DGVertex>& v) {
       v->reset();
 #if DEBUG
       std::cout << "DirectedGraph::reset: will unregister " << v->label() << std::endl;
@@ -197,7 +197,7 @@ namespace {
     }
   };
   struct __reset_safeptr {
-    void operator()(SafePtr<DGVertex>& v) {
+    void operator()(std::shared_ptr<DGVertex>& v) {
       v.reset();
     }
   };
@@ -217,7 +217,7 @@ DirectedGraph::del_vertex(vertices::iterator& v)
 #if DEBUG
     std::cout << "del_vertex: trying to remove " << (vertex_ptr(*v))->label() << std::endl;
 #endif
-    SafePtr<DGVertex> vptr = vertex_ptr(*v); // keep an instance of the pointer to avoid accidental automatic destruction of the DGVertex object
+    std::shared_ptr<DGVertex> vptr = vertex_ptr(*v); // keep an instance of the pointer to avoid accidental automatic destruction of the DGVertex object
     stack_.erase(v);
     rv(vptr);
 #if DEBUG
@@ -230,7 +230,7 @@ DirectedGraph::del_vertex(vertices::iterator& v)
 
 namespace{
   struct __prepare_to_traverse {
-    void operator()(SafePtr<DGVertex>& v) {
+    void operator()(std::shared_ptr<DGVertex>& v) {
       v->prepare_to_traverse();
     }
   };
@@ -298,10 +298,10 @@ DirectedGraph::traverse()
 }
 
 void
-DirectedGraph::traverse_from(const SafePtr<DGArc>& arc)
+DirectedGraph::traverse_from(const std::shared_ptr<DGArc>& arc)
 {
-  SafePtr<DGVertex> orig = arc->orig();
-  SafePtr<DGVertex> dest = arc->dest();
+  std::shared_ptr<DGVertex> orig = arc->orig();
+  std::shared_ptr<DGVertex> dest = arc->dest();
 #if DEBUG_TRAVERSAL
   std::cout << "traverse_from: orig = " << orig << " dest = " << dest << endl;
 #endif
@@ -321,7 +321,7 @@ DirectedGraph::traverse_from(const SafePtr<DGArc>& arc)
   if (num_tags == num_parents) {
 
     // ... check if it is on a subtree ...
-    if (SafePtr<DRTree> stree = dest->subtree()) {
+    if (std::shared_ptr<DRTree> stree = dest->subtree()) {
       // ... if yes, schedule only if it is a root of a subtree
       if (stree->root() == dest)
         schedule_computation(dest);
@@ -343,7 +343,7 @@ DirectedGraph::traverse_from(const SafePtr<DGArc>& arc)
 }
 
 void
-DirectedGraph::schedule_computation(const SafePtr<DGVertex>& vertex)
+DirectedGraph::schedule_computation(const std::shared_ptr<DGVertex>& vertex)
 {
   vertex->set_postcalc(first_to_compute_);
   first_to_compute_ = vertex;
@@ -357,7 +357,7 @@ DirectedGraph::schedule_computation(const SafePtr<DGVertex>& vertex)
 void
 DirectedGraph::debug_print_traversal(std::ostream& os) const
 {
-  SafePtr<DGVertex> current_vertex = first_to_compute_;
+  std::shared_ptr<DGVertex> current_vertex = first_to_compute_;
 
   os << "Debug print of traversal order" << endl;
 
@@ -373,7 +373,7 @@ namespace {
     bool symbols;
     std::ostream& os;
     __print_vertices_to_dot(bool s, std::ostream& o) : symbols(s), os(o) {}
-    void operator()(const SafePtr<DGVertex>& v) {
+    void operator()(const std::shared_ptr<DGVertex>& v) {
       os << "  " << v->graph_label()
 	 << " [ label = \"";
       if (symbols && v->symbol_set())
@@ -387,12 +387,12 @@ namespace {
   struct __print_arcs_to_dot {
     std::ostream& os;
     __print_arcs_to_dot(std::ostream& o) : os(o) {}
-    void operator()(const SafePtr<DGVertex>& v) {
+    void operator()(const std::shared_ptr<DGVertex>& v) {
       typedef DGVertex::ArcSetType::const_iterator aciter;
       const aciter abegin = v->first_exit_arc();
       const aciter aend = v->plast_exit_arc();
       for(aciter a=abegin; a!=aend; ++a) {
-	SafePtr<DGVertex> dest = (*a)->dest();
+	std::shared_ptr<DGVertex> dest = (*a)->dest();
 	os << "  " << v->graph_label() << " -> "
 	   << dest->graph_label() << endl;
       }
@@ -414,10 +414,10 @@ DirectedGraph::print_to_dot(bool symbols, std::ostream& os) const
   foreach(patd);
 
   // Print traversal order using dotted lines
-  SafePtr<DGVertex> current_vertex = first_to_compute_;
+  std::shared_ptr<DGVertex> current_vertex = first_to_compute_;
   if (current_vertex != 0) {
     do {
-      SafePtr<DGVertex> next = current_vertex->postcalc();
+      std::shared_ptr<DGVertex> next = current_vertex->postcalc();
       if (current_vertex && next) {
         os << "  " << current_vertex->graph_label() << " -> "
            << next->graph_label() << " [ style = dotted constraint = false ]";
@@ -448,10 +448,10 @@ DirectedGraph::reset()
 
 /// Apply a strategy to all vertices not yet computed (i.e. which do not have exit arcs)
 void
-DirectedGraph::apply(const SafePtr<Strategy>& strategy,
-                     const SafePtr<Tactic>& tactic)
+DirectedGraph::apply(const std::shared_ptr<Strategy>& strategy,
+                     const std::shared_ptr<Tactic>& tactic)
 {
-  const SafePtr<DirectedGraph> this_ptr = shared_from_this();
+  const std::shared_ptr<DirectedGraph> this_ptr = shared_from_this();
   typedef vertices::const_iterator citer;
   typedef vertices::iterator iter;
   for(iter v=stack_.begin(); v!=stack_.end(); ++v) {
@@ -459,22 +459,22 @@ DirectedGraph::apply(const SafePtr<Strategy>& strategy,
     if ((vptr)->num_exit_arcs() != 0 || (vptr)->precomputed() || !(vptr)->need_to_compute())
       continue;
 
-    SafePtr<RecurrenceRelation> rr0 = strategy->optimal_rr(this_ptr,(vptr),tactic);
+    std::shared_ptr<RecurrenceRelation> rr0 = strategy->optimal_rr(this_ptr,(vptr),tactic);
     if (rr0 == 0)
       continue;
 
     // add children to the graph
-    SafePtr<DGVertex> target = rr0->rr_target();
+    std::shared_ptr<DGVertex> target = rr0->rr_target();
     const int num_children = rr0->num_children();
     for(int c=0; c<num_children; c++) {
-      SafePtr<DGVertex> child = rr0->rr_child(c);
+      std::shared_ptr<DGVertex> child = rr0->rr_child(c);
       bool new_vertex = true;
-      SafePtr<DGVertex> dgchild = append_vertex(child);
+      std::shared_ptr<DGVertex> dgchild = append_vertex(child);
       if (dgchild != child) {
 	child = dgchild;
 	new_vertex = false;
       }
-      SafePtr<DGArc> arc(new DGArcRel<RecurrenceRelation>(target,child,rr0));
+      std::shared_ptr<DGArc> arc(new DGArcRel<RecurrenceRelation>(target,child,rr0));
       target->add_exit_arc(arc);
       if (new_vertex)
         apply_to(child,strategy,tactic);
@@ -484,28 +484,28 @@ DirectedGraph::apply(const SafePtr<Strategy>& strategy,
 
 /// Add vertex to graph and apply a strategy to vertex recursively
 void
-DirectedGraph::apply_to(const SafePtr<DGVertex>& vertex,
-                        const SafePtr<Strategy>& strategy,
-                        const SafePtr<Tactic>& tactic)
+DirectedGraph::apply_to(const std::shared_ptr<DGVertex>& vertex,
+                        const std::shared_ptr<Strategy>& strategy,
+                        const std::shared_ptr<Tactic>& tactic)
 {
   bool not_yet_computed = !vertex->precomputed() && vertex->need_to_compute() && (vertex->num_exit_arcs() == 0);
   if (!not_yet_computed)
     return;
-  SafePtr<RecurrenceRelation> rr0 = strategy->optimal_rr(shared_from_this(),vertex,tactic);
+  std::shared_ptr<RecurrenceRelation> rr0 = strategy->optimal_rr(shared_from_this(),vertex,tactic);
   if (rr0 == 0)
     return;
 
-  SafePtr<DGVertex> target = rr0->rr_target();
+  std::shared_ptr<DGVertex> target = rr0->rr_target();
   const int num_children = rr0->num_children();
   for(int c=0; c<num_children; c++) {
-    SafePtr<DGVertex> child = rr0->rr_child(c);
+    std::shared_ptr<DGVertex> child = rr0->rr_child(c);
     bool new_vertex = true;
-    SafePtr<DGVertex> dgchild = append_vertex(child);
+    std::shared_ptr<DGVertex> dgchild = append_vertex(child);
     if (dgchild != child) {
       child = dgchild;
       new_vertex = false;
     }
-    SafePtr<DGArc> arc(new DGArcRel<RecurrenceRelation>(target,child,rr0));
+    std::shared_ptr<DGArc> arc(new DGArcRel<RecurrenceRelation>(target,child,rr0));
     try {
       target->add_exit_arc(arc);
     }
@@ -520,7 +520,7 @@ DirectedGraph::apply_to(const SafePtr<DGVertex>& vertex,
 
 // Optimize out simple recurrence relations
 void
-DirectedGraph::optimize_rr_out(const SafePtr<CodeContext>& context)
+DirectedGraph::optimize_rr_out(const std::shared_ptr<CodeContext>& context)
 {
   replace_rr_with_expr();
   remove_trivial_arithmetics();
@@ -538,11 +538,11 @@ DirectedGraph::replace_rr_with_expr()
   for(iter v=stack_.begin(); v!=stack_.end(); ++v) {
     const ver_ptr& vptr = vertex_ptr(*v);
     if ((vptr)->num_exit_arcs()) {
-      SafePtr<DGArc> arc0 = *((vptr)->first_exit_arc());
-      SafePtr<DGArcRR> arc0_cast = dynamic_pointer_cast<DGArcRR,DGArc>(arc0);
+      std::shared_ptr<DGArc> arc0 = *((vptr)->first_exit_arc());
+      std::shared_ptr<DGArcRR> arc0_cast = dynamic_pointer_cast<DGArcRR,DGArc>(arc0);
       if (arc0_cast == 0)
         continue;
-      SafePtr<RecurrenceRelation> rr = arc0_cast->rr();
+      std::shared_ptr<RecurrenceRelation> rr = arc0_cast->rr();
 
       // Optimize if the recurrence relation is simple and the target and
       // children are of the same type
@@ -561,10 +561,10 @@ DirectedGraph::replace_rr_with_expr()
         (vptr)->del_exit_arcs();
 
         // and instead insert the numerical expression
-        SafePtr<RecurrenceRelation::ExprType> rr_expr = rr->rr_expr();
-        SafePtr<DGVertex> expr_vertex = static_pointer_cast<RecurrenceRelation::ExprType,DGVertex>(rr_expr);
+        std::shared_ptr<RecurrenceRelation::ExprType> rr_expr = rr->rr_expr();
+        std::shared_ptr<DGVertex> expr_vertex = static_pointer_cast<RecurrenceRelation::ExprType,DGVertex>(rr_expr);
         expr_vertex = insert_expr_at((vptr),rr_expr);
-        SafePtr<DGArc> arc(new DGArcDirect((vptr),expr_vertex));
+        std::shared_ptr<DGArc> arc(new DGArcDirect((vptr),expr_vertex));
         (vptr)->add_exit_arc(arc);
 
       }
@@ -579,28 +579,28 @@ DirectedGraph::replace_rr_with_expr()
 // can simply compare operand pointers and the operator type (very cheap operations compared
 // to the fully recursive explicit comparison).
 //
-SafePtr<DGVertex>
-DirectedGraph::insert_expr_at(const SafePtr<DGVertex>& where, const SafePtr<RecurrenceRelation::ExprType>& expr)
+std::shared_ptr<DGVertex>
+DirectedGraph::insert_expr_at(const std::shared_ptr<DGVertex>& where, const std::shared_ptr<RecurrenceRelation::ExprType>& expr)
 {
 #if DEBUG
   cout << "insert_expr_at: " << expr->description() << endl;
 #endif
 
   typedef RecurrenceRelation::ExprType ExprType;
-  SafePtr<DGVertex> expr_vertex = static_pointer_cast<DGVertex,ExprType>(expr);
+  std::shared_ptr<DGVertex> expr_vertex = static_pointer_cast<DGVertex,ExprType>(expr);
 
   // If the expression is already on then return it
   if (expr->dg() == this)
     return expr_vertex;
 
-  SafePtr<DGVertex> left_oper = expr->left();
-  SafePtr<DGVertex> right_oper = expr->right();
+  std::shared_ptr<DGVertex> left_oper = expr->left();
+  std::shared_ptr<DGVertex> right_oper = expr->right();
   bool new_left =  (left_oper->dg()  != this);       //
   bool new_right = (right_oper->dg() != this);       //
   bool need_to_clone = false;  // clone expression if (parts of) the expression was found on the graph
 
   // See if left operand is also an operator
-  const SafePtr<ExprType> left_cast = dynamic_pointer_cast<ExprType,DGVertex>(left_oper);
+  const std::shared_ptr<ExprType> left_cast = dynamic_pointer_cast<ExprType,DGVertex>(left_oper);
   // if yes -- add it to the graph recursively
   if (left_cast) {
     left_oper = insert_expr_at(expr_vertex,left_cast);
@@ -622,7 +622,7 @@ DirectedGraph::insert_expr_at(const SafePtr<DGVertex>& where, const SafePtr<Recu
 #endif
 
   // See if right operand is also an operator
-  SafePtr<ExprType> right_cast = dynamic_pointer_cast<ExprType,DGVertex>(right_oper);
+  std::shared_ptr<ExprType> right_cast = dynamic_pointer_cast<ExprType,DGVertex>(right_oper);
   // if yes -- add it to the graph recursively
   if (right_cast) {
     right_oper = insert_expr_at(expr_vertex,right_cast);
@@ -644,7 +644,7 @@ DirectedGraph::insert_expr_at(const SafePtr<DGVertex>& where, const SafePtr<Recu
 #endif
 
   if (need_to_clone) {
-    SafePtr<ExprType> expr_new(new ExprType(expr,left_oper,right_oper));
+    std::shared_ptr<ExprType> expr_new(new ExprType(expr,left_oper,right_oper));
     expr_vertex = static_pointer_cast<DGVertex,ExprType>(expr_new);
 #if DEBUG
     int nchildren = expr->num_exit_arcs();
@@ -656,7 +656,7 @@ DirectedGraph::insert_expr_at(const SafePtr<DGVertex>& where, const SafePtr<Recu
 #endif
   }
 
-  SafePtr<DGVertex> dgexpr_vertex = expr_vertex;
+  std::shared_ptr<DGVertex> dgexpr_vertex = expr_vertex;
   if (new_left || new_right)
     add_new_vertex(expr_vertex);
   else {
@@ -680,9 +680,9 @@ DirectedGraph::insert_expr_at(const SafePtr<DGVertex>& where, const SafePtr<Recu
     }
     expr_vertex = dgexpr_vertex;
   }
-  SafePtr<DGArc> left_arc(new DGArcDirect(expr_vertex,left_oper));
+  std::shared_ptr<DGArc> left_arc(new DGArcDirect(expr_vertex,left_oper));
   expr_vertex->add_exit_arc(left_arc);
-  SafePtr<DGArc> right_arc(new DGArcDirect(expr_vertex,right_oper));
+  std::shared_ptr<DGArc> right_arc(new DGArcDirect(expr_vertex,right_oper));
   expr_vertex->add_exit_arc(right_arc);
 #if DEBUG
   cout << "insert_expr_at: added arc between " << where->description() << " and " << expr_vertex->description() << endl;
@@ -696,20 +696,20 @@ void
 DirectedGraph::remove_trivial_arithmetics()
 {
   using libint2::prefactor::Scalar;
-  const SafePtr< CTimeEntity<double> > const_one_point_zero = Scalar(1.0);
-  const SafePtr< CTimeEntity<double> > const_zero_point_zero = Scalar(0.0);
+  const std::shared_ptr< CTimeEntity<double> > const_one_point_zero = Scalar(1.0);
+  const std::shared_ptr< CTimeEntity<double> > const_zero_point_zero = Scalar(0.0);
   typedef vertices::const_iterator citer;
   typedef vertices::iterator iter;
   for(iter v=stack_.begin(); v!=stack_.end(); ++v) {
     const ver_ptr& vptr = vertex_ptr(*v);
-    SafePtr< AlgebraicOperator<DGVertex> > oper_cast = dynamic_pointer_cast<AlgebraicOperator<DGVertex>,DGVertex>((vptr));
+    std::shared_ptr< AlgebraicOperator<DGVertex> > oper_cast = dynamic_pointer_cast<AlgebraicOperator<DGVertex>,DGVertex>((vptr));
     if (oper_cast) {
 
       //std::cout << "cast " << vptr->description() << " to " << oper_cast->description() << std::endl;
       typedef DGVertex::ArcSetType::const_iterator aciter;
       aciter a = oper_cast->first_exit_arc();
-      SafePtr<DGVertex> left = (*a)->dest();  ++a;
-      SafePtr<DGVertex> right = oper_cast->num_exit_arcs()>1 ? (*a)->dest() : left; // num_exit_arcs==1 is a corner case, e.g. 1*1
+      std::shared_ptr<DGVertex> left = (*a)->dest();  ++a;
+      std::shared_ptr<DGVertex> right = oper_cast->num_exit_arcs()>1 ? (*a)->dest() : left; // num_exit_arcs==1 is a corner case, e.g. 1*1
 
       using libint2::algebra::OperatorTypes;
       
@@ -747,7 +747,7 @@ DirectedGraph::remove_trivial_arithmetics()
 }
 
 namespace {
-  std::string stack_symbol(const SafePtr<CodeContext>& ctext, const DGVertex::Address& address, const DGVertex::Size& size,
+  std::string stack_symbol(const std::shared_ptr<CodeContext>& ctext, const DGVertex::Address& address, const DGVertex::Size& size,
                            const std::string& low_rank, const std::string& veclen,
                            const std::string& prefix)
   {
@@ -760,7 +760,7 @@ namespace {
   }
 
   /// Returns a "vector" form of stack symbol, e.g. converts libint->stack[x] to libint->stack[x+vi]
-  inline std::string to_vector_symbol(const SafePtr<DGVertex>& v)
+  inline std::string to_vector_symbol(const std::shared_ptr<DGVertex>& v)
   {
     std::string::size_type current_pos = 0;
     std::string symb = v->symbol();
@@ -806,7 +806,7 @@ namespace {
 // no code is generated for it.
 //
 void
-DirectedGraph::handle_trivial_nodes(const SafePtr<CodeContext>& context)
+DirectedGraph::handle_trivial_nodes(const std::shared_ptr<CodeContext>& context)
 {
   typedef vertices::const_iterator citer;
   typedef vertices::iterator iter;
@@ -815,21 +815,21 @@ DirectedGraph::handle_trivial_nodes(const SafePtr<CodeContext>& context)
     // or if has more than 1 child
     if ((vptr)->num_exit_arcs() != 1)
       continue;
-    SafePtr<DGArc> arc = *((vptr)->first_exit_arc());
+    std::shared_ptr<DGArc> arc = *((vptr)->first_exit_arc());
 
     // Is the exit arc DGArcRel<IntegralSet_to_Integrals> and (vptr)->size() == 1?
     if ((vptr)->size() == 1) {
-      SafePtr<DGArcRR> arc_cast = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
+      std::shared_ptr<DGArcRR> arc_cast = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
       if (arc_cast) {
-        SafePtr<RecurrenceRelation> rr = arc_cast->rr();
-        SafePtr<IntegralSet_to_Integrals_base> rr_cast = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
+        std::shared_ptr<RecurrenceRelation> rr = arc_cast->rr();
+        std::shared_ptr<IntegralSet_to_Integrals_base> rr_cast = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
         if (rr_cast) {
-          SafePtr<DGVertex> child = arc->dest();
+          std::shared_ptr<DGVertex> child = arc->dest();
 
           //if (child->symbol_set() == false)
           {
             const std::string stack_name("stack");
-            const SafePtr<ImplicitDimensions>& dims = ImplicitDimensions::default_dims();
+            const std::shared_ptr<ImplicitDimensions>& dims = ImplicitDimensions::default_dims();
             std::string low_rank = dims->low_label();
             std::string veclen = dims->vecdim_label();
 
@@ -851,7 +851,7 @@ DirectedGraph::handle_trivial_nodes(const SafePtr<CodeContext>& context)
 
     // Is the exit arc DGArcDirect?
     {
-      SafePtr<DGArcDirect> arc_cast = dynamic_pointer_cast<DGArcDirect,DGArc>(arc);
+      std::shared_ptr<DGArcDirect> arc_cast = dynamic_pointer_cast<DGArcDirect,DGArc>(arc);
       if (arc_cast) {
         // remove the vertex, if possible
         // if this is a target -- cannot remove
@@ -869,7 +869,7 @@ DirectedGraph::handle_trivial_nodes(const SafePtr<CodeContext>& context)
 // this function will reattach all arcs extering v1 to v2 and remove v1 from the graph alltogether.
 // return true if successful, false otherwise
 bool
-DirectedGraph::remove_vertex_at(const SafePtr<DGVertex>& v1, const SafePtr<DGVertex>& v2)
+DirectedGraph::remove_vertex_at(const std::shared_ptr<DGVertex>& v1, const std::shared_ptr<DGVertex>& v2)
 {
 #if DEBUG
     cout << "remove_vertex_at: replacing " << v1->description() << " with " << v2->description() << endl;
@@ -884,8 +884,8 @@ DirectedGraph::remove_vertex_at(const SafePtr<DGVertex>& v1, const SafePtr<DGVer
   // Verify that all entry arcs are DGArcDirect
   for(aciter a=abegin; a!=aend; ++a) {
     // See if this is a direct arc -- otherwise cannot do this
-    SafePtr<DGArc> arc = (*a);
-    SafePtr<DGArcDirect> arc_cast = dynamic_pointer_cast<DGArcDirect,DGArc>(arc);
+    std::shared_ptr<DGArc> arc = (*a);
+    std::shared_ptr<DGArcDirect> arc_cast = dynamic_pointer_cast<DGArcDirect,DGArc>(arc);
     if (arc_cast == 0)
       return false;
     v1_entry.push_back(*a);
@@ -899,8 +899,8 @@ DirectedGraph::remove_vertex_at(const SafePtr<DGVertex>& v1, const SafePtr<DGVer
     return false;*/
 
   // See if this is a direct arc -- otherwise cannot do this
-  SafePtr<DGArc> arc = *(v1->first_exit_arc());
-  SafePtr<DGArcDirect> arc_cast = dynamic_pointer_cast<DGArcDirect,DGArc>(arc);
+  std::shared_ptr<DGArc> arc = *(v1->first_exit_arc());
+  std::shared_ptr<DGArcDirect> arc_cast = dynamic_pointer_cast<DGArcDirect,DGArc>(arc);
   if (arc_cast == 0)
     return false;
 
@@ -916,12 +916,12 @@ DirectedGraph::remove_vertex_at(const SafePtr<DGVertex>& v1, const SafePtr<DGVer
   // Reconnect each of v1's entry arcs to v2
   unsigned int c = 0;
   for(aiter i=v1_entry.begin(); i != v1_entry.end(); ++i, ++c) {
-    SafePtr<DGVertex> parent = (*i)->orig();
+    std::shared_ptr<DGVertex> parent = (*i)->orig();
 #if DEBUG || DEBUG_RESTRUCTURE
     cout << "remove_vertex_at: replacing arc " << c << " connecting " << parent->description() << " to " << (*i)->dest()->description() << endl;
     cout << "remove_vertex_at: replacing arc " << c << " connecting " << parent << " to " << (*i)->dest() << endl;
 #endif
-    SafePtr<DGArcDirect> new_arc(new DGArcDirect(parent,v2));
+    std::shared_ptr<DGArcDirect> new_arc(new DGArcDirect(parent,v2));
 #if DEBUG || DEBUG_RESTRUCTURE
     cout << "remove_vertex_at:      with arc " << " connecting " << parent->description() << " to " << v2->description() << endl;
     cout << "remove_vertex_at:      with arc " << " connecting " << parent << " to " << v2 << endl;
@@ -983,8 +983,8 @@ DirectedGraph::remove_disconnected_vertices()
 // it's also used elsewhere
 namespace libint2 {
   std::string
-  declare_function(const SafePtr<CodeContext>& context, const SafePtr<ImplicitDimensions>& dims,
-                   const SafePtr<CodeSymbols>& args, const std::string& tlabel, const std::string& function_descr,
+  declare_function(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<ImplicitDimensions>& dims,
+                   const std::shared_ptr<CodeSymbols>& args, const std::string& tlabel, const std::string& function_descr,
                    std::ostream& decl) {
 
     std::string function_name = label_to_funcname(function_descr);
@@ -1026,15 +1026,15 @@ namespace libint2 {
 
 namespace {
   template <class Container>
-  SafePtr<MemBlockSet>
+  std::shared_ptr<MemBlockSet>
   to_memoryblks(Container& vertices) {
-    SafePtr<MemBlockSet> result(new MemBlockSet);
+    std::shared_ptr<MemBlockSet> result(new MemBlockSet);
     typedef typename Container::const_iterator citer;
     typedef typename Container::iterator iter;
     citer end(vertices.end());
     for(iter v=vertices.begin(); v!=end; ++v) {
       const DirectedGraph::ver_ptr& vptr = vertex_ptr(*v);
-      result->push_back(MemBlock((vptr)->address(),(vptr)->size(),false,SafePtr<MemBlock>(),SafePtr<MemBlock>()));
+      result->push_back(MemBlock((vptr)->address(),(vptr)->size(),false,std::shared_ptr<MemBlock>(),std::shared_ptr<MemBlock>()));
     }
     return result;
   }
@@ -1044,8 +1044,8 @@ namespace {
 //
 //
 void
-DirectedGraph::generate_code(const SafePtr<CodeContext>& context, const SafePtr<MemoryManager>& memman,
-                             const SafePtr<ImplicitDimensions>& dims, const SafePtr<CodeSymbols>& args,
+DirectedGraph::generate_code(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<MemoryManager>& memman,
+                             const std::shared_ptr<ImplicitDimensions>& dims, const std::shared_ptr<CodeSymbols>& args,
                              const std::string& label,
                              std::ostream& decl, std::ostream& def)
 {
@@ -1127,7 +1127,7 @@ DirectedGraph::generate_code(const SafePtr<CodeContext>& context, const SafePtr<
     PrerequisitesExtractor pe;
     this->foreach(pe);
     // merge their blocks (likely into one -- allocate_mem should have taken care of that)
-    SafePtr<MemBlockSet> targetblks = to_memoryblks(pe.vertices);
+    std::shared_ptr<MemBlockSet> targetblks = to_memoryblks(pe.vertices);
     merge(*targetblks);
 
     // zero each one out
@@ -1136,15 +1136,15 @@ DirectedGraph::generate_code(const SafePtr<CodeContext>& context, const SafePtr<
         b != targetblks->end();
         ++b) {
       const size s = b->size();
-      SafePtr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
+      std::shared_ptr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
 
-      SafePtr<Entity> bvecdim;
+      std::shared_ptr<Entity> bvecdim;
       if (!dims->vecdim_is_static()) {
-        SafePtr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
+        std::shared_ptr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
         bvecdim = vecdim * bdim;
       }
       else {
-        SafePtr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
+        std::shared_ptr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
         bvecdim = vecdim * bdim;
       }
       def << "_libint2_static_api_bzero_short_(" << registry()->stack_name() << "+"
@@ -1152,10 +1152,10 @@ DirectedGraph::generate_code(const SafePtr<CodeContext>& context, const SafePtr<
     }
 
     // and call the prereq evaluator
-    SafePtr<Entity> zero(new CTimeEntity<int>(0));
-    SafePtr<Entity> contr_depth(new RTimeEntity<EntityTypes::Int>("contrdepth"));
+    std::shared_ptr<Entity> zero(new CTimeEntity<int>(0));
+    std::shared_ptr<Entity> contr_depth(new RTimeEntity<EntityTypes::Int>("contrdepth"));
     std::string contr_index("c");
-    SafePtr<ForLoop> contr_loop(new ForLoop(context,contr_index,contr_depth,zero));
+    std::shared_ptr<ForLoop> contr_loop(new ForLoop(context,contr_index,contr_depth,zero));
 
     def << context->decldef("const int","contrdepth","inteval->contrdepth");
     def << contr_loop->open();
@@ -1199,8 +1199,8 @@ DirectedGraph::generate_code(const SafePtr<CodeContext>& context, const SafePtr<
   def << context->code_postfix();
 }
 
-void DirectedGraph::allocate_mem(const SafePtr<MemoryManager>& memman,
-const SafePtr<ImplicitDimensions>& dims,
+void DirectedGraph::allocate_mem(const std::shared_ptr<MemoryManager>& memman,
+const std::shared_ptr<ImplicitDimensions>& dims,
 unsigned int min_size_to_alloc)
 {
   // NOTE does this belong here?
@@ -1214,12 +1214,12 @@ unsigned int min_size_to_alloc)
     typedef DirectedGraph::address address;
 
     const DirectedGraph::targets& targets_;
-    const SafePtr<MemoryManager>& memman_;
+    const std::shared_ptr<MemoryManager>& memman_;
     bool all_targets_;
     sz size_;
 
     TargetAllocator(const DirectedGraph::targets& t,
-    const SafePtr<MemoryManager>& mm,
+    const std::shared_ptr<MemoryManager>& mm,
     bool all_targets) :
     targets_(t),
     memman_(mm),
@@ -1295,7 +1295,7 @@ unsigned int min_size_to_alloc)
     //const bool need_copies_of_targets = nonunrolled_targets(targets_);
     const bool need_copies_of_targets = std::find_if(targets_.begin(),
                                                      targets_.end(),
-                                                     [](SafePtr<DGVertex> i){
+                                                     [](std::shared_ptr<DGVertex> i){
       return !DecontractedIntegralSet()(i) && !UnrolledIntegralSet()(i);
     }) != targets_.end();
 
@@ -1336,9 +1336,9 @@ unsigned int min_size_to_alloc)
   // Once a child receives same number of tags as the number of parents,
   // it can be deallocated
   //
-  SafePtr<DGVertex> vertex = first_to_compute_;
+  std::shared_ptr<DGVertex> vertex = first_to_compute_;
   do {
-    SafePtr<DGArcRR> arcrr;
+    std::shared_ptr<DGArcRR> arcrr;
     // memory only needs to be managed for some quantities:
     // this conditional decides whether this vertex is on the stack
     bool need_to_allocate = true;
@@ -1393,7 +1393,7 @@ unsigned int min_size_to_alloc)
       const aciter aend = vertex->plast_exit_arc();
       // Verify that all entry arcs are DGArcDirect
       for(aciter a=abegin; a!=aend; ++a) {
-        SafePtr<DGVertex> child = (*a)->dest();
+        std::shared_ptr<DGVertex> child = (*a)->dest();
         const unsigned int ntags = child->tag();
         // Do NOT deallocate if it's a target!
         if (ntags == child->num_entry_arcs() && child->address_set() && !child->is_a_target()) {
@@ -1406,7 +1406,7 @@ unsigned int min_size_to_alloc)
 }
 
 void
-DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr<ImplicitDimensions>& dims)
+DirectedGraph::assign_symbols(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<ImplicitDimensions>& dims)
 {
   std::ostringstream os;
   const std::string null_str("");
@@ -1438,12 +1438,12 @@ DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr
       continue;
     if (vptr->refers_to_another())
       continue;
-    SafePtr<DGArc> arc = *((vptr)->first_exit_arc());
-    SafePtr<DGArcRR> arc_rr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
+    std::shared_ptr<DGArc> arc = *((vptr)->first_exit_arc());
+    std::shared_ptr<DGArcRR> arc_rr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
     if (arc_rr == 0)
       continue;
-    SafePtr<RecurrenceRelation> rr = arc_rr->rr();
-    SafePtr<IntegralSet_to_Integrals_base> iset_to_i = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
+    std::shared_ptr<RecurrenceRelation> rr = arc_rr->rr();
+    std::shared_ptr<IntegralSet_to_Integrals_base> iset_to_i = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
     if (iset_to_i == 0) {
       continue;
     }
@@ -1454,7 +1454,7 @@ DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr
       unsigned int c = 0;
       // Verify that all entry arcs are DGArcDirect
       for(aciter a=abegin; a!=aend; ++a, ++c) {
-        SafePtr<DGVertex> child = (*a)->dest();
+        std::shared_ptr<DGVertex> child = (*a)->dest();
         // If the child is precomputed and it's parent symbol is not set -- its symbol will be set as usual
         if (!child->precomputed() || (vptr)->symbol_set()) {
 
@@ -1493,7 +1493,7 @@ DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr
     // test if the vertex is a static quantity, like a constant
     {
       typedef CTimeEntity<double> cdouble;
-      SafePtr<cdouble> ptr_cast = dynamic_pointer_cast<cdouble,DGVertex>((vptr));
+      std::shared_ptr<cdouble> ptr_cast = dynamic_pointer_cast<cdouble,DGVertex>((vptr));
       if (ptr_cast) {
         (vptr)->set_symbol(ptr_cast->label());
         continue;
@@ -1512,7 +1512,7 @@ DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr
     // test if the vertex is other runtime quantity
     {
       typedef RTimeEntity<double> cdouble;
-      SafePtr<cdouble> ptr_cast = dynamic_pointer_cast<cdouble,DGVertex>((vptr));
+      std::shared_ptr<cdouble> ptr_cast = dynamic_pointer_cast<cdouble,DGVertex>((vptr));
       if (ptr_cast) {
         (vptr)->set_symbol(ptr_cast->label());
         continue;
@@ -1524,7 +1524,7 @@ DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr
     if (vptr->size() == 1) {
       { // basic integral
         typedef IntegralSet<IncableBFSet> intset;
-        SafePtr<intset> ptr_cast = dynamic_pointer_cast<intset,DGVertex>((vptr));
+        std::shared_ptr<intset> ptr_cast = dynamic_pointer_cast<intset,DGVertex>((vptr));
         if (ptr_cast) {
           (vptr)->set_symbol(context->unique_name<EntityTypes::FP>());
           continue;
@@ -1552,7 +1552,7 @@ DirectedGraph::assign_symbols(const SafePtr<CodeContext>& context, const SafePtr
 }
 
 void
-DirectedGraph::assign_oper_symbol(const SafePtr<CodeContext>& context, SafePtr<DGVertex>& vertex)
+DirectedGraph::assign_oper_symbol(const std::shared_ptr<CodeContext>& context, std::shared_ptr<DGVertex>& vertex)
 {
   // do nothing if the vertex has a symbol or is not an operator
   if (vertex->symbol_set())
@@ -1560,7 +1560,7 @@ DirectedGraph::assign_oper_symbol(const SafePtr<CodeContext>& context, SafePtr<D
 
   {
     typedef AlgebraicOperator<DGVertex> oper;
-    SafePtr<oper> ptr_cast = dynamic_pointer_cast<oper,DGVertex>(vertex);
+    std::shared_ptr<oper> ptr_cast = dynamic_pointer_cast<oper,DGVertex>(vertex);
     if (ptr_cast) {
       // is it in a subtree?
       const bool on_a_subtree = (vertex->subtree() != 0);
@@ -1572,8 +1572,8 @@ DirectedGraph::assign_oper_symbol(const SafePtr<CodeContext>& context, SafePtr<D
       else {
 	typedef DGVertex::ArcSetType::const_iterator aciter;
 	aciter arc = ptr_cast->first_exit_arc();
-        SafePtr<DGVertex> left = (*arc)->dest(); ++arc;
-        SafePtr<DGVertex> right = (*arc)->dest();
+        std::shared_ptr<DGVertex> left = (*arc)->dest(); ++arc;
+        std::shared_ptr<DGVertex> right = (*arc)->dest();
         assign_oper_symbol(context,left);
         assign_oper_symbol(context,right);
 
@@ -1627,13 +1627,13 @@ namespace {
 }
 
 void
-DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
-                        const SafePtr<ImplicitDimensions>& dims,
-                        const SafePtr<CodeSymbols>& args)
+DirectedGraph::print_def(const std::shared_ptr<CodeContext>& context, std::ostream& os,
+                        const std::shared_ptr<ImplicitDimensions>& dims,
+                        const std::shared_ptr<CodeSymbols>& args)
 {
   std::ostringstream oss;
   const std::string null_str("");
-  SafePtr<Entity > ctimeconst_zero(new CTimeEntity<int>(0));
+  std::shared_ptr<Entity > ctimeconst_zero(new CTimeEntity<int>(0));
 
   //
   // set stack ... if this function was given any arguments, the first is always stack
@@ -1648,15 +1648,15 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
   //
   // To optimize accumulation and setting blocks to zero, need to merge maximally the targets (the accumulation area is one block)
   //
-  SafePtr<MemBlockSet> targetblks;
+  std::shared_ptr<MemBlockSet> targetblks;
   if (registry()->accumulate_targets()) {
     if (accumulate_targets_directly) {
       targetblks = to_memoryblks(targets_);
       merge(*targetblks);
     }
     else {
-      targetblks = SafePtr<MemBlockSet>(new MemBlockSet);
-      targetblks->push_back(MemBlock(0,iregistry()->size_of_target_accum(),false,SafePtr<MemBlock>(),SafePtr<MemBlock>()));
+      targetblks = std::shared_ptr<MemBlockSet>(new MemBlockSet);
+      targetblks->push_back(MemBlock(0,iregistry()->size_of_target_accum(),false,std::shared_ptr<MemBlock>(),std::shared_ptr<MemBlock>()));
     }
   }
 
@@ -1676,15 +1676,15 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
     for(iter b=targetblks->begin(); b!=end; ++b) {
 
       size s = b->size();
-      SafePtr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
+      std::shared_ptr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
 
-      SafePtr<Entity> bvecdim;
+      std::shared_ptr<Entity> bvecdim;
       if (!vecdim_is_static) {
-	SafePtr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
+	std::shared_ptr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
 	bvecdim = vecdim * bdim;
       }
       else {
-	SafePtr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
+	std::shared_ptr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
 	bvecdim = vecdim * bdim;
       }
 
@@ -1710,11 +1710,11 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
 #endif
 
   std::string varname("hsi");
-  SafePtr<ForLoop> hsi_loop(new ForLoop(context,varname,dims->high(),SafePtr<Entity>(new CTimeEntity<int>(0))));
+  std::shared_ptr<ForLoop> hsi_loop(new ForLoop(context,varname,dims->high(),std::shared_ptr<Entity>(new CTimeEntity<int>(0))));
   os << hsi_loop->open();
 
   varname = "lsi";
-  SafePtr<ForLoop> lsi_loop(new ForLoop(context,varname,dims->low(),SafePtr<Entity>(new CTimeEntity<int>(0))));
+  std::shared_ptr<ForLoop> lsi_loop(new ForLoop(context,varname,dims->low(),std::shared_ptr<Entity>(new CTimeEntity<int>(0))));
   os << lsi_loop->open();
 
   // the vector loop is created outside of the body of the function if
@@ -1728,18 +1728,18 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
   const bool create_outer_vector_loop = !vectorize_by_line && !cannot_enclose_in_outer_vloop();
   varname = "vi";
   // outer vector loop
-  SafePtr<ForLoop> outer_vloop;
+  std::shared_ptr<ForLoop> outer_vloop;
   // vector loop for each code line
-  SafePtr<ForLoop> line_vloop;
+  std::shared_ptr<ForLoop> line_vloop;
   if (create_outer_vector_loop) {
-    SafePtr<ForLoop> tmp_vi_loop(new ForLoop(context,varname,dims->vecdim(),SafePtr<Entity>(new CTimeEntity<int>(0))));
+    std::shared_ptr<ForLoop> tmp_vi_loop(new ForLoop(context,varname,dims->vecdim(),std::shared_ptr<Entity>(new CTimeEntity<int>(0))));
     outer_vloop = tmp_vi_loop;
   }
   else {
-    SafePtr<Entity> unit_dim(new CTimeEntity<int>(1));
-    SafePtr<ForLoop> tmp_vi_loop(new ForLoop(context,varname,unit_dim,SafePtr<Entity>(new CTimeEntity<int>(0))));
+    std::shared_ptr<Entity> unit_dim(new CTimeEntity<int>(1));
+    std::shared_ptr<ForLoop> tmp_vi_loop(new ForLoop(context,varname,unit_dim,std::shared_ptr<Entity>(new CTimeEntity<int>(0))));
     outer_vloop = tmp_vi_loop;
-    SafePtr<ForLoop> tmp2_vi_loop(new ForLoop(context,varname,dims->vecdim(),SafePtr<Entity>(new CTimeEntity<int>(0))));
+    std::shared_ptr<ForLoop> tmp2_vi_loop(new ForLoop(context,varname,dims->vecdim(),std::shared_ptr<Entity>(new CTimeEntity<int>(0))));
     line_vloop = tmp2_vi_loop;
     // note that both loops use same variable name -- standard C++ scoping rules allow it -- but the outer
     // loop will become a declaration of a constant variable
@@ -1750,7 +1750,7 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
   // generate code for vertices
   //
   unsigned int nflops_total = 0;
-  SafePtr<DGVertex> current_vertex = first_to_compute_;
+  std::shared_ptr<DGVertex> current_vertex = first_to_compute_;
   do {
 
     // skip if already scheduled
@@ -1778,7 +1778,7 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
       // print algebraic expression
       {
         typedef AlgebraicOperator<DGVertex> oper_type;
-        SafePtr<oper_type> oper_ptr =
+        std::shared_ptr<oper_type> oper_ptr =
             dynamic_pointer_cast<oper_type, DGVertex> (current_vertex);
         if (oper_ptr) {
 
@@ -1816,8 +1816,8 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
           //     o it has one parent and the parent is a +/- operator
           //     o parent's other argument has been computed already
           bool generate_fma = false;
-          SafePtr<oper_type> parent_oper_ptr;
-          SafePtr<DGVertex> fma_other_arg;
+          std::shared_ptr<oper_type> parent_oper_ptr;
+          std::shared_ptr<DGVertex> fma_other_arg;
 #if LIBINT_GENERATE_FMA
           {
             if (oper_ptr->type() == algebra::OperatorTypes::Times &&
@@ -1970,7 +1970,7 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
       // print simple assignment statement
       if (current_vertex->num_exit_arcs() == 1) {
         typedef DGArcDirect arc_type;
-        SafePtr<arc_type>
+        std::shared_ptr<arc_type>
             arc_ptr =
                 dynamic_pointer_cast<arc_type, DGArc> (
                                                        *(current_vertex->first_exit_arc()));
@@ -1979,7 +1979,7 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
 #if CHECK_SAFETY
           current_vertex->declared(true);
 
-          SafePtr<DGVertex> rhs_arg = arc_ptr->dest();
+          std::shared_ptr<DGVertex> rhs_arg = arc_ptr->dest();
           if (!rhs_arg->declared() && rhs_arg->need_to_compute()) {
             std::cout << "Current vertex:" << endl; current_vertex->print(std::cout);
             std::cout << "rhs_arg      :" << endl; rhs_arg->print(std::cout);
@@ -2029,12 +2029,12 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
         // printing a recurrence relation
         //std::cout << "DirectedGraph::print_def(): a RR making " << current_vertex->description() << std::endl;
         typedef DGArcRR arc_type;
-        SafePtr<arc_type>
+        std::shared_ptr<arc_type>
             arc_ptr =
                 dynamic_pointer_cast<arc_type, DGArc> (
                                                        *(current_vertex->first_exit_arc()));
         if (arc_ptr) {
-          SafePtr<RecurrenceRelation> rr = arc_ptr->rr();
+          std::shared_ptr<RecurrenceRelation> rr = arc_ptr->rr();
           os << rr->spfunction_call(context, dims);
           nflops_total += rr->nflops();
 
@@ -2071,7 +2071,7 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
 #if 0
     unsigned int vecdim_rank;
     if (vecdim_is_static) {
-      SafePtr<CTimeEntity<int> > cptr = dynamic_pointer_cast<CTimeEntity<int> ,Entity >(dims->vecdim());
+      std::shared_ptr<CTimeEntity<int> > cptr = dynamic_pointer_cast<CTimeEntity<int> ,Entity >(dims->vecdim());
       vecdim_rank = cptr->value();
     }
     const std::string times_vecdim("*" + dims->vecdim_label());
@@ -2083,15 +2083,15 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
       const ver_ptr& tptr = vertex_ptr(*t);
 
       size s = (tptr)->size();
-      SafePtr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
+      std::shared_ptr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
 
-      SafePtr<Entity> bvecdim;
+      std::shared_ptr<Entity> bvecdim;
       if (!vecdim_is_static) {
-	SafePtr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
+	std::shared_ptr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
 	bvecdim = vecdim * bdim;
       }
       else {
-	SafePtr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
+	std::shared_ptr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
 	bvecdim = vecdim * bdim;
       }
 
@@ -2103,14 +2103,14 @@ DirectedGraph::print_def(const SafePtr<CodeContext>& context, std::ostream& os,
       // NOTE: single loop suffices because if outer/inner strides are not 1 this block of code should not be executed
 
 #if 0
-      SafePtr<Entity> loopmax;
+      std::shared_ptr<Entity> loopmax;
       if (vecdim_is_static) {
 	const int loopmax_value = s*vecdim_rank;
-	loopmax = SafePtr<Entity>(new CTimeEntity<int>(loopmax_value));
+	loopmax = std::shared_ptr<Entity>(new CTimeEntity<int>(loopmax_value));
       }
       else {
 	ostringstream oss;  oss << s << times_vecdim;
-	loopmax = SafePtr<Entity>(new RTimeEntity<EntityTypes::Int>(oss.str()));
+	loopmax = std::shared_ptr<Entity>(new RTimeEntity<EntityTypes::Int>(oss.str()));
       }
 
       std::string loopvar("i");
@@ -2187,10 +2187,10 @@ DirectedGraph::update_func_names()
     // for every vertex with children
     if ((vptr)->num_exit_arcs() > 0) {
       // if it must be computed using a RR
-      SafePtr<DGArc> arc = *((vptr)->first_exit_arc());
-      SafePtr<DGArcRR> arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
+      std::shared_ptr<DGArc> arc = *((vptr)->first_exit_arc());
+      std::shared_ptr<DGArcRR> arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
       if (arcrr != 0) {
-        SafePtr<RecurrenceRelation> rr = arcrr->rr();
+        std::shared_ptr<RecurrenceRelation> rr = arcrr->rr();
         // and the RR is complex (i.e. likely to result in a function call)
         if (!rr->is_simple()) {
           // add it to the RRStack
@@ -2204,19 +2204,19 @@ DirectedGraph::update_func_names()
 bool
 DirectedGraph::cannot_enclose_in_outer_vloop() const
 {
-  SafePtr<DGVertex> current_vertex = first_to_compute_;
+  std::shared_ptr<DGVertex> current_vertex = first_to_compute_;
   do {
     const int nchildren = current_vertex->num_exit_arcs();
     if (nchildren > 0) {
       arc_ptr aptr = *(current_vertex->first_exit_arc());
-      SafePtr<DGArcRR> aptr_cast = dynamic_pointer_cast<DGArcRR,arc>(aptr);
+      std::shared_ptr<DGArcRR> aptr_cast = dynamic_pointer_cast<DGArcRR,arc>(aptr);
       // if this is a RR
       if (aptr_cast != 0) {
         // and a non-trivial one
-        SafePtr<RecurrenceRelation> rr = aptr_cast->rr();
+        std::shared_ptr<RecurrenceRelation> rr = aptr_cast->rr();
         if (!rr->is_simple()) {
           // if this is an Uncontract_Integral call, return false
-          SafePtr<Uncontract_Integral_base> rr_ucb_ptr = dynamic_pointer_cast<Uncontract_Integral_base,RecurrenceRelation>(rr);
+          std::shared_ptr<Uncontract_Integral_base> rr_ucb_ptr = dynamic_pointer_cast<Uncontract_Integral_base,RecurrenceRelation>(rr);
           if (rr_ucb_ptr)
             return false;
           else
@@ -2249,7 +2249,7 @@ DirectedGraph::find_subtrees()
 }
 
 void
-DirectedGraph::find_subtrees_from(const SafePtr<DGVertex>& v)
+DirectedGraph::find_subtrees_from(const std::shared_ptr<DGVertex>& v)
 {
   // is not on a subtree already
   if (!v->subtree()) {
@@ -2262,8 +2262,8 @@ DirectedGraph::find_subtrees_from(const SafePtr<DGVertex>& v)
     //
     {
       if (v->num_exit_arcs() > 0) {
-        SafePtr<DGArc> arc = *(v->first_exit_arc());
-        SafePtr<DGArcRR> arc_rr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
+        std::shared_ptr<DGArc> arc = *(v->first_exit_arc());
+        std::shared_ptr<DGArcRR> arc_rr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
         if (arc_rr)
           useless_subtree = true;
       }
@@ -2271,7 +2271,7 @@ DirectedGraph::find_subtrees_from(const SafePtr<DGVertex>& v)
 
     // create subtree
     if (!useless_subtree) {
-      SafePtr<DRTree> stree = DRTree::CreateRootedAt(v);
+      std::shared_ptr<DRTree> stree = DRTree::CreateRootedAt(v);
 
       // Remove all trivial subtrees
       if (stree) {
@@ -2354,12 +2354,12 @@ namespace libint2 {
   }
 
   void
-  extract_symbols(const SafePtr<DirectedGraph>& dg)
+  extract_symbols(const std::shared_ptr<DirectedGraph>& dg)
   {
     LibraryTaskManager& taskmgr = LibraryTaskManager::Instance();
     // symbol extractor
     {
-      SafePtr<ExtractExternSymbols> extractor(new ExtractExternSymbols);
+      std::shared_ptr<ExtractExternSymbols> extractor(new ExtractExternSymbols);
       dg->foreach(*extractor);
       const ExtractExternSymbols::Symbols& symbols = extractor->symbols();
       // pass on to the symbol maintainer of the current task
@@ -2375,7 +2375,7 @@ namespace libint2 {
     }
     // RR extractor
     {
-      SafePtr<ExtractRR> extractor(new ExtractRR);
+      std::shared_ptr<ExtractRR> extractor(new ExtractRR);
       dg->foreach(*extractor);
       const ExtractRR::RRList& rrlist = extractor->rrlist();
       // pass on to the symbol maintainer of the current task
@@ -2385,7 +2385,7 @@ namespace libint2 {
 
   //////////////////////
   void
-  PrerequisitesExtractor::operator()(const SafePtr<DGVertex>& v) {
+  PrerequisitesExtractor::operator()(const std::shared_ptr<DGVertex>& v) {
 #if DEBUG
     std::cout << "PrerequisitesExtractor: considering " << v->description() << std::endl;
     v->print(std::cout);
@@ -2400,14 +2400,14 @@ namespace libint2 {
 #if EXTRACTINTEGRALSETS
       // if this is an integral that was a member of a shell set, add the parent set to the prerequisite level
       bool member_of_shellset = false;
-      SafePtr<DGVertex> parent_shellset;
+      std::shared_ptr<DGVertex> parent_shellset;
       typedef DGVertex::ArcSetType::const_iterator citer;
       for(citer i=v->entry_arcs().begin(); i != v->entry_arcs().end() && !member_of_shellset; ++i) {
-        const SafePtr<DGArc>& arc = *i;
-        SafePtr<DGArcRR> arc_cast = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
+        const std::shared_ptr<DGArc>& arc = *i;
+        std::shared_ptr<DGArcRR> arc_cast = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
         if (arc_cast) {
-          SafePtr<RecurrenceRelation> rr = arc_cast->rr();
-          SafePtr<IntegralSet_to_Integrals_base> rr_cast = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
+          std::shared_ptr<RecurrenceRelation> rr = arc_cast->rr();
+          std::shared_ptr<IntegralSet_to_Integrals_base> rr_cast = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
           if (rr_cast) {
             member_of_shellset = true;
             parent_shellset = rr->rr_target();
@@ -2449,7 +2449,7 @@ namespace libint2 {
   }
   //////////////////////
   void
-  VertexPrinter::operator()(const SafePtr<DGVertex>& v) {
+  VertexPrinter::operator()(const std::shared_ptr<DGVertex>& v) {
     os << "VertexPrinter: " << v->description() << std::endl;
 #if DEBUG
     v->print(os);
diff --git a/src/bin/libint/dg.h b/src/bin/libint/dg.h
index 568ba9fda..69f5750b8 100644
--- a/src/bin/libint/dg.h
+++ b/src/bin/libint/dg.h
@@ -64,8 +64,8 @@ namespace libint2 {
   public:
     typedef DGVertex vertex;
     typedef DGArc arc;
-    typedef SafePtr<DGVertex> ver_ptr;
-    typedef SafePtr<DGArc> arc_ptr;
+    typedef std::shared_ptr<DGVertex> ver_ptr;
+    typedef std::shared_ptr<DGArc> arc_ptr;
     typedef DGVertexKey key_type;
     typedef std::multimap<key_type,ver_ptr> VPtrAssociativeContainer;
     typedef std::list<ver_ptr> VPtrSequenceContainer;
@@ -119,16 +119,16 @@ namespace libint2 {
 #endif
     /// Find vertex v or it's equivalent on the graph. Return null pointer if not found.
     /// Computational cost for a graph based on a nonassociative container may be high
-    const SafePtr<DGVertex>& find(const SafePtr<DGVertex>& v) const { return vertex_is_on(v); }
+    const std::shared_ptr<DGVertex>& find(const std::shared_ptr<DGVertex>& v) const { return vertex_is_on(v); }
 
     /** appends v to the graph. If v's copy is already on the graph, return the pointer
 	to the copy. Else return pointer to *v.
      */
-    SafePtr<DGVertex> append_vertex(const SafePtr<DGVertex>& v);
+    std::shared_ptr<DGVertex> append_vertex(const std::shared_ptr<DGVertex>& v);
 
     /** non-template append_target appends the vertex to the graph as a target
      */
-    void append_target(const SafePtr<DGVertex>&);
+    void append_target(const std::shared_ptr<DGVertex>&);
 
     /** append_target appends I to the graph as a target vertex and applies
         RR to it. append_target can be called multiple times on the same
@@ -142,7 +142,7 @@ namespace libint2 {
         standard Bjarne Stroustrup's approach.
 
      */
-    template <class I, class RR> void append_target(const SafePtr<I>& target) {
+    template <class I, class RR> void append_target(const std::shared_ptr<I>& target) {
       target->make_a_target();
       recurse<I,RR>(target);
     }
@@ -165,17 +165,17 @@ namespace libint2 {
         ver_ptr& vptr = vertex_ptr(*v);
         if ((vptr)->num_exit_arcs() != 0)
           continue;
-        SafePtr<TT> tptr = dynamic_pointer_cast<TT,DGVertex>(v);
+        std::shared_ptr<TT> tptr = dynamic_pointer_cast<TT,DGVertex>(v);
         if (tptr == 0)
           continue;
 
-        SafePtr<RR> rr0(new RR(tptr));
+        std::shared_ptr<RR> rr0(new RR(tptr));
         const int num_children = rr0->num_children();
 
         for(int c=0; c<num_children; c++) {
 
-          SafePtr<DGVertex> child = rr0->child(c);
-          SafePtr<DGArc> arc(new DGArcRel<RR>(tptr,child,rr0));
+          std::shared_ptr<DGVertex> child = rr0->child(c);
+          std::shared_ptr<DGArc> arc(new DGArcRel<RR>(tptr,child,rr0));
           tptr->add_exit_arc(arc);
 
           recurse<RR>(child);
@@ -190,14 +190,14 @@ namespace libint2 {
       There usually are many ways to reduce a vertex.
       Tactic specifies which of these possibilities to choose.
      */
-    void apply(const SafePtr<Strategy>& strategy,
-        const SafePtr<Tactic>& tactic);
+    void apply(const std::shared_ptr<Strategy>& strategy,
+        const std::shared_ptr<Tactic>& tactic);
 
     typedef void (DGVertex::* DGVertexMethodPtr)();
     /** apply_at<method>(vertex) calls method() on vertex and all of its descendants
      */
     template <DGVertexMethodPtr method>
-    void apply_at(const SafePtr<DGVertex>& vertex) const {
+    void apply_at(const std::shared_ptr<DGVertex>& vertex) const {
       ((vertex.get())->*method)();
       typedef DGVertex::ArcSetType::const_iterator aciter;
       const aciter abegin = vertex->first_exit_arc();
@@ -253,7 +253,7 @@ namespace libint2 {
         optimized away. optimize_rr_out() will replace all simple recurrence relations
         with code representing them.
      */
-    void optimize_rr_out(const SafePtr<CodeContext>& context);
+    void optimize_rr_out(const std::shared_ptr<CodeContext>& context);
 
     /** after all apply's have been called, traverse()
         construct a heuristic order of traversal for the graph.
@@ -282,8 +282,8 @@ namespace libint2 {
        decl specifies the stream to receive declaration code,
        code specifies the stream to receive the definition code
      */
-    void generate_code(const SafePtr<CodeContext>& context, const SafePtr<MemoryManager>& memman,
-        const SafePtr<ImplicitDimensions>& dims, const SafePtr<CodeSymbols>& args,
+    void generate_code(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<MemoryManager>& memman,
+        const std::shared_ptr<ImplicitDimensions>& dims, const std::shared_ptr<CodeSymbols>& args,
         const std::string& label,
         std::ostream& decl, std::ostream& code);
 
@@ -297,7 +297,7 @@ namespace libint2 {
      */
     template <class RR>
     unsigned int
-    num_children_on(const SafePtr<RR>& rr) const {
+    num_children_on(const std::shared_ptr<RR>& rr) const {
       unsigned int nchildren = rr->num_children();
       unsigned int nchildren_on_stack = 0;
       for(unsigned int c=0; c<nchildren; c++) {
@@ -311,8 +311,8 @@ namespace libint2 {
     }
 
     /// Returns the registry
-    SafePtr<GraphRegistry>& registry() { return registry_; }
-    const SafePtr<GraphRegistry>& registry() const { return registry_; }
+    std::shared_ptr<GraphRegistry>& registry() { return registry_; }
+    const std::shared_ptr<GraphRegistry>& registry() const { return registry_; }
 
     /// return the graph label
     const std::string& label() const { return label_; }
@@ -345,43 +345,43 @@ namespace libint2 {
 #endif
 
     // maintains data about the graph which does not belong IN the graph
-    SafePtr<GraphRegistry> registry_;
+    std::shared_ptr<GraphRegistry> registry_;
     // maintains private data about the graph which does not belong IN the graph
-    SafePtr<InternalGraphRegistry> iregistry_;
+    std::shared_ptr<InternalGraphRegistry> iregistry_;
 
     /// Access the internal registry
-    SafePtr<InternalGraphRegistry>& iregistry() { return iregistry_; }
-    const SafePtr<InternalGraphRegistry>& iregistry() const { return iregistry_; }
+    std::shared_ptr<InternalGraphRegistry>& iregistry() { return iregistry_; }
+    const std::shared_ptr<InternalGraphRegistry>& iregistry() const { return iregistry_; }
 
     /** adds a vertex to the graph. If the vertex already found on the graph
         then the vertex is not added and the function returns false */
-    SafePtr<DGVertex> add_vertex(const SafePtr<DGVertex>&);
+    std::shared_ptr<DGVertex> add_vertex(const std::shared_ptr<DGVertex>&);
     /** same as add_vertex(), only assumes that there's no equivalent vertex on the graph (see vertex_is_on) */
-    void add_new_vertex(const SafePtr<DGVertex>&);
+    void add_new_vertex(const std::shared_ptr<DGVertex>&);
     /// returns true if vertex if already on graph
-    const SafePtr<DGVertex>& vertex_is_on(const SafePtr<DGVertex>& vertex) const;
+    const std::shared_ptr<DGVertex>& vertex_is_on(const std::shared_ptr<DGVertex>& vertex) const;
     /// removes vertex from the graph. may throw CannotPerformOperation
     void del_vertex(vertices::iterator&);
     /** This function is used to implement (recursive) append_target().
         vertex is appended to the graph and then RR is applied to is.
      */
-    template <class I, class RR> void recurse(const SafePtr<I>& vertex)  {
-      SafePtr<DGVertex> dgvertex = add_vertex(vertex);
+    template <class I, class RR> void recurse(const std::shared_ptr<I>& vertex)  {
+      std::shared_ptr<DGVertex> dgvertex = add_vertex(vertex);
       if (dgvertex != vertex)
         return;
 
-      SafePtr<RR> rr0(new RR(vertex));
+      std::shared_ptr<RR> rr0(new RR(vertex));
       const int num_children = rr0->num_children();
 
       for(int c=0; c<num_children; c++) {
 
-        SafePtr<DGVertex> child = rr0->child(c);
-        SafePtr<DGArc> arc(new DGArcRel<RR>(vertex,child,rr0));
+        std::shared_ptr<DGVertex> child = rr0->child(c);
+        std::shared_ptr<DGArc> arc(new DGArcRel<RR>(vertex,child,rr0));
         vertex->add_exit_arc(arc);
 
-        SafePtr<I> child_cast = dynamic_pointer_cast<I,DGVertex>(child);
+        std::shared_ptr<I> child_cast = dynamic_pointer_cast<I,DGVertex>(child);
         if (child_cast == 0)
-          throw std::runtime_error("DirectedGraph::recurse(const SafePtr<I>& vertex) -- dynamic cast failed, most probably this is a logic error!");
+          throw std::runtime_error("DirectedGraph::recurse(const std::shared_ptr<I>& vertex) -- dynamic cast failed, most probably this is a logic error!");
         recurse<I,RR>(child_cast);
 
       }
@@ -390,23 +390,23 @@ namespace libint2 {
     /** This function is used to implement (recursive) apply_to_all().
         RR is applied to vertex and all its children.
      */
-    template <class RR> void recurse(const SafePtr<DGVertex>& vertex)  {
-      SafePtr<DGVertex> dgvertex = add_vertex(vertex);
+    template <class RR> void recurse(const std::shared_ptr<DGVertex>& vertex)  {
+      std::shared_ptr<DGVertex> dgvertex = add_vertex(vertex);
       if (dgvertex != vertex)
         return;
 
       typedef typename RR::TargetType TT;
-      SafePtr<TT> tptr = dynamic_pointer_cast<TT,DGVertex>(vertex);
+      std::shared_ptr<TT> tptr = dynamic_pointer_cast<TT,DGVertex>(vertex);
       if (tptr == 0)
         return;
 
-      SafePtr<RR> rr0(new RR(tptr));
+      std::shared_ptr<RR> rr0(new RR(tptr));
       const int num_children = rr0->num_children();
 
       for(int c=0; c<num_children; c++) {
 
-        SafePtr<DGVertex> child = rr0->child(c);
-        SafePtr<DGArc> arc(new DGArcRel<RR>(vertex,child,rr0));
+        std::shared_ptr<DGVertex> child = rr0->child(c);
+        std::shared_ptr<DGArc> arc(new DGArcRel<RR>(vertex,child,rr0));
         vertex->add_exit_arc(arc);
 
         recurse<RR>(child);
@@ -416,11 +416,11 @@ namespace libint2 {
     /** This function is used to implement (recursive) apply().
       strategy and tactic are applied to vertex and all its children.
      */
-    void apply_to(const SafePtr<DGVertex>& vertex,
-        const SafePtr<Strategy>& strategy,
-        const SafePtr<Tactic>& tactic);
+    void apply_to(const std::shared_ptr<DGVertex>& vertex,
+        const std::shared_ptr<Strategy>& strategy,
+        const std::shared_ptr<Tactic>& tactic);
     /// This function insert expr of type AlgebraicOperator<DGVertex> into the graph
-    SafePtr<DGVertex> insert_expr_at(const SafePtr<DGVertex>& where, const SafePtr< AlgebraicOperator<DGVertex> >& expr);
+    std::shared_ptr<DGVertex> insert_expr_at(const std::shared_ptr<DGVertex>& where, const std::shared_ptr< AlgebraicOperator<DGVertex> >& expr);
     /// This function replaces RecurrenceRelations with concrete arithemtical expressions
     void replace_rr_with_expr();
     /// This function gets rid of trivial math such as multiplication/division by 1.0, etc.
@@ -428,7 +428,7 @@ namespace libint2 {
     /** This function gets rid of nodes which are connected
     to their equivalents (such as (ss|ss) shell quartet can only be connected to (ss|ss) integral)
      */
-    void handle_trivial_nodes(const SafePtr<CodeContext>& context);
+    void handle_trivial_nodes(const std::shared_ptr<CodeContext>& context);
     /// This functions removes vertices not connected to other vertices
     void remove_disconnected_vertices();
     /** Finds (binary) subtrees. The subtrees correspond to a single-line code (no intermediates
@@ -437,34 +437,34 @@ namespace libint2 {
     void find_subtrees();
     /** Finds (binary) subtrees starting (recursively) at v.
      */
-    void find_subtrees_from(const SafePtr<DGVertex>& v);
+    void find_subtrees_from(const std::shared_ptr<DGVertex>& v);
     /** If v1 and v2 are connected by DGArcDirect and all entry arcs to v1 are of the DGArcDirect type as well,
         this function will reattach all arcs extering v1 to v2 and remove v1 from the graph altogether.
 	May throw CannotPerformOperation.
      */
-    bool remove_vertex_at(const SafePtr<DGVertex>& v1, const SafePtr<DGVertex>& v2);
+    bool remove_vertex_at(const std::shared_ptr<DGVertex>& v1, const std::shared_ptr<DGVertex>& v2);
 
     // Which vertex is the first to compute
-    SafePtr<DGVertex> first_to_compute_;
+    std::shared_ptr<DGVertex> first_to_compute_;
     // prepare_to_traverse must be called before actual traversal
     void prepare_to_traverse();
     // traverse_from(arc) build recurively the traversal order
-    void traverse_from(const SafePtr<DGArc>&);
+    void traverse_from(const std::shared_ptr<DGArc>&);
     // schedule_computation(vertex) puts vertex first in the computation order
-    void schedule_computation(const SafePtr<DGVertex>&);
+    void schedule_computation(const std::shared_ptr<DGVertex>&);
 
     // Compute addresses on stack assuming that quantities larger than min_size_to_alloc to be allocated on stack
-    void allocate_mem(const SafePtr<MemoryManager>& memman,
-        const SafePtr<ImplicitDimensions>& dims,
+    void allocate_mem(const std::shared_ptr<MemoryManager>& memman,
+        const std::shared_ptr<ImplicitDimensions>& dims,
         unsigned int min_size_to_alloc = 1);
     // Assign symbols to the vertices
-    void assign_symbols(const SafePtr<CodeContext>& context, const SafePtr<ImplicitDimensions>& dims);
+    void assign_symbols(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<ImplicitDimensions>& dims);
     // If v is an AlgebraicOperator, assign (recursively) symbol to the operator. All other must have been already assigned
-    void assign_oper_symbol(const SafePtr<CodeContext>& context, SafePtr<DGVertex>& v);
+    void assign_oper_symbol(const std::shared_ptr<CodeContext>& context, std::shared_ptr<DGVertex>& v);
     // Print the code using symbols generated with assign_symbols()
-    void print_def(const SafePtr<CodeContext>& context, std::ostream& os,
-        const SafePtr<ImplicitDimensions>& dims,
-        const SafePtr<CodeSymbols>& args);
+    void print_def(const std::shared_ptr<CodeContext>& context, std::ostream& os,
+        const std::shared_ptr<ImplicitDimensions>& dims,
+        const std::shared_ptr<CodeSymbols>& args);
 
     /** Returns true if cannot enclose the code in a vector loop
         Possible reason: the traversal path contains a RecurrenceRelation that generates a function call
@@ -505,17 +505,17 @@ namespace libint2 {
   bool nonunrolled_targets(const DirectedGraph::targets& targets);
 
   /// extracts external symbols and RRs from the graph
-  void extract_symbols(const SafePtr<DirectedGraph>& dg);
+  void extract_symbols(const std::shared_ptr<DirectedGraph>& dg);
 
   // use these functors with DirectedGraph::foreach
   struct PrerequisitesExtractor {
-    std::deque< SafePtr<DGVertex> > vertices;
-    void operator()(const SafePtr<DGVertex>& v);
+    std::deque< std::shared_ptr<DGVertex> > vertices;
+    void operator()(const std::shared_ptr<DGVertex>& v);
   };
   struct VertexPrinter {
     VertexPrinter(std::ostream& ostr) : os(ostr) {}
     std::ostream& os;
-    void operator()(const SafePtr<DGVertex>& v);
+    void operator()(const std::shared_ptr<DGVertex>& v);
   };
 
 };
diff --git a/src/bin/libint/dgarc.cc b/src/bin/libint/dgarc.cc
index bba090599..aa89b5f65 100644
--- a/src/bin/libint/dgarc.cc
+++ b/src/bin/libint/dgarc.cc
@@ -23,9 +23,9 @@
 using namespace std;
 using namespace libint2;
 
-DGArc::DGArc(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest) :
+DGArc::DGArc(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest) :
   orig_(orig), dest_(dest) {}
 
-DGArcRR::DGArcRR(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest) :
+DGArcRR::DGArcRR(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest) :
   DGArc(orig,dest) {}
 
diff --git a/src/bin/libint/dgarc.h b/src/bin/libint/dgarc.h
index 61273a695..ced377f97 100644
--- a/src/bin/libint/dgarc.h
+++ b/src/bin/libint/dgarc.h
@@ -33,15 +33,15 @@ namespace libint2 {
       Each arc connects vertex orig_ to vertex dest_. */
   class DGArc {
 
-    SafePtr<DGVertex> orig_;  // Where this Arc leavs
-    SafePtr<DGVertex> dest_;  // Where this Arc leads to
+    std::shared_ptr<DGVertex> orig_;  // Where this Arc leavs
+    std::shared_ptr<DGVertex> dest_;  // Where this Arc leads to
 
   public:
-    DGArc(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest);
+    DGArc(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest);
     virtual ~DGArc() {}
 
-    SafePtr<DGVertex> orig() const { return orig_; }
-    SafePtr<DGVertex> dest() const { return dest_; }
+    std::shared_ptr<DGVertex> orig() const { return orig_; }
+    std::shared_ptr<DGVertex> dest() const { return dest_; }
 
     /// Print out the arc
     virtual void print(std::ostream& os) const =0;
@@ -53,7 +53,7 @@ namespace libint2 {
   class DGArcDirect : public DGArc {
 
   public:
-    DGArcDirect(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest) : DGArc(orig,dest) {}
+    DGArcDirect(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest) : DGArc(orig,dest) {}
     virtual ~DGArcDirect() {}
 
     /// Overload of DGArc::print()
@@ -71,10 +71,10 @@ namespace libint2 {
     virtual ~DGArcRR() {}
 
     /// rr() returns pointer to the RecurrenceRelation describing the arc
-    virtual SafePtr<RecurrenceRelation> rr() const =0;
+    virtual std::shared_ptr<RecurrenceRelation> rr() const =0;
 
   protected:
-    DGArcRR(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest);
+    DGArcRR(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest);
 
   };
 
@@ -84,15 +84,15 @@ namespace libint2 {
   // It obviously must implement some functions
   template <class ArcRel> class DGArcRel : public DGArcRR {
 
-    SafePtr<ArcRel> rel_;     // Relationship described by the arc
+    std::shared_ptr<ArcRel> rel_;     // Relationship described by the arc
 
   public:
-    DGArcRel(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest,
-	     const SafePtr<ArcRel>& rel);
+    DGArcRel(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest,
+	     const std::shared_ptr<ArcRel>& rel);
     virtual ~DGArcRel();
 
     /// Implementation of DGArcRR::rr()
-    SafePtr<RecurrenceRelation> rr() const override { return dynamic_pointer_cast<RecurrenceRelation,ArcRel>(rel_); }
+    std::shared_ptr<RecurrenceRelation> rr() const override { return dynamic_pointer_cast<RecurrenceRelation,ArcRel>(rel_); }
     /// Overload of DGArc::print()
     void print(std::ostream& os) const override
       {
@@ -102,8 +102,8 @@ namespace libint2 {
   };
 
   template <class ArcRel>
-    DGArcRel<ArcRel>::DGArcRel(const SafePtr<DGVertex>& orig, const SafePtr<DGVertex>& dest,
-			       const SafePtr<ArcRel>& rel) :
+    DGArcRel<ArcRel>::DGArcRel(const std::shared_ptr<DGVertex>& orig, const std::shared_ptr<DGVertex>& dest,
+			       const std::shared_ptr<ArcRel>& rel) :
     DGArcRR(orig,dest), rel_(rel)
     {
     };
diff --git a/src/bin/libint/dgvertex.cc b/src/bin/libint/dgvertex.cc
index a5d5e9d4e..218b6e53a 100644
--- a/src/bin/libint/dgvertex.cc
+++ b/src/bin/libint/dgvertex.cc
@@ -35,7 +35,7 @@ DGVertex::DGVertex(ClassID tid) :
   declared_(false),
 #endif
   parents_(), children_(), target_(false), can_add_arcs_(true), num_tagged_arcs_(0),
-  postcalc_(), scheduled_(false), subtree_(SafePtr<DRTree>())
+  postcalc_(), scheduled_(false), subtree_(std::shared_ptr<DRTree>())
 {
 }
 
@@ -62,10 +62,10 @@ DGVertex::make_a_target()
 }
 
 void
-DGVertex::add_exit_arc(const SafePtr<DGArc>& arc)
+DGVertex::add_exit_arc(const std::shared_ptr<DGArc>& arc)
 {
   if (can_add_arcs_) {
-    SafePtr<DGVertex> child = arc->dest();
+    std::shared_ptr<DGVertex> child = arc->dest();
 
     // check if such arc exists already
     if (!children_.empty()) {
@@ -89,7 +89,7 @@ DGVertex::add_exit_arc(const SafePtr<DGArc>& arc)
 }
 
 void
-DGVertex::del_exit_arc(const SafePtr<DGArc>& arc)
+DGVertex::del_exit_arc(const std::shared_ptr<DGArc>& arc)
 {
   if (can_add_arcs_) {
     if (!children_.empty()) {
@@ -137,7 +137,7 @@ DGVertex::del_exit_arcs()
 }
 
 void
-DGVertex::replace_exit_arc(const SafePtr<DGArc>& A, const SafePtr<DGArc>& B)
+DGVertex::replace_exit_arc(const std::shared_ptr<DGArc>& A, const std::shared_ptr<DGArc>& B)
 {
   if (can_add_arcs_) {
     typedef ArcSetType::iterator aiter;
@@ -171,7 +171,7 @@ DGVertex::replace_exit_arc(const SafePtr<DGArc>& A, const SafePtr<DGArc>& B)
 }
 
 void
-DGVertex::add_entry_arc(const SafePtr<DGArc>& arc)
+DGVertex::add_entry_arc(const std::shared_ptr<DGArc>& arc)
 {
   if (arc->orig() == arc->dest()) {
     std::cout << "DGVertex::add_entry_arc() : arc->orig = " << arc->orig()->description() << std::endl;
@@ -190,7 +190,7 @@ DGVertex::add_entry_arc(const SafePtr<DGArc>& arc)
 }
 
 void
-DGVertex::del_entry_arc(const SafePtr<DGArc>& arc)
+DGVertex::del_entry_arc(const std::shared_ptr<DGArc>& arc)
 {
   if (!parents_.empty()) {
     ArcSetType::iterator location = find(parents_.begin(), parents_.end(), arc);
@@ -251,16 +251,16 @@ DGVertex::num_exit_arcs() const
 
 namespace {
   struct __ArcDestEqual {
-    __ArcDestEqual(const SafePtr<DGVertex>& v) : v_(v) {}
-    bool operator()(const SafePtr<DGArc>& a) { return a->dest() == v_; }
-    const SafePtr<DGVertex>& v_;
+    __ArcDestEqual(const std::shared_ptr<DGVertex>& v) : v_(v) {}
+    bool operator()(const std::shared_ptr<DGArc>& a) { return a->dest() == v_; }
+    const std::shared_ptr<DGVertex>& v_;
   };
 }
 
-const SafePtr<DGArc>&
-DGVertex::exit_arc(const SafePtr<DGVertex>& v) const
+const std::shared_ptr<DGArc>&
+DGVertex::exit_arc(const std::shared_ptr<DGVertex>& v) const
 {
-  static SafePtr<DGArc> nullptr_;
+  static std::shared_ptr<DGArc> nullptr_;
   __ArcDestEqual predicate(v);
   const ArcSetType::const_iterator end = children_.end();
   const ArcSetType::const_iterator pos = find_if(children_.begin(),children_.end(),predicate);
@@ -274,7 +274,7 @@ void
 DGVertex::reset()
 {
   dg_ = 0;
-  subtree_ = SafePtr<DRTree>();
+  subtree_ = std::shared_ptr<DRTree>();
 
   typedef ArcSetType::const_iterator citer;
   typedef ArcSetType::iterator iter;
@@ -313,7 +313,7 @@ DGVertex::set_graph_label(const std::string& label)
 }
 
 void
-DGVertex::refer_this_to(const SafePtr<DGVertex>& V)
+DGVertex::refer_this_to(const std::shared_ptr<DGVertex>& V)
 {
   if (referred_vertex_ != 0) {
     if (referred_vertex_->equiv(V))
@@ -491,27 +491,27 @@ DGVertex::unregister() const
 ////
 
 bool
-UnrolledIntegralSet::operator()(const SafePtr<DGVertex>& V)
+UnrolledIntegralSet::operator()(const std::shared_ptr<DGVertex>& V)
 {
   const unsigned int outdegree = V->num_exit_arcs();
   if (outdegree == 0) return false;
 
-  const SafePtr<DGArc> arc0 = *(V->first_exit_arc());
+  const std::shared_ptr<DGArc> arc0 = *(V->first_exit_arc());
   // Is this DGArcRR?
-  const SafePtr<DGArcRR> arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(arc0);
+  const std::shared_ptr<DGArcRR> arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(arc0);
   if (arcrr == 0) return false;
   // Is this DGArcRR<IntegralSet_to_Integral>? If invariant_type() is false, then yes
   return !arcrr->rr()->invariant_type();
 }
 
 bool
-NotUnrolledIntegralSet::operator()(const SafePtr<DGVertex>& V)
+NotUnrolledIntegralSet::operator()(const std::shared_ptr<DGVertex>& V)
 {
   return !UnrolledIntegralSet()(V);
 }
 
 bool
-IntegralInTargetIntegralSet::operator()(const SafePtr<DGVertex>& V)
+IntegralInTargetIntegralSet::operator()(const std::shared_ptr<DGVertex>& V)
 {
   const unsigned int indegree = V->num_entry_arcs();
   if (indegree != 1) return false;
diff --git a/src/bin/libint/dgvertex.h b/src/bin/libint/dgvertex.h
index f20ba286a..24eb2c443 100644
--- a/src/bin/libint/dgvertex.h
+++ b/src/bin/libint/dgvertex.h
@@ -61,7 +61,7 @@ namespace libint2 {
     typedef KeyTypes::InstanceID KeyType;
     typedef Hashable<KeyType,ComputeKey>::KeyReturnType KeyReturnType;
     /// ArcSetType is a container used to maintain entry and exit arcs
-    typedef std::list< SafePtr<DGArc> > ArcSetType;
+    typedef std::list< std::shared_ptr<DGArc> > ArcSetType;
 
     /** typeid stores the ClassID of the concrete type. It is used to check quickly whether
         2 DGVertices are of the same type. Dynamic casts are too expensive. */
@@ -72,7 +72,7 @@ namespace libint2 {
     /// Sets typeid to tid
     DGVertex(ClassID tid);
     /// Sets typeid to tid
-    DGVertex(ClassID tid, const std::vector<SafePtr<DGArc> >& parents, const std::vector<SafePtr<DGArc> >& children);
+    DGVertex(ClassID tid, const std::vector<std::shared_ptr<DGArc> >& parents, const std::vector<std::shared_ptr<DGArc> >& children);
     /// This is a copy constructor
     DGVertex(const DGVertex& v);
     virtual ~DGVertex();
@@ -87,14 +87,14 @@ namespace libint2 {
         definition (such as AlgebraicOperator). Such DGVertices need to update their
         private members.
       */
-    virtual void add_exit_arc(const SafePtr<DGArc>&);
+    virtual void add_exit_arc(const std::shared_ptr<DGArc>&);
     /** del_exit_arcs() removes all exit arcs from this and corresponding children vertices.
         See documentation for del_exit_arc().
       */
     virtual void del_exit_arcs();
     /** replace_exit_arc() replaces A with B. See documentation for del_exit_arc().
      */
-    void replace_exit_arc(const SafePtr<DGArc>& A, const SafePtr<DGArc>& B);
+    void replace_exit_arc(const std::shared_ptr<DGArc>& A, const std::shared_ptr<DGArc>& B);
     /** this function detaches the vertex from other vertices. It cannot safely remove
         entry arcs, so the user must previously delete or replace them (see documentation for del_exit_arc()).
 	can throw CannotPerformOperation.
@@ -116,14 +116,14 @@ namespace libint2 {
     /// returns children::end()
     ArcSetType::const_iterator plast_exit_arc() const { return children_.end(); }
     /// return arc connecting this to v, otherwise null pointer
-    const SafePtr<DGArc>& exit_arc(const SafePtr<DGVertex>& v) const;
+    const std::shared_ptr<DGArc>& exit_arc(const std::shared_ptr<DGVertex>& v) const;
 
     /// computes key
     virtual KeyReturnType key() const =0;
     /** equiv(const DGVertex* aVertex) returns true if this vertex is
         equivalent to *aVertex.
     */
-    virtual bool equiv(const SafePtr<DGVertex>&) const =0;
+    virtual bool equiv(const std::shared_ptr<DGVertex>&) const =0;
 
     /** precomputed() returns whether this DGVertex is precomputed. See
     this_precomputed() for description.
@@ -158,7 +158,7 @@ namespace libint2 {
     void set_graph_label(const std::string& graph_label);
 
     /// Returns the subtree to which this vertex belongs
-    const SafePtr<DRTree>& subtree() const { return subtree_; }
+    const std::shared_ptr<DRTree>& subtree() const { return subtree_; }
 
     //
     // NOTE : the following functions probably belong to a separate class, such as Entity!
@@ -168,7 +168,7 @@ namespace libint2 {
     refer_this_to(V) makes this vertex act like a reference to V so that
     calls to symbol() and address() report code symbol and stack address of V
     */
-    void refer_this_to(const SafePtr<DGVertex>&  V);
+    void refer_this_to(const std::shared_ptr<DGVertex>&  V);
     /// refers to another vertex?
     bool refers_to_another() const { return referred_vertex_ != 0; }
     /// returns the code symbol. can throw SymbolNotSet
@@ -208,9 +208,9 @@ namespace libint2 {
     /// scheduled() returns true if the vertex has been scheduled
     bool scheduled() const { return scheduled_; }
     /// Returns pointer to vertex to be computed after this vertex, 0 if this is the last vertex
-    SafePtr<DGVertex> postcalc() const { return postcalc_; };
+    std::shared_ptr<DGVertex> postcalc() const { return postcalc_; };
     /// Sets postcalc
-    void set_postcalc(const SafePtr<DGVertex>& postcalc) { postcalc_ = postcalc; };
+    void set_postcalc(const std::shared_ptr<DGVertex>& postcalc) { postcalc_ = postcalc; };
 
     /// Resets the vertex, releasing all arcs
     void reset();
@@ -268,11 +268,11 @@ namespace libint2 {
         to use del_exit_arc() to replace an arc. replace_exit_arc() should be used
         in such instances.
       */
-    void del_exit_arc(const SafePtr<DGArc>& c);
+    void del_exit_arc(const std::shared_ptr<DGArc>& c);
     /// add_entry_arc(arc) adds arc as an arc connecting parents to this vertex
-    void add_entry_arc(const SafePtr<DGArc>&);
+    void add_entry_arc(const std::shared_ptr<DGArc>&);
     /// del_entry_arc(arc) removes arc as an arc connecting parents to this vertex
-    void del_entry_arc(const SafePtr<DGArc>&);
+    void del_entry_arc(const std::shared_ptr<DGArc>&);
 
     ////////
     // These members used in traversal and scheduling algorithms
@@ -281,7 +281,7 @@ namespace libint2 {
     /// num_tagged_arcs keeps track of how many entry arcs have been tagged during traversal
     unsigned int num_tagged_arcs_;
     /// Which DGVertex to be computed after this vertex (0, if this is the last vertex)
-    SafePtr<DGVertex> postcalc_;
+    std::shared_ptr<DGVertex> postcalc_;
     /// has it been scheduled?
     bool scheduled_;
 
@@ -294,10 +294,10 @@ namespace libint2 {
     // does not change class invariant -- hence mutable
 
     /// the subtree which contains this vertex (may be null). subtree is a directed rooted tree.
-    mutable SafePtr<DRTree> subtree_;
+    mutable std::shared_ptr<DRTree> subtree_;
     /// Only DRTree::set_subtree and DRTree::detach_from can change subtree_
-    friend void DRTree::add_vertex(const SafePtr<DGVertex>& vertex);
-    friend void DRTree::detach_from(const SafePtr<DGVertex>& v);
+    friend void DRTree::add_vertex(const std::shared_ptr<DGVertex>& vertex);
+    friend void DRTree::detach_from(const std::shared_ptr<DGVertex>& v);
 
   };
 
@@ -306,15 +306,15 @@ namespace libint2 {
   //
   /// return true if V is an unrolled IntegralSet
   struct UnrolledIntegralSet {
-    bool operator()(const SafePtr<DGVertex>& V);
+    bool operator()(const std::shared_ptr<DGVertex>& V);
   };
   /// return false if V is an unrolled IntegralSet
   struct NotUnrolledIntegralSet {
-    bool operator()(const SafePtr<DGVertex>& V);
+    bool operator()(const std::shared_ptr<DGVertex>& V);
   };
   /// return true if V is an Integral in an unrolled target IntegralSet
   struct IntegralInTargetIntegralSet {
-    bool operator()(const SafePtr<DGVertex>& V);
+    bool operator()(const std::shared_ptr<DGVertex>& V);
   };
 
   inline DGVertexKey key(const DGVertex& v) {
diff --git a/src/bin/libint/dims.cc b/src/bin/libint/dims.cc
index 3dce29b1f..e45dd82f0 100644
--- a/src/bin/libint/dims.cc
+++ b/src/bin/libint/dims.cc
@@ -24,17 +24,17 @@
 using namespace std;
 using namespace libint2;
 
-SafePtr<ImplicitDimensions>
-ImplicitDimensions::default_dims_ = SafePtr<ImplicitDimensions>();
+std::shared_ptr<ImplicitDimensions>
+ImplicitDimensions::default_dims_ = std::shared_ptr<ImplicitDimensions>();
 
 void
-ImplicitDimensions::set_default_dims(const SafePtr<CompilationParameters>& cparams)
+ImplicitDimensions::set_default_dims(const std::shared_ptr<CompilationParameters>& cparams)
 {
-  SafePtr<ImplicitDimensions> new_default(new ImplicitDimensions(1,1,cparams->max_vector_length()));
+  std::shared_ptr<ImplicitDimensions> new_default(new ImplicitDimensions(1,1,cparams->max_vector_length()));
   default_dims_ = new_default;
 }
 
-SafePtr<ImplicitDimensions>
+std::shared_ptr<ImplicitDimensions>
 ImplicitDimensions::default_dims()
 {
   if (default_dims_ == 0)
@@ -43,26 +43,26 @@ ImplicitDimensions::default_dims()
 }
 
 
-ImplicitDimensions::ImplicitDimensions(const SafePtr<Entity>& high,
-                                       const SafePtr<Entity>& low,
-                                       const SafePtr<Entity>& vecdim) :
+ImplicitDimensions::ImplicitDimensions(const std::shared_ptr<Entity>& high,
+                                       const std::shared_ptr<Entity>& low,
+                                       const std::shared_ptr<Entity>& vecdim) :
   high_(high), low_(low), vecdim_(vecdim)
   {
     init_();
   }
 
 ImplicitDimensions::ImplicitDimensions() :
-  high_(SafePtr<Entity>(new RTimeEntity<EntityTypes::Int>("highdim"))),
-  low_(SafePtr<Entity>(new RTimeEntity<EntityTypes::Int>("lowdim"))),
-  vecdim_(SafePtr<Entity>(new RTimeEntity<EntityTypes::Int>("libint->veclen")))
+  high_(std::shared_ptr<Entity>(new RTimeEntity<EntityTypes::Int>("highdim"))),
+  low_(std::shared_ptr<Entity>(new RTimeEntity<EntityTypes::Int>("lowdim"))),
+  vecdim_(std::shared_ptr<Entity>(new RTimeEntity<EntityTypes::Int>("libint->veclen")))
   {
     init_();
   }
 
 ImplicitDimensions::ImplicitDimensions(int high, int low, int vec) :
-  high_(SafePtr<Entity>(new CTimeEntity<int>(high))),
-  low_(SafePtr<Entity>(new CTimeEntity<int>(low))),
-  vecdim_(SafePtr<Entity>(new CTimeEntity<int>(vec)))
+  high_(std::shared_ptr<Entity>(new CTimeEntity<int>(high))),
+  low_(std::shared_ptr<Entity>(new CTimeEntity<int>(low))),
+  vecdim_(std::shared_ptr<Entity>(new CTimeEntity<int>(vec)))
   {
     init_();
   }
@@ -70,7 +70,7 @@ ImplicitDimensions::ImplicitDimensions(int high, int low, int vec) :
 void
 ImplicitDimensions::init_()
 {
-  SafePtr< CTimeEntity<int> > cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(high_);
+  std::shared_ptr< CTimeEntity<int> > cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(high_);
   if (cptr != 0) {
     high_is_static_ = true;
     ostringstream oss;
@@ -79,7 +79,7 @@ ImplicitDimensions::init_()
   }
   else {
     high_is_static_ = false;
-    SafePtr<DGVertex> dptr = dynamic_pointer_cast<DGVertex,Entity>(high_);
+    std::shared_ptr<DGVertex> dptr = dynamic_pointer_cast<DGVertex,Entity>(high_);
     high_label_ = dptr->label();
   }
   cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(low_);
@@ -91,7 +91,7 @@ ImplicitDimensions::init_()
   }
   else {
     low_is_static_ = false;
-    SafePtr<DGVertex> dptr = dynamic_pointer_cast<DGVertex,Entity>(low_);
+    std::shared_ptr<DGVertex> dptr = dynamic_pointer_cast<DGVertex,Entity>(low_);
     low_label_ = dptr->label();
   }
   cptr = dynamic_pointer_cast<CTimeEntity<int>,Entity>(vecdim_);
@@ -103,7 +103,7 @@ ImplicitDimensions::init_()
   }
   else {
     vecdim_is_static_ = false;
-    SafePtr<DGVertex> dptr = dynamic_pointer_cast<DGVertex,Entity>(vecdim_);
+    std::shared_ptr<DGVertex> dptr = dynamic_pointer_cast<DGVertex,Entity>(vecdim_);
     vecdim_label_ = dptr->label();
   }
 }
diff --git a/src/bin/libint/dims.h b/src/bin/libint/dims.h
index ab754959a..b1999ef3b 100644
--- a/src/bin/libint/dims.h
+++ b/src/bin/libint/dims.h
@@ -42,9 +42,9 @@ namespace libint2 {
   class ImplicitDimensions {
     public:
     /// Explicitly initialize both quantities. Their exact type is not known.
-    ImplicitDimensions(const SafePtr<Entity>& high,
-                       const SafePtr<Entity>& low,
-                       const SafePtr<Entity>& vecdim);
+    ImplicitDimensions(const std::shared_ptr<Entity>& high,
+                       const std::shared_ptr<Entity>& low,
+                       const std::shared_ptr<Entity>& vecdim);
     /// Default assumes runtime (dynamical) quantities
     ImplicitDimensions();
     /// Handy constructor to initialize dimensions as compile-time (static) quatities
@@ -52,11 +52,11 @@ namespace libint2 {
     ~ImplicitDimensions() {}
 
     /// Returns the high dimension
-    SafePtr<Entity> high() const { return high_; }
+    std::shared_ptr<Entity> high() const { return high_; }
     /// Returns the low dimension
-    SafePtr<Entity> low() const { return low_; }
+    std::shared_ptr<Entity> low() const { return low_; }
     /// Returns the vector dimension
-    SafePtr<Entity> vecdim() const { return vecdim_; }
+    std::shared_ptr<Entity> vecdim() const { return vecdim_; }
     /// Returns true if the rank of high dimension is known
     bool high_is_static() const { return high_is_static_; }
     /// Returns true if the rank of low dimension is known
@@ -71,15 +71,15 @@ namespace libint2 {
     const std::string& vecdim_label() const { return vecdim_label_; }
 
     /// Sets default ImplicitDimension object
-    static void set_default_dims(const SafePtr<CompilationParameters>& cparams);
+    static void set_default_dims(const std::shared_ptr<CompilationParameters>& cparams);
     /// Default ImplicitDimension object
-    static SafePtr<ImplicitDimensions> default_dims();
+    static std::shared_ptr<ImplicitDimensions> default_dims();
 
     private:
     // Dimensions can be runtime or compile-time quantities
-    const SafePtr<Entity> high_;
-    const SafePtr<Entity> low_;
-    const SafePtr<Entity> vecdim_;
+    const std::shared_ptr<Entity> high_;
+    const std::shared_ptr<Entity> low_;
+    const std::shared_ptr<Entity> vecdim_;
 
     // checks if the dimensions are CTImeEntities
     void init_();
@@ -92,7 +92,7 @@ namespace libint2 {
     std::string vecdim_label_;
 
     /// Default dimension
-    static SafePtr<ImplicitDimensions> default_dims_;
+    static std::shared_ptr<ImplicitDimensions> default_dims_;
 
   };
 
diff --git a/src/bin/libint/drtree.cc b/src/bin/libint/drtree.cc
index 1ebfc69e1..5adcdfbe6 100644
--- a/src/bin/libint/drtree.cc
+++ b/src/bin/libint/drtree.cc
@@ -25,12 +25,12 @@
 
 using namespace libint2;
 
-SafePtr<DRTree>
-DRTree::CreateRootedAt(const SafePtr<DGVertex>& v)
+std::shared_ptr<DRTree>
+DRTree::CreateRootedAt(const std::shared_ptr<DGVertex>& v)
 {
-  SafePtr<DRTree> stree = v->subtree();
+  std::shared_ptr<DRTree> stree = v->subtree();
   if (!stree) {
-    SafePtr<DRTree> result(new DRTree(v));
+    std::shared_ptr<DRTree> result(new DRTree(v));
     // Ugly that I have to add the vertex outside the constructor,
     // but enable_shared_from_this requires that a valid shared_ptr to this already exists
     result->grow();
@@ -40,7 +40,7 @@ DRTree::CreateRootedAt(const SafePtr<DGVertex>& v)
     return stree;
 }
 
-DRTree::DRTree(const SafePtr<DGVertex>& r) :
+DRTree::DRTree(const std::shared_ptr<DGVertex>& r) :
 nvertices_(0), root_(r)
 {
 }
@@ -55,14 +55,14 @@ DRTree::grow()
   add_vertex(root());
 }
 
-const SafePtr<DGVertex>&
+const std::shared_ptr<DGVertex>&
 DRTree::root() const
 {
   return root_;
 }
 
 void
-DRTree::add_vertex(const SafePtr<DGVertex>& vertex)
+DRTree::add_vertex(const std::shared_ptr<DGVertex>& vertex)
 {
   // If not root and has more than 1 parent -- it is not on the tree
   if ( (vertex->num_entry_arcs() <= 1 || vertex == root()) ) {
@@ -92,12 +92,12 @@ DRTree::detach()
 }
 
 void
-DRTree::detach_from(const SafePtr<DGVertex>& v)
+DRTree::detach_from(const std::shared_ptr<DGVertex>& v)
 {
   if (v->subtree_.get() != this)
     return;
   else {
-    v->subtree_ = SafePtr<DRTree>();
+    v->subtree_ = std::shared_ptr<DRTree>();
     typedef DGVertex::ArcSetType::const_iterator aciter;
     const aciter abegin = v->first_exit_arc();
     const aciter aend = v->plast_exit_arc();
diff --git a/src/bin/libint/drtree.h b/src/bin/libint/drtree.h
index 44868c100..03c395a12 100644
--- a/src/bin/libint/drtree.h
+++ b/src/bin/libint/drtree.h
@@ -35,28 +35,28 @@ namespace libint2 {
     typedef DRTree this_type;
     
     /// If v is not on a DRTree, make a new one using v as root
-    static SafePtr<DRTree> CreateRootedAt(const SafePtr<DGVertex>& v);
+    static std::shared_ptr<DRTree> CreateRootedAt(const std::shared_ptr<DGVertex>& v);
     ~DRTree();
     
     /// number of vertices
     unsigned int nvertices() const { return nvertices_; }
     /// the root of the tree
-    const SafePtr<DGVertex>& root() const;
+    const std::shared_ptr<DGVertex>& root() const;
     /// remove all references from vertices to the tree and vice versa
     void detach();
     /// will try to add v to this subtree. Should not be used by the user
-    void add_vertex(const SafePtr<DGVertex>& v);
+    void add_vertex(const std::shared_ptr<DGVertex>& v);
     /// recurively detach v from this
-    void detach_from(const SafePtr<DGVertex>& v);
+    void detach_from(const std::shared_ptr<DGVertex>& v);
     
     private:
     /// Create a tree starting at root
-    DRTree(const SafePtr<DGVertex>& root);
+    DRTree(const std::shared_ptr<DGVertex>& root);
     /// grows the tree from the root. Must be called after the constructor
     void grow();
     
     unsigned int nvertices_;
-    SafePtr<DGVertex> root_;
+    std::shared_ptr<DGVertex> root_;
   };
   
 }
diff --git a/src/bin/libint/entity.h b/src/bin/libint/entity.h
index 295eb1171..0f819db42 100644
--- a/src/bin/libint/entity.h
+++ b/src/bin/libint/entity.h
@@ -127,13 +127,13 @@ std::cout << "Allocated RTimeEntity id = " << this->id() << std::endl;
     unsigned int size() const override { return 1; }
 
     /// Implementation of DGVertex::equiv()
-    bool equiv(const SafePtr<DGVertex>& a) const override
+    bool equiv(const std::shared_ptr<DGVertex>& a) const override
     {
       if (a->typeid_ == typeid_) {
 #if USE_INT_KEY_TO_COMPARE
         return key() == a->key() && label() == a->label();
 #else
-        SafePtr<RTimeEntity> a_cast = static_pointer_cast<RTimeEntity,DGVertex>(a);
+        std::shared_ptr<RTimeEntity> a_cast = static_pointer_cast<RTimeEntity,DGVertex>(a);
         return id() == a_cast->id();
 #endif
       }
@@ -207,13 +207,13 @@ std::cout << "Allocated RTimeEntity id = " << this->id() << std::endl;
       unsigned int size() const override { return 1; }
 
       /// Implementation of DGVertex::equiv()
-      bool equiv(const SafePtr<DGVertex>& a) const override
+      bool equiv(const std::shared_ptr<DGVertex>& a) const override
       {
 	if (a->typeid_ == typeid_) {
 #if USE_INT_KEY_TO_COMPARE
           return key() == a->key();
 #else
-          SafePtr<CTimeEntity> a_cast = static_pointer_cast<CTimeEntity,DGVertex>(a);
+          std::shared_ptr<CTimeEntity> a_cast = static_pointer_cast<CTimeEntity,DGVertex>(a);
 	  return id() == a_cast->id();
 #endif
 	}
@@ -270,39 +270,39 @@ std::cout << "Allocated RTimeEntity id = " << this->id() << std::endl;
       then the result is a runtime entity as well. Otherwise the result is a compile-time entity.
   */
 //  template <typename T>
-//    SafePtr<Entity>
-//    operator*(const SafePtr<Entity>& A, const SafePtr< CTimeEntity<T> >& B);
+//    std::shared_ptr<Entity>
+//    operator*(const std::shared_ptr<Entity>& A, const std::shared_ptr< CTimeEntity<T> >& B);
 
   /** Creates product A*B.
   */
   template <typename T, typename U>
-    SafePtr< CTimeEntity< typename ProductType<T,U>::result > >
-    operator*(const SafePtr< CTimeEntity<T> >& A, const SafePtr< CTimeEntity<U> >& B)
+    std::shared_ptr< CTimeEntity< typename ProductType<T,U>::result > >
+    operator*(const std::shared_ptr< CTimeEntity<T> >& A, const std::shared_ptr< CTimeEntity<U> >& B)
     {
       typedef CTimeEntity< typename ProductType<T,U>::result > prodtype;
-      return SafePtr<prodtype>(new prodtype(A->value()*B->value()));
+      return std::shared_ptr<prodtype>(new prodtype(A->value()*B->value()));
     }
 
   /** Creates product A*B.
   */
   template <typename T, typename U>
-    SafePtr< RTimeEntity< typename ProductType<T,U>::result > >
-    operator*(const SafePtr< RTimeEntity<T> >& A, const SafePtr< CTimeEntity<U> >& B)
+    std::shared_ptr< RTimeEntity< typename ProductType<T,U>::result > >
+    operator*(const std::shared_ptr< RTimeEntity<T> >& A, const std::shared_ptr< CTimeEntity<U> >& B)
     {
       typedef RTimeEntity< typename ProductType<T,U>::result > prodtype;
       std::ostringstream oss;
       oss << A->id() << "*" << B->id();
       // TODO this should be false, but the logic of DirectedGraph construction depends on this being true
       const bool not_precomputed = true;
-      return SafePtr<prodtype>(new prodtype(oss.str(), not_precomputed));
+      return std::shared_ptr<prodtype>(new prodtype(oss.str(), not_precomputed));
     }
   // TODO should be possible to enable this, but this creates RTimeEntities that should not be precomputed, see the comment above
 #if 0
   /** Creates product B*A.
   */
   template <typename T, typename U>
-    SafePtr< RTimeEntity< typename ProductType<T,U>::result > >
-    operator*(const SafePtr< CTimeEntity<U> >& B, const SafePtr< RTimeEntity<T> >& A)
+    std::shared_ptr< RTimeEntity< typename ProductType<T,U>::result > >
+    operator*(const std::shared_ptr< CTimeEntity<U> >& B, const std::shared_ptr< RTimeEntity<T> >& A)
     {
       return A * B;
     }
diff --git a/src/bin/libint/equiv.h b/src/bin/libint/equiv.h
index 78021f8a5..2d9bc3b99 100644
--- a/src/bin/libint/equiv.h
+++ b/src/bin/libint/equiv.h
@@ -44,15 +44,15 @@ namespace libint2 {
       return a==b;
     }
     
-    static bool equiv(const SafePtr<T>& a, const SafePtr<T>& b) {
+    static bool equiv(const std::shared_ptr<T>& a, const std::shared_ptr<T>& b) {
       return a->operator==(*b.get());
     }
 
-    static bool equiv(const T* a, const SafePtr<T>& b) {
+    static bool equiv(const T* a, const std::shared_ptr<T>& b) {
       return a->operator==(*b.get());
     }
 
-    static bool equiv(const SafePtr<T>& b, const T* a) {
+    static bool equiv(const std::shared_ptr<T>& b, const T* a) {
       return a->operator==(*b.get());
     }
 
@@ -62,24 +62,24 @@ namespace libint2 {
 
 #if !PTREQUIV_USE_TYPEID
     
-    static bool equiv(const SafePtr<T>& a, const SafePtr<P>& b) {
-      SafePtr<T> b_cast = dynamic_pointer_cast<T,P>(b);
+    static bool equiv(const std::shared_ptr<T>& a, const std::shared_ptr<P>& b) {
+      std::shared_ptr<T> b_cast = dynamic_pointer_cast<T,P>(b);
       if (b_cast == 0)
         return false;
       else
         return a->operator==(*b_cast.get());
     }
 
-    static bool equiv(const T* a, const SafePtr<P>& b) {
-      SafePtr<T> b_cast = dynamic_pointer_cast<T,P>(b);
+    static bool equiv(const T* a, const std::shared_ptr<P>& b) {
+      std::shared_ptr<T> b_cast = dynamic_pointer_cast<T,P>(b);
       if (b_cast == 0)
         return false;
       else
         return a->operator==(*b_cast.get());
     }
 
-    static bool equiv(const T* a, const SafePtr<DGVertex>& b) {
-      SafePtr<T> b_cast = dynamic_pointer_cast<T,DGVertex>(b);
+    static bool equiv(const T* a, const std::shared_ptr<DGVertex>& b) {
+      std::shared_ptr<T> b_cast = dynamic_pointer_cast<T,DGVertex>(b);
       if (b_cast == 0)
         return false;
       else
@@ -88,16 +88,16 @@ namespace libint2 {
     
 #else
 
-    static bool equiv(const SafePtr<T>& a, const SafePtr<P>& b) {
+    static bool equiv(const std::shared_ptr<T>& a, const std::shared_ptr<P>& b) {
       if (a->typeid_ != b->typeid_)
         return false;
       else {
-        SafePtr<T> b_cast = static_pointer_cast<T,P>(b);
+        std::shared_ptr<T> b_cast = static_pointer_cast<T,P>(b);
         return a->operator==(*b_cast.get());
       }
     }
 
-    static bool equiv(const T* a, const SafePtr<DGVertex>& b) {
+    static bool equiv(const T* a, const std::shared_ptr<DGVertex>& b) {
       if (a->typeid_ != b->typeid_)
         return false;
       else {
@@ -108,7 +108,7 @@ namespace libint2 {
         return a->label() == b->label();
   #endif
 #else
-        SafePtr<T> b_cast = static_pointer_cast<T,DGVertex>(b);
+        std::shared_ptr<T> b_cast = static_pointer_cast<T,DGVertex>(b);
         return a->operator==(*b_cast.get());
 #endif
       }
@@ -119,8 +119,8 @@ namespace libint2 {
   };
     
     /*
-     static bool equiv(const SafePtr<parent_type>& b, const SafePtr<T>& a) const {
-       SafePtr<T> b_cast = dynamic_pointer_cast<T,parent_type>(b);
+     static bool equiv(const std::shared_ptr<parent_type>& b, const std::shared_ptr<T>& a) const {
+       std::shared_ptr<T> b_cast = dynamic_pointer_cast<T,parent_type>(b);
        if (b_cast == 0)
          return false;
        else
diff --git a/src/bin/libint/exception.h b/src/bin/libint/exception.h
index 73745bdeb..8e1622769 100644
--- a/src/bin/libint/exception.h
+++ b/src/bin/libint/exception.h
@@ -51,15 +51,15 @@ namespace libint2 {
   class VertexAlreadyOnStack : public std::logic_error {
     
   public:
-    VertexAlreadyOnStack(const SafePtr<DGVertex>& vertex) :
+    VertexAlreadyOnStack(const std::shared_ptr<DGVertex>& vertex) :
       logic_error("DirectedGraph -- vertex already on stack"), vertex_(vertex) {}
     ~VertexAlreadyOnStack() noexcept {}
 
-    SafePtr<DGVertex> vertex() const { return vertex_; }
+    std::shared_ptr<DGVertex> vertex() const { return vertex_; }
 
   private:
     // Vertex on the stack
-    SafePtr<DGVertex> vertex_;
+    std::shared_ptr<DGVertex> vertex_;
     
   };
 #endif
diff --git a/src/bin/libint/extract.cc b/src/bin/libint/extract.cc
index 337af75ac..2e2dd6d44 100644
--- a/src/bin/libint/extract.cc
+++ b/src/bin/libint/extract.cc
@@ -41,7 +41,7 @@ ExtractExternSymbols::operator()(const VertexPtr& v)
     // discard compile-time entities
     {
       typedef CTimeEntity<double> cdouble;
-      SafePtr<cdouble> ptr_cast = dynamic_pointer_cast<cdouble,DGVertex>(v);
+      std::shared_ptr<cdouble> ptr_cast = dynamic_pointer_cast<cdouble,DGVertex>(v);
       if (ptr_cast) {
         return;
       }
@@ -49,7 +49,7 @@ ExtractExternSymbols::operator()(const VertexPtr& v)
     
     // discard unrolled integral sets composed of precomputed integrals
     {
-      SafePtr<DGArcRR> arcrr;
+      std::shared_ptr<DGArcRR> arcrr;
       if (v->size() == 1 && v->num_exit_arcs() == 1 &&
           ( (arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(*(v->first_exit_arc()))) != 0 ?
               dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(arcrr->rr()) != 0 :
@@ -84,14 +84,14 @@ void
 ExtractRR::operator()(const VertexPtr& v)
 {
   if (v->num_exit_arcs() != 0) {
-    SafePtr<DGArc> arc = *(v->first_exit_arc());
-    SafePtr<DGArcRR> arc_rr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
+    std::shared_ptr<DGArc> arc = *(v->first_exit_arc());
+    std::shared_ptr<DGArcRR> arc_rr = dynamic_pointer_cast<DGArcRR,DGArc>(arc);
     if (arc_rr != 0) {
-      SafePtr<RecurrenceRelation> rr = arc_rr->rr();
-      SafePtr<IntegralSet_to_Integrals_base> iset_to_i = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
-      SafePtr<Uncontract_Integral_base> unc_i = dynamic_pointer_cast<Uncontract_Integral_base,RecurrenceRelation>(rr);
+      std::shared_ptr<RecurrenceRelation> rr = arc_rr->rr();
+      std::shared_ptr<IntegralSet_to_Integrals_base> iset_to_i = dynamic_pointer_cast<IntegralSet_to_Integrals_base,RecurrenceRelation>(rr);
+      std::shared_ptr<Uncontract_Integral_base> unc_i = dynamic_pointer_cast<Uncontract_Integral_base,RecurrenceRelation>(rr);
       if (iset_to_i == 0 && unc_i == 0) {
-        const SafePtr<RRStack>& rrstack = RRStack::Instance();
+        const std::shared_ptr<RRStack>& rrstack = RRStack::Instance();
         // RRStack must be guaranteed to have this rr
         const RRStack::value_type rrstackvalue = rrstack->find(rr);
         const RRid rrid = rrstackvalue.first;
diff --git a/src/bin/libint/extract.h b/src/bin/libint/extract.h
index 13b036b2f..b28bca441 100644
--- a/src/bin/libint/extract.h
+++ b/src/bin/libint/extract.h
@@ -36,7 +36,7 @@ namespace libint2 {
   /// This class collects labels of all external non-compile-time constants
   class ExtractExternSymbols {
   public:
-    typedef SafePtr<DGVertex> VertexPtr;
+    typedef std::shared_ptr<DGVertex> VertexPtr;
     typedef std::list<std::string> Symbols;
 
     ExtractExternSymbols() {}
@@ -58,7 +58,7 @@ namespace libint2 {
   /// This class collects all unique RRs. It uses RRStack to get their InstanceID
   class ExtractRR {
   public:
-    typedef SafePtr<DGVertex> VertexPtr;
+    typedef std::shared_ptr<DGVertex> VertexPtr;
     typedef RRStack::InstanceID RRid;
     typedef std::list<RRid> RRList;
 
diff --git a/src/bin/libint/gaussoper.h b/src/bin/libint/gaussoper.h
index 5f9ffe1e6..f45f5a49b 100644
--- a/src/bin/libint/gaussoper.h
+++ b/src/bin/libint/gaussoper.h
@@ -31,7 +31,7 @@ namespace libint2 {
   /// Applies R12vec_dot_Nabla1 to a physicists' braket
   template <class F, BraketType BKType>
   LinearCombination<
-    SafePtr<DGVertex>,
+    std::shared_ptr<DGVertex>,
     BraketPair<F,BKType>
   > R12vec_dot_Nabla1(const BraketPair<F,BKType>& bkt) {
     if (BKType == CBra || BKType == CKet)
@@ -42,7 +42,7 @@ namespace libint2 {
     
     const auto& f = bkt[0];
     const auto& g = bkt[1];
-    typedef LinearCombination< SafePtr<DGVertex> ,BraketPair<F,BKType> > ResultType;
+    typedef LinearCombination< std::shared_ptr<DGVertex> ,BraketPair<F,BKType> > ResultType;
     ResultType result;
     
     using namespace libint2::prefactor;
@@ -79,7 +79,7 @@ namespace libint2 {
   /// Applies R12vec_dot_Nabla2 to a physicists' braket
   template <class F, BraketType BKType>
   LinearCombination<
-    SafePtr<DGVertex>,
+    std::shared_ptr<DGVertex>,
     BraketPair<F,BKType>
   > R12vec_dot_Nabla2(const BraketPair<F,BKType>& bkt) {
     if (BKType == CBra || BKType == CKet)
@@ -90,7 +90,7 @@ namespace libint2 {
     
     const F& f = bkt[0];
     const F& g = bkt[1];
-    typedef LinearCombination< SafePtr<DGVertex> ,BraketPair<F,BKType> > ResultType;
+    typedef LinearCombination< std::shared_ptr<DGVertex> ,BraketPair<F,BKType> > ResultType;
     ResultType result;
     
     using namespace libint2::prefactor;
@@ -127,7 +127,7 @@ namespace libint2 {
   /// Applies Nabla1 to a physicists' braket
   template <class F, BraketType BKType>
   LinearCombination<
-    SafePtr<DGVertex>,
+    std::shared_ptr<DGVertex>,
     BraketPair<F,BKType>
   > Nabla1(const BraketPair<F,BKType>& bkt, int xyz) {
     if (BKType == CBra || BKType == CKet)
@@ -137,7 +137,7 @@ namespace libint2 {
     
     const F& f = bkt[0];
     const F& g = bkt[1];
-    typedef LinearCombination< SafePtr<DGVertex> ,BraketPair<F,BKType> > ResultType;
+    typedef LinearCombination< std::shared_ptr<DGVertex> ,BraketPair<F,BKType> > ResultType;
     ResultType result;
     
     using namespace libint2::prefactor;
@@ -160,7 +160,7 @@ namespace libint2 {
   /// Applies Nabla2 to a physicists' braket
   template <class F, BraketType BKType>
   LinearCombination<
-    SafePtr<DGVertex>,
+    std::shared_ptr<DGVertex>,
     BraketPair<F,BKType>
   > Nabla2(const BraketPair<F,BKType>& bkt, int xyz) {
     if (BKType == CBra || BKType == CKet)
@@ -170,7 +170,7 @@ namespace libint2 {
     
     const F& f = bkt[0];
     const F& g = bkt[1];
-    typedef LinearCombination< SafePtr<DGVertex> ,BraketPair<F,BKType> > ResultType;
+    typedef LinearCombination< std::shared_ptr<DGVertex> ,BraketPair<F,BKType> > ResultType;
     ResultType result;
     
     using namespace libint2::prefactor;
@@ -193,7 +193,7 @@ namespace libint2 {
   /// Applies R12v to a physicists' braket
   template <class F, BraketType BKType>
   LinearCombination<
-    SafePtr<DGVertex>,
+    std::shared_ptr<DGVertex>,
     BraketPair<F,BKType>
   > R12v(const BraketPair<F,BKType>& bkt,
          unsigned int xyz) {
@@ -204,7 +204,7 @@ namespace libint2 {
     
     const F& f = bkt[0];
     const F& g = bkt[1];
-    typedef LinearCombination< SafePtr<DGVertex> ,BraketPair<F,BKType> > ResultType;
+    typedef LinearCombination< std::shared_ptr<DGVertex> ,BraketPair<F,BKType> > ResultType;
     ResultType result;
     
     using namespace libint2::prefactor;
diff --git a/src/bin/libint/generic_rr.h b/src/bin/libint/generic_rr.h
index 675ece0d4..a14ab9271 100644
--- a/src/bin/libint/generic_rr.h
+++ b/src/bin/libint/generic_rr.h
@@ -52,27 +52,27 @@ namespace libint2 {
       typedef ParentType::ExprType ExprType;
 
       /// Return an instance if applicable, or a null pointer otherwise
-      static SafePtr<RRImpl> Instance(const SafePtr<TargetType>& Tint, unsigned int dir) {
+      static std::shared_ptr<RRImpl> Instance(const std::shared_ptr<TargetType>& Tint, unsigned int dir) {
         // screen out calls with nondefault extra parameters
         if (!RRImpl::directional() && dir != 0)
-          return SafePtr<RRImpl>();
+          return std::shared_ptr<RRImpl>();
         // attempt to construct
-        SafePtr<RRImpl> this_ptr(new RRImpl(Tint,dir));
+        std::shared_ptr<RRImpl> this_ptr(new RRImpl(Tint,dir));
         // if succeeded (nchildren > 0) do post-construction
         if (this_ptr->num_children() != 0) {
           this_ptr->template register_with_rrstack<RRImpl>();
           return this_ptr;
         }
         // else return null pointer
-        return SafePtr<RRImpl>();
+        return std::shared_ptr<RRImpl>();
       }
 
       /// Implementation of RecurrenceRelation::num_children()
       unsigned int num_children() const override { return children_.size(); }
       /// Implementation of RecurrenceRelation::rr_target()
-      SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target_); }
+      std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target_); }
       /// Implementation of RecurrenceRelation::rr_child()
-      SafePtr<DGVertex> rr_child(unsigned int i) const override {
+      std::shared_ptr<DGVertex> rr_child(unsigned int i) const override {
         return children_.at(i);
       }
       /// Implementation of RecurrenceRelation::is_simple()
@@ -89,7 +89,7 @@ namespace libint2 {
       }
 
     protected:
-      GenericRecurrenceRelation(const SafePtr<TargetType>& Tint, unsigned int dir) :
+      GenericRecurrenceRelation(const std::shared_ptr<TargetType>& Tint, unsigned int dir) :
         target_(Tint), dir_(dir) {
         children_.reserve(RRImpl::max_nchildren);
       }
@@ -105,8 +105,8 @@ namespace libint2 {
       unsigned int dir() const { return dir_; }
 
       /// add child
-      const SafePtr<DGVertex>& add_child(const SafePtr<DGVertex>& child) {
-        typedef std::vector< SafePtr<DGVertex> > cvector;
+      const std::shared_ptr<DGVertex>& add_child(const std::shared_ptr<DGVertex>& child) {
+        typedef std::vector< std::shared_ptr<DGVertex> > cvector;
         typedef typename cvector::const_iterator citer;
         const citer pos = std::find(children_.begin(),children_.end(),child);
         if (pos == children_.end()) {
@@ -123,22 +123,22 @@ namespace libint2 {
       /// TODO test is this works
 #if 0
       template <class RealChildType>
-      const SafePtr<DGVertex>& make_child(const typename RealChildType::BasisFunctionType& A,
+      const std::shared_ptr<DGVertex>& make_child(const typename RealChildType::BasisFunctionType& A,
                                           const typename RealChildType::BasisFunctionType& B,
                                           const typename RealChildType::BasisFunctionType& C,
                                           const typename RealChildType::BasisFunctionType& D,
                                           const typename RealChildType::AuxIndexType& aux = typename RealChildType::AuxIndexType(),
                                           const typename RealChildType::OperType& oper = typename RealChildType::OperType()) {
-        const SafePtr<DGVertex>& i = static_pointer_cast<DGVertex,RealChildType>(ChildType::Instance(A,B,C,D,aux,oper));
+        const std::shared_ptr<DGVertex>& i = static_pointer_cast<DGVertex,RealChildType>(ChildType::Instance(A,B,C,D,aux,oper));
         return add_child(i);
       }
 #endif
 
-      SafePtr<TargetType> target_;
+      std::shared_ptr<TargetType> target_;
 
     private:
       unsigned int dir_;
-      std::vector< SafePtr<DGVertex> > children_;
+      std::vector< std::shared_ptr<DGVertex> > children_;
 
   };
 
@@ -153,7 +153,7 @@ namespace libint2 {
     ChildFactory(GenRR* rr) : rr_(rr) {}
 
     /// make_child
-    const SafePtr<DGVertex>& make_child(const F& A,
+    const std::shared_ptr<DGVertex>& make_child(const F& A,
                                         const F& B,
                                         const F& C,
                                         const F& D,
@@ -163,7 +163,7 @@ namespace libint2 {
       return rr_->add_child(i);
     }
     /// make_child
-    const SafePtr<DGVertex>& make_child(const F& A,
+    const std::shared_ptr<DGVertex>& make_child(const F& A,
                                         const F& B,
                                         const AuxIndexType& aux = AuxIndexType(),
                                         const OperType& oper = OperType()) {
@@ -171,7 +171,7 @@ namespace libint2 {
       return rr_->add_child(i);
     }
     /// make a child from a wedge of physicists' brackets
-    const SafePtr<DGVertex>&
+    const std::shared_ptr<DGVertex>&
     make_child(const algebra::Wedge< BraketPair<F,PBra>, BraketPair<F,PKet> >& braket_wedge,
                const AuxIndexType& aux = AuxIndexType(),
                const OperType& oper = OperType()) {
@@ -179,7 +179,7 @@ namespace libint2 {
       return rr_->add_child(i);
     }
     /// make a child from a wedge of chemists' brackets
-    const SafePtr<DGVertex>&
+    const std::shared_ptr<DGVertex>&
     make_child(const algebra::Wedge< BraketPair<F,CBra>, BraketPair<F,CKet> >& braket_wedge,
                const AuxIndexType& aux = AuxIndexType(),
                const OperType& oper = OperType()) {
@@ -187,12 +187,12 @@ namespace libint2 {
       return rr_->add_child(i);
     }
     /// take a wedge product of various (linear combinations of) brakets
-    void wedge(const LinearCombination< SafePtr<DGVertex>, BraketPair<F,PBra> >& bra_lc,
-               const LinearCombination< SafePtr<DGVertex>, BraketPair<F,PKet> >& ket_lc,
+    void wedge(const LinearCombination< std::shared_ptr<DGVertex>, BraketPair<F,PBra> >& bra_lc,
+               const LinearCombination< std::shared_ptr<DGVertex>, BraketPair<F,PKet> >& ket_lc,
                const AuxIndexType& aux = AuxIndexType(),
                const OperType& oper = OperType()) {
       using namespace libint2::algebra;
-      typedef LinearCombination< SafePtr<DGVertex>,
+      typedef LinearCombination< std::shared_ptr<DGVertex>,
                                  Wedge< BraketPair<F,PBra>,
                                         BraketPair<F,PKet>
                                       >
@@ -211,20 +211,20 @@ namespace libint2 {
       }
     }
     void wedge(const BraketPair<F,PBra>& bra,
-               const LinearCombination< SafePtr<DGVertex>, BraketPair<F,PKet> >& ket_lc,
+               const LinearCombination< std::shared_ptr<DGVertex>, BraketPair<F,PKet> >& ket_lc,
                const AuxIndexType& aux = AuxIndexType(),
                const OperType& oper = OperType()) {
       using namespace libint2::prefactor;
-      LinearCombination< SafePtr<DGVertex>, BraketPair<F,PBra> > bra_lc;
+      LinearCombination< std::shared_ptr<DGVertex>, BraketPair<F,PBra> > bra_lc;
       bra_lc += make_pair(Scalar(1.0),bra);
       wedge(bra_lc,ket_lc,aux,oper);
     }
-    void wedge(const LinearCombination< SafePtr<DGVertex>, BraketPair<F,PBra> >& bra_lc,
+    void wedge(const LinearCombination< std::shared_ptr<DGVertex>, BraketPair<F,PBra> >& bra_lc,
                const BraketPair<F,PKet>& ket,
                const AuxIndexType& aux = AuxIndexType(),
                const OperType& oper = OperType()) {
       using namespace libint2::prefactor;
-      LinearCombination< SafePtr<DGVertex>, BraketPair<F,PKet> > ket_lc;
+      LinearCombination< std::shared_ptr<DGVertex>, BraketPair<F,PKet> > ket_lc;
       ket_lc += make_pair(Scalar(1.0),ket);
       wedge(bra_lc,ket_lc,aux,oper);
     }
diff --git a/src/bin/libint/hrr.h b/src/bin/libint/hrr.h
index 325d89c2a..c4af21777 100644
--- a/src/bin/libint/hrr.h
+++ b/src/bin/libint/hrr.h
@@ -65,13 +65,13 @@ namespace libint2 {
       typedef RecurrenceRelation::ExprType ExprType;
 
       /** Use Instance() to obtain an instance of RR. This function is provided to avoid
-       issues with getting a SafePtr from constructor (as needed for registry to work).
+       issues with getting a std::shared_ptr from constructor (as needed for registry to work).
 
        dir specifies which quantum number of a and b is shifted.
        For example, dir can be 0 (x), 1(y), or 2(z) if F is
        a Cartesian Gaussian.
        */
-      static SafePtr<ThisType> Instance(const SafePtr<TargetType>&, unsigned int dir = 0);
+      static std::shared_ptr<ThisType> Instance(const std::shared_ptr<TargetType>&, unsigned int dir = 0);
       virtual ~HRR();
 
       /// overrides RecurrenceRelation::braket_direction()
@@ -96,20 +96,20 @@ namespace libint2 {
       /// Implementation of RecurrenceRelation::num_children()
       unsigned int num_children() const override {return nchildren_;}
       /// returns pointer to the target
-      SafePtr<TargetType> target() const {return target_;};
+      std::shared_ptr<TargetType> target() const {return target_;};
       /// child(i) returns pointer to i-th child
-      SafePtr<ChildType> child(unsigned int i) const;
+      std::shared_ptr<ChildType> child(unsigned int i) const;
       /// Implementation of RecurrenceRelation::target()
-      SafePtr<DGVertex> rr_target() const override {return static_pointer_cast<DGVertex,TargetType>(target());}
+      std::shared_ptr<DGVertex> rr_target() const override {return static_pointer_cast<DGVertex,TargetType>(target());}
       /// Implementation of RecurrenceRelation::child()
-      SafePtr<DGVertex> rr_child(unsigned int i) const override {return static_pointer_cast<DGVertex,ChildType>(child(i));}
+      std::shared_ptr<DGVertex> rr_child(unsigned int i) const override {return static_pointer_cast<DGVertex,ChildType>(child(i));}
       /// Implementation of RecurrenceRelation::is_simple()
       bool is_simple() const override {
         return TrivialBFSet<BFSet>::result;
       }
       /// Implementation of RecurrenceRelation::spfunction_call()
-      std::string spfunction_call(const SafePtr<CodeContext>& context,
-          const SafePtr<ImplicitDimensions>& dims) const override;
+      std::string spfunction_call(const std::shared_ptr<CodeContext>& context,
+          const std::shared_ptr<ImplicitDimensions>& dims) const override;
 
       private:
       /**
@@ -117,12 +117,12 @@ namespace libint2 {
        For example, dir can be 0 (x), 1(y), or 2(z) if F is
        a Cartesian Gaussian.
        */
-      HRR(const SafePtr<TargetType>&, unsigned int dir);
+      HRR(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       unsigned int dir_;
-      SafePtr<TargetType> target_;
+      std::shared_ptr<TargetType> target_;
       static const unsigned int max_nchildren_ = 8;
-      SafePtr<ChildType> children_[max_nchildren_];
+      std::shared_ptr<ChildType> children_[max_nchildren_];
       unsigned int nchildren_;
 
       void oper_checks() const;
@@ -130,7 +130,7 @@ namespace libint2 {
       /// Implementation of RecurrenceRelation::label()
       std::string generate_label() const override;
       /// Reimplementation of RecurrenceRelation::adapt_dims_()
-      SafePtr<ImplicitDimensions> adapt_dims_(const SafePtr<ImplicitDimensions>& dims) const override;
+      std::shared_ptr<ImplicitDimensions> adapt_dims_(const std::shared_ptr<ImplicitDimensions>& dims) const override;
       /// Use instead of RecurrenceRelation::register_with_rrstack()
       bool register_with_rrstack() const;
       /** return true if the high dimension must be shown explicitly. For example,
@@ -144,22 +144,22 @@ namespace libint2 {
     template <class IntType, class F, int part,
     FunctionPosition loc_a, unsigned int pos_a,
     FunctionPosition loc_b, unsigned int pos_b>
-    SafePtr< HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b> >
-    HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::Instance(const SafePtr<TargetType>& Tint, unsigned int dir)
+    std::shared_ptr< HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b> >
+    HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::Instance(const std::shared_ptr<TargetType>& Tint, unsigned int dir)
     {
-      SafePtr<ThisType> this_ptr(new ThisType(Tint,dir));
+      std::shared_ptr<ThisType> this_ptr(new ThisType(Tint,dir));
       // Do post-construction duties
       if (this_ptr->num_children() != 0) {
         this_ptr->register_with_rrstack();
         return this_ptr;
       }
-      return SafePtr<ThisType>();
+      return std::shared_ptr<ThisType>();
     }
 
     template <class IntType, class F, int part,
     FunctionPosition loc_a, unsigned int pos_a,
     FunctionPosition loc_b, unsigned int pos_b>
-    HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::HRR(const SafePtr<TargetType>& Tint, unsigned int dir) :
+    HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::HRR(const std::shared_ptr<TargetType>& Tint, unsigned int dir) :
     dir_(dir), target_(Tint), nchildren_(0)
     {
       using namespace libint2::algebra;
@@ -384,8 +384,8 @@ namespace libint2 {
       }
       // if all bfsets not involved in transfer have zero quanta then this instance needs to be added to the stack
       if (!nonzero_quanta) {
-        SafePtr<RRStack> rrstack = RRStack::Instance();
-        SafePtr<ThisType> this_ptr =
+        std::shared_ptr<RRStack> rrstack = RRStack::Instance();
+        std::shared_ptr<ThisType> this_ptr =
         const_pointer_cast<ThisType,const ThisType>(
             static_pointer_cast<const ThisType, const ParentType>(
                 std::enable_shared_from_this<ParentType>::shared_from_this()
@@ -434,12 +434,12 @@ namespace libint2 {
       typedef GenIntegralSet<DummyOper, IncableBFSet, IBraType, IKetType, DummyQuanta> DummyIntegral;
       DummyOper dummy_oper;
       DummyQuanta dummy_quanta(std::vector<int>(0,0));
-      SafePtr<DummyIntegral> dummy_integral = DummyIntegral::Instance(bra_zero,ket_zero,dummy_quanta,dummy_oper);
+      std::shared_ptr<DummyIntegral> dummy_integral = DummyIntegral::Instance(bra_zero,ket_zero,dummy_quanta,dummy_oper);
 
       // Construct generic HRR and add it to the stack instead of this HRR
       typedef HRR<DummyIntegral,F,part,loc_a,pos_a,loc_b,pos_b> DummyHRR;
-      SafePtr<DummyHRR> dummy_hrr = DummyHRR::Instance(dummy_integral,dir_);
-      SafePtr<RRStack> rrstack = RRStack::Instance();
+      std::shared_ptr<DummyHRR> dummy_hrr = DummyHRR::Instance(dummy_integral,dir_);
+      std::shared_ptr<RRStack> rrstack = RRStack::Instance();
       rrstack->find(dummy_hrr);
       return true;
     }
@@ -479,7 +479,7 @@ namespace libint2 {
     template <class IntType, class F, int part,
     FunctionPosition loc_a, unsigned int pos_a,
     FunctionPosition loc_b, unsigned int pos_b>
-    SafePtr<typename HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::ChildType>
+    std::shared_ptr<typename HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::ChildType>
     HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::child(unsigned int i) const
     {
         assert(i>=0 && i<nchildren_);
@@ -550,7 +550,7 @@ namespace libint2 {
     FunctionPosition loc_b, unsigned int pos_b>
     std::string
     HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::spfunction_call(
-        const SafePtr<CodeContext>& context, const SafePtr<ImplicitDimensions>& dims) const
+        const std::shared_ptr<CodeContext>& context, const std::shared_ptr<ImplicitDimensions>& dims) const
         {
         std::ostringstream os;
         os << context->label_to_name(label_to_funcname(context->cparams()->api_prefix() + label()))
@@ -652,27 +652,27 @@ namespace libint2 {
     template <class IntType, class F, int part,
     FunctionPosition loc_a, unsigned int pos_a,
     FunctionPosition loc_b, unsigned int pos_b>
-    SafePtr<ImplicitDimensions>
-    HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::adapt_dims_(const SafePtr<ImplicitDimensions>& dims) const
+    std::shared_ptr<ImplicitDimensions>
+    HRR<IntType,F,part,loc_a,pos_a,loc_b,pos_b>::adapt_dims_(const std::shared_ptr<ImplicitDimensions>& dims) const
     {
         bool high_rank = expl_high_dim();
         bool low_rank = expl_low_dim();
 
-        SafePtr<Entity> high_dim, low_dim;
+        std::shared_ptr<Entity> high_dim, low_dim;
         if (high_rank) {
-          high_dim = SafePtr<Entity>(new RTimeEntity<EntityTypes::Int>("highdim"));
+          high_dim = std::shared_ptr<Entity>(new RTimeEntity<EntityTypes::Int>("highdim"));
         }
         else {
           high_dim = dims->high();
         }
         if (low_rank) {
-          low_dim = SafePtr<Entity>(new RTimeEntity<EntityTypes::Int>("lowdim"));
+          low_dim = std::shared_ptr<Entity>(new RTimeEntity<EntityTypes::Int>("lowdim"));
         }
         else {
           low_dim = dims->low();
         }
 
-        SafePtr<ImplicitDimensions> localdims(new ImplicitDimensions(high_dim,low_dim,dims->vecdim()));
+        std::shared_ptr<ImplicitDimensions> localdims(new ImplicitDimensions(high_dim,low_dim,dims->vecdim()));
         return localdims;
     }
 
diff --git a/src/bin/libint/iface.cc b/src/bin/libint/iface.cc
index 75a382b0f..dd68230e9 100644
--- a/src/bin/libint/iface.cc
+++ b/src/bin/libint/iface.cc
@@ -46,8 +46,8 @@ namespace {
 
 };
 
-Libint2Iface::Libint2Iface(const SafePtr<CompilationParameters>& cparams,
-                           const SafePtr<CodeContext>& ctext) :
+Libint2Iface::Libint2Iface(const std::shared_ptr<CompilationParameters>& cparams,
+                           const std::shared_ptr<CodeContext>& ctext) :
   null_str_(""), oss_(), cparams_(cparams), ctext_(ctext),
   th_((cparams_->source_directory() + th_name).c_str()),
   ph_((cparams_->source_directory() + ph_name).c_str()),
@@ -201,7 +201,7 @@ Libint2Iface::~Libint2Iface()
   LibraryTaskManager& taskmgr = LibraryTaskManager::Instance();
   typedef LibraryTaskManager::TasksCIter tciter;
   for(tciter t=taskmgr.first(); t!=taskmgr.plast(); ++t) {
-    SafePtr<TaskParameters> tparams = t->params();
+    std::shared_ptr<TaskParameters> tparams = t->params();
     const std::string& tlabel = t->label();
     ph_ << macro_define(tlabel,"NUM_TARGETS",tparams->max_ntarget());
     const unsigned int max_am = tparams->max_am();
@@ -430,7 +430,7 @@ Libint2Iface::generate_inteval_type(std::ostream& os)
   typedef LibraryTaskManager::TasksCIter tciter;
   const tciter tend = cparams_->single_evaltype() ? taskmgr.first()+1 : taskmgr.plast();
   for(tciter t=taskmgr.first(); t!=tend; ++t) {
-    const SafePtr<TaskExternSymbols> tsymbols = t->symbols();
+    const std::shared_ptr<TaskExternSymbols> tsymbols = t->symbols();
     
     // Prologue
     os << "typedef struct {" << std::endl;
@@ -445,7 +445,7 @@ Libint2Iface::generate_inteval_type(std::ostream& os)
       TaskExternSymbols composite_symbols;
       const tciter tend = taskmgr.plast();
       for(tciter t=taskmgr.first(); t!=tend; ++t) {
-        const SafePtr<TaskExternSymbols> tsymbols = t->symbols();
+        const std::shared_ptr<TaskExternSymbols> tsymbols = t->symbols();
         composite_symbols.add(tsymbols->symbols());
       }
       symbols = composite_symbols.symbols();
@@ -521,7 +521,7 @@ Libint2Iface::generate_inteval_type(std::ostream& os)
       unsigned int max_ntargets = 0;
       const tciter tend = taskmgr.plast();
       for(tciter t=taskmgr.first(); t!=tend; ++t) {
-        SafePtr<TaskParameters> tparams = t->params();
+        std::shared_ptr<TaskParameters> tparams = t->params();
         max_ntargets = std::max(max_ntargets,tparams->max_ntarget());
       }
       ostringstream oss;
diff --git a/src/bin/libint/iface.h b/src/bin/libint/iface.h
index 97f84227e..a6eb4fd67 100644
--- a/src/bin/libint/iface.h
+++ b/src/bin/libint/iface.h
@@ -41,8 +41,8 @@ namespace libint2 {
     class Libint2Iface {
       public:
       typedef std::vector<std::string> Tasks;
-      Libint2Iface(const SafePtr<CompilationParameters>& cparams,
-                   const SafePtr<CodeContext>& ctext);
+      Libint2Iface(const std::shared_ptr<CompilationParameters>& cparams,
+                   const std::shared_ptr<CodeContext>& ctext);
       ~Libint2Iface();
 
       /// Writes string s to the types header
@@ -105,8 +105,8 @@ namespace libint2 {
       private:
       std::string null_str_;
       std::ostringstream oss_;
-      SafePtr<CompilationParameters> cparams_;
-      SafePtr<CodeContext> ctext_;
+      std::shared_ptr<CompilationParameters> cparams_;
+      std::shared_ptr<CodeContext> ctext_;
 
       // computation-specific functions are libint2_init_xxx, libint2_cleanup_xxx, etc. -- these are their declarations,
       // e.g. "libint2_init_xxx(Libint_t* libint, int max_am, LIBINT2_REALTYPE* buf)"
diff --git a/src/bin/libint/integral.h b/src/bin/libint/integral.h
index 276fb87bd..763eef800 100644
--- a/src/bin/libint/integral.h
+++ b/src/bin/libint/integral.h
@@ -69,9 +69,9 @@ namespace libint2 {
     /// Return the number of particles
     virtual unsigned int np() const =0;
     /// Obtain pointers to ith BasisFunctionSet for particle p in bra
-    virtual const SafePtr<BasisFunctionSet> bra(unsigned int p, unsigned int i) const =0;
+    virtual const std::shared_ptr<BasisFunctionSet> bra(unsigned int p, unsigned int i) const =0;
     /// Obtain pointers to ith BasisFunctionSet for particle p in ket
-    virtual const SafePtr<BasisFunctionSet> ket(unsigned int p, unsigned int i) const =0;
+    virtual const std::shared_ptr<BasisFunctionSet> ket(unsigned int p, unsigned int i) const =0;
 #endif
   };
 
@@ -126,12 +126,12 @@ namespace libint2 {
       virtual ~GenIntegralSet();
 
       /// Returns a pointer to a unique instance, a la Singleton
-      static const SafePtr<GenIntegralSet> Instance(const BraSetType& bra, const KetSetType& ket, const AuxQuanta& aux, const Oper& oper=Oper());
+      static const std::shared_ptr<GenIntegralSet> Instance(const BraSetType& bra, const KetSetType& ket, const AuxQuanta& aux, const Oper& oper=Oper());
 
       /// Comparison operator
       virtual bool operator==(const GenIntegralSet&) const;
       /// Specialization of DGVertex::equiv()
-      bool equiv(const SafePtr<DGVertex>& v) const override
+      bool equiv(const std::shared_ptr<DGVertex>& v) const override
       {
         return PtrComp::equiv(this,v);
       }
@@ -165,13 +165,13 @@ namespace libint2 {
       typedef AuxQuanta AuxQuantaType;
 
       /// Obtain the operator
-      const SafePtr<Oper> oper() const;
+      const std::shared_ptr<Oper> oper() const;
       /// Obtain const ref to bra
       const BraType& bra() const;
       /// Obtain const ref to bra
       const KetType& ket() const;
       /// Obtain the auxiliary quanta
-      const SafePtr<AuxQuanta> aux() const;
+      const std::shared_ptr<AuxQuanta> aux() const;
 
       /// Implements Hashable::key()
       DGVertex::KeyReturnType key() const override {
@@ -233,9 +233,9 @@ namespace libint2 {
       static SingletonManagerType singl_manager_;
 
       // The operator needs to be a real object rather than real type to be able to construct a SubIterator, etc.
-      SafePtr<Oper> O_;
+      std::shared_ptr<Oper> O_;
       // Same for AuxQuanta
-      SafePtr<AuxQuanta> aux_;
+      std::shared_ptr<AuxQuanta> aux_;
 
       // size of the integral set
       mutable unsigned int size_;
@@ -268,7 +268,7 @@ namespace libint2 {
 
   template <class Op, class BFS, class BraSetType, class KetSetType, class AuxQuanta>
     GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta>::GenIntegralSet(const Op& oper, const BraSetType& bra, const KetSetType& ket, const AuxQuanta& aux) :
-    DGVertex(ClassInfo<GenIntegralSet>::Instance().id()), bra_(bra), ket_(ket), O_(SafePtr<Op>(new Op(oper))), aux_(SafePtr<AuxQuanta>(new AuxQuanta(aux))),
+    DGVertex(ClassInfo<GenIntegralSet>::Instance().id()), bra_(bra), ket_(ket), O_(std::shared_ptr<Op>(new Op(oper))), aux_(std::shared_ptr<AuxQuanta>(new AuxQuanta(aux))),
     size_(0), label_()
     {
       if (Op::Properties::np != bra.num_part())
@@ -292,14 +292,14 @@ namespace libint2 {
     }
 
   template <class Op, class BFS, class BraSetType, class KetSetType, class AuxQuanta>
-    const SafePtr< GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta> >
+    const std::shared_ptr< GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta> >
     GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta>::Instance(const BraSetType& bra, const KetSetType& ket, const AuxQuanta& aux, const Op& oper)
     {
       typedef typename SingletonManagerType::value_type map_value_type;
       key_type key = compute_key(oper,bra,ket,aux);
       const map_value_type& val = singl_manager_.find(key);
       if (!val.second) {
-	SafePtr<this_type> this_int(new this_type(oper,bra,ket,aux));
+	std::shared_ptr<this_type> this_int(new this_type(oper,bra,ket,aux));
 	// Use singl_manager_ to make sure this is a new object of this type
 	const map_value_type& val = singl_manager_.find(this_int);
 	val.second->instid_ = val.first;
@@ -354,14 +354,14 @@ namespace libint2 {
     }
 
   template <class Op, class BFS, class BraSetType, class KetSetType, class AuxQuanta>
-    const SafePtr<Op>
+    const std::shared_ptr<Op>
     GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta>::oper() const
     {
       return O_;
     }
 
   template <class Op, class BFS, class BraSetType, class KetSetType, class AuxQuanta>
-    const SafePtr<AuxQuanta>
+    const std::shared_ptr<AuxQuanta>
     GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta>::aux() const
     {
       return aux_;
@@ -405,8 +405,8 @@ namespace libint2 {
     size_ = bra_.size() * ket_.size() * O_->num_oper();
 #else
       // compute size
-      SafePtr<this_type> this_ptr = const_pointer_cast<this_type,const this_type>(std::enable_shared_from_this<GenIntegralSet>::shared_from_this());
-      SafePtr< SubIteratorBase<this_type> > siter(new SubIteratorBase<this_type>(this_ptr));
+      std::shared_ptr<this_type> this_ptr = const_pointer_cast<this_type,const this_type>(std::enable_shared_from_this<GenIntegralSet>::shared_from_this());
+      std::shared_ptr< SubIteratorBase<this_type> > siter(new SubIteratorBase<this_type>(this_ptr));
       size_ = siter->num_iter();
       if (size_ == 0)
         throw std::runtime_error("GenIntegralSet<Op,BFS,BraSetType,KetSetType,AuxQuanta>::size() -- size is 0");
@@ -424,7 +424,7 @@ namespace libint2 {
 
   template <class BraSetType, class KetSetType, class AuxQuanta, class Op>
     std::string
-    genintegralset_label(const BraSetType& bra, const KetSetType& ket, const SafePtr<AuxQuanta>& aux, const SafePtr<Op>& O)
+    genintegralset_label(const BraSetType& bra, const KetSetType& ket, const std::shared_ptr<AuxQuanta>& aux, const std::shared_ptr<Op>& O)
     {
       std::ostringstream os;
       os << "< ";
diff --git a/src/bin/libint/integral_11_11.h b/src/bin/libint/integral_11_11.h
index 685816367..2ac2bebac 100644
--- a/src/bin/libint/integral_11_11.h
+++ b/src/bin/libint/integral_11_11.h
@@ -53,10 +53,10 @@ namespace libint2 {
           Note that the ordering of arguments is a bit counterintuitive,
           but in fact corresponds to their practical (rather than logical) importance.
       */
-      static const SafePtr<this_type> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
+      static const std::shared_ptr<this_type> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
       /** This "constructor" uses a wedge of 2 physicists brakets.
       */
-      static const SafePtr<this_type>
+      static const std::shared_ptr<this_type>
       Instance(const algebra::Wedge< BraketPair<BFS,PBra>, BraketPair<BFS,PKet> >& braket_wedge,
                const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType()) {
         return Instance(braket_wedge.left[0],
@@ -68,7 +68,7 @@ namespace libint2 {
       }
       /** This "constructor" uses a wedge of 2 chemists brakets.
       */
-      static const SafePtr<this_type>
+      static const std::shared_ptr<this_type>
       Instance(const algebra::Wedge< BraketPair<BFS,CBra>, BraketPair<BFS,CKet> >& braket_wedge,
                const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType()) {
         return Instance(braket_wedge.left[0],
@@ -82,7 +82,7 @@ namespace libint2 {
           Note that the ordering of arguments is a bit counterintuitive,
           but in fact corresponds to their practical (rather than logical) importance.
       */
-      static const SafePtr<this_type> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
+      static const std::shared_ptr<this_type> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
       ~GenIntegralSet_11_11();
 
       /// Comparison operator
@@ -140,7 +140,7 @@ namespace libint2 {
     }
 
   template <class BFS, class Oper, class AuxQuanta>
-    const SafePtr< GenIntegralSet_11_11<BFS,Oper,AuxQuanta> >
+    const std::shared_ptr< GenIntegralSet_11_11<BFS,Oper,AuxQuanta> >
     GenIntegralSet_11_11<BFS,Oper,AuxQuanta>::Instance(const BraType& bra, const KetType& ket,
                                                        const AuxIndexType& aux, const OperType& oper)
     {
@@ -148,7 +148,7 @@ namespace libint2 {
       key_type key = parent_type::compute_key(oper,bra,ket,aux);
       const map_value_type& val = singl_manager_.find(key);
       if (!val.second) {
-        SafePtr<this_type> this_int(new this_type(oper,bra,ket,aux));
+        std::shared_ptr<this_type> this_int(new this_type(oper,bra,ket,aux));
         // Use singl_manager_ to make sure this is a new object of this type
         const typename SingletonManagerType::value_type& val = singl_manager_.find(this_int);
         val.second->instid_ = val.first;
@@ -158,7 +158,7 @@ namespace libint2 {
     }
 
   template <class BFS, class Oper, class AuxQuanta>
-    const SafePtr< GenIntegralSet_11_11<BFS,Oper,AuxQuanta> >
+    const std::shared_ptr< GenIntegralSet_11_11<BFS,Oper,AuxQuanta> >
     GenIntegralSet_11_11<BFS,Oper,AuxQuanta>::Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1,
                                                        const AuxIndexType& aux, const OperType& oper)
     {
@@ -169,7 +169,7 @@ namespace libint2 {
       BFSRef ket0_ref(ket0);
       BFSRef ket1_ref(ket1);
 #else
-      typedef SafePtr<BFS> BFSRef;
+      typedef std::shared_ptr<BFS> BFSRef;
       BFSRef bra0_ref(new BFS(bra0));
       BFSRef bra1_ref(new BFS(bra1));
       BFSRef ket0_ref(new BFS(ket0));
@@ -197,8 +197,8 @@ namespace libint2 {
     void
     GenIntegralSet_11_11<BFS,Oper,AuxQuanta>::unregister() const
     {
-      SafePtr<parent_type> this_parent_ptr = const_pointer_cast<parent_type,const parent_type>(std::enable_shared_from_this<parent_type>::shared_from_this());
-      SafePtr<this_type> this_ptr = static_pointer_cast<this_type>(this_parent_ptr);
+      std::shared_ptr<parent_type> this_parent_ptr = const_pointer_cast<parent_type,const parent_type>(std::enable_shared_from_this<parent_type>::shared_from_this());
+      std::shared_ptr<this_type> this_ptr = static_pointer_cast<this_type>(this_parent_ptr);
       singl_manager_.remove(this_ptr);
     }
 
diff --git a/src/bin/libint/integral_1_1.h b/src/bin/libint/integral_1_1.h
index 72fbf9396..43e721d02 100644
--- a/src/bin/libint/integral_1_1.h
+++ b/src/bin/libint/integral_1_1.h
@@ -53,12 +53,12 @@ namespace libint2 {
           Note that the ordering of arguments is a bit counterintuitive,
           but in fact corresponds to their practical (rather than logical) importance.
       */
-      static const SafePtr<this_type> Instance(const BFS& bra0, const BFS& ket0, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
+      static const std::shared_ptr<this_type> Instance(const BFS& bra0, const BFS& ket0, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
 
 #if 0
       /** This "constructor" uses a wedge of 2 physicists brakets.
       */
-      static const SafePtr<this_type>
+      static const std::shared_ptr<this_type>
       Instance(const algebra::Wedge< BraketPair<BFS,PBra>, BraketPair<BFS,PKet> >& braket_wedge,
                const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType()) {
         return Instance(braket_wedge.left[0],
@@ -68,7 +68,7 @@ namespace libint2 {
       }
       /** This "constructor" uses a wedge of 2 chemists brakets.
       */
-      static const SafePtr<this_type>
+      static const std::shared_ptr<this_type>
       Instance(const algebra::Wedge< BraketPair<BFS,CBra>, BraketPair<BFS,CKet> >& braket_wedge,
                const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType()) {
         return Instance(braket_wedge.left[0],
@@ -84,7 +84,7 @@ namespace libint2 {
           Note that the ordering of arguments is a bit counterintuitive,
           but in fact corresponds to their practical (rather than logical) importance.
       */
-      static const SafePtr<this_type> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
+      static const std::shared_ptr<this_type> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux = AuxIndexType(), const OperType& oper = OperType());
       virtual ~GenIntegralSet_1_1();
 
       /// Comparison operator
@@ -138,7 +138,7 @@ namespace libint2 {
     }
 
   template <class BFS, class Oper, class AuxQuanta>
-    const SafePtr< GenIntegralSet_1_1<BFS,Oper,AuxQuanta> >
+    const std::shared_ptr< GenIntegralSet_1_1<BFS,Oper,AuxQuanta> >
     GenIntegralSet_1_1<BFS,Oper,AuxQuanta>::Instance(const BraType& bra, const KetType& ket,
                                                        const AuxIndexType& aux, const OperType& oper)
     {
@@ -146,7 +146,7 @@ namespace libint2 {
       key_type key = parent_type::compute_key(oper,bra,ket,aux);
       const map_value_type& val = singl_manager_.find(key);
       if (!val.second) {
-        SafePtr<this_type> this_int(new this_type(oper,bra,ket,aux));
+        std::shared_ptr<this_type> this_int(new this_type(oper,bra,ket,aux));
         // Use singl_manager_ to make sure this is a new object of this type
         const typename SingletonManagerType::value_type& val = singl_manager_.find(this_int);
         val.second->instid_ = val.first;
@@ -156,7 +156,7 @@ namespace libint2 {
     }
 
   template <class BFS, class Oper, class AuxQuanta>
-    const SafePtr< GenIntegralSet_1_1<BFS,Oper,AuxQuanta> >
+    const std::shared_ptr< GenIntegralSet_1_1<BFS,Oper,AuxQuanta> >
     GenIntegralSet_1_1<BFS,Oper,AuxQuanta>::Instance(const BFS& bra0, const BFS& ket0,
                                                        const AuxIndexType& aux, const OperType& oper)
     {
@@ -165,7 +165,7 @@ namespace libint2 {
       BFSRef bra0_ref(bra0);
       BFSRef ket0_ref(ket0);
 #else
-      typedef SafePtr<BFS> BFSRef;
+      typedef std::shared_ptr<BFS> BFSRef;
       BFSRef bra0_ref(new BFS(bra0));
       BFSRef ket0_ref(new BFS(ket0));
 #endif
@@ -189,8 +189,8 @@ namespace libint2 {
     void
     GenIntegralSet_1_1<BFS,Oper,AuxQuanta>::unregister() const
     {
-      SafePtr<parent_type> this_parent_ptr = const_pointer_cast<parent_type,const parent_type>(std::enable_shared_from_this<parent_type>::shared_from_this());
-      SafePtr<this_type> this_ptr = static_pointer_cast<this_type>(this_parent_ptr);
+      std::shared_ptr<parent_type> this_parent_ptr = const_pointer_cast<parent_type,const parent_type>(std::enable_shared_from_this<parent_type>::shared_from_this());
+      std::shared_ptr<this_type> this_ptr = static_pointer_cast<this_type>(this_parent_ptr);
       singl_manager_.remove(this_ptr);
     }
 
diff --git a/src/bin/libint/intset_to_ints.h b/src/bin/libint/intset_to_ints.h
index d1803ef2c..d0354e9e7 100644
--- a/src/bin/libint/intset_to_ints.h
+++ b/src/bin/libint/intset_to_ints.h
@@ -52,14 +52,14 @@ namespace libint2 {
     /// The type of expressions in which RecurrenceRelations result.
     typedef RecurrenceRelation::ExprType ExprType;
 
-    IntegralSet_to_Integrals(const SafePtr<I>&);
+    IntegralSet_to_Integrals(const std::shared_ptr<I>&);
     virtual ~IntegralSet_to_Integrals() {}
 
     /// Return an instance if applicable, or a null pointer otherwise
-    static SafePtr<IntegralSet_to_Integrals<I>> Instance(const SafePtr<TargetType>& Tint, unsigned int dir) {
+    static std::shared_ptr<IntegralSet_to_Integrals<I>> Instance(const std::shared_ptr<TargetType>& Tint, unsigned int dir) {
       assert(dir == 0);
       // attempt to construct
-      SafePtr<IntegralSet_to_Integrals<I>> this_ptr(new IntegralSet_to_Integrals<I>(Tint));
+      std::shared_ptr<IntegralSet_to_Integrals<I>> this_ptr(new IntegralSet_to_Integrals<I>(Tint));
       // if succeeded (nchildren > 0) do post-construction
       assert(this_ptr->num_children() != 0);
       return this_ptr;
@@ -70,13 +70,13 @@ namespace libint2 {
     /// Implementation of RecurrenceRelation::num_children()
     unsigned int num_children() const override { return children_.size(); }
     /// target() returns pointer to target
-    SafePtr<TargetType> target() const { return target_; };
+    std::shared_ptr<TargetType> target() const { return target_; };
     /// child(i) returns pointer i-th child
-    SafePtr<ChildType> child(unsigned int i) const;
+    std::shared_ptr<ChildType> child(unsigned int i) const;
     /// Implementation of RecurrenceRelation's target()
-    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
+    std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
     /// Implementation of RecurrenceRelation's child()
-    SafePtr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(child(i)); }
+    std::shared_ptr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(child(i)); }
     /// Implementation of RecurrenceRelation::is_simple()
     bool is_simple() const override {
       return true;
@@ -88,8 +88,8 @@ namespace libint2 {
     }
 
   private:
-    SafePtr<TargetType> target_;
-    std::vector< SafePtr<ChildType> > children_;
+    std::shared_ptr<TargetType> target_;
+    std::vector< std::shared_ptr<ChildType> > children_;
 
     /// Implementation of RecurrenceRelation::generate_label()
     std::string generate_label() const override {
@@ -97,8 +97,8 @@ namespace libint2 {
       //throw std::runtime_error("IntegralSet_to_Integrals::label() -- code for this RR is never generated, so this function should never be used");
     }
     /// Reimplementation of RecurrenceRelation::spfunction_call()
-    std::string spfunction_call(const SafePtr<CodeContext>& context,
-                                const SafePtr<ImplicitDimensions>& dims) const override
+    std::string spfunction_call(const std::shared_ptr<CodeContext>& context,
+                                const std::shared_ptr<ImplicitDimensions>& dims) const override
     {
       throw std::logic_error("IntegralSet_to_Integrals::spfunction_call -- should not call this function");
     }
@@ -107,7 +107,7 @@ namespace libint2 {
 
 
   template <class I>
-    IntegralSet_to_Integrals<I>::IntegralSet_to_Integrals(const SafePtr<I>& Tint) :
+    IntegralSet_to_Integrals<I>::IntegralSet_to_Integrals(const std::shared_ptr<I>& Tint) :
     target_(Tint)
     {
       target_ = Tint;
@@ -121,7 +121,7 @@ namespace libint2 {
     };
 
   template <class I>
-    SafePtr<typename I::iter_type>
+    std::shared_ptr<typename I::iter_type>
     IntegralSet_to_Integrals<I>::child(unsigned int i) const
     {
       return children_.at(i);
diff --git a/src/bin/libint/iter.h b/src/bin/libint/iter.h
index d8ec7628a..461786c9d 100644
--- a/src/bin/libint/iter.h
+++ b/src/bin/libint/iter.h
@@ -116,7 +116,7 @@ namespace libint2 {
     template <typename X>
     struct PElemImpl<X,true> {
       static cp_rettype pelem(const iref& elem) {
-        SafePtr<ConstructablePolymorphically> elem_cast = dynamic_pointer_cast<ConstructablePolymorphically,X>(elem);
+        std::shared_ptr<ConstructablePolymorphically> elem_cast = dynamic_pointer_cast<ConstructablePolymorphically,X>(elem);
         return *(elem_cast.get());
       }
     };
@@ -173,7 +173,7 @@ namespace libint2 {
 
 #if 0
   template <class T, template <class> class P>
-    const SafePtr<ConstructablePolymorphically>
+    const std::shared_ptr<ConstructablePolymorphically>
     SubIteratorBase<T,P>::pelem() const
     {
       return dynamic_pointer_cast<ConstructablePolymorphically,iter_type>(elem());
diff --git a/src/bin/libint/itr_11_twoprep_11.h b/src/bin/libint/itr_11_twoprep_11.h
index aeb8f9b4a..c5c6d90cd 100644
--- a/src/bin/libint/itr_11_twoprep_11.h
+++ b/src/bin/libint/itr_11_twoprep_11.h
@@ -58,13 +58,13 @@ namespace libint2 {
     typedef RecurrenceRelation::ExprType ExprType;
 
     /** Use Instance() to obtain an instance of RR. This function is provided to avoid
-        issues with getting a SafePtr from constructor (as needed for registry to work).
+        issues with getting a std::shared_ptr from constructor (as needed for registry to work).
 
         dir specifies which quantum number of a and b is shifted.
         For example, dir can be 0 (x), 1(y), or 2(z) if F is
         a Cartesian Gaussian.
     */
-    static SafePtr<ThisType> Instance(const SafePtr<TargetType>&, unsigned int dir = 0);
+    static std::shared_ptr<ThisType> Instance(const std::shared_ptr<TargetType>&, unsigned int dir = 0);
     virtual ~ITR_11_TwoPRep_11() { assert(part == 0 || part == 1); }
 
     /// overrides RecurrenceRelation::partindex_direction()
@@ -86,9 +86,9 @@ namespace libint2 {
     /// Implementation of RecurrenceRelation::num_children()
     unsigned int num_children() const override { return children_.size(); }
     /// Implementation of RecurrenceRelation::rr_target()
-    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target_); }
+    std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target_); }
     /// Implementation of RecurrenceRelation::rr_child()
-    SafePtr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(children_.at(i)); }
+    std::shared_ptr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(children_.at(i)); }
     /// Implementation of RecurrenceRelation::is_simple()
     bool is_simple() const override {
       return TrivialBFSet<BFSet>::result;
@@ -101,14 +101,14 @@ namespace libint2 {
       For example, dir can be 0 (x), 1(y), or 2(z) if BFSet is
       a Cartesian Gaussian.
      */
-    ITR_11_TwoPRep_11(const SafePtr<TargetType>&, unsigned int dir);
+    ITR_11_TwoPRep_11(const std::shared_ptr<TargetType>&, unsigned int dir);
 
     static const unsigned int max_nchildren_ = 4;
     unsigned int dir_;
-    SafePtr<TargetType> target_;
-    std::vector< SafePtr<ChildType> > children_;
-    const SafePtr<ChildType>& make_child(const BFSet& A, const BFSet& B, const BFSet& C, const BFSet& D, unsigned int m) {
-      const SafePtr<ChildType>& i = ChildType::Instance(A,B,C,D,m);
+    std::shared_ptr<TargetType> target_;
+    std::vector< std::shared_ptr<ChildType> > children_;
+    const std::shared_ptr<ChildType>& make_child(const BFSet& A, const BFSet& B, const BFSet& C, const BFSet& D, unsigned int m) {
+      const std::shared_ptr<ChildType>& i = ChildType::Instance(A,B,C,D,m);
       children_.push_back(i);
       return *(children_.end()-1);
     }
@@ -116,7 +116,7 @@ namespace libint2 {
     std::string generate_label() const override
     {
       typedef typename TargetType::AuxIndexType mType;
-      static SafePtr<mType> aux0(new mType(0u));
+      static std::shared_ptr<mType> aux0(new mType(0u));
       std::ostringstream os;
       // ITR recurrence relation code is independent of m (it never appears anywhere in equations), hence
       // to avoid generating identical code make sure that the (unique) label does not contain m
@@ -126,30 +126,30 @@ namespace libint2 {
 
 #if LIBINT_ENABLE_GENERIC_CODE
     /// Implementation of RecurrenceRelation::has_generic()
-    bool has_generic(const SafePtr<CompilationParameters>& cparams) const override;
+    bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const override;
     /// Implementation of RecurrenceRelation::generic_header()
     std::string generic_header() const override;
     /// Implementation of RecurrenceRelation::generic_instance()
-    std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const override;
+    std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const override;
 #endif
   };
 
   template <template <typename,typename,typename> class ERI, class F, int part, FunctionPosition where>
-    SafePtr< ITR_11_TwoPRep_11<ERI,F,part,where> >
-    ITR_11_TwoPRep_11<ERI,F,part,where>::Instance(const SafePtr<TargetType>& Tint,
+    std::shared_ptr< ITR_11_TwoPRep_11<ERI,F,part,where> >
+    ITR_11_TwoPRep_11<ERI,F,part,where>::Instance(const std::shared_ptr<TargetType>& Tint,
                                                   unsigned int dir)
     {
-      SafePtr<ThisType> this_ptr(new ThisType(Tint,dir));
+      std::shared_ptr<ThisType> this_ptr(new ThisType(Tint,dir));
       // Do post-construction duties
       if (this_ptr->num_children() != 0) {
         this_ptr->template register_with_rrstack<ThisType>();
         return this_ptr;
       }
-      return SafePtr<ThisType>();
+      return std::shared_ptr<ThisType>();
     }
 
   template <template <typename,typename,typename> class ERI, class F, int part, FunctionPosition where>
-    ITR_11_TwoPRep_11<ERI,F,part,where>::ITR_11_TwoPRep_11(const SafePtr<TargetType>& Tint,
+    ITR_11_TwoPRep_11<ERI,F,part,where>::ITR_11_TwoPRep_11(const std::shared_ptr<TargetType>& Tint,
                                                            unsigned int dir) :
     target_(Tint), dir_(dir)
     {
@@ -197,21 +197,21 @@ namespace libint2 {
         // must be (A0|C0)
         if (not (b.zero() && d.zero())) return;
 
-        const SafePtr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
+        const std::shared_ptr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
         if (is_simple()) { expr_ = Vector("TwoPRepITR_pfac0_0_0")[dir] * ABCD_m;  nflops_+=1; }
 
         const F& cp1 = c + _1;
-        const SafePtr<ChildType>& ABCp1D_m = make_child(a,b,cp1,d,m);
+        const std::shared_ptr<ChildType>& ABCp1D_m = make_child(a,b,cp1,d,m);
         if (is_simple()) { expr_ -= Scalar("eoz") * ABCp1D_m;  nflops_+=2; }
 
         const F& am1 = a - _1;
         if (exists(am1)) {
-          const SafePtr<ChildType>& Am1BCD_m = make_child(am1,b,c,d,m);
+          const std::shared_ptr<ChildType>& Am1BCD_m = make_child(am1,b,c,d,m);
           if (is_simple()) { expr_ += Scalar(a[dir]) * Scalar("oo2z") * Am1BCD_m;  nflops_+=3; }
         }
         const F& cm1 = c - _1;
         if (exists(cm1)) {
-          const SafePtr<ChildType>& ABCm1D_m = make_child(a,b,cm1,d,m);
+          const std::shared_ptr<ChildType>& ABCm1D_m = make_child(a,b,cm1,d,m);
           if (is_simple()) { expr_ += Scalar(c[dir]) * Scalar("oo2z") * ABCm1D_m;  nflops_+=3; }
         }
         return;
@@ -227,21 +227,21 @@ namespace libint2 {
         // must be (A0|C0)
         if (not (b.zero() && d.zero())) return;
 
-        const SafePtr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
+        const std::shared_ptr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
         if (is_simple()) { expr_ = Vector("TwoPRepITR_pfac0_1_0")[dir] * ABCD_m;  nflops_+=1; }
 
         const F& ap1 = a + _1;
-        const SafePtr<ChildType>& Ap1BCD_m = make_child(ap1,b,c,d,m);
+        const std::shared_ptr<ChildType>& Ap1BCD_m = make_child(ap1,b,c,d,m);
         if (is_simple()) { expr_ -= Scalar("zoe") * Ap1BCD_m;  nflops_+=2; }
 
         const F& cm1 = c - _1;
         if (exists(cm1)) {
-          const SafePtr<ChildType>& ABCm1D_m = make_child(a,b,cm1,d,m);
+          const std::shared_ptr<ChildType>& ABCm1D_m = make_child(a,b,cm1,d,m);
           if (is_simple()) { expr_ += Scalar(c[dir]) * Scalar("oo2e") * ABCm1D_m;  nflops_+=3; }
         }
         const F& am1 = a - _1;
         if (exists(am1)) {
-          const SafePtr<ChildType>& Am1BCD_m = make_child(am1,b,c,d,m);
+          const std::shared_ptr<ChildType>& Am1BCD_m = make_child(am1,b,c,d,m);
           if (is_simple()) { expr_ += Scalar(a[dir]) * Scalar("oo2e") * Am1BCD_m;  nflops_+=3; }
         }
         return;
@@ -257,21 +257,21 @@ namespace libint2 {
         // must be (0B|0D)
         if (not (a.zero() && c.zero())) return;
 
-        const SafePtr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
+        const std::shared_ptr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
         if (is_simple()) { expr_ = Vector("TwoPRepITR_pfac0_0_1")[dir] * ABCD_m;  nflops_+=1; }
 
         const F& dp1 = d + _1;
-        const SafePtr<ChildType>& ABCDp1_m = make_child(a,b,c,dp1,m);
+        const std::shared_ptr<ChildType>& ABCDp1_m = make_child(a,b,c,dp1,m);
         if (is_simple()) { expr_ -= Scalar("eoz") * ABCDp1_m;  nflops_+=2; }
 
         const F& bm1 = b - _1;
         if (exists(bm1)) {
-          const SafePtr<ChildType>& ABm1CD_m = make_child(a,bm1,c,d,m);
+          const std::shared_ptr<ChildType>& ABm1CD_m = make_child(a,bm1,c,d,m);
           if (is_simple()) { expr_ += Scalar(b[dir]) * Scalar("oo2z") * ABm1CD_m;  nflops_+=3; }
         }
         const F& dm1 = d - _1;
         if (exists(dm1)) {
-          const SafePtr<ChildType>& ABCDm1_m = make_child(a,b,c,dm1,m);
+          const std::shared_ptr<ChildType>& ABCDm1_m = make_child(a,b,c,dm1,m);
           if (is_simple()) { expr_ += Scalar(d[dir]) * Scalar("oo2z") * ABCDm1_m;  nflops_+=3; }
         }
         return;
@@ -287,21 +287,21 @@ namespace libint2 {
         // must be (0B|0D)
         if (not (a.zero() && c.zero())) return;
 
-        const SafePtr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
+        const std::shared_ptr<ChildType>& ABCD_m = make_child(a,b,c,d,m);
         if (is_simple()) { expr_ = Vector("TwoPRepITR_pfac0_1_1")[dir] * ABCD_m;  nflops_+=1; }
 
         const F& bp1 = b + _1;
-        const SafePtr<ChildType>& ABp1CD_m = make_child(a,bp1,c,d,m);
+        const std::shared_ptr<ChildType>& ABp1CD_m = make_child(a,bp1,c,d,m);
         if (is_simple()) { expr_ -= Scalar("zoe") * ABp1CD_m;  nflops_+=2; }
 
         const F& dm1 = d - _1;
         if (exists(dm1)) {
-          const SafePtr<ChildType>& ABCDm1_m = make_child(a,b,c,dm1,m);
+          const std::shared_ptr<ChildType>& ABCDm1_m = make_child(a,b,c,dm1,m);
           if (is_simple()) { expr_ += Scalar(d[dir]) * Scalar("oo2e") * ABCDm1_m;  nflops_+=3; }
         }
         const F& bm1 = b - _1;
         if (exists(bm1)) {
-          const SafePtr<ChildType>& ABm1CD_m = make_child(a,bm1,c,d,m);
+          const std::shared_ptr<ChildType>& ABm1CD_m = make_child(a,bm1,c,d,m);
           if (is_simple()) { expr_ += Scalar(b[dir]) * Scalar("oo2e") * ABm1CD_m;  nflops_+=3; }
         }
         return;
@@ -312,7 +312,7 @@ namespace libint2 {
 #if LIBINT_ENABLE_GENERIC_CODE
   template <template <typename,typename,typename> class ERI, class F, int part, FunctionPosition where>
   bool
-    ITR_11_TwoPRep_11<ERI,F,part,where>::has_generic(const SafePtr<CompilationParameters>& cparams) const
+    ITR_11_TwoPRep_11<ERI,F,part,where>::has_generic(const std::shared_ptr<CompilationParameters>& cparams) const
     {
       if (TrivialBFSet<F>::result)
         return false;
@@ -379,7 +379,7 @@ namespace libint2 {
 
   template <template <typename,typename,typename> class ERI, class F, int part, FunctionPosition where>
   std::string
-    ITR_11_TwoPRep_11<ERI,F,part,where>::generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const
+    ITR_11_TwoPRep_11<ERI,F,part,where>::generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const
     {
       std::ostringstream oss;
       F sh_a(target_->bra(0,0));
diff --git a/src/bin/libint/memory.cc b/src/bin/libint/memory.cc
index 7969243ca..38986073b 100644
--- a/src/bin/libint/memory.cc
+++ b/src/bin/libint/memory.cc
@@ -36,7 +36,7 @@ using namespace __gnu_cxx;
 #endif
 
 MemoryManager::MemoryManager(const Size& maxmem) :
-  maxmem_(maxmem), blks_(), superblock_(new MemBlock(Address(0),maxmem,true,SafePtr<MemBlock>(),SafePtr<MemBlock>())),
+  maxmem_(maxmem), blks_(), superblock_(new MemBlock(Address(0),maxmem,true,std::shared_ptr<MemBlock>(),std::shared_ptr<MemBlock>())),
   max_memory_used_(0)
 {
 }
@@ -46,8 +46,8 @@ MemoryManager::~MemoryManager()
   reset();
 }
 
-SafePtr<MemoryManager::MemBlock>
-MemoryManager::steal_from_block(const SafePtr<MemBlock>& blk, const Size& size)
+std::shared_ptr<MemoryManager::MemBlock>
+MemoryManager::steal_from_block(const std::shared_ptr<MemBlock>& blk, const Size& size)
 {
   if (!blk->free())
     throw std::runtime_error("MemoryManager::steal_from_block() -- block is not free");
@@ -64,8 +64,8 @@ MemoryManager::steal_from_block(const SafePtr<MemBlock>& blk, const Size& size)
   Address address = blk->address();
   blk->set_size(new_size);
   blk->set_address(address+size);
-  SafePtr<MemBlock> left = blk->left();
-  SafePtr<MemBlock> newblk(new MemBlock(address,size,false,left,blk));
+  std::shared_ptr<MemBlock> left = blk->left();
+  std::shared_ptr<MemBlock> newblk(new MemBlock(address,size,false,left,blk));
   if (left)
     left->right(newblk);
   blk->left(newblk);
@@ -76,7 +76,7 @@ MemoryManager::steal_from_block(const SafePtr<MemBlock>& blk, const Size& size)
   return newblk;
 }
 
-SafePtr<MemoryManager::MemBlock>
+std::shared_ptr<MemoryManager::MemBlock>
 MemoryManager::find_block(const Address& address)
 {
   typedef memblkset::iterator iter;
@@ -91,23 +91,23 @@ MemoryManager::find_block(const Address& address)
 void
 MemoryManager::free(const Address& address)
 {
-  SafePtr<MemBlock> blk = find_block(address);
+  std::shared_ptr<MemBlock> blk = find_block(address);
   if (!blk->free())
     blk->set_free(true);
   else
     throw std::runtime_error("WorstFitMemoryManager::free() tried to free a free block");
 
   // Find blocks adjacent to this one and, if they are free, merge them
-  SafePtr<MemBlock> left = blk->left();
-  SafePtr<MemBlock> right = blk->right();
+  std::shared_ptr<MemBlock> left = blk->left();
+  std::shared_ptr<MemBlock> right = blk->right();
   if (left && left->free())
     blk = merge_blocks(left,blk);
   if (right && right->free())
     merge_blocks(blk,right);
 }
 
-SafePtr<MemoryManager::MemBlock>
-MemoryManager::merge_blocks(const SafePtr<MemBlock>& left, const SafePtr<MemBlock>& right)
+std::shared_ptr<MemoryManager::MemBlock>
+MemoryManager::merge_blocks(const std::shared_ptr<MemBlock>& left, const std::shared_ptr<MemBlock>& right)
 {
   if (left->free() != right->free())
     throw std::runtime_error("MemoryManager::merge_block() -- both blocks must be occupied or free");
@@ -122,8 +122,8 @@ MemoryManager::merge_blocks(const SafePtr<MemBlock>& left, const SafePtr<MemBloc
   if (right == superblock())
     return merge_to_superblock(left);
   else {
-    SafePtr<MemBlock> lleft = left->left();
-    SafePtr<MemBlock> rright = right->right();
+    std::shared_ptr<MemBlock> lleft = left->left();
+    std::shared_ptr<MemBlock> rright = right->right();
 
     typedef memblkset::iterator iter;
     iter liter = find(blks_.begin(),blks_.end(),left);
@@ -137,7 +137,7 @@ MemoryManager::merge_blocks(const SafePtr<MemBlock>& left, const SafePtr<MemBloc
     else
       throw std::runtime_error("MemoryManager::merge_block() -- right block is not found");
 
-    SafePtr<MemBlock> newblk(new MemBlock(address,size,free,lleft,rright));
+    std::shared_ptr<MemBlock> newblk(new MemBlock(address,size,free,lleft,rright));
     blks_.push_back(newblk);
     if (lleft) {
       lleft->right(newblk);
@@ -150,10 +150,10 @@ MemoryManager::merge_blocks(const SafePtr<MemBlock>& left, const SafePtr<MemBloc
   }
 }
 
-SafePtr<MemoryManager::MemBlock>
-MemoryManager::merge_to_superblock(const SafePtr<MemBlock>& blk)
+std::shared_ptr<MemoryManager::MemBlock>
+MemoryManager::merge_to_superblock(const std::shared_ptr<MemBlock>& blk)
 {
-  SafePtr<MemBlock> sblk = superblock();
+  std::shared_ptr<MemBlock> sblk = superblock();
   typedef memblkset::iterator iter;
   iter biter = find(blks_.begin(),blks_.end(),blk);
   if (biter != blks_.end())
@@ -162,7 +162,7 @@ MemoryManager::merge_to_superblock(const SafePtr<MemBlock>& blk)
     throw std::runtime_error("MemoryManager::merge_to_superblock(blk) --  blk is not found");
   sblk->set_address(blk->address());
   sblk->set_size(sblk->size() + blk->size());
-  SafePtr<MemBlock> left = blk->left();
+  std::shared_ptr<MemBlock> left = blk->left();
   if (left)
     left->right(sblk);
   sblk->left(left);
@@ -180,16 +180,16 @@ MemoryManager::update_max_memory()
 void
 MemoryManager::reset()
 {
-  // for each block reset left and right pointers to break up cyclic dependencies that prevent automatic destruction of SafePtr-managed MemBlock objects
-  superblock_->left(SafePtr<MemBlock>());
-  superblock_->right(SafePtr<MemBlock>());
+  // for each block reset left and right pointers to break up cyclic dependencies that prevent automatic destruction of std::shared_ptr-managed MemBlock objects
+  superblock_->left(std::shared_ptr<MemBlock>());
+  superblock_->right(std::shared_ptr<MemBlock>());
   for(memblkset::iterator b=blks_.begin(); b!=blks_.end(); ++b) {
-    (*b)->left(SafePtr<MemBlock>());
-    (*b)->right(SafePtr<MemBlock>());
+    (*b)->left(std::shared_ptr<MemBlock>());
+    (*b)->right(std::shared_ptr<MemBlock>());
   }
   memblkset empty_blks;
   swap(blks_,empty_blks);
-  superblock_ = SafePtr<MemBlock>(new MemBlock(Address(0),maxmem_,true,SafePtr<MemBlock>(),SafePtr<MemBlock>()));
+  superblock_ = std::shared_ptr<MemBlock>(new MemBlock(Address(0),maxmem_,true,std::shared_ptr<MemBlock>(),std::shared_ptr<MemBlock>()));
 }
 
 ///////////////
@@ -239,7 +239,7 @@ WorstFitMemoryManager::alloc(const Size& size)
   }
 
   // find all free_blocks
-  std::list< SafePtr<MemBlock> > free_blks;
+  std::list< std::shared_ptr<MemBlock> > free_blks;
   for(iter b=blks.begin(); b!=blks.end(); b++) {
     b = find_if(b,blks.end(),&MemBlock::is_free);
     if (b != blks.end())
@@ -249,15 +249,15 @@ WorstFitMemoryManager::alloc(const Size& size)
   }
 
   // if no exact match found -- find the largest free block and grab memory from it
-  std::list< SafePtr<MemBlock> >::iterator largest_free_block = max_element(free_blks.begin(),free_blks.end(),&MemBlock::size_less_than);
+  std::list< std::shared_ptr<MemBlock> >::iterator largest_free_block = max_element(free_blks.begin(),free_blks.end(),&MemBlock::size_less_than);
   if (largest_free_block != free_blks.end() &&
       (*largest_free_block)->size() > size) {
-    SafePtr<MemBlock> result = steal_from_block(*largest_free_block,size);
+    std::shared_ptr<MemBlock> result = steal_from_block(*largest_free_block,size);
     return result->address();
   }
 
   // lastly, if all failed -- steal from the super block
-  SafePtr<MemBlock> result = steal_from_block(superblock(),size);
+  std::shared_ptr<MemBlock> result = steal_from_block(superblock(),size);
   return result->address();
 }
 
@@ -308,8 +308,8 @@ BestFitMemoryManager::alloc(const Size& size)
   }
 
   // find all free_blocks
-  std::list< SafePtr<MemBlock> > free_blks;
-  typedef std::list< SafePtr<MemBlock> >::iterator fiter;
+  std::list< std::shared_ptr<MemBlock> > free_blks;
+  typedef std::list< std::shared_ptr<MemBlock> >::iterator fiter;
   for(iter b=blks.begin(); b!=blks.end(); b++) {
     b = find_if(b,blks.end(),&MemBlock::is_free);
     if (b != blks.end())
@@ -320,7 +320,7 @@ BestFitMemoryManager::alloc(const Size& size)
 
   // if there are no free blocks left -- steal from the super block
   if (free_blks.empty()) {
-    SafePtr<MemBlock> result = steal_from_block(superblock(),size);
+    std::shared_ptr<MemBlock> result = steal_from_block(superblock(),size);
     return result->address();
   }
 
@@ -330,7 +330,7 @@ BestFitMemoryManager::alloc(const Size& size)
   do {
 
     if ((*smallest_free_block)->size() > size + tight_fit_) {
-      SafePtr<MemBlock> result = steal_from_block(*smallest_free_block,size);
+      std::shared_ptr<MemBlock> result = steal_from_block(*smallest_free_block,size);
       return result->address();
     }
     else {
@@ -342,7 +342,7 @@ BestFitMemoryManager::alloc(const Size& size)
   } while (smallest_free_block != free_blks.end());
 
   // Steal from superblock as a last resort
-  SafePtr<MemBlock> result = steal_from_block(superblock(),size);
+  std::shared_ptr<MemBlock> result = steal_from_block(superblock(),size);
   return result->address();
 
 }
@@ -401,7 +401,7 @@ FirstFitMemoryManager::alloc(const Size& size)
                            bind2nd(ptr_fun(MemBlock::size_geq),size),
                            &MemBlock::is_free));
     if (blk != blks.end()) {
-      SafePtr<MemBlock> result = steal_from_block(*blk,size);
+      std::shared_ptr<MemBlock> result = steal_from_block(*blk,size);
       return result->address();
     }
 #else
@@ -409,14 +409,14 @@ FirstFitMemoryManager::alloc(const Size& size)
     iter end = blks.end();
     for(iter b=begin; b!=end; b++) {
       if((*b)->size() >= size && (*b)->free()) {
-        SafePtr<MemBlock> result = steal_from_block(*b,size);
+        std::shared_ptr<MemBlock> result = steal_from_block(*b,size);
         return result->address();
       }
     }
 #endif
 
   // Steal from superblock as a last resort
-  SafePtr<MemBlock> result = steal_from_block(superblock(),size);
+  std::shared_ptr<MemBlock> result = steal_from_block(superblock(),size);
   return result->address();
 
 }
@@ -477,68 +477,68 @@ LastFitMemoryManager::alloc(const Size& size)
                            bind2nd(ptr_fun(MemBlock::size_geq),size),
                            &MemBlock::is_free));
     if (blk != rend) {
-      SafePtr<MemBlock> result = steal_from_block(*blk,size);
+      std::shared_ptr<MemBlock> result = steal_from_block(*blk,size);
       return result->address();
     }
 #else
     for(riter b=rbegin; b!=rend; b++) {
       if((*b)->size() >= size && (*b)->free()) {
-        SafePtr<MemBlock> result = steal_from_block(*b,size);
+        std::shared_ptr<MemBlock> result = steal_from_block(*b,size);
         return result->address();
       }
     }
 #endif
 
   // Steal from superblock as a last resort
-  SafePtr<MemBlock> result = steal_from_block(superblock(),size);
+  std::shared_ptr<MemBlock> result = steal_from_block(superblock(),size);
   return result->address();
 
 }
 
 //////////////
 
-SafePtr<MemoryManager>
+std::shared_ptr<MemoryManager>
 MemoryManagerFactory::memman(unsigned int type) const
 {
   switch (type) {
   case 0:
     {
-      SafePtr<MemoryManager> result(new WorstFitMemoryManager(true));
+      std::shared_ptr<MemoryManager> result(new WorstFitMemoryManager(true));
       return result;
     }
   case 1:
     {
-      SafePtr<MemoryManager> result(new WorstFitMemoryManager(false));
+      std::shared_ptr<MemoryManager> result(new WorstFitMemoryManager(false));
       return result;
     }
   case 2:
     {
-      SafePtr<MemoryManager> result(new BestFitMemoryManager(true));
+      std::shared_ptr<MemoryManager> result(new BestFitMemoryManager(true));
       return result;
     }
   case 3:
     {
-      SafePtr<MemoryManager> result(new BestFitMemoryManager(false));
+      std::shared_ptr<MemoryManager> result(new BestFitMemoryManager(false));
       return result;
     }
   case 4:
     {
-      SafePtr<MemoryManager> result(new FirstFitMemoryManager(true));
+      std::shared_ptr<MemoryManager> result(new FirstFitMemoryManager(true));
       return result;
     }
   case 5:
     {
-      SafePtr<MemoryManager> result(new FirstFitMemoryManager(false));
+      std::shared_ptr<MemoryManager> result(new FirstFitMemoryManager(false));
       return result;
     }
   case 6:
     {
-      SafePtr<MemoryManager> result(new LastFitMemoryManager(true));
+      std::shared_ptr<MemoryManager> result(new LastFitMemoryManager(true));
       return result;
     }
   case 7:
     {
-      SafePtr<MemoryManager> result(new LastFitMemoryManager(false));
+      std::shared_ptr<MemoryManager> result(new LastFitMemoryManager(false));
       return result;
     }
   default:
diff --git a/src/bin/libint/memory.h b/src/bin/libint/memory.h
index b26be8c9f..4d77f6d5c 100644
--- a/src/bin/libint/memory.h
+++ b/src/bin/libint/memory.h
@@ -38,8 +38,8 @@ namespace libint2 {
       typedef S Size;
 
       MemoryBlock(const Address& address, const Size& size, bool free,
-                  const SafePtr<MemoryBlock>& left,
-                  const SafePtr<MemoryBlock>& right) :
+                  const std::shared_ptr<MemoryBlock>& left,
+                  const std::shared_ptr<MemoryBlock>& right) :
         address_(address), size_(size), free_(free),
         left_(left), right_(right)
         {
@@ -69,13 +69,13 @@ namespace libint2 {
       /// Returns true if the block is free
       bool free() const { return free_; }
       /// Returns the left adjacent block
-      SafePtr<MemoryBlock> left() const { return left_; }
+      std::shared_ptr<MemoryBlock> left() const { return left_; }
       /// Returns the right adjacent block
-      SafePtr<MemoryBlock> right() const { return right_; }
+      std::shared_ptr<MemoryBlock> right() const { return right_; }
       /// Sets the left adjacent block
-      void left(const SafePtr<MemoryBlock>& l) { left_ = l; }
+      void left(const std::shared_ptr<MemoryBlock>& l) { left_ = l; }
       /// Sets the right adjacent block
-      void right(const SafePtr<MemoryBlock>& r) { right_ = r; }
+      void right(const std::shared_ptr<MemoryBlock>& r) { right_ = r; }
 
       /// Sets the address
       void set_address(const Address& address) { address_ = address; }
@@ -85,35 +85,35 @@ namespace libint2 {
       void set_free(bool free) { free_ = free; }
 
       /// Returns true if the size of *i is less than the size of *j
-      static bool size_less_than(const SafePtr<MemoryBlock>& i,
-                                 const SafePtr<MemoryBlock>& j) {
+      static bool size_less_than(const std::shared_ptr<MemoryBlock>& i,
+                                 const std::shared_ptr<MemoryBlock>& j) {
         return i->size() < j->size();
       }
       /** Returns true if the size of *i equals sz. Note that the arguments are
           not passed by reference since this function is designed to be converted
           to std::pointer_to_binary_function, which adds references to the arguments */
-      static bool size_eq(SafePtr<MemoryBlock> i, Size sz) {
+      static bool size_eq(std::shared_ptr<MemoryBlock> i, Size sz) {
         return i->size() == sz;
       }
       /** Returns true if the size of *i greater or equal than sz. Note that the arguments are
           not passed by reference since this function is designed to be converted
           to std::pointer_to_binary_function, which adds references to the arguments */
-      static bool size_geq(SafePtr<MemoryBlock> i, Size sz) {
+      static bool size_geq(std::shared_ptr<MemoryBlock> i, Size sz) {
         return i->size() >= sz;
       }
       /// Returns true if the address of *i is less than the address of *j
-      static bool address_less_than(const SafePtr<MemoryBlock>& i,
-                                    const SafePtr<MemoryBlock>& j) {
+      static bool address_less_than(const std::shared_ptr<MemoryBlock>& i,
+                                    const std::shared_ptr<MemoryBlock>& j) {
         return i->address() < j->address();
       }
       /** Returns true if the address of *i equals a. Note that the arguments are
           not passed by reference since this function is designed to be converted
           to std::pointer_to_binary_function, which adds references to the arguments */
-      static bool address_eq(SafePtr<MemoryBlock> i, Address a) {
+      static bool address_eq(std::shared_ptr<MemoryBlock> i, Address a) {
         return i->address() == a;
       }
       /// Returns true if *i is free
-      static bool is_free(const SafePtr<MemoryBlock>& i) {
+      static bool is_free(const std::shared_ptr<MemoryBlock>& i) {
         return i->free();
       }
 
@@ -131,8 +131,8 @@ namespace libint2 {
       Size size_;
       bool free_;
       typedef MemoryBlock<Address,Size> this_type;
-      SafePtr<this_type> left_;
-      SafePtr<MemoryBlock> right_;
+      std::shared_ptr<this_type> left_;
+      std::shared_ptr<MemoryBlock> right_;
 
       MemoryBlock();
     };
@@ -152,7 +152,7 @@ namespace libint2 {
     static const Address InvalidAddress = -1;
 
   protected:
-    typedef std::list< SafePtr<MemBlock> > memblkset;
+    typedef std::list< std::shared_ptr<MemBlock> > memblkset;
 
   private:
     /// Upper limit on the amount of memory this MemoryManager can handle
@@ -160,12 +160,12 @@ namespace libint2 {
     /// manages MemBlocks
     memblkset blks_;
     /// This block is guaranteed to be free until all memory is exhausted
-    SafePtr<MemBlock> superblock_;
+    std::shared_ptr<MemBlock> superblock_;
     /// Max amount of memory used
     Size max_memory_used_;
 
-    SafePtr<MemBlock> merge_blocks(const SafePtr<MemBlock>& left, const SafePtr<MemBlock>& right);
-    SafePtr<MemBlock> merge_to_superblock(const SafePtr<MemBlock>& blk);
+    std::shared_ptr<MemBlock> merge_blocks(const std::shared_ptr<MemBlock>& left, const std::shared_ptr<MemBlock>& right);
+    std::shared_ptr<MemBlock> merge_to_superblock(const std::shared_ptr<MemBlock>& blk);
     void update_max_memory();
 
 
@@ -190,11 +190,11 @@ namespace libint2 {
     /// Returns blocks
     memblkset& blocks() { return blks_;}
     /// Returns the superblock
-    SafePtr<MemBlock> superblock() const { return superblock_; }
+    std::shared_ptr<MemBlock> superblock() const { return superblock_; }
     /// steals size memory from block blk and returns the new block
-    SafePtr<MemBlock> steal_from_block(const SafePtr<MemBlock>& blk, const Size& size);
+    std::shared_ptr<MemBlock> steal_from_block(const std::shared_ptr<MemBlock>& blk, const Size& size);
     /// finds the block at Address a
-    SafePtr<MemBlock> find_block(const Address& a);
+    std::shared_ptr<MemBlock> find_block(const Address& a);
 
   };
 
@@ -277,7 +277,7 @@ namespace libint2 {
   class MemoryManagerFactory {
   public:
     static const unsigned int ntypes = 8;
-    SafePtr<MemoryManager> memman(unsigned int type) const;
+    std::shared_ptr<MemoryManager> memman(unsigned int type) const;
     std::string label(unsigned int type) const;
   };
 
diff --git a/src/bin/libint/oper.h b/src/bin/libint/oper.h
index 7df88319e..73b424d27 100644
--- a/src/bin/libint/oper.h
+++ b/src/bin/libint/oper.h
@@ -59,7 +59,7 @@ namespace libint2 {
 
   /** OperSet is the base class for all (sets of) operators.
      OperSet's must be constructable using
-     SafePtr<OperSet> or SafePtr<ConstructablePolymorphically>.
+     std::shared_ptr<OperSet> or std::shared_ptr<ConstructablePolymorphically>.
   */
   class OperSet : public ConstructablePolymorphically {
     public:
@@ -182,9 +182,9 @@ namespace libint2 {
       const Descr& descr() const { return descr_; }
 
       GenOper(Descr descr = Descr()) : descr_(descr) {}
-      GenOper(const SafePtr<GenOper>& o) : descr_(o->descr_) {}
-      GenOper(const SafePtr<OperSet>& o) : descr_(require_dynamic_cast<GenOper,OperSet>(o)->descr_) {}
-      GenOper(const SafePtr<ConstructablePolymorphically>& o) : descr_(require_dynamic_cast<GenOper,ConstructablePolymorphically>(o)->descr_) {}
+      GenOper(const std::shared_ptr<GenOper>& o) : descr_(o->descr_) {}
+      GenOper(const std::shared_ptr<OperSet>& o) : descr_(require_dynamic_cast<GenOper,OperSet>(o)->descr_) {}
+      GenOper(const std::shared_ptr<ConstructablePolymorphically>& o) : descr_(require_dynamic_cast<GenOper,ConstructablePolymorphically>(o)->descr_) {}
       explicit GenOper(const ConstructablePolymorphically& o) : descr_(require_dynamic_cast<GenOper,ConstructablePolymorphically>(&o)->descr_) {}
       virtual ~GenOper() {}
 
diff --git a/src/bin/libint/policy.h b/src/bin/libint/policy.h
index 65368355f..db81e00f9 100644
--- a/src/bin/libint/policy.h
+++ b/src/bin/libint/policy.h
@@ -130,12 +130,12 @@ namespace libint2 {
       typedef typename TDPol<T>::obj_type obj_type;
       typedef typename obj_type::iter_type subobj_type;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, const vector< SafePtr<subobj_type> >& subobj)
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, const vector< std::shared_ptr<subobj_type> >& subobj)
       {
         TDPol<T>::init_subobj(obj,subobj);
       }
 
-      static void dealloc_subobj(const vector< SafePtr<subobj_type> >& subobj)
+      static void dealloc_subobj(const vector< std::shared_ptr<subobj_type> >& subobj)
       {
         TDPol<T>::dealloc_subobj(subobj);
       }
@@ -143,7 +143,7 @@ namespace libint2 {
 
      private:
      /// Returns whether to unroll an IntegralSet
-     bool can_unroll_intset(const SafePtr<T>& iset)
+     bool can_unroll_intset(const std::shared_ptr<T>& iset)
      {
        return iset->set_size() <= TIPol::max_set_size_to_unroll();
      }
diff --git a/src/bin/libint/policy_spec.h b/src/bin/libint/policy_spec.h
index c98beb858..3792f72ba 100644
--- a/src/bin/libint/policy_spec.h
+++ b/src/bin/libint/policy_spec.h
@@ -115,7 +115,7 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         std::vector< SubIterator* > siters_inord; // subiterators used to iterate over each set (in the above order)
 	typedef std::vector< std::vector< SubIterator* > > bra_siters_type;
@@ -178,7 +178,7 @@ namespace libint2 {
           }
 
           // construct this subobj
-	  SafePtr<subobj_type> curr_subobj_sptr = subobj_type::Instance(bra,ket,aux,oper);
+	  std::shared_ptr<subobj_type> curr_subobj_sptr = subobj_type::Instance(bra,ket,aux,oper);
           subobj.push_back(curr_subobj_sptr);
 
           // update subiterators to refer to the next element
@@ -228,7 +228,7 @@ namespace libint2 {
       }
 
       // Nothing is done here because GenIntegralSet objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr<subobj_type> >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr<subobj_type> >& subobj) {
       }
     };
 
@@ -244,20 +244,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get(), *curr_gis_ptr->oper().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because GenIntegralSet_1_1 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< subobj_type > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< subobj_type > >& subobj) {
       }
     };
 #endif // LIBINT_SUPPORT_ONEBODYINTS
@@ -273,20 +273,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get(), *curr_gis_ptr->oper().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because GenIntegralSet_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< subobj_type > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< subobj_type > >& subobj) {
       }
     };
 
@@ -305,20 +305,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename TwoPRep_11_11<BFS>::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename TwoPRep_11_11<BFS>::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because TwoPRep_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< TwoPRep_11_11<typename BFS::iter_type> > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< TwoPRep_11_11<typename BFS::iter_type> > >& subobj) {
       }
     };
 #endif
@@ -337,20 +337,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because R12kG12_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< R12kG12_11_11<typename BFS::iter_type,K> > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< R12kG12_11_11<typename BFS::iter_type,K> > >& subobj) {
       }
     };
 
@@ -369,20 +369,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because TiG12_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< TiG12_11_11<typename BFS::iter_type,K> > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< TiG12_11_11<typename BFS::iter_type,K> > >& subobj) {
       }
     };
 
@@ -401,20 +401,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because R1dotR1G12_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< R1dotR1G12_11_11<typename BFS::iter_type> > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< R1dotR1G12_11_11<typename BFS::iter_type> > >& subobj) {
       }
     };
 
@@ -432,20 +432,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because R2dotR2G12_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< R2dotR2G12_11_11<typename BFS::iter_type> > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< R2dotR2G12_11_11<typename BFS::iter_type> > >& subobj) {
       }
     };
 
@@ -463,20 +463,20 @@ namespace libint2 {
       /// how these subobjects are stored
       typedef typename TypeTraits<subobj_type>::StorageType subobj_stype;
 
-      static void init_subobj(const SafePtr<obj_type>& obj, std::vector< SafePtr<subobj_type> >& subobj) {
+      static void init_subobj(const std::shared_ptr<obj_type>& obj, std::vector< std::shared_ptr<subobj_type> >& subobj) {
 
         // Iterate over all SubIteratorBase<GenIntegralSet::iter_type>
         parent_siter gis_siter(obj);
         for(gis_siter.init(); gis_siter; ++gis_siter) {
-          const SafePtr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
-          const SafePtr<subobj_type> curr_subobj =
+          const std::shared_ptr<typename obj_type::parent_type::iter_type> curr_gis_ptr = gis_siter.elem();
+          const std::shared_ptr<subobj_type> curr_subobj =
             subobj_type::Instance(curr_gis_ptr->bra(), curr_gis_ptr->ket(), *curr_gis_ptr->aux().get());
           subobj.push_back(curr_subobj);
         }
       }
 
       // Nothing is done here because R1dotR2G12_11_11 objects are Singleton-like and don't need to be destroyed
-      static void dealloc_subobj(std::vector< SafePtr< R1dotR2G12_11_11<typename BFS::iter_type> > >& subobj) {
+      static void dealloc_subobj(std::vector< std::shared_ptr< R1dotR2G12_11_11<typename BFS::iter_type> > >& subobj) {
       }
     };
 
diff --git a/src/bin/libint/polyconstr.h b/src/bin/libint/polyconstr.h
index 026b63127..8552fcee6 100644
--- a/src/bin/libint/polyconstr.h
+++ b/src/bin/libint/polyconstr.h
@@ -25,8 +25,8 @@
 namespace libint2 {
 
   /** ConstructablePolymorphically is a base for all objects
-      which can be constructed using a SafePtr to a base or a
-      SafePtr to ConstructablePolymorphically.
+      which can be constructed using a std::shared_ptr to a base or a
+      std::shared_ptr to ConstructablePolymorphically.
   */
   class ConstructablePolymorphically {
   protected:
diff --git a/src/bin/libint/prefactors.cc b/src/bin/libint/prefactors.cc
index eb686a14e..8a2b2b1c3 100644
--- a/src/bin/libint/prefactors.cc
+++ b/src/bin/libint/prefactors.cc
@@ -28,8 +28,8 @@ Prefactors::Prefactors() :
   rho(new rdouble("rho")),
   one_o_2alphasum(new rdouble("oo2ze"))
 {
-  typedef SafePtr<rdouble> rdptr;
-  typedef SafePtr<rdouble> cdptr;
+  typedef std::shared_ptr<rdouble> rdptr;
+  typedef std::shared_ptr<rdouble> cdptr;
 
   char XY[np][2] = { "P", "Q" };
   char X[np][2][2] = { {"A", "B"},
@@ -210,7 +210,7 @@ Prefactors::~Prefactors()
 }
 
 #if CTIMEENTITIES_SINGLETONS
-SafePtr<Prefactors::cdouble>
+std::shared_ptr<Prefactors::cdouble>
 Prefactors::Cdouble(double a)
 {
   return prefactor::Scalar(a);
diff --git a/src/bin/libint/prefactors.h b/src/bin/libint/prefactors.h
index 51542fd5d..82ec68b90 100644
--- a/src/bin/libint/prefactors.h
+++ b/src/bin/libint/prefactors.h
@@ -53,17 +53,17 @@ namespace libint2 {
        X-Y vectors, where X and Y are for the same particle:
        X_Y[0] = AB, X_Y[1] = CD, etc.
      */
-    SafePtr<rdouble> vX_Y[np];
+    std::shared_ptr<rdouble> vX_Y[np];
     /// Cartesian components of X-Y vectors
-    SafePtr<rdouble> X_Y[np][3];
+    std::shared_ptr<rdouble> X_Y[np][3];
 
     /**
        Y-X vectors, where X and Y are for the same particle:
        Y_X[0] = BA, Y_X[1] = DC, etc.
      */
-    SafePtr<rdouble> vY_X[np];
+    std::shared_ptr<rdouble> vY_X[np];
     /// Cartesian components of Y_X vectors
-    SafePtr<rdouble> Y_X[np][3];
+    std::shared_ptr<rdouble> Y_X[np][3];
 
     /**
        XY-X vectors:
@@ -72,50 +72,50 @@ namespace libint2 {
        Hence, vXY_X[0][0] = P-A, vXY_X[1][0] = Q-C,
        vXY_X[0][1] = P-B, and vXY_X[1][1] = Q-D.
     */
-    SafePtr<rdouble> vXY_X[np][2];
+    std::shared_ptr<rdouble> vXY_X[np][2];
     /// cartesian components of vXY_X vector
-    SafePtr<rdouble> XY_X[np][2][3];
+    std::shared_ptr<rdouble> XY_X[np][2][3];
     /**
        W-XY vectors:
        vW_XY[0] = W-P, vW_XY[1] = W-Q.
     */
-    SafePtr<rdouble> vW_XY[np];
+    std::shared_ptr<rdouble> vW_XY[np];
     /// cartesian components of W_XY vector
-    SafePtr<rdouble> W_XY[np][3];
+    std::shared_ptr<rdouble> W_XY[np][3];
 
     /**
        orbital exponents
     */
-    SafePtr<rdouble> zeta[np][2];
+    std::shared_ptr<rdouble> zeta[np][2];
     /**
        squared orbital exponents
     */
-    SafePtr<rdouble> zeta2[np][2];
+    std::shared_ptr<rdouble> zeta2[np][2];
 
     /**
        alpha12[p] is the sum of exponents for particle p:
        alpha12[0] = zeta,
        alpha12[1] = eta.
     */
-    SafePtr<rdouble> alpha12[np];
+    std::shared_ptr<rdouble> alpha12[np];
     /// rho = zeta*eta/(zeta+eta)
-    SafePtr<rdouble> rho;
+    std::shared_ptr<rdouble> rho;
     /// 1/(2*alpha12)
-    SafePtr<rdouble> one_o_2alpha12[np];
+    std::shared_ptr<rdouble> one_o_2alpha12[np];
     /// rho/alpha12
-    SafePtr<rdouble> rho_o_alpha12[np];
+    std::shared_ptr<rdouble> rho_o_alpha12[np];
     /// 1/(2*(zeta+eta))
-    SafePtr<rdouble> one_o_2alphasum;
+    std::shared_ptr<rdouble> one_o_2alphasum;
 
     /**
     Prefactors for the ITR relation for TwoPRep integrals (a+1 0|c0):
     */
     /// prefactor in front of (a0|c0) = -(zeta[0][1] AB + zeta[1][1] CD)/alpha12[0]
-    SafePtr<rdouble> TwoPRepITR_vpfac0[np];
+    std::shared_ptr<rdouble> TwoPRepITR_vpfac0[np];
     /// cartesian components of pfac0 vector
-    SafePtr<rdouble> TwoPRepITR_pfac0[np][3];
+    std::shared_ptr<rdouble> TwoPRepITR_pfac0[np][3];
     /// prefactor in front of (a0|c+1 0) = -alpha12[1]/alpha12[0]
-    SafePtr<rdouble> TwoPRepITR_pfac1[np];
+    std::shared_ptr<rdouble> TwoPRepITR_pfac1[np];
     /// prefactor in front of (a-1 0|c0) is one_o_2alpha12[0]
     /// prefactor in front of (a0|c-1 0) is one_o_2alpha12[0]
 
@@ -123,32 +123,32 @@ namespace libint2 {
        Prefactors for the VRR relation for R12_k_G12 integrals (k>=0):
     */
     /// prefactor in front of (a0|c0)
-    SafePtr<rdouble> R12kG12VRR_vpfac0[np];
+    std::shared_ptr<rdouble> R12kG12VRR_vpfac0[np];
     /// cartesian components of pfac0 vector
-    SafePtr<rdouble> R12kG12VRR_pfac0[np][3];
+    std::shared_ptr<rdouble> R12kG12VRR_pfac0[np][3];
     /// prefactor in front of (a-1 0|c0)
-    SafePtr<rdouble> R12kG12VRR_pfac1[np];
+    std::shared_ptr<rdouble> R12kG12VRR_pfac1[np];
     /// prefactor in front of (a0|c-1 0)
-    SafePtr<rdouble> R12kG12VRR_pfac2;
+    std::shared_ptr<rdouble> R12kG12VRR_pfac2;
     /// prefactor in front of (|k-2|)
-    SafePtr<rdouble> R12kG12VRR_pfac3[np];
+    std::shared_ptr<rdouble> R12kG12VRR_pfac3[np];
     /// prefactor in front of (a0|k-2|c0)
-    SafePtr<rdouble> R12kG12VRR_vpfac4[np];
+    std::shared_ptr<rdouble> R12kG12VRR_vpfac4[np];
     /// cartesian components of pfac4 vector
-    SafePtr<rdouble> R12kG12VRR_pfac4[np][3];
+    std::shared_ptr<rdouble> R12kG12VRR_pfac4[np][3];
 
     /**
      * Precomputed 1-d integrals
      */
     /// (0|0)_xyz 1-d overlap integrals
-    SafePtr<rdouble> Overlap00_1d[3];
+    std::shared_ptr<rdouble> Overlap00_1d[3];
 
 
 #if CTIMEENTITIES_SINGLETONS
     /// integers represented as doubles
-    SafePtr<cdouble> N_i[NMAX];
+    std::shared_ptr<cdouble> N_i[NMAX];
 
-    SafePtr<cdouble> Cdouble(double a);
+    std::shared_ptr<cdouble> Cdouble(double a);
 #endif
 
   private:
@@ -161,35 +161,35 @@ namespace libint2 {
 
     template <typename T> struct RTimeSingletons {
       typedef SingletonStack<RTimeEntity<T>,typename RTimeEntity<T>::key_type> ManagerType;
-      static SafePtr<ManagerType>& Manager() {
+      static std::shared_ptr<ManagerType>& Manager() {
         if (manager_ == 0) {
-          manager_ = SafePtr<ManagerType>(new ManagerType(&RTimeEntity<T>::key));
+          manager_ = std::shared_ptr<ManagerType>(new ManagerType(&RTimeEntity<T>::key));
         }
         return manager_;
       }
-      static SafePtr<ManagerType> manager_;
+      static std::shared_ptr<ManagerType> manager_;
     };
-    template <typename T> SafePtr<typename RTimeSingletons<T>::ManagerType> RTimeSingletons<T>::manager_;
+    template <typename T> std::shared_ptr<typename RTimeSingletons<T>::ManagerType> RTimeSingletons<T>::manager_;
 
 #if CTIMEENTITIES_SINGLETONS
     template <typename T> struct CTimeSingletons {
       typedef SingletonStack<CTimeEntity<T>,T> ManagerType;
-      static SafePtr<ManagerType>& Manager() {
+      static std::shared_ptr<ManagerType>& Manager() {
         if (manager_ == 0) {
-          manager_ = SafePtr<ManagerType>(new ManagerType(&CTimeEntity<T>::value));
+          manager_ = std::shared_ptr<ManagerType>(new ManagerType(&CTimeEntity<T>::value));
         }
         return manager_;
       }
-      static SafePtr<ManagerType> manager_;
+      static std::shared_ptr<ManagerType> manager_;
     };
-    template <typename T> SafePtr<typename CTimeSingletons<T>::ManagerType> CTimeSingletons<T>::manager_;
+    template <typename T> std::shared_ptr<typename CTimeSingletons<T>::ManagerType> CTimeSingletons<T>::manager_;
 #endif
 
     /// make a floating-point compile-time quantity from an integer
     template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
-    SafePtr< CTimeEntity<double> > Scalar(T a) {
+    std::shared_ptr< CTimeEntity<double> > Scalar(T a) {
       typedef CTimeEntity<double> return_type;
-      SafePtr<return_type> tmp(new return_type(a));
+      std::shared_ptr<return_type> tmp(new return_type(a));
 #if CTIMEENTITIES_SINGLETONS
       typedef CTimeSingletons<double> singletons_type;
       typedef typename singletons_type::ManagerType ManagerType;
@@ -200,9 +200,9 @@ namespace libint2 {
 #endif
     }
     /// make a compile-time quantity
-    inline SafePtr< CTimeEntity<double> > Scalar(double a) {
+    inline std::shared_ptr< CTimeEntity<double> > Scalar(double a) {
       typedef CTimeEntity<double> return_type;
-      SafePtr<return_type> tmp(new return_type(a));
+      std::shared_ptr<return_type> tmp(new return_type(a));
 #if CTIMEENTITIES_SINGLETONS
       typedef CTimeSingletons<double> singletons_type;
       typedef typename singletons_type::ManagerType ManagerType;
@@ -213,22 +213,22 @@ namespace libint2 {
 #endif
     }
     /// make a runtime quantity
-//    inline SafePtr< RTimeEntity<double> > Scalar(const char* id) {
+//    inline std::shared_ptr< RTimeEntity<double> > Scalar(const char* id) {
 //      typedef double T;
 //      typedef RTimeEntity<T> return_type;
 //      typedef RTimeSingletons<T> singletons_type;
 //      typedef singletons_type::ManagerType ManagerType;
-//      SafePtr<return_type> tmp(new return_type(id));
+//      std::shared_ptr<return_type> tmp(new return_type(id));
 //      const ManagerType::value_type& result = singletons_type::Manager()->find(tmp);
 //      return result.second;
 //    }
     /// make a runtime quantity
-    inline SafePtr< RTimeEntity<double> > Scalar(const std::string& id) {
+    inline std::shared_ptr< RTimeEntity<double> > Scalar(const std::string& id) {
       typedef double T;
       typedef RTimeEntity<T> return_type;
       typedef RTimeSingletons<T> singletons_type;
       typedef singletons_type::ManagerType ManagerType;
-      SafePtr<return_type> tmp(new return_type(id));
+      std::shared_ptr<return_type> tmp(new return_type(id));
       const ManagerType::value_type& result = singletons_type::Manager()->find(tmp);
       return result.second;
     }
@@ -238,7 +238,7 @@ namespace libint2 {
     public:
       RTimeVector3(const char* id) : id_(id) { }
       RTimeVector3(const std::string& id) : id_(id) { }
-      SafePtr< RTimeEntity<T> > operator[](unsigned int xyz) {
+      std::shared_ptr< RTimeEntity<T> > operator[](unsigned int xyz) {
         return Scalar(id_ + "_" + dirchar[xyz]);
       }
       private:
@@ -253,7 +253,7 @@ namespace libint2 {
       CTimeVector3(const T* val) {
         for(int xyz=0; xyz<3; ++xyz) val_[xyz] = val[xyz];
       }
-      SafePtr< CTimeEntity<T> > operator[](unsigned int xyz) {
+      std::shared_ptr< CTimeEntity<T> > operator[](unsigned int xyz) {
         return Scalar(val_[xyz]);
       }
       private:
diff --git a/src/bin/libint/quanta.h b/src/bin/libint/quanta.h
index 39a4e7e4a..a875929cd 100644
--- a/src/bin/libint/quanta.h
+++ b/src/bin/libint/quanta.h
@@ -31,7 +31,7 @@ namespace libint2 {
 
   /** QuantumSet is the base class for all (sets of) quantum numbers.
       QuantumSet's must be constructable using
-      SafePtr<QuantumSet> or SafePtr<ConstructablePolymorphically>.
+      std::shared_ptr<QuantumSet> or std::shared_ptr<ConstructablePolymorphically>.
   */
   class QuantumSet : public ConstructablePolymorphically,
                      public Hashable<LIBINT2_UINT_LEAST64,ComputeKey> {
@@ -63,9 +63,9 @@ namespace libint2 {
     typedef QuantumNumbers iter_type;
 
     QuantumNumbers(const std::vector<T>& qn);
-    QuantumNumbers(const SafePtr<QuantumNumbers>&);
-    QuantumNumbers(const SafePtr<QuantumSet>&);
-    QuantumNumbers(const SafePtr<ConstructablePolymorphically>&);
+    QuantumNumbers(const std::shared_ptr<QuantumNumbers>&);
+    QuantumNumbers(const std::shared_ptr<QuantumSet>&);
+    QuantumNumbers(const std::shared_ptr<ConstructablePolymorphically>&);
     QuantumNumbers(const ConstructablePolymorphically&);
     ~QuantumNumbers();
 
@@ -125,30 +125,30 @@ namespace libint2 {
     }
 
   template<typename T, unsigned int N>
-    QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<QuantumNumbers>& sptr) :
+    QuantumNumbers<T,N>::QuantumNumbers(const std::shared_ptr<QuantumNumbers>& sptr) :
     qn_(sptr->qn_)
     {
     }
 
   template<typename T, unsigned int N>
-    QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<QuantumSet>& sptr)
+    QuantumNumbers<T,N>::QuantumNumbers(const std::shared_ptr<QuantumSet>& sptr)
     {
-      const SafePtr< QuantumNumbers<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbers,QuantumSet>(sptr);
+      const std::shared_ptr< QuantumNumbers<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbers,QuantumSet>(sptr);
 #if CHECK_SAFETY
       if (sptr_cast == 0)
-        throw std::runtime_error("QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<QuantumSet>& sptr) -- type of sptr is incompatible with QuantumNumbers");
+        throw std::runtime_error("QuantumNumbers<T,N>::QuantumNumbers(const std::shared_ptr<QuantumSet>& sptr) -- type of sptr is incompatible with QuantumNumbers");
 #endif
 
       qn_ = sptr_cast->qn_;
     }
 
   template<typename T, unsigned int N>
-    QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<ConstructablePolymorphically>& sptr)
+    QuantumNumbers<T,N>::QuantumNumbers(const std::shared_ptr<ConstructablePolymorphically>& sptr)
     {
-      const SafePtr< QuantumNumbers<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbers,ConstructablePolymorphically>(sptr);
+      const std::shared_ptr< QuantumNumbers<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbers,ConstructablePolymorphically>(sptr);
 #if CHECK_SAFETY
       if (sptr_cast == 0)
-        throw std::runtime_error("QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<ConstructablePolymorphically>& sptr) -- type of sptr is incompatible with QuantumNumbers");
+        throw std::runtime_error("QuantumNumbers<T,N>::QuantumNumbers(const std::shared_ptr<ConstructablePolymorphically>& sptr) -- type of sptr is incompatible with QuantumNumbers");
 #endif
 
       qn_ = sptr_cast->qn_;
@@ -207,9 +207,9 @@ namespace libint2 {
     QuantumNumbersA(const T& val);
     QuantumNumbersA(const T* qn);
     QuantumNumbersA(const std::vector<T>& qn);
-    QuantumNumbersA(const SafePtr<QuantumNumbersA>&);
-    QuantumNumbersA(const SafePtr<QuantumSet>&);
-    QuantumNumbersA(const SafePtr<ConstructablePolymorphically>&);
+    QuantumNumbersA(const std::shared_ptr<QuantumNumbersA>&);
+    QuantumNumbersA(const std::shared_ptr<QuantumSet>&);
+    QuantumNumbersA(const std::shared_ptr<ConstructablePolymorphically>&);
     ~QuantumNumbersA();
 
     bool operator==(const QuantumNumbersA&) const;
@@ -288,7 +288,7 @@ namespace libint2 {
     }
 
   template<typename T, unsigned int N>
-    QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<QuantumNumbersA>& sptr)
+    QuantumNumbersA<T,N>::QuantumNumbersA(const std::shared_ptr<QuantumNumbersA>& sptr)
     {
       T* qn = sptr->qn_;
       for(unsigned int i=0; i<N; i++)
@@ -296,12 +296,12 @@ namespace libint2 {
     }
 
   template<typename T, unsigned int N>
-    QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<QuantumSet>& sptr)
+    QuantumNumbersA<T,N>::QuantumNumbersA(const std::shared_ptr<QuantumSet>& sptr)
     {
-      const SafePtr< QuantumNumbersA<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbersA,QuantumSet>(sptr);
+      const std::shared_ptr< QuantumNumbersA<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbersA,QuantumSet>(sptr);
 #if CHECK_SAFETY
       if (sptr_cast == 0)
-        throw std::runtime_error("QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<QuantumSet>& sptr) -- type of sptr is incompatible with QuantumNumbersA");
+        throw std::runtime_error("QuantumNumbersA<T,N>::QuantumNumbersA(const std::shared_ptr<QuantumSet>& sptr) -- type of sptr is incompatible with QuantumNumbersA");
 #endif
 
       T* qn = sptr_cast->qn_;
@@ -310,12 +310,12 @@ namespace libint2 {
     }
 
   template<typename T, unsigned int N>
-    QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<ConstructablePolymorphically>& sptr)
+    QuantumNumbersA<T,N>::QuantumNumbersA(const std::shared_ptr<ConstructablePolymorphically>& sptr)
     {
-      const SafePtr< QuantumNumbersA<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbersA,ConstructablePolymorphically>(sptr);
+      const std::shared_ptr< QuantumNumbersA<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbersA,ConstructablePolymorphically>(sptr);
 #if CHECK_SAFETY
       if (sptr_cast == 0)
-        throw std::runtime_error("QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<ConstructablePolymorphically>& sptr) -- type of sptr is incompatible with QuantumNumbersA");
+        throw std::runtime_error("QuantumNumbersA<T,N>::QuantumNumbersA(const std::shared_ptr<ConstructablePolymorphically>& sptr) -- type of sptr is incompatible with QuantumNumbersA");
 #endif
       T* qn = sptr_cast->qn_;
       for(int i=0; i<N; i++)
@@ -365,9 +365,9 @@ namespace libint2 {
     QuantumNumbersA() {}
     QuantumNumbersA(const T* qn) {}
     QuantumNumbersA(const std::vector<T>& qn) {}
-    QuantumNumbersA(const SafePtr<QuantumNumbersA>&) {}
-    QuantumNumbersA(const SafePtr<QuantumSet>&) {}
-    QuantumNumbersA(const SafePtr<ConstructablePolymorphically>&) {}
+    QuantumNumbersA(const std::shared_ptr<QuantumNumbersA>&) {}
+    QuantumNumbersA(const std::shared_ptr<QuantumSet>&) {}
+    QuantumNumbersA(const std::shared_ptr<ConstructablePolymorphically>&) {}
     ~QuantumNumbersA() {}
 
     bool operator==(const QuantumNumbersA&) const { return true; }
diff --git a/src/bin/libint/r1dotr1g12_11_11.h b/src/bin/libint/r1dotr1g12_11_11.h
index 2e7eaf462..ce00b4b68 100644
--- a/src/bin/libint/r1dotr1g12_11_11.h
+++ b/src/bin/libint/r1dotr1g12_11_11.h
@@ -55,9 +55,9 @@ namespace libint2 {
       /* This "constructor" takes basis function sets, in Mulliken ordering.
          Returns a pointer to a unique instance, a la Singleton
       */
-      static const SafePtr<R1dotR1G12_11_11> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1);
+      static const std::shared_ptr<R1dotR1G12_11_11> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1);
       /// Returns a pointer to a unique instance, a la Singleton
-      static const SafePtr<R1dotR1G12_11_11> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux);
+      static const std::shared_ptr<R1dotR1G12_11_11> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux);
       ~R1dotR1G12_11_11();
 
       /// Comparison operator
@@ -116,14 +116,14 @@ namespace libint2 {
     }
 
   template <class BFS>
-    const SafePtr< R1dotR1G12_11_11<BFS> >
+    const std::shared_ptr< R1dotR1G12_11_11<BFS> >
     R1dotR1G12_11_11<BFS>::Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux)
     {
       typedef typename SingletonManagerType::value_type map_value_type;
       key_type key = compute_key(OperType(),bra,ket,aux);
       const map_value_type& val = singl_manager_.find(key);
       if (!val.second) {
-	SafePtr<R1dotR1G12_11_11> this_int(new R1dotR1G12_11_11<BFS>(bra,ket,aux));
+	std::shared_ptr<R1dotR1G12_11_11> this_int(new R1dotR1G12_11_11<BFS>(bra,ket,aux));
 	// Use singl_manager_ to make sure this is a new object of this type
 	const typename SingletonManagerType::value_type& val = singl_manager_.find(this_int);
 	val.second->instid_ = val.first;
@@ -133,7 +133,7 @@ namespace libint2 {
     }
 
   template <class BFS>
-    const SafePtr< R1dotR1G12_11_11<BFS> >
+    const std::shared_ptr< R1dotR1G12_11_11<BFS> >
     R1dotR1G12_11_11<BFS>::Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1)
     {
 #if USE_BRAKET_H
@@ -143,7 +143,7 @@ namespace libint2 {
       BFSRef ket0_ref(ket0);
       BFSRef ket1_ref(ket1);
 #else
-      typedef SafePtr<BFS> BFSRef;
+      typedef std::shared_ptr<BFS> BFSRef;
       BFSRef bra0_ref(new BFS(bra0));
       BFSRef bra1_ref(new BFS(bra1));
       BFSRef ket0_ref(new BFS(ket0));
diff --git a/src/bin/libint/r1dotr2g12_11_11.h b/src/bin/libint/r1dotr2g12_11_11.h
index 29f864f79..609be3232 100644
--- a/src/bin/libint/r1dotr2g12_11_11.h
+++ b/src/bin/libint/r1dotr2g12_11_11.h
@@ -63,9 +63,9 @@ namespace libint2 {
       /* This "constructor" takes basis function sets, in Mulliken ordering.
          Returns a pointer to a unique instance, a la Singleton
       */
-      static const SafePtr<R1dotR2G12_11_11> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1);
+      static const std::shared_ptr<R1dotR2G12_11_11> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1);
       /// Returns a pointer to a unique instance, a la Singleton
-      static const SafePtr<R1dotR2G12_11_11> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux);
+      static const std::shared_ptr<R1dotR2G12_11_11> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux);
       ~R1dotR2G12_11_11();
 
       /// Comparison operator
@@ -124,14 +124,14 @@ namespace libint2 {
     }
 
   template <class BFS>
-    const SafePtr< R1dotR2G12_11_11<BFS> >
+    const std::shared_ptr< R1dotR2G12_11_11<BFS> >
     R1dotR2G12_11_11<BFS>::Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux)
     {
       typedef typename SingletonManagerType::value_type map_value_type;
       key_type key = compute_key(OperType(),bra,ket,aux);
       const map_value_type& val = singl_manager_.find(key);
       if (!val.second) {
-	SafePtr<R1dotR2G12_11_11> this_int(new R1dotR2G12_11_11<BFS>(bra,ket,aux));
+	std::shared_ptr<R1dotR2G12_11_11> this_int(new R1dotR2G12_11_11<BFS>(bra,ket,aux));
 	// Use singl_manager_ to make sure this is a new object of this type
 	const typename SingletonManagerType::value_type& val = singl_manager_.find(this_int);
 	val.second->instid_ = val.first;
@@ -141,7 +141,7 @@ namespace libint2 {
     }
 
   template <class BFS>
-    const SafePtr< R1dotR2G12_11_11<BFS> >
+    const std::shared_ptr< R1dotR2G12_11_11<BFS> >
     R1dotR2G12_11_11<BFS>::Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1)
     {
 #if USE_BRAKET_H
@@ -151,7 +151,7 @@ namespace libint2 {
       BFSRef ket0_ref(ket0);
       BFSRef ket1_ref(ket1);
 #else
-      typedef SafePtr<BFS> BFSRef;
+      typedef std::shared_ptr<BFS> BFSRef;
       BFSRef bra0_ref(new BFS(bra0));
       BFSRef bra1_ref(new BFS(bra1));
       BFSRef ket0_ref(new BFS(ket0));
diff --git a/src/bin/libint/r2dotr2g12_11_11.h b/src/bin/libint/r2dotr2g12_11_11.h
index f51487f69..c81dc5a5c 100644
--- a/src/bin/libint/r2dotr2g12_11_11.h
+++ b/src/bin/libint/r2dotr2g12_11_11.h
@@ -55,9 +55,9 @@ namespace libint2 {
       /* This "constructor" takes basis function sets, in Mulliken ordering.
          Returns a pointer to a unique instance, a la Singleton
       */
-      static const SafePtr<R2dotR2G12_11_11> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1);
+      static const std::shared_ptr<R2dotR2G12_11_11> Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1);
       /// Returns a pointer to a unique instance, a la Singleton
-      static const SafePtr<R2dotR2G12_11_11> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux);
+      static const std::shared_ptr<R2dotR2G12_11_11> Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux);
       ~R2dotR2G12_11_11();
 
       /// Comparison operator
@@ -116,14 +116,14 @@ namespace libint2 {
     }
 
   template <class BFS>
-    const SafePtr< R2dotR2G12_11_11<BFS> >
+    const std::shared_ptr< R2dotR2G12_11_11<BFS> >
     R2dotR2G12_11_11<BFS>::Instance(const BraType& bra, const KetType& ket, const AuxIndexType& aux)
     {
       typedef typename SingletonManagerType::value_type map_value_type;
       key_type key = compute_key(OperType(),bra,ket,aux);
       const map_value_type& val = singl_manager_.find(key);
       if (!val.second) {
-	SafePtr<R2dotR2G12_11_11> this_int(new R2dotR2G12_11_11<BFS>(bra,ket,aux));
+	std::shared_ptr<R2dotR2G12_11_11> this_int(new R2dotR2G12_11_11<BFS>(bra,ket,aux));
 	// Use singl_manager_ to make sure this is a new object of this type
 	const typename SingletonManagerType::value_type& val = singl_manager_.find(this_int);
 	val.second->instid_ = val.first;
@@ -133,7 +133,7 @@ namespace libint2 {
     }
 
   template <class BFS>
-    const SafePtr< R2dotR2G12_11_11<BFS> >
+    const std::shared_ptr< R2dotR2G12_11_11<BFS> >
     R2dotR2G12_11_11<BFS>::Instance(const BFS& bra0, const BFS& ket0, const BFS& bra1, const BFS& ket1)
     {
 #if USE_BRAKET_H
@@ -143,7 +143,7 @@ namespace libint2 {
       BFSRef ket0_ref(ket0);
       BFSRef ket1_ref(ket1);
 #else
-      typedef SafePtr<BFS> BFSRef;
+      typedef std::shared_ptr<BFS> BFSRef;
       BFSRef bra0_ref(new BFS(bra0));
       BFSRef bra1_ref(new BFS(bra1));
       BFSRef ket0_ref(new BFS(ket0));
diff --git a/src/bin/libint/rr.cc b/src/bin/libint/rr.cc
index 1759ca8b6..37ee29b1b 100644
--- a/src/bin/libint/rr.cc
+++ b/src/bin/libint/rr.cc
@@ -56,8 +56,8 @@ RecurrenceRelation::~RecurrenceRelation()
 // 5) call dg->generate_code()
 //
 void
-RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
-                                  const SafePtr<ImplicitDimensions>& dims,
+RecurrenceRelation::generate_code(const std::shared_ptr<CodeContext>& context,
+                                  const std::shared_ptr<ImplicitDimensions>& dims,
                                   const std::string& funcname,
                                   std::ostream& decl, std::ostream& def)
 {
@@ -69,13 +69,13 @@ RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
     return;
   }
 
-  const SafePtr<DGVertex> target_vptr = rr_target();
+  const std::shared_ptr<DGVertex> target_vptr = rr_target();
 #if DEBUG
   std::cout << "RecurrenceRelation::generate_code: target = " << target_vptr->label() << std::endl;
 #endif
 
-  const SafePtr<CompilationParameters>& cparams = context->cparams();
-  SafePtr<DirectedGraph> dg(new DirectedGraph);
+  const std::shared_ptr<CompilationParameters>& cparams = context->cparams();
+  std::shared_ptr<DirectedGraph> dg(new DirectedGraph);
   dg->set_label(context->label_to_name(label_to_funcname(funcname)));
   generate_graph_(dg);
 
@@ -86,7 +86,7 @@ RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
 
   // check if CSE to be performed
   typedef IntegralSet<IncableBFSet> ISet;
-  SafePtr<ISet> target = dynamic_pointer_cast<ISet,DGVertex>(target_vptr);
+  std::shared_ptr<ISet> target = dynamic_pointer_cast<ISet,DGVertex>(target_vptr);
   if (target) {
     //
     // do CSE only if max_am <= cparams->max_am_opt()
@@ -127,7 +127,7 @@ RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
 #endif
 
   // Assign symbols for the target and source integral sets
-  SafePtr<CodeSymbols> symbols(new CodeSymbols);
+  std::shared_ptr<CodeSymbols> symbols(new CodeSymbols);
   assign_symbols_(symbols);
   // Traverse the graph
   dg->optimize_rr_out(context);
@@ -139,12 +139,12 @@ RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
     }
 #endif
   // Generate code
-  SafePtr<MemoryManager> memman(new WorstFitMemoryManager());
-  SafePtr<ImplicitDimensions> localdims = adapt_dims_(dims);
+  std::shared_ptr<MemoryManager> memman(new WorstFitMemoryManager());
+  std::shared_ptr<ImplicitDimensions> localdims = adapt_dims_(dims);
   dg->generate_code(context,memman,localdims,symbols,funcname,decl,def);
 
   // extract all external symbols -- these will be members of the evaluator structure
-  SafePtr<ExtractExternSymbols> extractor(new ExtractExternSymbols);
+  std::shared_ptr<ExtractExternSymbols> extractor(new ExtractExternSymbols);
   dg->foreach(*extractor);
   const ExtractExternSymbols::Symbols& externsymbols = extractor->symbols();
 
@@ -174,7 +174,7 @@ RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
   typedef LibraryTaskManager::TasksCIter tciter;
   const tciter tend = taskmgr.plast();
   for(tciter t=taskmgr.first(); t!=tend; ++t) {
-    const SafePtr<TaskExternSymbols> tsymbols = t->symbols();
+    const std::shared_ptr<TaskExternSymbols> tsymbols = t->symbols();
     if (tsymbols->find(myid)) {
       // update max stack size
       t->params()->max_vector_stack_size(memman->max_memory_used());
@@ -188,25 +188,25 @@ RecurrenceRelation::generate_code(const SafePtr<CodeContext>& context,
 
 namespace libint2 {
   // generate_generic_code reuses this function from dg.cc:
-  extern std::string declare_function(const SafePtr<CodeContext>& context, const SafePtr<ImplicitDimensions>& dims,
-                                      const SafePtr<CodeSymbols>& args, const std::string& tlabel, const std::string& function_descr,
+  extern std::string declare_function(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<ImplicitDimensions>& dims,
+                                      const std::shared_ptr<CodeSymbols>& args, const std::string& tlabel, const std::string& function_descr,
                                       std::ostream& decl);
 }
 
 void
-RecurrenceRelation::generate_generic_code(const SafePtr<CodeContext>& context,
-                                          const SafePtr<ImplicitDimensions>& dims,
+RecurrenceRelation::generate_generic_code(const std::shared_ptr<CodeContext>& context,
+                                          const std::shared_ptr<ImplicitDimensions>& dims,
                                           const std::string& funcname,
                                           std::ostream& decl, std::ostream& def)
 {
-  const SafePtr<DGVertex> target_vptr = rr_target();
+  const std::shared_ptr<DGVertex> target_vptr = rr_target();
   std::cout << "RecurrenceRelation::generate_generic_code: target = " << target_vptr->label() << std::endl;
 
   LibraryTaskManager& taskmgr = LibraryTaskManager::Instance();
   const std::string tlabel = taskmgr.current().label();
-  SafePtr<ImplicitDimensions> localdims = adapt_dims_(dims);
+  std::shared_ptr<ImplicitDimensions> localdims = adapt_dims_(dims);
   // Assign symbols for the target and source integral sets
-  SafePtr<CodeSymbols> symbols(new CodeSymbols);
+  std::shared_ptr<CodeSymbols> symbols(new CodeSymbols);
   assign_symbols_(symbols);
 
   // declare function
@@ -237,8 +237,8 @@ RecurrenceRelation::generate_generic_code(const SafePtr<CodeContext>& context,
   def << context->code_postfix();
 }
 
-SafePtr<DirectedGraph>
-RecurrenceRelation::generate_graph_(const SafePtr<DirectedGraph>& dg)
+std::shared_ptr<DirectedGraph>
+RecurrenceRelation::generate_graph_(const std::shared_ptr<DirectedGraph>& dg)
 {
   dg->append_target(rr_target());
   for(unsigned int c=0; c<num_children(); c++)
@@ -246,8 +246,8 @@ RecurrenceRelation::generate_graph_(const SafePtr<DirectedGraph>& dg)
 #if DEBUG
   cout << "RecurrenceRelation::generate_code -- the number of integral sets = " << dg->num_vertices() << endl;
 #endif
-  SafePtr<Strategy> strat(new Strategy);
-  SafePtr<Tactic> ntactic(new NullTactic);
+  std::shared_ptr<Strategy> strat(new Strategy);
+  std::shared_ptr<Tactic> ntactic(new NullTactic);
   // Always need to unroll integral sets first
   dg->registry()->unroll_threshold(std::numeric_limits<unsigned int>::max());
   dg->apply(strat,ntactic);
@@ -259,7 +259,7 @@ RecurrenceRelation::generate_graph_(const SafePtr<DirectedGraph>& dg)
     dg->apply_at<&DGVertex::not_need_to_compute>(rr_child(c));
   // Apply recurrence relations using existing vertices on the graph (i.e.
   // such that no new vertices appear)
-  SafePtr<Tactic> ztactic(new FewestNewVerticesTactic(dg));
+  std::shared_ptr<Tactic> ztactic(new FewestNewVerticesTactic(dg));
   dg->apply(strat,ztactic);
 #if DEBUG
   cout << "RecurrenceRelation::generate_code -- should be same as previous = " << dg->num_vertices() << endl;
@@ -269,7 +269,7 @@ RecurrenceRelation::generate_graph_(const SafePtr<DirectedGraph>& dg)
 }
 
 void
-RecurrenceRelation::assign_symbols_(SafePtr<CodeSymbols>& symbols)
+RecurrenceRelation::assign_symbols_(std::shared_ptr<CodeSymbols>& symbols)
 {
   // Set symbols on the target and children sets
   rr_target()->set_symbol("target");
@@ -283,8 +283,8 @@ RecurrenceRelation::assign_symbols_(SafePtr<CodeSymbols>& symbols)
   }
 }
 
-SafePtr<ImplicitDimensions>
-RecurrenceRelation::adapt_dims_(const SafePtr<ImplicitDimensions>& dims) const
+std::shared_ptr<ImplicitDimensions>
+RecurrenceRelation::adapt_dims_(const std::shared_ptr<ImplicitDimensions>& dims) const
 {
   return dims;
 }
@@ -304,7 +304,7 @@ RecurrenceRelation::description() const
 }
 
 void
-RecurrenceRelation::add_expr(const SafePtr<ExprType>& expr, int minus)
+RecurrenceRelation::add_expr(const std::shared_ptr<ExprType>& expr, int minus)
 {
   if (expr_ == 0) {
     if (minus != -1) {
@@ -312,19 +312,19 @@ RecurrenceRelation::add_expr(const SafePtr<ExprType>& expr, int minus)
     }
     else {
       using libint2::prefactor::Scalar;
-      SafePtr<ExprType> negative(new ExprType(ExprType::OperatorTypes::Times,expr,Scalar(-1.0)));
+      std::shared_ptr<ExprType> negative(new ExprType(ExprType::OperatorTypes::Times,expr,Scalar(-1.0)));
       expr_ = negative;
       ++nflops_;
     }
   }
   else {
     if (minus != -1) {
-      SafePtr<ExprType> sum(new ExprType(ExprType::OperatorTypes::Plus,expr_,expr));
+      std::shared_ptr<ExprType> sum(new ExprType(ExprType::OperatorTypes::Plus,expr_,expr));
       expr_ = sum;
       ++nflops_;
     }
     else {
-      SafePtr<ExprType> sum(new ExprType(ExprType::OperatorTypes::Minus,expr_,expr));
+      std::shared_ptr<ExprType> sum(new ExprType(ExprType::OperatorTypes::Minus,expr_,expr));
       expr_ = sum;
       ++nflops_;
     }
@@ -339,7 +339,7 @@ RecurrenceRelation::invariant_type() const {
 }
 
 std::string
-RecurrenceRelation::spfunction_call(const SafePtr<CodeContext>& context, const SafePtr<ImplicitDimensions>& dims) const
+RecurrenceRelation::spfunction_call(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<ImplicitDimensions>& dims) const
 {
   ostringstream os;
   os << context->label_to_name(label_to_funcname(context->cparams()->api_prefix() + label()))
@@ -357,7 +357,7 @@ RecurrenceRelation::spfunction_call(const SafePtr<CodeContext>& context, const S
 }
 
 bool
-RecurrenceRelation::has_generic(const SafePtr<CompilationParameters>& cparams) const {
+RecurrenceRelation::has_generic(const std::shared_ptr<CompilationParameters>& cparams) const {
   return false;
 }
 
@@ -367,7 +367,7 @@ RecurrenceRelation::generic_header() const {
 }
 
 std::string
-RecurrenceRelation::generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const {
+RecurrenceRelation::generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const {
   throw std::logic_error("RecurrenceRelation::generic_instance() -- should not be called! Check if DerivedRecurrenceRelation::generic_instance() is implemented");
 }
 
@@ -383,59 +383,59 @@ RecurrenceRelation::size_of_children() const {
 
 namespace libint2 { namespace algebra {
   /// these operators are extremely useful to write compact expressions
-  SafePtr<RecurrenceRelation::ExprType> operator+(const SafePtr<DGVertex>& A,
-                                                  const SafePtr<DGVertex>& B) {
+  std::shared_ptr<RecurrenceRelation::ExprType> operator+(const std::shared_ptr<DGVertex>& A,
+                                                  const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
-    return SafePtr<Oper>(new Oper(Oper::OperatorTypes::Plus,A,B));
+    return std::shared_ptr<Oper>(new Oper(Oper::OperatorTypes::Plus,A,B));
   }
-  SafePtr<RecurrenceRelation::ExprType> operator-(const SafePtr<DGVertex>& A,
-                                                  const SafePtr<DGVertex>& B) {
+  std::shared_ptr<RecurrenceRelation::ExprType> operator-(const std::shared_ptr<DGVertex>& A,
+                                                  const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
-    return SafePtr<Oper>(new Oper(Oper::OperatorTypes::Minus,A,B));
+    return std::shared_ptr<Oper>(new Oper(Oper::OperatorTypes::Minus,A,B));
   }
-  SafePtr<RecurrenceRelation::ExprType> operator*(const SafePtr<DGVertex>& A,
-                                                  const SafePtr<DGVertex>& B) {
+  std::shared_ptr<RecurrenceRelation::ExprType> operator*(const std::shared_ptr<DGVertex>& A,
+                                                  const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
-    return SafePtr<Oper>(new Oper(Oper::OperatorTypes::Times,A,B));
+    return std::shared_ptr<Oper>(new Oper(Oper::OperatorTypes::Times,A,B));
   }
-  SafePtr<RecurrenceRelation::ExprType> operator/(const SafePtr<DGVertex>& A,
-                                                  const SafePtr<DGVertex>& B) {
+  std::shared_ptr<RecurrenceRelation::ExprType> operator/(const std::shared_ptr<DGVertex>& A,
+                                                  const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
-    return SafePtr<Oper>(new Oper(Oper::OperatorTypes::Divide,A,B));
+    return std::shared_ptr<Oper>(new Oper(Oper::OperatorTypes::Divide,A,B));
   }
-  const SafePtr<RecurrenceRelation::ExprType>& operator+=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                          const SafePtr<DGVertex>& B) {
+  const std::shared_ptr<RecurrenceRelation::ExprType>& operator+=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                          const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
     if (A) {
-      const SafePtr<Oper>& Sum = A + B;
+      const std::shared_ptr<Oper>& Sum = A + B;
       A = Sum;
     }
     else
       A = Scalar(0) + B;
     return A;
   }
-  const SafePtr<RecurrenceRelation::ExprType>& operator-=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                          const SafePtr<DGVertex>& B) {
+  const std::shared_ptr<RecurrenceRelation::ExprType>& operator-=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                          const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
     if (A) {
-      const SafePtr<Oper>& Diff = A - B;
+      const std::shared_ptr<Oper>& Diff = A - B;
       A = Diff;
     }
     else
       A = Scalar(0) - B;
     return A;
   }
-  const SafePtr<RecurrenceRelation::ExprType>& operator*=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                          const SafePtr<DGVertex>& B) {
+  const std::shared_ptr<RecurrenceRelation::ExprType>& operator*=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                          const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
-    const SafePtr<Oper>& Product = A * B;
+    const std::shared_ptr<Oper>& Product = A * B;
     A = Product;
     return A;
   }
-  const SafePtr<RecurrenceRelation::ExprType>& operator/=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                          const SafePtr<DGVertex>& B) {
+  const std::shared_ptr<RecurrenceRelation::ExprType>& operator/=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                          const std::shared_ptr<DGVertex>& B) {
     typedef RecurrenceRelation::ExprType Oper;
-    const SafePtr<Oper>& Quotient = A / B;
+    const std::shared_ptr<Oper>& Quotient = A / B;
     A = Quotient;
     return A;
   }
diff --git a/src/bin/libint/rr.h b/src/bin/libint/rr.h
index 879952175..3a125b8f8 100644
--- a/src/bin/libint/rr.h
+++ b/src/bin/libint/rr.h
@@ -52,7 +52,7 @@ namespace libint2 {
   {
   private:
 
-    static SafePtr<RRStackBase<RR> > rrstack_;
+    static std::shared_ptr<RRStackBase<RR> > rrstack_;
 
     // private constructor because it's a Singleton
     RRStackBase() : parent_type(& RR::label) {}
@@ -66,9 +66,9 @@ namespace libint2 {
     typedef typename parent_type::InstanceID InstanceID;
 
     /// Obtain the unique Instance of RRStack
-    static SafePtr<RRStackBase<RR> >& Instance() {
+    static std::shared_ptr<RRStackBase<RR> >& Instance() {
       if (!rrstack_) {
-        SafePtr<RRStackBase<RR> > tmpstack(new RRStackBase<RR>);
+        std::shared_ptr<RRStackBase<RR> > tmpstack(new RRStackBase<RR>);
         rrstack_ = tmpstack;
       }
       return rrstack_;
@@ -77,7 +77,7 @@ namespace libint2 {
     virtual ~RRStackBase() {}
 
     /// adds content of rrs to this stack
-    void add(const SafePtr<RRStackBase<RR> >& rrs) {
+    void add(const std::shared_ptr<RRStackBase<RR> >& rrs) {
       for(citer_type it=rrs->begin(); it != rrs->end(); it++) {
         find((*it).second.second);
       }
@@ -90,7 +90,7 @@ namespace libint2 {
   };
 
   template <typename RR>
-  SafePtr<RRStackBase<RR> > RRStackBase<RR>::rrstack_;
+  std::shared_ptr<RRStackBase<RR> > RRStackBase<RR>::rrstack_;
 
 
   /**
@@ -110,15 +110,15 @@ namespace libint2 {
     */
     virtual unsigned int num_children() const =0;
     /// Returns i-th child
-    virtual SafePtr<DGVertex> rr_child(unsigned int i) const =0;
+    virtual std::shared_ptr<DGVertex> rr_child(unsigned int i) const =0;
     /// Returns the target
-    virtual SafePtr<DGVertex> rr_target() const =0;
+    virtual std::shared_ptr<DGVertex> rr_target() const =0;
 
     /** Numerical expression of a recurrence relation is always expressed as
         an AlgebraicOperator<DGVertex> */
     typedef AlgebraicOperator<DGVertex> ExprType;
     /// Returns the expression
-    const SafePtr<ExprType>& rr_expr() const { return expr_; }
+    const std::shared_ptr<ExprType>& rr_expr() const { return expr_; }
 
     /**
        Returns true is this recurrence relation is simple enough to optimize away.
@@ -158,21 +158,21 @@ namespace libint2 {
     virtual std::string description() const;
 
     /// Generate declaration and definition for the recurrence relation
-    virtual void generate_code(const SafePtr<CodeContext>& context,
-                               const SafePtr<ImplicitDimensions>& dims,
+    virtual void generate_code(const std::shared_ptr<CodeContext>& context,
+                               const std::shared_ptr<ImplicitDimensions>& dims,
                                const std::string& funcname,
                                std::ostream& decl, std::ostream& def);
 
     /// Generate declaration and definition for the recurrence relation
     /// using generic code (typically, a manually written code)
-    virtual void generate_generic_code(const SafePtr<CodeContext>& context,
-                                       const SafePtr<ImplicitDimensions>& dims,
+    virtual void generate_generic_code(const std::shared_ptr<CodeContext>& context,
+                                       const std::shared_ptr<ImplicitDimensions>& dims,
                                        const std::string& funcname,
                                        std::ostream& decl, std::ostream& def);
 
     /// Generate a callback for this recurrence relation
-    virtual std::string spfunction_call(const SafePtr<CodeContext>& context,
-                                        const SafePtr<ImplicitDimensions>& dims) const;
+    virtual std::string spfunction_call(const std::shared_ptr<CodeContext>& context,
+                                        const std::shared_ptr<ImplicitDimensions>& dims) const;
 
     /// Return the number of FLOPs per this recurrence relation
     unsigned int nflops() const { return nflops_; }
@@ -183,9 +183,9 @@ namespace libint2 {
     protected:
     unsigned int nflops_;
     mutable std::string label_;
-    SafePtr<ExprType> expr_;
+    std::shared_ptr<ExprType> expr_;
     /// Adds a (or -a, if minus = -1) to expr_.
-    void add_expr(const SafePtr<ExprType>& a, int minus=1);
+    void add_expr(const std::shared_ptr<ExprType>& a, int minus=1);
     /// Generates the label
     virtual std::string generate_label() const =0;
     /// Registers with the stack
@@ -193,8 +193,8 @@ namespace libint2 {
       // only register RRs with for shell sets
       if (TrivialBFSet<typename RR::BasisFunctionType>::result)
         return false;
-      SafePtr<RRStackBase<RecurrenceRelation> > rrstack = RRStackBase<RecurrenceRelation>::Instance();
-      SafePtr<RR> this_ptr =
+      std::shared_ptr<RRStackBase<RecurrenceRelation> > rrstack = RRStackBase<RecurrenceRelation>::Instance();
+      std::shared_ptr<RR> this_ptr =
         const_pointer_cast<RR,const RR>(
           static_pointer_cast<const RR, const RecurrenceRelation>(
             std::enable_shared_from_this<RecurrenceRelation>::shared_from_this()
@@ -210,52 +210,52 @@ namespace libint2 {
 
     /** used by generate_code to initialize the computation graph that computes sets of integrals using the RR
     */
-    SafePtr<DirectedGraph> generate_graph_(const SafePtr<DirectedGraph>& dg);
+    std::shared_ptr<DirectedGraph> generate_graph_(const std::shared_ptr<DirectedGraph>& dg);
     /** assigns "target" symbol to the target vertex and "src<i>" to the i-th child vertex. Also
         appends these symbols to S. */
-    void assign_symbols_(SafePtr<CodeSymbols>& S);
+    void assign_symbols_(std::shared_ptr<CodeSymbols>& S);
     /** given an ImplicitDimension for the computation, adapt it for this recurrence
         relation. Default version does not do anything. */
-    virtual SafePtr<ImplicitDimensions> adapt_dims_(const SafePtr<ImplicitDimensions>& dims) const;
+    virtual std::shared_ptr<ImplicitDimensions> adapt_dims_(const std::shared_ptr<ImplicitDimensions>& dims) const;
 
     /// does this recurrent relation have a generic equivalent? Default is no.
-    virtual bool has_generic(const SafePtr<CompilationParameters>& cparams) const;
+    virtual bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const;
     /// return the name of a header file with the declaration of the generic code
     virtual std::string generic_header() const;
     /// return the implementation of this recurrence relation in terms of generic code
-    virtual std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const;
+    virtual std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const;
 
   };
 
   namespace algebra {
     /// these operators are extremely useful to write compact expressions
-    SafePtr<RecurrenceRelation::ExprType> operator+(const SafePtr<DGVertex>& A,
-                                                    const SafePtr<DGVertex>& B);
-    SafePtr<RecurrenceRelation::ExprType> operator-(const SafePtr<DGVertex>& A,
-                                                    const SafePtr<DGVertex>& B);
-    SafePtr<RecurrenceRelation::ExprType> operator*(const SafePtr<DGVertex>& A,
-                                                    const SafePtr<DGVertex>& B);
-    SafePtr<RecurrenceRelation::ExprType> operator/(const SafePtr<DGVertex>& A,
-                                                    const SafePtr<DGVertex>& B);
-    const SafePtr<RecurrenceRelation::ExprType>& operator+=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                            const SafePtr<DGVertex>& B);
-    const SafePtr<RecurrenceRelation::ExprType>& operator-=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                            const SafePtr<DGVertex>& B);
-    const SafePtr<RecurrenceRelation::ExprType>& operator*=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                            const SafePtr<DGVertex>& B);
-    const SafePtr<RecurrenceRelation::ExprType>& operator/=(SafePtr<RecurrenceRelation::ExprType>& A,
-                                                            const SafePtr<DGVertex>& B);
+    std::shared_ptr<RecurrenceRelation::ExprType> operator+(const std::shared_ptr<DGVertex>& A,
+                                                    const std::shared_ptr<DGVertex>& B);
+    std::shared_ptr<RecurrenceRelation::ExprType> operator-(const std::shared_ptr<DGVertex>& A,
+                                                    const std::shared_ptr<DGVertex>& B);
+    std::shared_ptr<RecurrenceRelation::ExprType> operator*(const std::shared_ptr<DGVertex>& A,
+                                                    const std::shared_ptr<DGVertex>& B);
+    std::shared_ptr<RecurrenceRelation::ExprType> operator/(const std::shared_ptr<DGVertex>& A,
+                                                    const std::shared_ptr<DGVertex>& B);
+    const std::shared_ptr<RecurrenceRelation::ExprType>& operator+=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                            const std::shared_ptr<DGVertex>& B);
+    const std::shared_ptr<RecurrenceRelation::ExprType>& operator-=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                            const std::shared_ptr<DGVertex>& B);
+    const std::shared_ptr<RecurrenceRelation::ExprType>& operator*=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                            const std::shared_ptr<DGVertex>& B);
+    const std::shared_ptr<RecurrenceRelation::ExprType>& operator/=(std::shared_ptr<RecurrenceRelation::ExprType>& A,
+                                                            const std::shared_ptr<DGVertex>& B);
 
     class Entity;
     template <class T> class RTimeEntity;
     template <class T> class CTimeEntity;
     // seems to confound Intel compiler on Linux?
-    //SafePtr<RecurrenceRelation::ExprType> operator*(const SafePtr<Entity>& A,
-    //                                                const SafePtr<DGVertex>& B);
-    template<typename T> SafePtr<RecurrenceRelation::ExprType> operator*(const SafePtr<RTimeEntity<T> >& A,
-                                                                         const SafePtr<DGVertex>& B);
-    template<typename T> SafePtr<RecurrenceRelation::ExprType> operator*(const SafePtr<CTimeEntity<T> >& A,
-                                                                         const SafePtr<DGVertex>& B);
+    //std::shared_ptr<RecurrenceRelation::ExprType> operator*(const std::shared_ptr<Entity>& A,
+    //                                                const std::shared_ptr<DGVertex>& B);
+    template<typename T> std::shared_ptr<RecurrenceRelation::ExprType> operator*(const std::shared_ptr<RTimeEntity<T> >& A,
+                                                                         const std::shared_ptr<DGVertex>& B);
+    template<typename T> std::shared_ptr<RecurrenceRelation::ExprType> operator*(const std::shared_ptr<CTimeEntity<T> >& A,
+                                                                         const std::shared_ptr<DGVertex>& B);
   };
 
   // Instantiate the RRStack
diff --git a/src/bin/libint/singl_stack.h b/src/bin/libint/singl_stack.h
index c50f029f8..75fcd60aa 100644
--- a/src/bin/libint/singl_stack.h
+++ b/src/bin/libint/singl_stack.h
@@ -44,10 +44,10 @@ namespace libint2 {
   {
   public:
     typedef KeyType key_type;
-    typedef SafePtr<T> data_type;
+    typedef std::shared_ptr<T> data_type;
     /// Specifies type for the instance index variables
     typedef KeyTypes::InstanceID InstanceID;
-    typedef std::pair<InstanceID,SafePtr<T> > value_type;
+    typedef std::pair<InstanceID,std::shared_ptr<T> > value_type;
     typedef std::map<key_type,value_type> map_type;
     /// use iter_type objects to iterate over the stack
     typedef typename map_type::iterator iter_type;
@@ -77,7 +77,7 @@ namespace libint2 {
           if found -- returns the pointer to the corresponding object on ostack_,
           otherwise pushes obj to the end of ostack_ and returns obj.
      */
-    const value_type& find(const SafePtr<T>& obj) {
+    const value_type& find(const std::shared_ptr<T>& obj) {
       key_type key = ((obj.get())->*callback_)();
 
       typedef typename map_type::iterator miter;
@@ -103,7 +103,7 @@ namespace libint2 {
           else returns a null value_type.
      */
     const value_type& find(const key_type& key) {
-      static value_type null_value(make_pair(InstanceID(0),SafePtr<T>()));
+      static value_type null_value(make_pair(InstanceID(0),std::shared_ptr<T>()));
       typedef typename map_type::iterator miter;
       miter pos = map_.find(key);
       if (pos != map_.end()) {
@@ -119,7 +119,7 @@ namespace libint2 {
           else returns a null value_type.
      */
     const value_type& find_hashed(const InstanceID& hashed_key) const {
-      static value_type null_value(make_pair(InstanceID(0),SafePtr<T>()));
+      static value_type null_value(make_pair(InstanceID(0),std::shared_ptr<T>()));
       for(auto& i: map_) {
         if (i.second.first == hashed_key)
           return i.second;
@@ -129,7 +129,7 @@ namespace libint2 {
 
     /** Searches for obj on the stack and, if found, removes the unique instance
      */
-    void remove(const SafePtr<T>& obj) {
+    void remove(const std::shared_ptr<T>& obj) {
       key_type key = ((obj.get())->*callback_)();
 
       typedef typename map_type::iterator miter;
diff --git a/src/bin/libint/smart_ptr.h b/src/bin/libint/smart_ptr.h
index fd2700710..514a7d449 100644
--- a/src/bin/libint/smart_ptr.h
+++ b/src/bin/libint/smart_ptr.h
@@ -25,32 +25,31 @@
 #include <memory>
 
 namespace libint2 {
-template<typename T> using SafePtr = std::shared_ptr<T>;
 using std::const_pointer_cast;
 using std::dynamic_pointer_cast;
 using std::static_pointer_cast;
 
 namespace detail {
-/** Can be used to determine whether a type is a SafePtr */
+/** Can be used to determine whether a type is a std::shared_ptr */
 template <typename T>
 struct IsSafePtr {
   enum { result = false };
 };
 
 template <typename T>
-struct IsSafePtr< SafePtr<T> > {
+struct IsSafePtr< std::shared_ptr<T> > {
   enum { result = true };
 };
 template <typename T>
-struct IsSafePtr< const SafePtr<T> > {
+struct IsSafePtr< const std::shared_ptr<T> > {
   enum { result = true };
 };
 template <typename T>
-struct IsSafePtr< SafePtr<T>& > {
+struct IsSafePtr< std::shared_ptr<T>& > {
   enum { result = true };
 };
 template <typename T>
-struct IsSafePtr< const SafePtr<T>& > {
+struct IsSafePtr< const std::shared_ptr<T>& > {
   enum { result = true };
 };
 }  // namespace detail
diff --git a/src/bin/libint/strategy.cc b/src/bin/libint/strategy.cc
index 094d97eb0..bd4be2fc0 100644
--- a/src/bin/libint/strategy.cc
+++ b/src/bin/libint/strategy.cc
@@ -394,10 +394,10 @@ namespace libint2 {
     public:
     typedef typename RRType::TargetType IntType;
     // return true if no more visitations necessary
-    static bool visit(const SafePtr<DirectedGraph>& dg,
-                      const SafePtr<IntType>& integral,
-                      const SafePtr<Tactic>& tactic,
-                      SafePtr<RecurrenceRelation>& rr,
+    static bool visit(const std::shared_ptr<DirectedGraph>& dg,
+                      const std::shared_ptr<IntType>& integral,
+                      const std::shared_ptr<Tactic>& tactic,
+                      std::shared_ptr<RecurrenceRelation>& rr,
                       Tactic::rr_stack& rrstack) {
 #if DEBUG
       std::cout << "Visiting integral " << integral->label() << " with RR " << class_name<RRType>() << std::endl;
@@ -408,32 +408,32 @@ namespace libint2 {
         return _visit_cgshell(dg,integral,tactic,rr,rrstack);
     }
     private:
-      static bool _visit_cgshell(const SafePtr<DirectedGraph>& dg,
-                          const SafePtr<IntType>& integral,
-                          const SafePtr<Tactic>& tactic,
-                          SafePtr<RecurrenceRelation>& rr,
+      static bool _visit_cgshell(const std::shared_ptr<DirectedGraph>& dg,
+                          const std::shared_ptr<IntType>& integral,
+                          const std::shared_ptr<Tactic>& tactic,
+                          std::shared_ptr<RecurrenceRelation>& rr,
                           Tactic::rr_stack& rrstack) {
         const bool rr_is_directional = RRType::directional();
         for (int xyz = (rr_is_directional ? 2 : 0); xyz >= 0; xyz--) {
-          SafePtr<RRType> rr_ptr = RRType::Instance(integral, xyz);
+          std::shared_ptr<RRType> rr_ptr = RRType::Instance(integral, xyz);
           if (rr_ptr != 0)
             rrstack.push_back(static_pointer_cast<RecurrenceRelation, RRType>(rr_ptr));
         }
         return false;
       }
-      static bool _visit_cgf(const SafePtr<DirectedGraph>& dg,
-                      const SafePtr<IntType>& integral,
-                      const SafePtr<Tactic>& tactic,
-                      SafePtr<RecurrenceRelation>& rr,
+      static bool _visit_cgf(const std::shared_ptr<DirectedGraph>& dg,
+                      const std::shared_ptr<IntType>& integral,
+                      const std::shared_ptr<Tactic>& tactic,
+                      std::shared_ptr<RecurrenceRelation>& rr,
                       Tactic::rr_stack& rrstack) {
         // If given NullTactic -- skip
-        SafePtr<NullTactic> ntactic = dynamic_pointer_cast<NullTactic,Tactic>(tactic);
+        std::shared_ptr<NullTactic> ntactic = dynamic_pointer_cast<NullTactic,Tactic>(tactic);
         if (ntactic)
           return false;
 
         // in CGF case collect all rrs on rrstack
         for (int xyz = 2; xyz >= 0; xyz--) {
-          SafePtr<RRType> rr_ptr = RRType::Instance(integral, xyz);
+          std::shared_ptr<RRType> rr_ptr = RRType::Instance(integral, xyz);
           // TODO: can I use the knowledge of Tactic behavior to skip some iteration?
           if (rr_ptr != 0)
             rrstack.push_back(static_pointer_cast<RecurrenceRelation, RRType>(rr_ptr));
@@ -454,13 +454,13 @@ namespace libint2 {
     public:
 
       struct Impl {
-        Impl(const SafePtr<DirectedGraph>& dg,
-             const SafePtr<IntType>& integral,
-             const SafePtr<Tactic>& tactic) :
+        Impl(const std::shared_ptr<DirectedGraph>& dg,
+             const std::shared_ptr<IntType>& integral,
+             const std::shared_ptr<Tactic>& tactic) :
                dg_(dg), integral_(integral), tactic_(tactic), done_(false) {
             }
 
-            const SafePtr<RecurrenceRelation>& rr() {
+            const std::shared_ptr<RecurrenceRelation>& rr() {
               // if rr() is called then we should no longer do any processing
               done_ = true;
               // determine optimal rr
@@ -468,23 +468,23 @@ namespace libint2 {
               return rr_;
             }
 
-            SafePtr<DirectedGraph> dg_;
-            SafePtr<IntType> integral_;
-            SafePtr<Tactic> tactic_;
-            SafePtr<RecurrenceRelation> rr_;
+            std::shared_ptr<DirectedGraph> dg_;
+            std::shared_ptr<IntType> integral_;
+            std::shared_ptr<Tactic> tactic_;
+            std::shared_ptr<RecurrenceRelation> rr_;
             bool done_;
             Tactic::rr_stack rrstack_;
 
             // determine the optimal RR to use given the rrstack and tactic
-            void postprocess_rr(const SafePtr<Tactic>& tactic,
-                                SafePtr<RecurrenceRelation>& rr,
+            void postprocess_rr(const std::shared_ptr<Tactic>& tactic,
+                                std::shared_ptr<RecurrenceRelation>& rr,
                                 const Tactic::rr_stack& rrstack) {
               rr = tactic->optimal_rr(rrstack);
             }
 
         };
 
-    apply_strategy(const SafePtr<Impl>& impl) : impl_(impl) {}
+    apply_strategy(const std::shared_ptr<Impl>& impl) : impl_(impl) {}
     apply_strategy(const apply_strategy& app) : impl_(app.impl_) {}
     const apply_strategy& operator=(const apply_strategy& app) {
       impl_ = app.impl_;
@@ -497,10 +497,10 @@ namespace libint2 {
         impl_->done_ = Visitor::visit(impl_->dg_, impl_->integral_, impl_->tactic_, impl_->rr_, impl_->rrstack_);
     }
 
-    const SafePtr<Impl>& impl() const { return impl_; }
+    const std::shared_ptr<Impl>& impl() const { return impl_; }
 
     private:
-      SafePtr<Impl> impl_;
+      std::shared_ptr<Impl> impl_;
   };
 
   /// transform<T> encapsulates T and the action associated with T
@@ -508,11 +508,11 @@ namespace libint2 {
   template <class T>
   struct match_first_inttype_transform {
 
-    static bool visit(const SafePtr<DirectedGraph>& dg,
-                      const SafePtr<DGVertex>& integral,
-                      const SafePtr<Tactic>& tactic,
-                      SafePtr<RecurrenceRelation>& rr) {
-      SafePtr<T> tptr = dynamic_pointer_cast<T,DGVertex>(integral);
+    static bool visit(const std::shared_ptr<DirectedGraph>& dg,
+                      const std::shared_ptr<DGVertex>& integral,
+                      const std::shared_ptr<Tactic>& tactic,
+                      std::shared_ptr<RecurrenceRelation>& rr) {
+      std::shared_ptr<T> tptr = dynamic_pointer_cast<T,DGVertex>(integral);
       if (tptr != 0) {
 #if 0
         std::cout << "Visiting integral " << integral->label() << ", its type is " << class_name<T>() << std::endl;
@@ -545,7 +545,7 @@ namespace libint2 {
 #endif
         if (can_unroll) {
           typedef IntegralSet_to_Integrals<T> ISet2I;
-          SafePtr<ISet2I> x(new ISet2I(tptr));
+          std::shared_ptr<ISet2I> x(new ISet2I(tptr));
           rr = static_pointer_cast<RecurrenceRelation,ISet2I>(x);
 #if DEBUG
           std::cout << "Unrolled " << tptr->label() << std::endl;
@@ -556,7 +556,7 @@ namespace libint2 {
           const bool can_uncontract = dg->registry()->uncontract();
           if (can_uncontract) {
             typedef Uncontract_Integral<T> UncI;
-            SafePtr<UncI> x(new UncI(tptr));
+            std::shared_ptr<UncI> x(new UncI(tptr));
             rr = static_pointer_cast<RecurrenceRelation,UncI>(x);
             if (rr != 0) {
               if (rr->num_children() != 0) {
@@ -571,7 +571,7 @@ namespace libint2 {
           // if uncontraction failed -- apply the known strategy
           typedef apply_strategy<T> apply_strategy_t;
           typedef typename apply_strategy_t::Impl apply_strategy_t_impl;
-          SafePtr<apply_strategy_t_impl> applier_impl(new apply_strategy_t_impl(dg,tptr,tactic));
+          std::shared_ptr<apply_strategy_t_impl> applier_impl(new apply_strategy_t_impl(dg,tptr,tactic));
           apply_strategy_t applier(applier_impl);
           mpl::for_each<typename MasterStrategy<T>::value, apply_strategy_transform<_1>, apply_strategy_t& >(applier);
           rr = applier_impl->rr();
@@ -596,9 +596,9 @@ namespace libint2 {
   class match_first_inttype {
   public:
     struct Impl {
-      Impl(const SafePtr<DirectedGraph>& dg,
-           const SafePtr<DGVertex>& integral,
-           const SafePtr<Tactic>& tactic) :
+      Impl(const std::shared_ptr<DirectedGraph>& dg,
+           const std::shared_ptr<DGVertex>& integral,
+           const std::shared_ptr<Tactic>& tactic) :
                    dg_(dg),
                    integral_(integral),
                    tactic_(tactic),
@@ -606,16 +606,16 @@ namespace libint2 {
                    {
                    }
 
-      const SafePtr<RecurrenceRelation>& rr() const { return rr_; }
+      const std::shared_ptr<RecurrenceRelation>& rr() const { return rr_; }
 
-      SafePtr<DirectedGraph> dg_;
-      SafePtr<DGVertex> integral_;
-      SafePtr<Tactic> tactic_;
-      SafePtr<RecurrenceRelation> rr_;
+      std::shared_ptr<DirectedGraph> dg_;
+      std::shared_ptr<DGVertex> integral_;
+      std::shared_ptr<Tactic> tactic_;
+      std::shared_ptr<RecurrenceRelation> rr_;
       bool found_this_type_;
     };
 
-    match_first_inttype(const SafePtr<Impl>& impl) : impl_(impl) {}
+    match_first_inttype(const std::shared_ptr<Impl>& impl) : impl_(impl) {}
     match_first_inttype(const match_first_inttype& x) : impl_(x.impl_) {}
     const match_first_inttype& operator=(const match_first_inttype& x) {
       impl_ = x.impl_;
@@ -628,19 +628,19 @@ namespace libint2 {
         impl_->found_this_type_ = Visitor::visit(impl_->dg_,impl_->integral_,impl_->tactic_,impl_->rr_);
     }
 
-    const SafePtr<Impl>& impl() const { return impl_; }
+    const std::shared_ptr<Impl>& impl() const { return impl_; }
 
     private:
-      SafePtr<Impl> impl_;
+      std::shared_ptr<Impl> impl_;
 };
 
 
 }
 
-SafePtr<RecurrenceRelation>
-Strategy::optimal_rr(const SafePtr<DirectedGraph>& graph,
-                     const SafePtr<DGVertex>& integral,
-                     const SafePtr<Tactic>& tactic)
+std::shared_ptr<RecurrenceRelation>
+Strategy::optimal_rr(const std::shared_ptr<DirectedGraph>& graph,
+                     const std::shared_ptr<DGVertex>& integral,
+                     const std::shared_ptr<Tactic>& tactic)
 {
 #if 0
   {
@@ -654,7 +654,7 @@ Strategy::optimal_rr(const SafePtr<DirectedGraph>& graph,
 
   // iterate over the master typelist to determine the type of this integral
   // matcher then uses the type to search through the type-specific strategy (see apply_strategy<T>)
-  SafePtr<match_first_inttype::Impl> matcher_impl(new match_first_inttype::Impl(graph,integral,tactic));
+  std::shared_ptr<match_first_inttype::Impl> matcher_impl(new match_first_inttype::Impl(graph,integral,tactic));
   match_first_inttype matcher(matcher_impl);
   mpl::for_each<MasterIntegralTypeList, match_first_inttype_transform<_1>, match_first_inttype& >(matcher);
   return matcher_impl->rr();
diff --git a/src/bin/libint/strategy.h b/src/bin/libint/strategy.h
index 9aa0fab62..4d062fc5b 100644
--- a/src/bin/libint/strategy.h
+++ b/src/bin/libint/strategy.h
@@ -39,14 +39,14 @@ namespace libint2 {
   class Strategy {
 
   public:
-    typedef SafePtr<RecurrenceRelation> RR;
+    typedef std::shared_ptr<RecurrenceRelation> RR;
     Strategy() {}
     ~Strategy() {}
 
     /// Returns the optimal recurrence relation for integral
-    RR optimal_rr(const SafePtr<DirectedGraph>& graph,
-                  const SafePtr<DGVertex>& integral,
-                  const SafePtr<Tactic>& tactic);
+    RR optimal_rr(const std::shared_ptr<DirectedGraph>& graph,
+                  const std::shared_ptr<DGVertex>& integral,
+                  const std::shared_ptr<Tactic>& tactic);
   };
 
 };
diff --git a/src/bin/libint/tactic.cc b/src/bin/libint/tactic.cc
index edfe6fb84..3ac117531 100644
--- a/src/bin/libint/tactic.cc
+++ b/src/bin/libint/tactic.cc
@@ -75,10 +75,10 @@ ZeroNewVerticesTactic::optimal_rr(const rr_stack& stack) const {
       }
 //      else {
 //        std::cout << "ZeroNewVerticesTactic::optimal_rr: not optimal: " << stack[i]->label() << std::endl;
-//        SafePtr<DGVertex> target = stack[i]->rr_target();
+//        std::shared_ptr<DGVertex> target = stack[i]->rr_target();
 //        const unsigned int nchildren = stack[i]->num_children();
 //        for(unsigned int c=0; c<nchildren; ++c) {
-//          SafePtr<DGVertex> child = stack[i]->rr_child(c);
+//          std::shared_ptr<DGVertex> child = stack[i]->rr_child(c);
 //          std::cout << "  child " << c << ": " << child->label() << std::endl;
 //        }
 //
diff --git a/src/bin/libint/tactic.h b/src/bin/libint/tactic.h
index b53bc10a1..d5a046d66 100644
--- a/src/bin/libint/tactic.h
+++ b/src/bin/libint/tactic.h
@@ -39,7 +39,7 @@ namespace libint2 {
   */
   class Tactic {
     public:
-    typedef SafePtr<RecurrenceRelation> RR;
+    typedef std::shared_ptr<RecurrenceRelation> RR;
     typedef std::vector<RR> rr_stack;
 
     Tactic() {}
@@ -58,7 +58,7 @@ namespace libint2 {
   template <class RandomizePolicy = DummyRandomizePolicy>
     class FirstChoiceTactic : public Tactic {
     public:
-    FirstChoiceTactic(const SafePtr<RandomizePolicy>& rpolicy = SafePtr<RandomizePolicy>(new RandomizePolicy)) : Tactic(), rpolicy_(rpolicy) {}
+    FirstChoiceTactic(const std::shared_ptr<RandomizePolicy>& rpolicy = std::shared_ptr<RandomizePolicy>(new RandomizePolicy)) : Tactic(), rpolicy_(rpolicy) {}
     virtual ~FirstChoiceTactic() {}
 
     RR optimal_rr(const rr_stack& stack) const {
@@ -69,7 +69,7 @@ namespace libint2 {
     }
 
     private:
-    SafePtr<RandomizePolicy> rpolicy_;
+    std::shared_ptr<RandomizePolicy> rpolicy_;
   };
 
   /** FewestNewVerticesTactic chooses RR which adds fewest new vertices to
@@ -77,13 +77,13 @@ namespace libint2 {
     */
   class FewestNewVerticesTactic : public Tactic {
     public:
-    FewestNewVerticesTactic(const SafePtr<DirectedGraph>& dg) : Tactic(), dg_(dg) {}
+    FewestNewVerticesTactic(const std::shared_ptr<DirectedGraph>& dg) : Tactic(), dg_(dg) {}
     virtual ~FewestNewVerticesTactic() {}
 
     RR optimal_rr(const rr_stack& stack) const;
 
     private:
-    SafePtr<DirectedGraph> dg_;
+    std::shared_ptr<DirectedGraph> dg_;
   };
 
   /** ZeroNewVerticesTactic chooses first RR which adds no new vertices on
@@ -91,13 +91,13 @@ namespace libint2 {
     */
   class ZeroNewVerticesTactic : public Tactic {
     public:
-    ZeroNewVerticesTactic(const SafePtr<DirectedGraph>& dg) : Tactic(), dg_(dg) {}
+    ZeroNewVerticesTactic(const std::shared_ptr<DirectedGraph>& dg) : Tactic(), dg_(dg) {}
     virtual ~ZeroNewVerticesTactic() {}
 
     RR optimal_rr(const rr_stack& stack) const;
 
     private:
-    SafePtr<DirectedGraph> dg_;
+    std::shared_ptr<DirectedGraph> dg_;
   };
 
   /** RandomChoiceTactic chooses randomly among the applicable RRs
diff --git a/src/bin/libint/task.cc b/src/bin/libint/task.cc
index 4c05e8dde..7cffcbfd4 100644
--- a/src/bin/libint/task.cc
+++ b/src/bin/libint/task.cc
@@ -44,7 +44,7 @@ LibraryTaskManager::add(const std::string& task_label)
     if (t->label() == task_label)
       return;
   }
-  tasks_.push_back(LibraryTask(task_label,SafePtr<TaskParameters>(new TaskParameters),SafePtr<TaskExternSymbols>(new TaskExternSymbols)));
+  tasks_.push_back(LibraryTask(task_label,std::shared_ptr<TaskParameters>(new TaskParameters),std::shared_ptr<TaskExternSymbols>(new TaskExternSymbols)));
   // make the first added task current
   if (tasks_.size() == 1)
     current_ = 0;
diff --git a/src/bin/libint/task.h b/src/bin/libint/task.h
index 19e719276..baffb9f73 100644
--- a/src/bin/libint/task.h
+++ b/src/bin/libint/task.h
@@ -44,19 +44,19 @@ namespace libint2 {
   */
   class LibraryTask {
   public:
-    LibraryTask(const std::string& l, const SafePtr<TaskParameters>& p, const SafePtr<TaskExternSymbols>& s) :
+    LibraryTask(const std::string& l, const std::shared_ptr<TaskParameters>& p, const std::shared_ptr<TaskExternSymbols>& s) :
       label_(l), params_(p), symbols_(s) {
     }
     ~LibraryTask() {
     }
     const std::string& label() const { return label_; }
-    const SafePtr<TaskParameters>& params() const { return params_; }
-    const SafePtr<TaskExternSymbols>& symbols() const { return symbols_; }
+    const std::shared_ptr<TaskParameters>& params() const { return params_; }
+    const std::shared_ptr<TaskExternSymbols>& symbols() const { return symbols_; }
 
   private:
     std::string label_;
-    SafePtr<TaskParameters> params_;
-    SafePtr<TaskExternSymbols> symbols_;
+    std::shared_ptr<TaskParameters> params_;
+    std::shared_ptr<TaskExternSymbols> symbols_;
   };
 
   /// Manages tasks. This is a Singleton.
diff --git a/src/bin/libint/test.cc b/src/bin/libint/test.cc
index 94c2f8946..31fe85ca7 100644
--- a/src/bin/libint/test.cc
+++ b/src/bin/libint/test.cc
@@ -108,7 +108,7 @@ namespace {
   CGShell sh_n(10);
   CGShell sh_o(11);
   CGShell sh_q(12);
-  SafePtr<CompilationParameters> cparams;
+  std::shared_ptr<CompilationParameters> cparams;
 
   int try_main (int argc, char* argv[])
   {
@@ -116,7 +116,7 @@ namespace {
     taskmgr.add("test");
 
     // initialize cparams
-    SafePtr<CompilationParameters> tmpcparams(new CompilationParameters);
+    std::shared_ptr<CompilationParameters> tmpcparams(new CompilationParameters);
     cparams = tmpcparams;
     cparams->max_am("test",2);
 
@@ -169,8 +169,8 @@ namespace {
   void
   test0()
   {
-    SafePtr<TwoPRep_11_11_sq> pppp_quartet = TwoPRep_11_11_sq::Instance(sh_p,sh_p,sh_p,sh_p,0u);
-    SafePtr<DGVertex> pppp_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_11_11_sq>(pppp_quartet);
+    std::shared_ptr<TwoPRep_11_11_sq> pppp_quartet = TwoPRep_11_11_sq::Instance(sh_p,sh_p,sh_p,sh_p,0u);
+    std::shared_ptr<DGVertex> pppp_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_11_11_sq>(pppp_quartet);
 
     // test CGShell iterator
     test_cgshell_iter(sh_s);
@@ -184,7 +184,7 @@ namespace {
     test_cgshell_iter(sh_l);
 
     // test IntegralSet iterator
-    SafePtr<TwoPRep_11_11_sq> obj(pppp_quartet);
+    std::shared_ptr<TwoPRep_11_11_sq> obj(pppp_quartet);
     cout << obj->description() << endl;
     SubIteratorBase< TwoPRep_11_11_sq > siter2(obj);
     for(siter2.init(); siter2; ++siter2)
@@ -196,24 +196,24 @@ namespace {
   test1()
   {
 
-    SafePtr<Strategy> strat(new Strategy);
-    SafePtr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
-    SafePtr<TwoPRep_11_11_sq> xsxs_quartet = TwoPRep_11_11_sq::Instance(sh_f,sh_f,sh_f,sh_f,0u);
+    std::shared_ptr<Strategy> strat(new Strategy);
+    std::shared_ptr<Tactic> tactic(new FirstChoiceTactic<DummyRandomizePolicy>);
+    std::shared_ptr<TwoPRep_11_11_sq> xsxs_quartet = TwoPRep_11_11_sq::Instance(sh_f,sh_f,sh_f,sh_f,0u);
     cout << "Building " << xsxs_quartet->description() << endl;
-    SafePtr<DGVertex> xsxs_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_11_11_sq>(xsxs_quartet);
+    std::shared_ptr<DGVertex> xsxs_ptr = dynamic_pointer_cast<DGVertex,TwoPRep_11_11_sq>(xsxs_quartet);
 
-    SafePtr<MemoryManagerFactory> mmfactory(new MemoryManagerFactory);
+    std::shared_ptr<MemoryManagerFactory> mmfactory(new MemoryManagerFactory);
 
     for(unsigned int m = 0; m < MemoryManagerFactory::ntypes; m++) {
-      SafePtr<DirectedGraph> dg_xxxx3(new DirectedGraph);
-      SafePtr<CodeContext> context(new CppCodeContext(cparams));
-      SafePtr<MemoryManager> memman = mmfactory->memman(m);
+      std::shared_ptr<DirectedGraph> dg_xxxx3(new DirectedGraph);
+      std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+      std::shared_ptr<MemoryManager> memman = mmfactory->memman(m);
       dg_xxxx3->append_target(xsxs_ptr);
       dg_xxxx3->apply(strat,tactic);
       dg_xxxx3->optimize_rr_out(context);
       dg_xxxx3->traverse();
       std::basic_ofstream<char> devnull("/dev/null");
-      dg_xxxx3->generate_code(context,memman,ImplicitDimensions::default_dims(),SafePtr<CodeSymbols>(new CodeSymbols),xsxs_quartet->label(),devnull,devnull);
+      dg_xxxx3->generate_code(context,memman,ImplicitDimensions::default_dims(),std::shared_ptr<CodeSymbols>(new CodeSymbols),xsxs_quartet->label(),devnull,devnull);
       cout << "Using " << mmfactory->label(m) << ": max memory used = " << memman->max_memory_used() << endl;
       dg_xxxx3->reset();
     }
@@ -222,15 +222,15 @@ namespace {
     const unsigned int tf_max = 6;
     for(unsigned int tf = 1; tf <= tf_max; tf++) {
       for(int ex=1; ex>=0; ex--) {
-	SafePtr<DirectedGraph> dg_xxxx3(new DirectedGraph);
-    SafePtr<CodeContext> context(new CppCodeContext(cparams));
-    SafePtr<MemoryManager> memman(new BestFitMemoryManager(ex,tf));
+	std::shared_ptr<DirectedGraph> dg_xxxx3(new DirectedGraph);
+    std::shared_ptr<CodeContext> context(new CppCodeContext(cparams));
+    std::shared_ptr<MemoryManager> memman(new BestFitMemoryManager(ex,tf));
 	dg_xxxx3->append_target(xsxs_ptr);
 	dg_xxxx3->apply(strat,tactic);
 	dg_xxxx3->optimize_rr_out(context);
 	dg_xxxx3->traverse();
 	std::basic_ofstream<char> devnull("/dev/null");
-	dg_xxxx3->generate_code(context,memman,ImplicitDimensions::default_dims(),SafePtr<CodeSymbols>(new CodeSymbols),xsxs_quartet->label(),devnull,devnull);
+	dg_xxxx3->generate_code(context,memman,ImplicitDimensions::default_dims(),std::shared_ptr<CodeSymbols>(new CodeSymbols),xsxs_quartet->label(),devnull,devnull);
 	cout << "Using BestFitMemoryManager(" << (ex == 1 ? "true" : "false")
 	     << "," << tf << "): max memory used = " << memman->max_memory_used() << endl;
 	dg_xxxx3->reset();
@@ -246,12 +246,12 @@ namespace {
 		      unsigned int size_to_unroll)
     {
       std::string descr("build ");
-      SafePtr<Integral> i = Integral::Instance(f1,f2,f3,f4);
+      std::shared_ptr<Integral> i = Integral::Instance(f1,f2,f3,f4);
       descr += i->label();
-      std::vector<SafePtr<Integral> > targets(1,i);
+      std::vector<std::shared_ptr<Integral> > targets(1,i);
       RunTest(boost::bind(__BuildTest<Integral,false>, targets, cparams,
-			  size_to_unroll, boost::ref(cout), SafePtr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
-			  SafePtr<MemoryManager>(new WorstFitMemoryManager), descr), descr);
+			  size_to_unroll, boost::ref(cout), std::shared_ptr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
+			  std::shared_ptr<MemoryManager>(new WorstFitMemoryManager), descr), descr);
     }
 
   template <class Integral>
@@ -262,12 +262,12 @@ namespace {
 		      unsigned int m, unsigned int size_to_unroll)
     {
       std::string descr("build ");
-      SafePtr<Integral> i = Integral::Instance(f1,f2,f3,f4,m);
+      std::shared_ptr<Integral> i = Integral::Instance(f1,f2,f3,f4,m);
       descr += i->label();
-      std::vector<SafePtr<Integral> > targets(1,i);
+      std::vector<std::shared_ptr<Integral> > targets(1,i);
       RunTest(boost::bind(__BuildTest<Integral,false>, targets, cparams,
-			  size_to_unroll, boost::ref(cout), SafePtr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
-			  SafePtr<MemoryManager>(new WorstFitMemoryManager), descr), descr);
+			  size_to_unroll, boost::ref(cout), std::shared_ptr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
+			  std::shared_ptr<MemoryManager>(new WorstFitMemoryManager), descr), descr);
     }
   template <class Integral>
     void RunBuildTest(const typename Integral::BasisFunctionType& f1,
@@ -280,19 +280,19 @@ namespace {
       std::string descr_label("build ");
       typedef typename Integral::OperType::Descriptor Descriptor;
       GenOper<Descriptor> oper(descr);
-      SafePtr<Integral> i = Integral::Instance(f1,f2,f3,f4,m,oper);
+      std::shared_ptr<Integral> i = Integral::Instance(f1,f2,f3,f4,m,oper);
       descr_label += i->label();
-      std::vector<SafePtr<Integral> > targets(1,i);
+      std::vector<std::shared_ptr<Integral> > targets(1,i);
       RunTest(boost::bind(__BuildTest<Integral,false>, targets, cparams,
-              size_to_unroll, boost::ref(cout), SafePtr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
-              SafePtr<MemoryManager>(new WorstFitMemoryManager), descr_label), descr_label);
+              size_to_unroll, boost::ref(cout), std::shared_ptr<Tactic>(new FirstChoiceTactic<DummyRandomizePolicy>),
+              std::shared_ptr<MemoryManager>(new WorstFitMemoryManager), descr_label), descr_label);
     }
 
 
   void test_cgshell_iter(const CGShell& sh)
   {
     const unsigned int nbf = sh.num_bf();
-    SafePtr<CGShell> sh_ptr(new CGShell(sh));
+    std::shared_ptr<CGShell> sh_ptr(new CGShell(sh));
     sh_ptr->print(cout);
     SubIteratorBase<CGShell> siter1(*sh_ptr);
     unsigned int bf = 0;
@@ -317,32 +317,32 @@ namespace {
 
     {
       typedef TwoPRep_11_11_sq IType;
-      SafePtr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u);
+      std::shared_ptr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u);
       std::cout << "Created integral set " << iset->label() << " key = " << iset->key() << std::endl;
     }
     {
       typedef R12kG12_11_11_sq IType;
-      SafePtr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u,IType::OperType(-1));
+      std::shared_ptr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u,IType::OperType(-1));
       std::cout << "Created integral set " << iset->label() << " key = " << iset->key() << std::endl;
     }
     {
       typedef TwoPRep_11_11_sq IType;
-      SafePtr<IType> iset = IType::Instance(csh_s,csh_q,csh_s,csh_s,0u);
+      std::shared_ptr<IType> iset = IType::Instance(csh_s,csh_q,csh_s,csh_s,0u);
       std::cout << "Created integral set " << iset->label() << " key = " << iset->key() << std::endl;
     }
     {
       typedef TwoPRep_11_11_sq IType;
-      SafePtr<IType> iset = IType::Instance(csh_s,csh_d_dx,csh_s,csh_s,0u);
+      std::shared_ptr<IType> iset = IType::Instance(csh_s,csh_d_dx,csh_s,csh_s,0u);
       std::cout << "Created integral set " << iset->label() << " key = " << iset->key() << std::endl;
     }
     {
       typedef TwoPRep_11_11_sq IType;
-      SafePtr<IType> iset = IType::Instance(csh_s,csh_f_dx,csh_s,csh_s,0u);
+      std::shared_ptr<IType> iset = IType::Instance(csh_s,csh_f_dx,csh_s,csh_s,0u);
       std::cout << "Created integral set " << iset->label() << " key = " << iset->key() << std::endl;
     }
     {
       typedef TwoPRep_11_11_sq IType;
-      SafePtr<IType> iset = IType::Instance(csh_q,csh_q,csh_q,csh_q,0u);
+      std::shared_ptr<IType> iset = IType::Instance(csh_q,csh_q,csh_q,csh_q,0u);
       std::cout << "Created integral set " << iset->label() << " key = " << iset->key() << std::endl;
     }
   }
@@ -353,22 +353,22 @@ namespace {
     {
       typedef TwoPRep_11_11_sq IType;
       typedef VRR_a_11_TwoPRep_11_sh RRType;
-      SafePtr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u);
-      SafePtr<RRType> rr = RRType::Instance(iset,0);
+      std::shared_ptr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u);
+      std::shared_ptr<RRType> rr = RRType::Instance(iset,0);
       std::cout << "Created recurrence relation " << rr->label() << std::endl;
     }
     {
       typedef TwoPRep_11_11_sq IType;
       typedef VRR_c_11_TwoPRep_11_sh RRType;
-      SafePtr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u);
-      SafePtr<RRType> rr = RRType::Instance(iset,0);
+      std::shared_ptr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u);
+      std::shared_ptr<RRType> rr = RRType::Instance(iset,0);
       std::cout << "Created recurrence relation " << rr->label() << std::endl;
     }
     {
       typedef DivG12prime_xTx_11_11_sq IType;
       typedef CR_11_DivG12prime_xTx_11_sh RRType;
-      SafePtr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u,DivG12prime_xTx_Descr(0));
-      SafePtr<RRType> rr = RRType::Instance(iset,0);
+      std::shared_ptr<IType> iset = IType::Instance(sh_p,sh_p,sh_p,sh_p,0u,DivG12prime_xTx_Descr(0));
+      std::shared_ptr<RRType> rr = RRType::Instance(iset,0);
       std::cout << "Created recurrence relation " << rr->label() << std::endl;
     }
   }
@@ -441,11 +441,11 @@ namespace {
     CGShell csh_s_d2x(0u); csh_s_d2x.deriv().inc(0,2);
     CGShell csh_p_d2x(1u); csh_p_d2x.deriv().inc(0,2);
 
-    SafePtr<TwoPRep_11_11_sq> target = TwoPRep_11_11_sq::Instance(csh_p,csh_d_dx,csh_s,csh_s,mType(0u));
+    std::shared_ptr<TwoPRep_11_11_sq> target = TwoPRep_11_11_sq::Instance(csh_p,csh_d_dx,csh_s,csh_s,mType(0u));
 
-    SafePtr<RecurrenceRelation> rr = HRR_ab_11_TwoPRep_11_sh::Instance(target,0);
+    std::shared_ptr<RecurrenceRelation> rr = HRR_ab_11_TwoPRep_11_sh::Instance(target,0);
     assert(rr != 0 && rr->num_children() != 0);
-    SafePtr<RRStack> rrstack = RRStack::Instance();
+    std::shared_ptr<RRStack> rrstack = RRStack::Instance();
     rrstack->find(rr);
 
     std::deque<std::string> decl_filenames, def_filenames;
diff --git a/src/bin/libint/traits.h b/src/bin/libint/traits.h
index 75450db57..75ad62636 100644
--- a/src/bin/libint/traits.h
+++ b/src/bin/libint/traits.h
@@ -29,7 +29,7 @@ namespace libint2 {
   
   template <typename T>
   struct StorageTraits {
-    typedef SafePtr<T> StorageType;
+    typedef std::shared_ptr<T> StorageType;
     enum { StoredAsPtr = true };
     static const T& const_ref(const StorageType& s) { return *s; };
   };
@@ -66,21 +66,21 @@ namespace libint2 {
   
   ///////////
   
-  /// Converts Base to a type of the same signature as Ref. For example, if Ref is SafePtr<T> then Base is converted to SafePtr<Base>
+  /// Converts Base to a type of the same signature as Ref. For example, if Ref is std::shared_ptr<T> then Base is converted to std::shared_ptr<Base>
   template <typename Ref, typename Base>
   struct ReturnTypeAnalog {
     typedef const Base& result;
   };
   template <typename Ref, typename Base>
-  struct ReturnTypeAnalog< SafePtr<Ref>, Base> {
-    typedef SafePtr<Base> result;
+  struct ReturnTypeAnalog< std::shared_ptr<Ref>, Base> {
+    typedef std::shared_ptr<Base> result;
   };
   
   ///////////
   
   template <typename T>
   struct TypeTraits {
-    /// By default, use SafePtr to manage these objects
+    /// By default, use std::shared_ptr to manage these objects
     typedef typename StorageTraits<T>::StorageType StorageType;
     /// Whether stored as a pointer
     enum { StoredAsPtr = StorageTraits<T>::StoredAsPtr};
diff --git a/src/bin/libint/uncontract.h b/src/bin/libint/uncontract.h
index 385a71d14..7f4925bd5 100644
--- a/src/bin/libint/uncontract.h
+++ b/src/bin/libint/uncontract.h
@@ -56,19 +56,19 @@ namespace libint2 {
     /// The type of expressions in which RecurrenceRelations result.
     typedef RecurrenceRelation::ExprType ExprType;
 
-    Uncontract_Integral(const SafePtr<I>&);
+    Uncontract_Integral(const std::shared_ptr<I>&);
     virtual ~Uncontract_Integral() {}
 
     /// Implementation of RecurrenceRelation::num_children()
     unsigned int num_children() const override { return children_.size(); }
     /// target() returns pointer to target
-    SafePtr<TargetType> target() const { return target_; };
+    std::shared_ptr<TargetType> target() const { return target_; };
     /// child(i) returns pointer i-th child
-    SafePtr<ChildType> child(unsigned int i) const;
+    std::shared_ptr<ChildType> child(unsigned int i) const;
     /// Implementation of RecurrenceRelation's target()
-    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
+    std::shared_ptr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
     /// Implementation of RecurrenceRelation's child()
-    SafePtr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(child(i)); }
+    std::shared_ptr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(child(i)); }
     /// to inline this would require a unary operator (+=).
     /// instead will always implement as a function call.
     bool is_simple() const override {
@@ -76,8 +76,8 @@ namespace libint2 {
     }
 
   private:
-    SafePtr<TargetType> target_;
-    std::vector< SafePtr<ChildType> > children_;
+    std::shared_ptr<TargetType> target_;
+    std::vector< std::shared_ptr<ChildType> > children_;
 
     // contracting integrals only depends on the number of integrals in a set
     // can simplify this to only refer to that number
@@ -88,14 +88,14 @@ namespace libint2 {
     }
 
     //
-    std::string spfunction_call(const SafePtr<CodeContext>& context,
-                                const SafePtr<ImplicitDimensions>& dims) const override;
+    std::string spfunction_call(const std::shared_ptr<CodeContext>& context,
+                                const std::shared_ptr<ImplicitDimensions>& dims) const override;
 
   };
 
 
   template <class I>
-  Uncontract_Integral<I>::Uncontract_Integral(const SafePtr<I>& Tint) :
+  Uncontract_Integral<I>::Uncontract_Integral(const std::shared_ptr<I>& Tint) :
     target_(Tint)
     {
       target_ = Tint;
@@ -137,7 +137,7 @@ namespace libint2 {
 #if DEBUG
         std::cout << "Uncontract_Integral: " << target_->description() << " is contracted" << std::endl;
 #endif
-        SafePtr<ChildType> c = ChildType::Instance(bra_unc, ket_unc,
+        std::shared_ptr<ChildType> c = ChildType::Instance(bra_unc, ket_unc,
                                                    target_->aux(),
                                                    oper_unc);
         children_.push_back(c);
@@ -145,7 +145,7 @@ namespace libint2 {
     };
 
   template <class I>
-    SafePtr<typename Uncontract_Integral<I>::ChildType>
+    std::shared_ptr<typename Uncontract_Integral<I>::ChildType>
     Uncontract_Integral<I>::child(unsigned int i) const
     {
       return children_.at(i);
@@ -153,20 +153,20 @@ namespace libint2 {
 
   template <class I>
   std::string
-  Uncontract_Integral<I>::spfunction_call(const SafePtr<CodeContext>& context,
-                                          const SafePtr<ImplicitDimensions>& dims) const {
+  Uncontract_Integral<I>::spfunction_call(const std::shared_ptr<CodeContext>& context,
+                                          const std::shared_ptr<ImplicitDimensions>& dims) const {
 
     const unsigned int s = target_->size();
-    SafePtr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
-    SafePtr<Entity> bvecdim;
+    std::shared_ptr<CTimeEntity<int> > bdim(new CTimeEntity<int>(s));
+    std::shared_ptr<Entity> bvecdim;
     bool vectorize = false;
     if (!dims->vecdim_is_static()) {
       vectorize = true;
-      SafePtr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
+      std::shared_ptr< RTimeEntity<EntityTypes::Int> > vecdim = dynamic_pointer_cast<RTimeEntity<EntityTypes::Int>,Entity>(dims->vecdim());
       bvecdim = vecdim * bdim;
     }
     else {
-      SafePtr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
+      std::shared_ptr< CTimeEntity<int> > vecdim = dynamic_pointer_cast<CTimeEntity<int>,Entity>(dims->vecdim());
       vectorize = vecdim->value() == 1 ? false : true;
       bvecdim = vecdim * bdim;
     }
@@ -193,15 +193,15 @@ namespace libint2 {
 
   /// return true if V is a decontracted IntegralSet
   struct DecontractedIntegralSet {
-    bool operator()(const SafePtr<DGVertex>& V) {
+    bool operator()(const std::shared_ptr<DGVertex>& V) {
       const unsigned int outdegree = V->num_exit_arcs();
       if (outdegree == 0) return false;
 
-      const SafePtr<DGArc> arc0 = *(V->first_exit_arc());
+      const std::shared_ptr<DGArc> arc0 = *(V->first_exit_arc());
       // Is this DGArcRR?
-      const SafePtr<DGArcRR> arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(arc0);
+      const std::shared_ptr<DGArcRR> arcrr = dynamic_pointer_cast<DGArcRR,DGArc>(arc0);
       if (arcrr == 0) return false;
-      const SafePtr<Uncontract_Integral_base> uib_ptr = dynamic_pointer_cast<Uncontract_Integral_base,RecurrenceRelation>(arcrr->rr());
+      const std::shared_ptr<Uncontract_Integral_base> uib_ptr = dynamic_pointer_cast<Uncontract_Integral_base,RecurrenceRelation>(arcrr->rr());
       return uib_ptr != 0;
     }
   };
diff --git a/src/bin/libint/util.h b/src/bin/libint/util.h
index db2386626..35cd09597 100644
--- a/src/bin/libint/util.h
+++ b/src/bin/libint/util.h
@@ -31,8 +31,8 @@
 namespace libint2 {
   std::string to_string(FunctionPosition pos);
   
-  template <class Target, class Source> SafePtr<Target> require_dynamic_cast(const SafePtr<Source>& s) {
-    const SafePtr<Target> t = dynamic_pointer_cast<Target,Source>(s);
+  template <class Target, class Source> std::shared_ptr<Target> require_dynamic_cast(const std::shared_ptr<Source>& s) {
+    const std::shared_ptr<Target> t = dynamic_pointer_cast<Target,Source>(s);
     if (t == 0)
       throw std::runtime_error("require_dynamic_cast: dynamic case failed");
     return t;
diff --git a/src/bin/libint/vrr_11_r12kg12_11.h b/src/bin/libint/vrr_11_r12kg12_11.h
index de94b1997..d5c3f596e 100644
--- a/src/bin/libint/vrr_11_r12kg12_11.h
+++ b/src/bin/libint/vrr_11_r12kg12_11.h
@@ -55,7 +55,7 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      VRR_11_R12kG12_11(const SafePtr<TargetType>&, unsigned int dir);
+      VRR_11_R12kG12_11(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return "VRR"; }
       /** Re-Implementation of GenericRecurrenceRelation::generate_label():
@@ -64,7 +64,7 @@ namespace libint2 {
       std::string generate_label() const override
       {
         typedef typename TargetType::AuxIndexType mType;
-        static SafePtr<mType> aux0(new mType(0u));
+        static std::shared_ptr<mType> aux0(new mType(0u));
         std::ostringstream os;
         os << descr() << "P" << part << to_string(where)
            << genintegralset_label(target_->bra(),target_->ket(),aux0,target_->oper());
@@ -73,16 +73,16 @@ namespace libint2 {
 
   #if LIBINT_ENABLE_GENERIC_CODE
       /// Implementation of RecurrenceRelation::has_generic()
-      bool has_generic(const SafePtr<CompilationParameters>& cparams) const override;
+      bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const override;
       /// Implementation of RecurrenceRelation::generic_header()
       std::string generic_header() const override;
       /// Implementation of RecurrenceRelation::generic_instance()
-      std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const override;
+      std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const override;
   #endif
     };
 
     template <class F, int part, FunctionPosition where>
-      VRR_11_R12kG12_11<F,part,where>::VRR_11_R12kG12_11(const SafePtr< TargetType >& Tint,
+      VRR_11_R12kG12_11<F,part,where>::VRR_11_R12kG12_11(const std::shared_ptr< TargetType >& Tint,
                                                                  unsigned int dir) :
       ParentType(Tint,dir)
       {
@@ -432,7 +432,7 @@ namespace libint2 {
   #if LIBINT_ENABLE_GENERIC_CODE
     template <class F, int part, FunctionPosition where>
       bool
-      VRR_11_R12kG12_11<F,part,where>::has_generic(const SafePtr<CompilationParameters>& cparams) const
+      VRR_11_R12kG12_11<F,part,where>::has_generic(const std::shared_ptr<CompilationParameters>& cparams) const
       {
         F sh_a(target_->bra(0,0));
         F sh_b(target_->ket(0,0));
@@ -485,7 +485,7 @@ namespace libint2 {
 
     template <class F, int part, FunctionPosition where>
       std::string
-      VRR_11_R12kG12_11<F,part,where>::generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const
+      VRR_11_R12kG12_11<F,part,where>::generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const
       {
         const int K = target_->oper()->descr().K();
         std::ostringstream oss;
diff --git a/src/bin/libint/vrr_11_twoprep_11.h b/src/bin/libint/vrr_11_twoprep_11.h
index bc1179152..968d2cdfd 100644
--- a/src/bin/libint/vrr_11_twoprep_11.h
+++ b/src/bin/libint/vrr_11_twoprep_11.h
@@ -54,7 +54,7 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      VRR_11_TwoPRep_11(const SafePtr<TargetType>&, unsigned int dir);
+      VRR_11_TwoPRep_11(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return "OSVRR"; }
       /** Re-Implementation of GenericRecurrenceRelation::generate_label():
@@ -63,7 +63,7 @@ namespace libint2 {
       std::string generate_label() const override
       {
         typedef typename TargetType::AuxIndexType mType;
-        static SafePtr<mType> aux0(new mType(0u));
+        static std::shared_ptr<mType> aux0(new mType(0u));
         std::ostringstream os;
         os << descr() << "P" << part << to_string(where)
            << genintegralset_label(target_->bra(),target_->ket(),aux0,target_->oper());
@@ -72,16 +72,16 @@ namespace libint2 {
 
   #if LIBINT_ENABLE_GENERIC_CODE
       /// Implementation of RecurrenceRelation::has_generic()
-      bool has_generic(const SafePtr<CompilationParameters>& cparams) const override;
+      bool has_generic(const std::shared_ptr<CompilationParameters>& cparams) const override;
       /// Implementation of RecurrenceRelation::generic_header()
       std::string generic_header() const override;
       /// Implementation of RecurrenceRelation::generic_instance()
-      std::string generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const override;
+      std::string generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const override;
   #endif
     };
 
   template <class F, int part, FunctionPosition where>
-    VRR_11_TwoPRep_11<F,part,where>::VRR_11_TwoPRep_11(const SafePtr< TargetType >& Tint,
+    VRR_11_TwoPRep_11<F,part,where>::VRR_11_TwoPRep_11(const std::shared_ptr< TargetType >& Tint,
                                                        unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -150,7 +150,7 @@ namespace libint2 {
         F c(Tint->bra(1,0));
         F d(Tint->ket(1,0));
 
-        SafePtr<DGVertex> ABCD_m; if (not unit_b) ABCD_m = factory.make_child(a,b,c,d,m);
+        std::shared_ptr<DGVertex> ABCD_m; if (not unit_b) ABCD_m = factory.make_child(a,b,c,d,m);
         auto ABCD_mp1 = factory.make_child(a,b,c,d,m+1);
         if (is_simple()) {
           if (not unit_b) {
@@ -204,7 +204,7 @@ namespace libint2 {
         F c(Tint->bra(1,0));
         F d(Tint->ket(1,0));
 
-        SafePtr<DGVertex> ABCD_m; if (not unit_a) ABCD_m = factory.make_child(a,b,c,d,m);
+        std::shared_ptr<DGVertex> ABCD_m; if (not unit_a) ABCD_m = factory.make_child(a,b,c,d,m);
         auto ABCD_mp1 = factory.make_child(a,b,c,d,m+1);
         if (is_simple()) {
           if (not unit_a) {
@@ -258,7 +258,7 @@ namespace libint2 {
         if (!exists(c)) return;
         F d(Tint->ket(1,0)); const bool unit_d = (d == F::unit()); part1_has_unit |= unit_d;
 
-        SafePtr<DGVertex> ABCD_m; if (not unit_d) ABCD_m = factory.make_child(a,b,c,d,m);
+        std::shared_ptr<DGVertex> ABCD_m; if (not unit_d) ABCD_m = factory.make_child(a,b,c,d,m);
         auto ABCD_mp1 = factory.make_child(a,b,c,d,m+1);
         if (is_simple()) {
           if (not unit_d) {
@@ -312,7 +312,7 @@ namespace libint2 {
         F d(Tint->ket(1,0) - _1);
         if (!exists(d)) return;
 
-        SafePtr<DGVertex> ABCD_m; if (not unit_c) ABCD_m = factory.make_child(a,b,c,d,m);
+        std::shared_ptr<DGVertex> ABCD_m; if (not unit_c) ABCD_m = factory.make_child(a,b,c,d,m);
         auto ABCD_mp1 = factory.make_child(a,b,c,d,m+1);
         if (is_simple()) {
           if (not unit_c) {
@@ -378,7 +378,7 @@ namespace libint2 {
 
           OriginDerivative<3u> _d1; _d1.inc(dxyz);
 
-          SafePtr<DGVertex> _nullptr;
+          std::shared_ptr<DGVertex> _nullptr;
 
           // dA - _1?
           {
@@ -512,7 +512,7 @@ namespace libint2 {
 #if LIBINT_ENABLE_GENERIC_CODE
   template <class F, int part, FunctionPosition where>
     bool
-    VRR_11_TwoPRep_11<F,part,where>::has_generic(const SafePtr<CompilationParameters>& cparams) const
+    VRR_11_TwoPRep_11<F,part,where>::has_generic(const std::shared_ptr<CompilationParameters>& cparams) const
     {
       if (TrivialBFSet<F>::result)
         return false;
@@ -578,7 +578,7 @@ namespace libint2 {
 
   template <class F, int part, FunctionPosition where>
     std::string
-    VRR_11_TwoPRep_11<F,part,where>::generic_instance(const SafePtr<CodeContext>& context, const SafePtr<CodeSymbols>& args) const
+    VRR_11_TwoPRep_11<F,part,where>::generic_instance(const std::shared_ptr<CodeContext>& context, const std::shared_ptr<CodeSymbols>& args) const
     {
       std::ostringstream oss;
       F sh_a(target_->bra(0,0));
diff --git a/src/bin/libint/vrr_1_onep_1.h b/src/bin/libint/vrr_1_onep_1.h
index 35aba16fd..8161925fb 100644
--- a/src/bin/libint/vrr_1_onep_1.h
+++ b/src/bin/libint/vrr_1_onep_1.h
@@ -55,13 +55,13 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      VRR_1_Overlap_1(const SafePtr<TargetType>&, unsigned int dir);
+      VRR_1_Overlap_1(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return "OSVRROverlap"; }
     };
 
   template <class F, FunctionPosition where>
-  VRR_1_Overlap_1<F,where>::VRR_1_Overlap_1(const SafePtr< TargetType >& Tint,
+  VRR_1_Overlap_1<F,where>::VRR_1_Overlap_1(const std::shared_ptr< TargetType >& Tint,
                                             unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -128,7 +128,7 @@ namespace libint2 {
 
           OriginDerivative<3u> _d1; _d1.inc(dxyz);
 
-          SafePtr<DGVertex> _nullptr;
+          std::shared_ptr<DGVertex> _nullptr;
 
           // dA - _1?
           {
@@ -197,13 +197,13 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      VRR_1_Overlap_1_1d(const SafePtr<TargetType>&, unsigned int dir);
+      VRR_1_Overlap_1_1d(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return std::string("OSVRROverlap") + to_string(axis); }
     };
 
   template <CartesianAxis Axis, FunctionPosition where>
-  VRR_1_Overlap_1_1d<Axis,where>::VRR_1_Overlap_1_1d(const SafePtr< TargetType >& Tint,
+  VRR_1_Overlap_1_1d<Axis,where>::VRR_1_Overlap_1_1d(const std::shared_ptr< TargetType >& Tint,
                                                      unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -237,7 +237,7 @@ namespace libint2 {
       // by copying from inteval
       auto zero = Tint->bra(0,0).zero() and Tint->ket(0,0).zero() and not deriv;
       if (zero) {
-        SafePtr<DGVertex> int00 = Vector("_0_Overlap_0")[Axis];
+        std::shared_ptr<DGVertex> int00 = Vector("_0_Overlap_0")[Axis];
         expr_ = Scalar(0u) + int00;
         this->add_child(int00);
         return;
@@ -277,7 +277,7 @@ namespace libint2 {
         {
           OriginDerivative<1u> _d1; _d1.inc(0);
 
-          SafePtr<DGVertex> _nullptr;
+          std::shared_ptr<DGVertex> _nullptr;
 
           // dA - _1?
           {
@@ -346,13 +346,13 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-      VRR_1_Kinetic_1(const SafePtr<TargetType>&, unsigned int dir);
+      VRR_1_Kinetic_1(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return "OSVRRKinetic"; }
     };
 
   template <class F, FunctionPosition where>
-  VRR_1_Kinetic_1<F,where>::VRR_1_Kinetic_1(const SafePtr< TargetType >& Tint,
+  VRR_1_Kinetic_1<F,where>::VRR_1_Kinetic_1(const std::shared_ptr< TargetType >& Tint,
                                             unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -394,7 +394,7 @@ namespace libint2 {
         auto am1 = a - _1;
         if (exists(am1)) {
           auto Am1B = factory.make_child(am1,b);
-          auto S_Am1B = (where == InBra) ? overlap_factory.make_child(am1,b) : SafePtr<DGVertex>();
+          auto S_Am1B = (where == InBra) ? overlap_factory.make_child(am1,b) : std::shared_ptr<DGVertex>();
           if (is_simple()) {
             if (where == InBra) {
               expr_ += Scalar(a[dir]) * ( Scalar("oo2z") * Am1B -
@@ -410,7 +410,7 @@ namespace libint2 {
         auto bm1 = b - _1;
         if (exists(bm1)) {
           auto ABm1 = factory.make_child(a,bm1);
-          auto S_ABm1 = (where == InKet) ? overlap_factory.make_child(a,bm1) : SafePtr<DGVertex>();
+          auto S_ABm1 = (where == InKet) ? overlap_factory.make_child(a,bm1) : std::shared_ptr<DGVertex>();
           if (is_simple()) {
             if (where == InKet) {
               expr_ += Scalar(b[dir]) * ( Scalar("oo2z") * ABm1 -
@@ -453,7 +453,7 @@ namespace libint2 {
 
           OriginDerivative<3u> _d1; _d1.inc(dxyz);
 
-          SafePtr<DGVertex> _nullptr;
+          std::shared_ptr<DGVertex> _nullptr;
 
           // dA - _1?
           {
@@ -521,7 +521,7 @@ namespace libint2 {
       using ParentType::is_simple;
 
       /// Constructor is private, used by ParentType::Instance that mainains registry of these objects
-      VRR_1_ElecPot_1(const SafePtr<TargetType>&, unsigned int dir);
+      VRR_1_ElecPot_1(const std::shared_ptr<TargetType>&, unsigned int dir);
 
       static std::string descr() { return "OSVRRElecPot"; }
       /** Re-Implementation of GenericRecurrenceRelation::generate_label():
@@ -530,7 +530,7 @@ namespace libint2 {
       std::string generate_label() const override
       {
         typedef typename TargetType::AuxIndexType mType;
-        static SafePtr<mType> aux0(new mType(0u));
+        static std::shared_ptr<mType> aux0(new mType(0u));
         std::ostringstream os;
         os << descr() <<  to_string(where)
            << genintegralset_label(target_->bra(),target_->ket(),aux0,target_->oper());
@@ -539,7 +539,7 @@ namespace libint2 {
     };
 
   template <class F, FunctionPosition where>
-  VRR_1_ElecPot_1<F,where>::VRR_1_ElecPot_1(const SafePtr< TargetType >& Tint,
+  VRR_1_ElecPot_1<F,where>::VRR_1_ElecPot_1(const std::shared_ptr< TargetType >& Tint,
                                             unsigned int dir) :
     ParentType(Tint,dir)
     {
@@ -613,7 +613,7 @@ namespace libint2 {
 
           OriginDerivative<3u> _d1; _d1.inc(dxyz);
 
-          SafePtr<DGVertex> _nullptr;
+          std::shared_ptr<DGVertex> _nullptr;
 
           // dA - _1?
           {
@@ -687,7 +687,7 @@ namespace libint2 {
     static std::string descr() { return "OSVRRSMultipole"; }
 
     /// Constructor is private, used by ParentType::Instance that maintains registry of these objects
-    VRR_1_SMultipole_1(const SafePtr<TargetType>& Tint, unsigned int dir) :
+    VRR_1_SMultipole_1(const std::shared_ptr<TargetType>& Tint, unsigned int dir) :
         ParentType(Tint,dir)
         {
           using namespace libint2::algebra;
@@ -723,7 +723,7 @@ namespace libint2 {
           typedef TargetType ChildType;
           ChildFactory<ThisType,ChildType> factory(this);
 
-          auto make_child = [&](const F& bra, const F& ket, const OperType::Descriptor& descr) -> SafePtr<DGVertex> {
+          auto make_child = [&](const F& bra, const F& ket, const OperType::Descriptor& descr) -> std::shared_ptr<DGVertex> {
             return factory.make_child(bra, ket, EmptySet(), descr);
           };
 
@@ -746,7 +746,7 @@ namespace libint2 {
             auto am1 = a - _1; auto am1_exists = exists(am1);
             auto bm1 = b - _1; auto bm1_exists = exists(bm1);
 
-            SafePtr<ExprType> subexpr;  // to be multiplied by 1/(2 zeta)
+            std::shared_ptr<ExprType> subexpr;  // to be multiplied by 1/(2 zeta)
 
             if (am1_exists) {
               auto Am1B = make_child(am1, b, O_l_m);
@@ -832,7 +832,7 @@ namespace libint2 {
                   expr_ = Scalar(1) * S00;  // Eq. (25) and Eq. (61)
                 }
               } else {
-                SafePtr<ExprType> subexpr;  // to be multiplied by - 1/(2 m)
+                std::shared_ptr<ExprType> subexpr;  // to be multiplied by - 1/(2 m)
 
                 // Eqs. (25-26)
                 // (0|N^+_{m,m}|0) = -(1/(2m)) ( x (0|N^+_{m-1,m-1}|0) - y
@@ -861,7 +861,7 @@ namespace libint2 {
                 }
               }
             } else {                      // l != m, use Eq. 27
-              SafePtr<ExprType> subexpr;  // to be multiplied by 1/((l+m)(l-m))
+              std::shared_ptr<ExprType> subexpr;  // to be multiplied by 1/((l+m)(l-m))
 
               auto O_lm1_m = SphericalMultipole_Descr(l - 1, m, sign);
               if (exists(O_lm1_m)) {
diff --git a/src/bin/profile/generate_t0g12_code.cc b/src/bin/profile/generate_t0g12_code.cc
index 07e0ddd00..bd93c1a2c 100644
--- a/src/bin/profile/generate_t0g12_code.cc
+++ b/src/bin/profile/generate_t0g12_code.cc
@@ -50,7 +50,7 @@ namespace {
   {
     TesterCmdLine<4> cmdline(argc,argv);
     std::vector<unsigned int> l = cmdline.am();
-    const SafePtr<IntegralSet> integral = IntegralSet::Instance(CGShell(am[l[0]]),
+    const std::shared_ptr<IntegralSet> integral = IntegralSet::Instance(CGShell(am[l[0]]),
 								CGShell(am[l[1]]),
 								CGShell(am[l[2]]),
 								CGShell(am[l[3]]));
diff --git a/src/bin/test_eri/generate_eri_code.cc b/src/bin/test_eri/generate_eri_code.cc
index 66866e67a..b2acc44a6 100644
--- a/src/bin/test_eri/generate_eri_code.cc
+++ b/src/bin/test_eri/generate_eri_code.cc
@@ -69,7 +69,7 @@ namespace {
     //
     // generate all targets
     //
-    std::vector< SafePtr<ERIQtet> > targets;
+    std::vector< std::shared_ptr<ERIQtet> > targets;
     // iterate over the distribution of all derivative quanta among 12 different directions
     bool last_deriv = false;
     do {
@@ -78,7 +78,7 @@ namespace {
       CGShell c(l[2]);  for(unsigned int xyz=0; xyz<3; ++xyz) c.deriv().inc(xyz, (*diter)[6+xyz]);
       CGShell d(l[3]);  for(unsigned int xyz=0; xyz<3; ++xyz) d.deriv().inc(xyz, (*diter)[9+xyz]);
 
-      const SafePtr<ERIQtet> abcd0 = ERIQtet::Instance(a,b,c,d, 0u);
+      const std::shared_ptr<ERIQtet> abcd0 = ERIQtet::Instance(a,b,c,d, 0u);
       targets.push_back(abcd0);
       last_deriv = diter.last();
       if (!last_deriv) diter.next();
diff --git a/src/bin/test_eri/test_eri.cc b/src/bin/test_eri/test_eri.cc
index c19872fff..0a4639d9c 100644
--- a/src/bin/test_eri/test_eri.cc
+++ b/src/bin/test_eri/test_eri.cc
@@ -118,10 +118,10 @@ int main(int argc, char** argv)
   LIBINT2_REF_REALTYPE Dref[4]; for(int i=0; i<4; ++i) Dref[i] = D[i];
 
   typedef SubIteratorBase<CGShell> iter;
-  SafePtr<iter> sh0_iter(new iter(sh0));
-  SafePtr<iter> sh1_iter(new iter(sh1));
-  SafePtr<iter> sh2_iter(new iter(sh2));
-  SafePtr<iter> sh3_iter(new iter(sh3));
+  std::shared_ptr<iter> sh0_iter(new iter(sh0));
+  std::shared_ptr<iter> sh1_iter(new iter(sh1));
+  std::shared_ptr<iter> sh2_iter(new iter(sh2));
+  std::shared_ptr<iter> sh3_iter(new iter(sh3));
 
   Libint_eri0_t* erieval = libint2::malloc<Libint_eri0_t>(contrdepth4);
   const int max_am = max(max(am[0],am[1]),max(am[2],am[3]));
@@ -173,10 +173,10 @@ int main(int argc, char** argv)
           uint m3 = bf3.qn(1);
           uint n3 = bf3.qn(2);
 #else
-          SafePtr<CGF> bf0 = sh0_iter->elem();
-          SafePtr<CGF> bf1 = sh1_iter->elem();
-          SafePtr<CGF> bf2 = sh2_iter->elem();
-          SafePtr<CGF> bf3 = sh3_iter->elem();
+          std::shared_ptr<CGF> bf0 = sh0_iter->elem();
+          std::shared_ptr<CGF> bf1 = sh1_iter->elem();
+          std::shared_ptr<CGF> bf2 = sh2_iter->elem();
+          std::shared_ptr<CGF> bf3 = sh3_iter->elem();
 
           uint l0 = bf0->qn(0);
           uint m0 = bf0->qn(1);
diff --git a/src/bin/test_eri/test_eri_rys.cc b/src/bin/test_eri/test_eri_rys.cc
index edf956377..0afc4848e 100644
--- a/src/bin/test_eri/test_eri_rys.cc
+++ b/src/bin/test_eri/test_eri_rys.cc
@@ -231,10 +231,10 @@ int main(int argc, char** argv)
   LIBINT2_REF_REALTYPE Dref[4]; for(int i=0; i<4; ++i) Dref[i] = D[i];
 
   typedef SubIteratorBase<CGShell> iter;
-  SafePtr<iter> sh0_iter(new iter(sh0));
-  SafePtr<iter> sh1_iter(new iter(sh1));
-  SafePtr<iter> sh2_iter(new iter(sh2));
-  SafePtr<iter> sh3_iter(new iter(sh3));
+  std::shared_ptr<iter> sh0_iter(new iter(sh0));
+  std::shared_ptr<iter> sh1_iter(new iter(sh1));
+  std::shared_ptr<iter> sh2_iter(new iter(sh2));
+  std::shared_ptr<iter> sh3_iter(new iter(sh3));
 
   //------------------------------------------------------
   // compute recurrence prefactors, Rys roots and weights
@@ -431,10 +431,10 @@ int main(int argc, char** argv)
           uint m3 = bf3.qn(1);
           uint n3 = bf3.qn(2);
 #else
-          SafePtr<CGF> bf0 = sh0_iter->elem();
-          SafePtr<CGF> bf1 = sh1_iter->elem();
-          SafePtr<CGF> bf2 = sh2_iter->elem();
-          SafePtr<CGF> bf3 = sh3_iter->elem();
+          std::shared_ptr<CGF> bf0 = sh0_iter->elem();
+          std::shared_ptr<CGF> bf1 = sh1_iter->elem();
+          std::shared_ptr<CGF> bf2 = sh2_iter->elem();
+          std::shared_ptr<CGF> bf3 = sh3_iter->elem();
 
           uint l0 = bf0->qn(0);
           uint m0 = bf0->qn(1);
diff --git a/src/bin/test_eri/test_eri_rys_vec.cc b/src/bin/test_eri/test_eri_rys_vec.cc
index 704e361f0..e25bd76f8 100644
--- a/src/bin/test_eri/test_eri_rys_vec.cc
+++ b/src/bin/test_eri/test_eri_rys_vec.cc
@@ -235,10 +235,10 @@ std::cout<<"number of points"<<npts<<endl;
   LIBINT2_REF_REALTYPE Dref[4]; for(int i=0; i<4; ++i) Dref[i] = D[i];
 
   typedef SubIteratorBase<CGShell> iter;
-  SafePtr<iter> sh0_iter(new iter(sh0));
-  SafePtr<iter> sh1_iter(new iter(sh1));
-  SafePtr<iter> sh2_iter(new iter(sh2));
-  SafePtr<iter> sh3_iter(new iter(sh3));
+  std::shared_ptr<iter> sh0_iter(new iter(sh0));
+  std::shared_ptr<iter> sh1_iter(new iter(sh1));
+  std::shared_ptr<iter> sh2_iter(new iter(sh2));
+  std::shared_ptr<iter> sh3_iter(new iter(sh3));
 
   //------------------------------------------------------
   // compute recurrence prefactors, Rys roots and weights
@@ -433,10 +433,10 @@ std::cout<<"number of points"<<npts<<endl;
           uint m3 = bf3.qn(1);
           uint n3 = bf3.qn(2);
 #else
-          SafePtr<CGF> bf0 = sh0_iter->elem();
-          SafePtr<CGF> bf1 = sh1_iter->elem();
-          SafePtr<CGF> bf2 = sh2_iter->elem();
-          SafePtr<CGF> bf3 = sh3_iter->elem();
+          std::shared_ptr<CGF> bf0 = sh0_iter->elem();
+          std::shared_ptr<CGF> bf1 = sh1_iter->elem();
+          std::shared_ptr<CGF> bf2 = sh2_iter->elem();
+          std::shared_ptr<CGF> bf3 = sh3_iter->elem();
 
           uint l0 = bf0->qn(0);
           uint m0 = bf0->qn(1);
diff --git a/src/bin/test_eri/time_eri.cc b/src/bin/test_eri/time_eri.cc
index a27404947..cfb53b1ec 100644
--- a/src/bin/test_eri/time_eri.cc
+++ b/src/bin/test_eri/time_eri.cc
@@ -87,10 +87,10 @@ int main(int argc, char** argv)
   const double* D = &(rsqset.R[3][0]);
 
   typedef SubIteratorBase<CGShell> iter;
-  SafePtr<iter> sh0_iter(new iter(sh0));
-  SafePtr<iter> sh1_iter(new iter(sh1));
-  SafePtr<iter> sh2_iter(new iter(sh2));
-  SafePtr<iter> sh3_iter(new iter(sh3));
+  std::shared_ptr<iter> sh0_iter(new iter(sh0));
+  std::shared_ptr<iter> sh1_iter(new iter(sh1));
+  std::shared_ptr<iter> sh2_iter(new iter(sh2));
+  std::shared_ptr<iter> sh3_iter(new iter(sh3));
   
   Libint_eri0_t* erieval = libint2::malloc<Libint_eri0_t>(contrdepth4);
   const int max_am = max(max(am[0],am[1]),max(am[2],am[3]));