diff --git a/include/boost/container/detail/destroyers.hpp b/include/boost/container/detail/destroyers.hpp
index 9b0be44..ab492f5 100644
--- a/include/boost/container/detail/destroyers.hpp
+++ b/include/boost/container/detail/destroyers.hpp
@@ -183,28 +183,31 @@ struct scoped_destructor_n
    typedef typename AllocTraits::value_type value_type;
    typedef typename AllocTraits::size_type  size_type;
 
-   scoped_destructor_n(pointer p, Allocator& a, size_type n)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, size_type n)
       : m_p(p), m_a(a), m_n(n)
    {}
 
-   void release()
-   {  m_p = 0; }
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {  m_p = 0; m_n = 0; }
 
-   void increment_size(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type inc)
    {  m_n += inc;   }
 
-   void increment_size_backwards(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type inc)
    {  m_n += inc;   m_p -= inc;  }
 
-   void shrink_forward(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type inc)
    {  m_n -= inc;   m_p += inc;  }
 
    ~scoped_destructor_n()
    {
-      if(!m_p) return;
-      value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
-      while(m_n--){
-         AllocTraits::destroy(m_a, raw_ptr++);
+      if(m_n){
+         value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
+         do {
+            --m_n;
+            AllocTraits::destroy(m_a, raw_ptr);
+            ++raw_ptr;
+         } while(m_n);
       }
    }
 
@@ -223,19 +226,19 @@ struct null_scoped_destructor_n
    typedef typename AllocTraits::pointer pointer;
    typedef typename AllocTraits::size_type size_type;
 
-   null_scoped_destructor_n(pointer, Allocator&, size_type)
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, size_type)
    {}
 
-   void increment_size(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type)
    {}
 
-   void increment_size_backwards(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type)
    {}
 
-   void shrink_forward(size_type)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type)
    {}
 
-   void release()
+   BOOST_CONTAINER_FORCEINLINE void release()
    {}
 };
 
@@ -245,24 +248,24 @@ class scoped_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef typename Allocator::value_type value_type;
-   scoped_destructor(Allocator &a, value_type *pv)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor(Allocator &a, value_type *pv)
       : pv_(pv), a_(a)
    {}
 
-   ~scoped_destructor()
+   BOOST_CONTAINER_FORCEINLINE ~scoped_destructor()
    {
       if(pv_){
          AllocTraits::destroy(a_, pv_);
       }
    }
 
-   void release()
+   BOOST_CONTAINER_FORCEINLINE void release()
    {  pv_ = 0; }
 
 
-   void set(value_type *ptr) { pv_ = ptr; }
+   BOOST_CONTAINER_FORCEINLINE void set(value_type *ptr) { pv_ = ptr; }
 
-   value_type *get() const { return pv_; }
+   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return pv_; }
 
    private:
    value_type *pv_;
@@ -276,11 +279,11 @@ class value_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef Value value_type;
-   value_destructor(Allocator &a, value_type &rv)
+   BOOST_CONTAINER_FORCEINLINE value_destructor(Allocator &a, value_type &rv)
       : rv_(rv), a_(a)
    {}
 
-   ~value_destructor()
+   BOOST_CONTAINER_FORCEINLINE ~value_destructor()
    {
       AllocTraits::destroy(a_, &rv_);
    }
@@ -304,18 +307,18 @@ class allocator_destroyer
    Allocator & a_;
 
    private:
-   void priv_deallocate(const pointer &p, version_1)
+   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_1)
    {  AllocTraits::deallocate(a_,p, 1); }
 
-   void priv_deallocate(const pointer &p, version_2)
+   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_2)
    {  a_.deallocate_one(p); }
 
    public:
-   explicit allocator_destroyer(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE explicit allocator_destroyer(Allocator &a)
       : a_(a)
    {}
 
-   void operator()(const pointer &p)
+   BOOST_CONTAINER_FORCEINLINE void operator()(const pointer &p)
    {
       AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
       this->priv_deallocate(p, alloc_version());
@@ -333,11 +336,11 @@ class allocator_destroyer_and_chain_builder
    multiallocation_chain &c_;
 
    public:
-   allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
+   BOOST_CONTAINER_FORCEINLINE allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
       :  a_(a), c_(c)
    {}
 
-   void operator()(const typename Allocator::pointer &p)
+   BOOST_CONTAINER_FORCEINLINE void operator()(const typename Allocator::pointer &p)
    {
       allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
       c_.push_back(p);
@@ -356,14 +359,14 @@ class allocator_multialloc_chain_node_deallocator
    multiallocation_chain c_;
 
    public:
-   allocator_multialloc_chain_node_deallocator(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE allocator_multialloc_chain_node_deallocator(Allocator &a)
       :  a_(a), c_()
    {}
 
-   chain_builder get_chain_builder()
+   BOOST_CONTAINER_FORCEINLINE chain_builder get_chain_builder()
    {  return chain_builder(a_, c_);  }
 
-   ~allocator_multialloc_chain_node_deallocator()
+   BOOST_CONTAINER_FORCEINLINE ~allocator_multialloc_chain_node_deallocator()
    {
       a_.deallocate_individual(c_);
    }