diff --git a/panda/src/putil/ordered_vector.I b/panda/src/putil/ordered_vector.I
index fa89545cf6..05a9cdb1b3 100644
--- a/panda/src/putil/ordered_vector.I
+++ b/panda/src/putil/ordered_vector.I
@@ -72,7 +72,7 @@ INLINE ordered_vector<Key, Compare>::
 //               the ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
 begin() {
   return _vector.begin();
 }
@@ -84,7 +84,7 @@ begin() {
 //               ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
 end() {
   return _vector.end();
 }
@@ -96,7 +96,7 @@ end() {
 //               the ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::reverse_iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rbegin() {
   return _vector.rbegin();
 }
@@ -108,7 +108,7 @@ rbegin() {
 //               ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::reverse_iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rend() {
   return _vector.rend();
 }
@@ -120,7 +120,7 @@ rend() {
 //               the ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
 begin() const {
   return _vector.begin();
 }
@@ -132,7 +132,7 @@ begin() const {
 //               ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
 end() const {
   return _vector.end();
 }
@@ -144,7 +144,7 @@ end() const {
 //               the ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_reverse_iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rbegin() const {
   return _vector.rbegin();
 }
@@ -156,7 +156,7 @@ rbegin() const {
 //               ordered vector, when viewed in reverse order.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_reverse_iterator ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
 rend() const {
   return _vector.rend();
 }
@@ -167,8 +167,8 @@ rend() const {
 //  Description: Returns the nth element.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::reference ordered_vector<Key, Compare>::
-operator [] (ordered_vector<Key, Compare>::size_type n) {
+INLINE ordered_vector<Key, Compare>::REFERENCE ordered_vector<Key, Compare>::
+operator [] (ordered_vector<Key, Compare>::SIZE_TYPE n) {
   return _vector[n];
 }
 
@@ -178,8 +178,8 @@ operator [] (ordered_vector<Key, Compare>::size_type n) {
 //  Description: Returns the nth element.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_reference ordered_vector<Key, Compare>::
-operator [] (ordered_vector<Key, Compare>::size_type n) const {
+INLINE ordered_vector<Key, Compare>::CONST_REFERENCE ordered_vector<Key, Compare>::
+operator [] (ordered_vector<Key, Compare>::SIZE_TYPE n) const {
   return _vector[n];
 }
 
@@ -189,7 +189,7 @@ operator [] (ordered_vector<Key, Compare>::size_type n) const {
 //  Description: Returns the number of elements in the ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::size_type ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
 size() const {
   return _vector.size();
 }
@@ -201,7 +201,7 @@ size() const {
 //               possibly be stored in an ordered vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::size_type ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
 max_size() const {
   return _vector.max_size();
 }
@@ -309,25 +309,25 @@ operator >= (const ordered_vector<Key, Compare> &other) const {
 //               the insert operation has taken place.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<ordered_vector<Key, Compare>::iterator, bool> ordered_vector<Key, Compare>::
-insert_unique(const ordered_vector<Key, Compare>::value_type &key) {
-  iterator position = find_insert_position(begin(), end(), key);
+INLINE pair<ordered_vector<Key, Compare>::ITERATOR, bool> ordered_vector<Key, Compare>::
+insert_unique(const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
+  ITERATOR position = find_insert_position(begin(), end(), key);
 #ifdef NDEBUG
-  pair<iterator, bool> bogus_result(end(), false);
+  pair<ITERATOR, bool> bogus_result(end(), false);
   nassertr(position >= begin() && position <= end(), bogus_result);
 #endif
 
   // If there's already an equivalent key in the vector, it's at
   // *(position - 1).
   if (position != begin() && !_compare(*(position - 1), key)) {
-    pair<iterator, bool> result(position - 1, false);
+    pair<ITERATOR, bool> result(position - 1, false);
     nassertr(!_compare(key, *(position - 1)), result);
     return result;
   }
 
-  iterator result = _vector.insert(position, key);
+  ITERATOR result = _vector.insert(position, key);
   verify_list();
-  return pair<iterator, bool>(result, true);
+  return pair<ITERATOR, bool>(result, true);
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -342,12 +342,12 @@ insert_unique(const ordered_vector<Key, Compare>::value_type &key) {
 //               element.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-insert_nonunique(const ordered_vector<Key, Compare>::value_type &key) {
-  iterator position = find_insert_position(begin(), end(), key);
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+insert_nonunique(const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
+  ITERATOR position = find_insert_position(begin(), end(), key);
   nassertr(position >= begin() && position <= end(), end());
 
-  iterator result = _vector.insert(position, key);
+  ITERATOR result = _vector.insert(position, key);
   verify_list();
   return result;
 }
@@ -360,9 +360,9 @@ insert_nonunique(const ordered_vector<Key, Compare>::value_type &key) {
 //               and returns the next sequential iterator.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-erase(ordered_vector<Key, Compare>::iterator position) {
-  size_type count = position - begin();
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+erase(ordered_vector<Key, Compare>::ITERATOR position) {
+  SIZE_TYPE count = position - begin();
   _vector.erase(position);
   return begin() + count;
 }
@@ -374,10 +374,10 @@ erase(ordered_vector<Key, Compare>::iterator position) {
 //               returns the number of elements removed.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::size_type ordered_vector<Key, Compare>::
-erase(const ordered_vector<Key, Compare>::key_type &key) {
-  pair<iterator, iterator> result = equal_range(key);
-  size_type count = result.second - result.first;
+INLINE ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+erase(const ordered_vector<Key, Compare>::KEY_TYPE &key) {
+  pair<ITERATOR, ITERATOR> result = equal_range(key);
+  SIZE_TYPE count = result.second - result.first;
   erase(result.first, result.second);
   return count;
 }
@@ -390,8 +390,8 @@ erase(const ordered_vector<Key, Compare>::key_type &key) {
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
 INLINE void ordered_vector<Key, Compare>::
-erase(ordered_vector<Key, Compare>::iterator first,
-      ordered_vector<Key, Compare>::iterator last) {
+erase(ordered_vector<Key, Compare>::ITERATOR first,
+      ordered_vector<Key, Compare>::ITERATOR last) {
   _vector.erase(first, last);
 }
 
@@ -415,8 +415,8 @@ clear() {
 //               key, the particular iterator returned is not defined.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-find(const ordered_vector<Key, Compare>::key_type &key) {
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+find(const ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_find(begin(), end(), end(), key));
 }
 
@@ -429,8 +429,8 @@ find(const ordered_vector<Key, Compare>::key_type &key) {
 //               key, the particular iterator returned is not defined.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-find(const ordered_vector<Key, Compare>::key_type &key) const {
+INLINE ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+find(const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_find(begin(), end(), end(), key);
 }
 
@@ -451,8 +451,8 @@ find(const ordered_vector<Key, Compare>::key_type &key) const {
 //               !Compare(b, a), but not necessarily the converse.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-find_particular(const ordered_vector<Key, Compare>::key_type &key) {
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+find_particular(const ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_find_particular(begin(), end(), end(), key));
 }
 
@@ -470,8 +470,8 @@ find_particular(const ordered_vector<Key, Compare>::key_type &key) {
 //               particular iterator returned is not defined./
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-find_particular(const ordered_vector<Key, Compare>::key_type &key) const {
+INLINE ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+find_particular(const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_find_particular(begin(), end(), end(), key);
 }
 
@@ -482,7 +482,7 @@ find_particular(const ordered_vector<Key, Compare>::key_type &key) const {
 //               to the key that are in the vector.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::size_type ordered_vector<Key, Compare>::
+INLINE ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
 count(const key_type &key) const {
   return r_count(begin(), end(), key);
 }
@@ -494,8 +494,8 @@ count(const key_type &key) const {
 //               than key, or end() if all elements are less than key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-lower_bound(const ordered_vector<Key, Compare>::key_type &key) {
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+lower_bound(const ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_lower_bound(begin(), end(), key));
 }
 
@@ -506,8 +506,8 @@ lower_bound(const ordered_vector<Key, Compare>::key_type &key) {
 //               than key, or end() if all elements are less than key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-lower_bound(const ordered_vector<Key, Compare>::key_type &key) const {
+INLINE ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+lower_bound(const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_lower_bound(begin(), end(), key);
 }
 
@@ -519,8 +519,8 @@ lower_bound(const ordered_vector<Key, Compare>::key_type &key) const {
 //               key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-upper_bound(const ordered_vector<Key, Compare>::key_type &key) {
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+upper_bound(const ordered_vector<Key, Compare>::KEY_TYPE &key) {
   return nci(r_upper_bound(begin(), end(), key));
 }
 
@@ -532,8 +532,8 @@ upper_bound(const ordered_vector<Key, Compare>::key_type &key) {
 //               key.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-upper_bound(const ordered_vector<Key, Compare>::key_type &key) const {
+INLINE ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+upper_bound(const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_upper_bound(begin(), end(), key);
 }
 
@@ -543,11 +543,11 @@ upper_bound(const ordered_vector<Key, Compare>::key_type &key) const {
 //  Description: Returns the pair (lower_bound(key), upper_bound(key)).
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<ordered_vector<Key, Compare>::iterator, ordered_vector<Key, Compare>::iterator> ordered_vector<Key, Compare>::
-equal_range(const ordered_vector<Key, Compare>::key_type &key) {
-  pair<ordered_vector<Key, Compare>::const_iterator, ordered_vector<Key, Compare>::const_iterator> result;
+INLINE pair<ordered_vector<Key, Compare>::ITERATOR, ordered_vector<Key, Compare>::ITERATOR> ordered_vector<Key, Compare>::
+equal_range(const ordered_vector<Key, Compare>::KEY_TYPE &key) {
+  pair<ordered_vector<Key, Compare>::CONST_ITERATOR, ordered_vector<Key, Compare>::CONST_ITERATOR> result;
   result = r_equal_range(begin(), end(), key);
-  return pair<ordered_vector<Key, Compare>::iterator, ordered_vector<Key, Compare>::iterator>(nci(result.first), nci(result.second));
+  return pair<ordered_vector<Key, Compare>::ITERATOR, ordered_vector<Key, Compare>::ITERATOR>(nci(result.first), nci(result.second));
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -556,8 +556,8 @@ equal_range(const ordered_vector<Key, Compare>::key_type &key) {
 //  Description: Returns the pair (lower_bound(key), upper_bound(key)).
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<ordered_vector<Key, Compare>::const_iterator, ordered_vector<Key, Compare>::const_iterator> ordered_vector<Key, Compare>::
-equal_range(const ordered_vector<Key, Compare>::key_type &key) const {
+INLINE pair<ordered_vector<Key, Compare>::CONST_ITERATOR, ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
+equal_range(const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   return r_equal_range(begin(), end(), key);
 }
 
@@ -582,7 +582,7 @@ swap(ordered_vector<Key, Compare> &copy) {
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
 INLINE void ordered_vector<Key, Compare>::
-reserve(ordered_vector<Key, Compare>::size_type n) {
+reserve(ordered_vector<Key, Compare>::SIZE_TYPE n) {
   _vector.reserve(n);
 }
 
@@ -644,9 +644,9 @@ push_back(const value_type &key) {
 //               some of these methods.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-nci(ordered_vector<Key, Compare>::const_iterator iterator) {
-  return begin() + (iterator - begin());
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+nci(ordered_vector<Key, Compare>::CONST_ITERATOR i) {
+  return begin() + (i - begin());
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -657,11 +657,11 @@ nci(ordered_vector<Key, Compare>::const_iterator iterator) {
 //               corresponding iterator.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-find_insert_position(ordered_vector<Key, Compare>::iterator first,
-                     ordered_vector<Key, Compare>::iterator last,
-                     const ordered_vector<Key, Compare>::key_type &key) {
-  iterator result = r_find_insert_position(first, last, key);
+INLINE ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+find_insert_position(ordered_vector<Key, Compare>::ITERATOR first,
+                     ordered_vector<Key, Compare>::ITERATOR last,
+                     const ordered_vector<Key, Compare>::KEY_TYPE &key) {
+  ITERATOR result = r_find_insert_position(first, last, key);
 
 #ifndef NDEBUG
   // Verify the result.
@@ -743,9 +743,9 @@ operator = (const ov_set<Key, Compare> &copy) {
 //  Description: Maps to insert_unique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ov_set<Key, Compare>::iterator ov_set<Key, Compare>::
-insert(ordered_vector<Key, Compare>::iterator position, 
-       const ordered_vector<Key, Compare>::value_type &key) {
+ordered_vector<Key, Compare>::ITERATOR ov_set<Key, Compare>::
+insert(ordered_vector<Key, Compare>::ITERATOR position, 
+       const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_unique(position, key);
 }
 
@@ -755,8 +755,8 @@ insert(ordered_vector<Key, Compare>::iterator position,
 //  Description: Maps to insert_unique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE pair<ov_set<Key, Compare>::iterator, bool> ov_set<Key, Compare>::
-insert(const ordered_vector<Key, Compare>::value_type &key) {
+INLINE pair<ordered_vector<Key, Compare>::ITERATOR, bool> ov_set<Key, Compare>::
+insert(const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_unique(key);
 }
 
@@ -813,9 +813,9 @@ operator = (const ov_multiset<Key, Compare> &copy) {
 //  Description: Maps to insert_nonunique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ov_multiset<Key, Compare>::iterator ov_multiset<Key, Compare>::
-insert(ov_multiset<Key, Compare>::iterator position, 
-       const ov_multiset<Key, Compare>::value_type &key) {
+ordered_vector<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
+insert(ordered_vector<Key, Compare>::ITERATOR position, 
+       const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_nonunique(position, key);
 }
 
@@ -825,8 +825,8 @@ insert(ov_multiset<Key, Compare>::iterator position,
 //  Description: Maps to insert_nonunique().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-INLINE ov_multiset<Key, Compare>::iterator ov_multiset<Key, Compare>::
-insert(const ov_multiset<Key, Compare>::value_type &key) {
+INLINE ordered_vector<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
+insert(const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   return ordered_vector<Key, Compare>::insert_nonunique(key);
 }
 
diff --git a/panda/src/putil/ordered_vector.T b/panda/src/putil/ordered_vector.T
index 53811627ec..4622e39243 100644
--- a/panda/src/putil/ordered_vector.T
+++ b/panda/src/putil/ordered_vector.T
@@ -32,9 +32,9 @@
 //               referencing the original value is returned.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-insert_unique(ordered_vector<Key, Compare>::iterator position, 
-              const ordered_vector<Key, Compare>::value_type &key) {
+ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+insert_unique(ordered_vector<Key, Compare>::ITERATOR position, 
+              const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   if (position != end()) {
     // If we're not inserting at the end, the element we're
     // inserting before should not lexicographically precede this one.
@@ -61,7 +61,7 @@ insert_unique(ordered_vector<Key, Compare>::iterator position,
   }
 
   // Otherwise, we may insert where the caller requested.
-  iterator result = _vector.insert(position, key);
+  ITERATOR result = _vector.insert(position, key);
   verify_list();
   return result;
 }
@@ -79,9 +79,9 @@ insert_unique(ordered_vector<Key, Compare>::iterator position,
 //               same key to be inserted.
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-insert_nonunique(ordered_vector<Key, Compare>::iterator position, 
-                 const ordered_vector<Key, Compare>::value_type &key) {
+ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+insert_nonunique(ordered_vector<Key, Compare>::ITERATOR position, 
+                 const ordered_vector<Key, Compare>::VALUE_TYPE &key) {
   if (position != end()) {
     // If we're not inserting at the end, the element we're
     // inserting before should not lexicographically precede this one.
@@ -99,7 +99,7 @@ insert_nonunique(ordered_vector<Key, Compare>::iterator position,
   }
 
   // Otherwise, we may insert where the caller requested.
-  iterator result = _vector.insert(position, key);
+  ITERATOR result = _vector.insert(position, key);
   verify_list();
   return result;
 }
@@ -111,16 +111,16 @@ insert_nonunique(ordered_vector<Key, Compare>::iterator position,
 //               find_insert_position().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::iterator ordered_vector<Key, Compare>::
-r_find_insert_position(ordered_vector<Key, Compare>::iterator first,
-                       ordered_vector<Key, Compare>::iterator last,
-                       const ordered_vector<Key, Compare>::key_type &key) {
+ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
+r_find_insert_position(ordered_vector<Key, Compare>::ITERATOR first,
+                       ordered_vector<Key, Compare>::ITERATOR last,
+                       const ordered_vector<Key, Compare>::KEY_TYPE &key) {
   if (first == last) {
     // The list is empty; the insert position is the last of the list.
     return last;
   }
 
-  iterator center = first + (last - first) / 2;
+  ITERATOR center = first + (last - first) / 2;
   nassertr(center < last, last);
 
   if (_compare(key, *center)) {
@@ -139,17 +139,17 @@ r_find_insert_position(ordered_vector<Key, Compare>::iterator first,
 //  Description: The recursive implementation of find().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-r_find(ordered_vector<Key, Compare>::const_iterator first,
-       ordered_vector<Key, Compare>::const_iterator last,
-       ordered_vector<Key, Compare>::const_iterator not_found,
-       const ordered_vector<Key, Compare>::key_type &key) const {
+ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_find(ordered_vector<Key, Compare>::CONST_ITERATOR first,
+       ordered_vector<Key, Compare>::CONST_ITERATOR last,
+       ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
+       const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return not_found;
   }
 
-  const_iterator center = first + (last - first) / 2;
+  CONST_ITERATOR center = first + (last - first) / 2;
   nassertr(center < last, last);
 
   if (_compare(key, *center)) {
@@ -172,17 +172,17 @@ r_find(ordered_vector<Key, Compare>::const_iterator first,
 //  Description: The recursive implementation of find_particular().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-r_find_particular(ordered_vector<Key, Compare>::const_iterator first,
-                  ordered_vector<Key, Compare>::const_iterator last,
-                  ordered_vector<Key, Compare>::const_iterator not_found,
-                  const ordered_vector<Key, Compare>::key_type &key) const {
+ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_find_particular(ordered_vector<Key, Compare>::CONST_ITERATOR first,
+                  ordered_vector<Key, Compare>::CONST_ITERATOR last,
+                  ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
+                  const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return not_found;
   }
 
-  const_iterator center = first + (last - first) / 2;
+  CONST_ITERATOR center = first + (last - first) / 2;
   nassertr(center < last, last);
 
   if (_compare(key, *center)) {
@@ -196,7 +196,7 @@ r_find_particular(ordered_vector<Key, Compare>::const_iterator first,
   } else {
     // The center's sort matches the key's sort.  It could be either
     // before or after the center.  First try after.
-    const_iterator i = center;
+    CONST_ITERATOR i = center;
     while (i < last && !_compare(key, *i)) {
       if ((*i) == key) {
         return i;
@@ -225,18 +225,18 @@ r_find_particular(ordered_vector<Key, Compare>::const_iterator first,
 //  Description: The recursive implementation of count().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::size_type ordered_vector<Key, Compare>::
-r_count(ordered_vector<Key, Compare>::const_iterator first,
-        ordered_vector<Key, Compare>::const_iterator last,
-        const ordered_vector<Key, Compare>::key_type &key) const {
-  typedef pair<ordered_vector<Key, Compare>::const_iterator, ordered_vector<Key, Compare>::const_iterator> pair_type;
+ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
+r_count(ordered_vector<Key, Compare>::CONST_ITERATOR first,
+        ordered_vector<Key, Compare>::CONST_ITERATOR last,
+        const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+  typedef pair<ordered_vector<Key, Compare>::CONST_ITERATOR, ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
 
   if (first == last) {
     // The list is empty; the key is not on the list.
     return 0;
   }
 
-  const_iterator center = first + (last - first) / 2;
+  CONST_ITERATOR center = first + (last - first) / 2;
   nassertr(center < last, 0);
 
   if (_compare(key, *center)) {
@@ -261,16 +261,16 @@ r_count(ordered_vector<Key, Compare>::const_iterator first,
 //  Description: The recursive implementation of lower_bound().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-r_lower_bound(ordered_vector<Key, Compare>::const_iterator first,
-              ordered_vector<Key, Compare>::const_iterator last,
-              const ordered_vector<Key, Compare>::key_type &key) const {
+ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_lower_bound(ordered_vector<Key, Compare>::CONST_ITERATOR first,
+              ordered_vector<Key, Compare>::CONST_ITERATOR last,
+              const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return last;
   }
 
-  const_iterator center = first + (last - first) / 2;
+  CONST_ITERATOR center = first + (last - first) / 2;
   nassertr(center < last, last);
 
   if (_compare(key, *center)) {
@@ -294,10 +294,10 @@ r_lower_bound(ordered_vector<Key, Compare>::const_iterator first,
 //  Description: The recursive implementation of upper_bound().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-ordered_vector<Key, Compare>::const_iterator ordered_vector<Key, Compare>::
-r_upper_bound(ordered_vector<Key, Compare>::const_iterator first,
-              ordered_vector<Key, Compare>::const_iterator last,
-              const ordered_vector<Key, Compare>::key_type &key) const {
+ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
+r_upper_bound(ordered_vector<Key, Compare>::CONST_ITERATOR first,
+              ordered_vector<Key, Compare>::CONST_ITERATOR last,
+              const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
   if (first == last) {
     // The list is empty; the key is not on the list.
     return last;
@@ -327,18 +327,18 @@ r_upper_bound(ordered_vector<Key, Compare>::const_iterator first,
 //  Description: The recursive implementation of equal_range().
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
-pair<ordered_vector<Key, Compare>::const_iterator, ordered_vector<Key, Compare>::const_iterator> ordered_vector<Key, Compare>::
-r_equal_range(ordered_vector<Key, Compare>::const_iterator first,
-              ordered_vector<Key, Compare>::const_iterator last,
-              const ordered_vector<Key, Compare>::key_type &key) const {
-  typedef pair<ordered_vector<Key, Compare>::const_iterator, ordered_vector<Key, Compare>::const_iterator> pair_type;
+pair<ordered_vector<Key, Compare>::CONST_ITERATOR, ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
+r_equal_range(ordered_vector<Key, Compare>::CONST_ITERATOR first,
+              ordered_vector<Key, Compare>::CONST_ITERATOR last,
+              const ordered_vector<Key, Compare>::KEY_TYPE &key) const {
+  typedef pair<ordered_vector<Key, Compare>::CONST_ITERATOR, ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
 
   if (first == last) {
     // The list is empty; the key is not on the list.
     return pair_type(last, last);
   }
 
-  const_iterator center = first + (last - first) / 2;
+  CONST_ITERATOR center = first + (last - first) / 2;
   nassertr(center < last, pair_type(last, last));
 
   if (_compare(key, *center)) {
@@ -351,8 +351,8 @@ r_equal_range(ordered_vector<Key, Compare>::const_iterator first,
 
   } else {
     // The center matches the key; the range is here.
-    const_iterator lower = r_lower_bound(first, center, key);
-    const_iterator upper = r_upper_bound(center + 1, last, key);
+    CONST_ITERATOR lower = r_lower_bound(first, center, key);
+    CONST_ITERATOR upper = r_upper_bound(center + 1, last, key);
     return pair_type(lower, upper);
   }
 }
@@ -365,11 +365,11 @@ r_equal_range(ordered_vector<Key, Compare>::const_iterator first,
 ////////////////////////////////////////////////////////////////////
 template<class Key, class Compare>
 bool ordered_vector<Key, Compare>::
-verify_list_impl(ordered_vector<Key, Compare>::iterator first, 
-                 ordered_vector<Key, Compare>::iterator last) {
+verify_list_impl(ordered_vector<Key, Compare>::ITERATOR first, 
+                 ordered_vector<Key, Compare>::ITERATOR last) {
   if (first < last) {
-    iterator prev = first;
-    iterator i = first;
+    ITERATOR prev = first;
+    ITERATOR i = first;
     ++i;
     while (i < last) {
       bool ordered_correctly = !_compare(*i, *prev);
diff --git a/panda/src/putil/ordered_vector.h b/panda/src/putil/ordered_vector.h
index 4042f58bd5..79971dbd2a 100644
--- a/panda/src/putil/ordered_vector.h
+++ b/panda/src/putil/ordered_vector.h
@@ -26,6 +26,54 @@
 #include "pset.h"
 #include <algorithm>
 
+// Two different compilers that both should have known better had
+// problems parsing the inheritance of typedefs in the template
+// classes below.  Both gcc 2.95.3 and the Intel Windows compiler (not
+// sure of the version) got confused in different ways.  It is a
+// mystery how these compilers are able to handle the actual STL
+// headers, which do this sort of thing all over the place.
+
+// One effective workaround for both compilers seems to be to rename
+// the typedef names slightly.  If the following symbol is declared,
+// the macros in this file will do the job of renaming the typedef
+// names for these broken compilers.  We should probably make this a
+// configurable parameter, but since it doesn't do any harm to leave
+// it declared even for non-broken compilers, we might as well just
+// leave it alone.
+#define BROKEN_TYPEDEF_INHERITANCE 1
+
+// Maybe eventually, when STL is more than only about ten years old
+// and compiler support of anything more than trivial template classes
+// is more universal, we can pull this nonsense out of here.
+
+#ifdef BROKEN_TYPEDEF_INHERITANCE
+  #define KEY_TYPE key_type_0
+  #define VALUE_TYPE value_type_0
+  #define REFERENCE reference_0
+  #define CONST_REFERENCE const_reference_0
+  #define KEY_COMPARE key_compare_0
+  #define VALUE_COMPARE value_compare_0
+  #define ITERATOR iterator_0
+  #define CONST_ITERATOR const_iterator_0
+  #define REVERSE_ITERATOR reverse_iterator_0
+  #define CONST_REVERSE_ITERATOR const_reverse_iterator_0
+  #define DIFFERENCE_TYPE difference_type_0
+  #define SIZE_TYPE size_type_0
+#else
+  #define KEY_TYPE key_type
+  #define VALUE_TYPE value_type
+  #define REFERENCE reference
+  #define CONST_REFERENCE const_reference
+  #define KEY_COMPARE key_compare
+  #define VALUE_COMPARE value_compare
+  #define ITERATOR iterator
+  #define CONST_ITERATOR const_iterator
+  #define REVERSE_ITERATOR reverse_iterator
+  #define CONST_REVERSE_ITERATOR const_reverse_iterator
+  #define DIFFERENCE_TYPE difference_type
+  #define SIZE_TYPE size_type
+#endif
+
 ////////////////////////////////////////////////////////////////////
 //       Class : ordered_vector
 // Description : This template class presents an interface similar to
@@ -69,23 +117,41 @@ private:
   
 public:
   // Typedefs
-  typedef Key key_type;
-  typedef Key value_type;
-  typedef Key &reference;
-  typedef const Key &const_reference;
-  typedef Compare key_compare;
-  typedef Compare value_compare;
+  typedef Key KEY_TYPE;
+  typedef Key VALUE_TYPE;
+  typedef Key &REFERENCE;
+  typedef const Key &CONST_REFERENCE;
+  typedef Compare KEY_COMPARE;
+  typedef Compare VALUE_COMPARE;
 
   // Be careful when using the non-const iterators that you do not
   // disturb the sorted order of the vector, or that if you do, you
   // call sort() when you are done.
-  typedef Vector::iterator iterator;
-  typedef Vector::const_iterator const_iterator;
-  typedef Vector::reverse_iterator reverse_iterator;
-  typedef Vector::const_reverse_iterator const_reverse_iterator;
+  typedef Vector::iterator ITERATOR;
+  typedef Vector::const_iterator CONST_ITERATOR;
+  typedef Vector::reverse_iterator REVERSE_ITERATOR;
+  typedef Vector::const_reverse_iterator CONST_REVERSE_ITERATOR;
 
-  typedef Vector::difference_type difference_type;
-  typedef Vector::size_type size_type;
+  typedef Vector::difference_type DIFFERENCE_TYPE;
+  typedef Vector::size_type SIZE_TYPE;
+
+#ifdef BROKEN_TYPEDEF_INHERITANCE
+  // Since the #define symbols do not actually expand to the correct
+  // names, we have to re-typedef them so callers can reference them
+  // by their correct, lowercase names.
+  typedef KEY_TYPE key_type;
+  typedef VALUE_TYPE value_type;
+  typedef REFERENCE reference;
+  typedef CONST_REFERENCE const_reference;
+  typedef KEY_COMPARE key_compare;
+  typedef VALUE_COMPARE value_compare;
+  typedef ITERATOR iterator;
+  typedef CONST_ITERATOR const_iterator;
+  typedef REVERSE_ITERATOR reverse_iterator;
+  typedef CONST_REVERSE_ITERATOR const_reverse_iterator;
+  typedef DIFFERENCE_TYPE difference_type;
+  typedef SIZE_TYPE size_type;
+#endif
 
 public:
   // Constructors.  We don't implement the whole slew of STL
@@ -96,23 +162,23 @@ public:
   INLINE ~ordered_vector();
 
   // Iterator access.
-  INLINE iterator begin();
-  INLINE iterator end();
-  INLINE reverse_iterator rbegin();
-  INLINE reverse_iterator rend();
+  INLINE ITERATOR begin();
+  INLINE ITERATOR end();
+  INLINE REVERSE_ITERATOR rbegin();
+  INLINE REVERSE_ITERATOR rend();
 
-  INLINE const_iterator begin() const;
-  INLINE const_iterator end() const;
-  INLINE const_reverse_iterator rbegin() const;
-  INLINE const_reverse_iterator rend() const;
+  INLINE CONST_ITERATOR begin() const;
+  INLINE CONST_ITERATOR end() const;
+  INLINE CONST_REVERSE_ITERATOR rbegin() const;
+  INLINE CONST_REVERSE_ITERATOR rend() const;
 
   // Random access.
-  INLINE reference operator [] (size_type n);
-  INLINE const_reference operator [] (size_type n) const;
+  INLINE reference operator [] (SIZE_TYPE n);
+  INLINE const_reference operator [] (SIZE_TYPE n) const;
 
   // Size information.
-  INLINE size_type size() const;
-  INLINE size_type max_size() const;
+  INLINE SIZE_TYPE size() const;
+  INLINE SIZE_TYPE max_size() const;
   INLINE bool empty() const;
 
   // Equivalence and lexicographical comparisons.
@@ -125,64 +191,64 @@ public:
   INLINE bool operator >= (const ordered_vector<Key, Compare> &other) const;
 
   // Insert operations.
-  iterator insert_unique(iterator position, const value_type &key);
-  iterator insert_nonunique(iterator position, const value_type &key);
-  INLINE pair<iterator, bool> insert_unique(const value_type &key);
-  INLINE iterator insert_nonunique(const value_type &key);
+  ITERATOR insert_unique(ITERATOR position, const VALUE_TYPE &key);
+  ITERATOR insert_nonunique(ITERATOR position, const VALUE_TYPE &key);
+  INLINE pair<ITERATOR, bool> insert_unique(const VALUE_TYPE &key);
+  INLINE ITERATOR insert_nonunique(const VALUE_TYPE &key);
 
   // Erase operations.
-  INLINE iterator erase(iterator position);
-  INLINE size_type erase(const key_type &key);
-  INLINE void erase(iterator first, iterator last);
+  INLINE ITERATOR erase(ITERATOR position);
+  INLINE SIZE_TYPE erase(const KEY_TYPE &key);
+  INLINE void erase(ITERATOR first, ITERATOR last);
   INLINE void clear();
 
   // Find operations.
-  INLINE iterator find(const key_type &key);
-  INLINE const_iterator find(const key_type &key) const;
-  INLINE iterator find_particular(const key_type &key);
-  INLINE const_iterator find_particular(const key_type &key) const;
-  INLINE size_type count(const key_type &key) const;
+  INLINE ITERATOR find(const KEY_TYPE &key);
+  INLINE CONST_ITERATOR find(const KEY_TYPE &key) const;
+  INLINE ITERATOR find_particular(const KEY_TYPE &key);
+  INLINE CONST_ITERATOR find_particular(const KEY_TYPE &key) const;
+  INLINE SIZE_TYPE count(const KEY_TYPE &key) const;
 
-  INLINE iterator lower_bound(const key_type &key);
-  INLINE const_iterator lower_bound(const key_type &key) const;
-  INLINE iterator upper_bound(const key_type &key);
-  INLINE const_iterator upper_bound(const key_type &key) const;
-  INLINE pair<iterator, iterator> equal_range(const key_type &key);
-  INLINE pair<const_iterator, const_iterator> equal_range(const key_type &key) const;
+  INLINE ITERATOR lower_bound(const KEY_TYPE &key);
+  INLINE CONST_ITERATOR lower_bound(const KEY_TYPE &key) const;
+  INLINE ITERATOR upper_bound(const KEY_TYPE &key);
+  INLINE CONST_ITERATOR upper_bound(const KEY_TYPE &key) const;
+  INLINE pair<ITERATOR, ITERATOR> equal_range(const KEY_TYPE &key);
+  INLINE pair<CONST_ITERATOR, CONST_ITERATOR> equal_range(const KEY_TYPE &key) const;
 
   // Special operations.
   INLINE void swap(ordered_vector<Key, Compare> &other);
-  INLINE void reserve(size_type n);
+  INLINE void reserve(SIZE_TYPE n);
   INLINE void sort_unique();
   INLINE void sort_nonunique();
 
-  INLINE void push_back(const value_type &key);
+  INLINE void push_back(const VALUE_TYPE &key);
 
 private:
-  INLINE iterator nci(const_iterator iterator);
-  INLINE iterator find_insert_position(iterator first, iterator last, 
-                                       const key_type &key);
-  iterator r_find_insert_position(iterator first, iterator last, 
-                                  const key_type &key);
-  const_iterator r_find(const_iterator first, const_iterator last,
-                        const_iterator not_found,
-                        const key_type &key) const;
-  const_iterator r_find_particular(const_iterator first, const_iterator last,
-                                   const_iterator not_found,
-                                   const key_type &key) const;
-  size_type r_count(const_iterator first, const_iterator last,
-                    const key_type &key) const;
-  const_iterator r_lower_bound(const_iterator first, const_iterator last,
-                               const key_type &key) const;
-  const_iterator r_upper_bound(const_iterator first, const_iterator last,
-                               const key_type &key) const;
-  pair<const_iterator, const_iterator>
-  r_equal_range(const_iterator first, const_iterator last,
-                const key_type &key) const;
+  INLINE ITERATOR nci(CONST_ITERATOR i);
+  INLINE ITERATOR find_insert_position(ITERATOR first, ITERATOR last, 
+                                       const KEY_TYPE &key);
+  ITERATOR r_find_insert_position(ITERATOR first, ITERATOR last, 
+                                  const KEY_TYPE &key);
+  CONST_ITERATOR r_find(CONST_ITERATOR first, CONST_ITERATOR last,
+                        CONST_ITERATOR not_found,
+                        const KEY_TYPE &key) const;
+  CONST_ITERATOR r_find_particular(CONST_ITERATOR first, CONST_ITERATOR last,
+                                   CONST_ITERATOR not_found,
+                                   const KEY_TYPE &key) const;
+  SIZE_TYPE r_count(CONST_ITERATOR first, CONST_ITERATOR last,
+                    const KEY_TYPE &key) const;
+  CONST_ITERATOR r_lower_bound(CONST_ITERATOR first, CONST_ITERATOR last,
+                               const KEY_TYPE &key) const;
+  CONST_ITERATOR r_upper_bound(CONST_ITERATOR first, CONST_ITERATOR last,
+                               const KEY_TYPE &key) const;
+  pair<CONST_ITERATOR, CONST_ITERATOR>
+  r_equal_range(CONST_ITERATOR first, CONST_ITERATOR last,
+                const KEY_TYPE &key) const;
   INLINE bool verify_list();
 
 #ifndef NDEBUG
-  bool verify_list_impl(iterator first, iterator last);
+  bool verify_list_impl(ITERATOR first, ITERATOR last);
 #endif
 
   // This function object is used in sort_unique().  It returns true
@@ -195,7 +261,7 @@ private:
     // template class cannot be defined outside the class".
     INLINE EquivalentTest(const Compare &compare) :
       _compare(compare) { }
-    INLINE bool operator () (const key_type &a, const key_type &b) {
+    INLINE bool operator () (const KEY_TYPE &a, const KEY_TYPE &b) {
       nassertr(!_compare(b, a), false);
       return !_compare(a, b);
     }
@@ -216,28 +282,12 @@ private:
 template<class Key, class Compare = less<Key> >
 class ov_set : public ordered_vector<Key, Compare> {
 public:
-  // The Intel compiler doesn't seem to inherit these typedefs
-  // completely--it gets confused in certain cases.  We'll make it
-  // explicit.
-  typedef ordered_vector<Key, Compare>::key_type key_type;
-  typedef ordered_vector<Key, Compare>::value_type value_type;
-  typedef ordered_vector<Key, Compare>::reference reference;
-  typedef ordered_vector<Key, Compare>::const_reference const_reference;
-  typedef ordered_vector<Key, Compare>::key_compare key_compare;
-  typedef ordered_vector<Key, Compare>::value_compare value_compare;
-  typedef ordered_vector<Key, Compare>::iterator iterator;
-  typedef ordered_vector<Key, Compare>::const_iterator const_iterator;
-  typedef ordered_vector<Key, Compare>::reverse_iterator reverse_iterator;
-  typedef ordered_vector<Key, Compare>::const_reverse_iterator const_reverse_iterator;
-  typedef ordered_vector<Key, Compare>::difference_type difference_type;
-  typedef ordered_vector<Key, Compare>::size_type size_type;
-
   INLINE ov_set(const Compare &compare = Compare());
   INLINE ov_set(const ov_set<Key, Compare> &copy);
   INLINE ov_set<Key, Compare> &operator = (const ov_set<Key, Compare> &copy);
 
-  INLINE iterator insert(iterator position, const value_type &key);
-  INLINE pair<iterator, bool> insert(const value_type &key);
+  INLINE ITERATOR insert(ITERATOR position, const VALUE_TYPE &key0);
+  INLINE pair<ITERATOR, bool> insert(const VALUE_TYPE &key0);
 
   INLINE void sort();
 };
@@ -251,28 +301,12 @@ public:
 template<class Key, class Compare = less<Key> >
 class ov_multiset : public ordered_vector<Key, Compare> {
 public:
-  // The Intel compiler doesn't seem to inherit these typedefs
-  // completely--it gets confused in certain cases.  We'll make it
-  // explicit.
-  typedef ordered_vector<Key, Compare>::key_type key_type;
-  typedef ordered_vector<Key, Compare>::value_type value_type;
-  typedef ordered_vector<Key, Compare>::reference reference;
-  typedef ordered_vector<Key, Compare>::const_reference const_reference;
-  typedef ordered_vector<Key, Compare>::key_compare key_compare;
-  typedef ordered_vector<Key, Compare>::value_compare value_compare;
-  typedef ordered_vector<Key, Compare>::iterator iterator;
-  typedef ordered_vector<Key, Compare>::const_iterator const_iterator;
-  typedef ordered_vector<Key, Compare>::reverse_iterator reverse_iterator;
-  typedef ordered_vector<Key, Compare>::const_reverse_iterator const_reverse_iterator;
-  typedef ordered_vector<Key, Compare>::difference_type difference_type;
-  typedef ordered_vector<Key, Compare>::size_type size_type;
-
   INLINE ov_multiset(const Compare &compare = Compare());
   INLINE ov_multiset(const ov_multiset<Key, Compare> &copy);
   INLINE ov_multiset<Key, Compare> &operator = (const ov_multiset<Key, Compare> &copy);
 
-  INLINE iterator insert(iterator position, const value_type &key);
-  INLINE iterator insert(const value_type &key);
+  INLINE ITERATOR insert(ITERATOR position, const VALUE_TYPE &key);
+  INLINE ITERATOR insert(const VALUE_TYPE &key);
 
   INLINE void sort();
 };