diff --git a/include/boost/pending/detail/int_iterator.hpp b/include/boost/pending/detail/int_iterator.hpp
new file mode 100644
index 0000000..346774c
--- /dev/null
+++ b/include/boost/pending/detail/int_iterator.hpp
@@ -0,0 +1,68 @@
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+#ifndef BOOST_INT_ITERATOR_H
+#define BOOST_INT_ITERATOR_H
+
+#include <boost/iterator.hpp>
+#if !defined BOOST_MSVC
+#include <boost/operators.hpp>
+#endif
+#include <iostream>
+//using namespace std;
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+#endif
+
+// this should use random_access_iterator_helper but I've had
+// VC++ portablility problems with that. -JGS
+template <class IntT>
+class int_iterator
+{
+  typedef int_iterator self;
+public:
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef IntT value_type;
+  typedef IntT& reference;
+  typedef IntT* pointer;
+  typedef ptrdiff_t difference_type;
+
+  inline int_iterator() : _i(0) { }
+  inline int_iterator(IntT i) : _i(i) { }
+  inline int_iterator(const self& x) : _i(x._i) { }
+  inline self& operator=(const self& x) { _i = x._i; return *this; }
+  inline IntT operator*() { return _i; }
+  inline IntT operator[](IntT n) { return _i + n; }
+  inline self& operator++() { ++_i; return *this; }
+  inline self operator++(int) { self t = *this; ++_i; return t; }
+  inline self& operator+=(IntT n) { _i += n; return *this; }
+  inline self operator+(IntT n) { self t = *this; t._i += n; return t; }
+  inline self& operator--() { --_i; return *this; }
+  inline self operator--(int) { self t = *this; --_i; return t; }
+  inline self& operator-=(IntT n) { _i -= n; return *this; }
+  inline IntT operator-(const self& x) const { return _i - x._i; }
+  inline bool operator==(const self& x) const { return _i == x._i; }
+  // vc++ had a problem finding != in random_access_iterator_helper
+  // need to look into this... for now implementing everything here -JGS
+  inline bool operator!=(const self& x) const { return _i != x._i; }
+  inline bool operator<(const self& x) const { return _i < x._i; }
+protected:
+  IntT _i;
+};
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} /* namespace boost */
+#endif
+
+#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+  using ::int_iterator;
+}
+#endif
+
+
+#endif /* BOOST_INT_ITERATOR_H */
diff --git a/include/boost/pending/integer_range.hpp b/include/boost/pending/integer_range.hpp
new file mode 100644
index 0000000..710ebe7
--- /dev/null
+++ b/include/boost/pending/integer_range.hpp
@@ -0,0 +1,76 @@
+// (C) Copyright David Abrahams 2000. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#ifndef BOOST_INTEGER_RANGE_HPP_
+#define BOOST_INTEGER_RANGE_HPP_
+
+#ifdef BOOST_MSVC
+#include <boost/pending/detail/int_iterator.hpp>
+#else
+#include <boost/pending/iterator_adaptor.hpp>
+#endif
+
+namespace boost {
+
+//=============================================================================
+// Counting Iterator and Integer Range Class
+
+struct counting_iterator_policies : public default_iterator_policies
+{
+    template <class IntegerType>
+    IntegerType dereference(type<IntegerType>, const IntegerType& i) const
+        { return i; }
+};
+template <class IntegerType>
+struct counting_iterator_traits {
+    typedef IntegerType value_type;
+    typedef IntegerType reference;
+    typedef value_type* pointer;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::random_access_iterator_tag iterator_category;
+};
+
+template <class IntegerType>
+struct integer_range {
+#ifdef BOOST_MSVC
+    typedef int_iterator<IntegerType> iterator;
+#else
+    typedef iterator_adaptor<IntegerType, counting_iterator_policies,
+      counting_iterator_traits<IntegerType>, IntegerType> iterator;
+#endif
+    typedef iterator const_iterator;
+    typedef IntegerType value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef IntegerType reference;
+    typedef IntegerType const_reference;
+    typedef const IntegerType* pointer;
+    typedef const IntegerType* const_pointer;
+    typedef IntegerType size_type;
+
+    integer_range(IntegerType start, IntegerType finish)
+        : m_start(start), m_finish(finish) { }
+
+    iterator begin() const { return iterator(m_start); }
+    iterator end() const { return iterator(m_finish); }
+    size_type size() const { return m_finish - m_start; }
+    bool empty() const { return m_finish == m_start; }
+    void swap(integer_range& x) {
+        std::swap(m_start, x.m_start);
+        std::swap(m_finish, x.m_finish);
+    }
+protected:
+    IntegerType m_start, m_finish;
+};
+
+} // namespace boost
+
+#endif // BOOST_INTEGER_RANGE_HPP_