Изменить std::map

                    ??=ifndef _MAP_
                      ??=if defined(__MVS__)
                        ??=if defined(__COMPILER_VER__)
                          ??=pragma filetag("IBM-1047")
                        #endif /* defined(__COMPILER_VER__) */
                        #pragma nomargins nosequence
                        #pragma checkout(suspend)
                      #endif /* defined(__MVS__) */
                      #define _MAP_
 
// map standard header
 
#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(level, E)
#endif
#pragma info(restore)
 
#if defined(__MVS__)
#  if (__IBMCPP__ < 41020)
#    error\
     This file to be used only with IBM z/OS C++ V1R2 and later compilers
#  endif /* __IBMCPP__ < 41020 */
#else
#  if (__IBMCPP__ < 400)
#    error\
     This file to be used only with IBM VisualAge C++ v4 and later compilers
#  endif /* __IBMCPP__ < 400 */
#endif /* defined(__MVS__) */
 
#if (__OS400_TGTVRM__ >= 510)
#if defined(__LLP64_IFC__) || defined(__LLP64_RTBND__)
   #pragma datamodel(LLP64)
#else
   #pragma datamodel(P128)
#endif
#endif
 
#if !(defined(__MVS__) && defined(_LP64))
#pragma object_model(compat)
#endif
#if (__OS400_TGTVRM__ > 610)
#if __V8_NAME_MANGLING
  #pragma namemangling(v8)
#else
  #pragma namemangling(v7)
#endif
#else
#pragma namemangling(ansi)
#endif
 
/**********************************************************************/
/*  <map> header file                                                 */
/*                                                                    */
/**********************************************************************/
/*                                                                    */
/*   Licensed Materials - Property of IBM.                            */
/*                                                                    */
/*   Product(s):                                                      */
/*     5722-SS1                                                       */
/*     5761-SS1                                                       */
/*     5770-SS1                                                       */
/*                                                                    */
/*   (C)Copyright IBM Corp.  1991, 2013                               */
/*                                                                    */
/*   All Rights Reserved.                                             */
/*   US Government Users Restricted Rights -                          */
/*   Use, duplication or disclosure restricted by                     */
/*   GSA ADP Schedule Contract with IBM Corp.                         */
/*                                                                    */
/**********************************************************************/
/*                                                                    */
/*  Dinkum C++ Library                                                */
/*  Copyright (c) 1998.  Licensed to IBM Corp. and its suppliers.     */
/*                                                                    */
/**********************************************************************/
 
#include <xtree>
_STD_BEGIN
                // TEMPLATE CLASS _Tmap_traits
template<class _K, class _Ty, class _Pr, class _Ax, bool _Mfl>
        class _Tmap_traits {
public:
        typedef _K key_type;
        typedef pair<const _K, _Ty> value_type;
        typedef _Pr key_compare;
        typedef typename _Ax::template rebind<value_type>::other
                allocator_type;
        enum {_Multi = _Mfl};
        _Tmap_traits()
                : comp()
                {}
        _Tmap_traits(_Pr _Parg)
                : comp(_Parg)
                {}
        class value_compare
                : public binary_function<value_type, value_type, bool> {
                friend class _Tmap_traits<_K, _Ty, _Pr, _Ax, _Mfl>;
        public:
                bool operator()(const value_type& _X,
                        const value_type& _Y) const
                        {return (comp(_X.first, _Y.first)); }
                value_compare(key_compare _Pred)
                        : comp(_Pred) {}
        protected:
                key_compare comp;
                };
        struct _Kfn {
                const _K& operator()(const value_type& _X) const
                        {return (_X.first); }
                };
        _Pr comp;
        };
 
                // TEMPLATE CLASS map
template<class _K, class _Ty,
        class _Pr _TDEF(less<_K>),
        class _A _TDEF2(allocator<pair<const _K, _Ty> >) >
        class map
                : public _Tree<_Tmap_traits<_K, _Ty, _Pr, _A, false> > {
public:
        typedef map<_K, _Ty, _Pr, _A> _Myt;
        typedef _Tree<_Tmap_traits<_K, _Ty, _Pr, _A, false> >
                _Mybase;
        typedef _K key_type;
        typedef _Ty mapped_type;
        typedef _Ty referent_type;
        typedef _Pr key_compare;
        typedef typename _Mybase::value_compare value_compare;
        typedef typename _Mybase::allocator_type allocator_type;
        typedef typename _Mybase::size_type size_type;
        typedef typename _Mybase::difference_type difference_type;
        typedef typename _Mybase::pointer pointer;
        typedef typename _Mybase::const_pointer const_pointer;
        typedef typename _Mybase::reference reference;
        typedef typename _Mybase::const_reference const_reference;
        typedef typename _Mybase::iterator iterator;
        typedef typename _Mybase::const_iterator const_iterator;
        typedef typename _Mybase::reverse_iterator reverse_iterator;
        typedef typename _Mybase::const_reverse_iterator
                const_reverse_iterator;
        typedef typename _Mybase::value_type value_type;
        map()
                : _Mybase(key_compare(), allocator_type()) {}
        explicit map(const key_compare& _Pred)
                : _Mybase(_Pred, allocator_type()) {}
        map(const key_compare& _Pred, const allocator_type& _Al)
                : _Mybase(_Pred, _Al) {}
        template<class _It>
                map(_It _F, _It _L)
                : _Mybase(key_compare(), allocator_type())
                {for (; _F != _L; ++_F)
                        _Mybase::insert(*_F); }
        template<class _It>
                map(_It _F, _It _L, const key_compare& _Pred)
                : _Mybase(_Pred, allocator_type())
                {for (; _F != _L; ++_F)
                        _Mybase::insert(*_F); }
        template<class _It>
                map(_It _F, _It _L, const key_compare& _Pred,
                const allocator_type& _Al)
                : _Mybase(_Pred, _Al)
                {for (; _F != _L; ++_F)
                        _Mybase::insert(*_F); }
        mapped_type& operator[](const key_type& _Kv)
                {iterator _P =
                        _Mybase::insert(value_type(_Kv, mapped_type())).first;
                return ((*_P).second); }
        };
 
                // TEMPLATE CLASS multimap
template<class _K, class _Ty,
        class _Pr _TDEF(less<_K>),
        class _A _TDEF2(allocator<pair<const _K, _Ty> >) >
        class multimap
                : public _Tree<_Tmap_traits<_K, _Ty, _Pr, _A, true> > {
public:
        typedef multimap<_K, _Ty, _Pr, _A> _Myt;
        typedef _Tree<_Tmap_traits<_K, _Ty, _Pr, _A, true> >
                _Mybase;
        typedef _K key_type;
        typedef _Ty mapped_type;
        typedef _Ty referent_type;      // old name, magically gone
        typedef _Pr key_compare;
        typedef typename _Mybase::value_compare value_compare;
        typedef typename _Mybase::allocator_type allocator_type;
        typedef typename _Mybase::size_type size_type;
        typedef typename _Mybase::difference_type difference_type;
        typedef typename _Mybase::pointer pointer;
        typedef typename _Mybase::const_pointer const_pointer;
        typedef typename _Mybase::reference reference;
        typedef typename _Mybase::const_reference const_reference;
        typedef typename _Mybase::iterator iterator;
        typedef typename _Mybase::const_iterator const_iterator;
        typedef typename _Mybase::reverse_iterator reverse_iterator;
        typedef typename _Mybase::const_reverse_iterator
                const_reverse_iterator;
        typedef typename _Mybase::value_type value_type;
        multimap()
                : _Mybase(key_compare(), allocator_type()) {}
        explicit multimap(const key_compare& _Pred)
                : _Mybase(_Pred, allocator_type()) {}
        multimap(const key_compare& _Pred, const allocator_type& _Al)
                : _Mybase(_Pred, _Al) {}
        template<class _It>
                multimap(_It _F, _It _L)
                : _Mybase(key_compare(), allocator_type())
                {for (; _F != _L; ++_F)
                        insert(*_F); }
        template<class _It>
                multimap(_It _F, _It _L, const key_compare& _Pred)
                : _Mybase(_Pred, allocator_type())
                {for (; _F != _L; ++_F)
                        insert(*_F); }
        template<class _It>
                multimap(_It _F, _It _L, const key_compare& _Pred,
                const allocator_type& _Al)
                : _Mybase(_Pred, _Al)
                {for (; _F != _L; ++_F)
                        insert(*_F); }
        iterator insert(const value_type& _X)
                {return (_Mybase::insert(_X).first); }
        iterator insert(iterator _P, const value_type& _X)
                {return (_Mybase::insert(_P, _X)); }
        template<class _It>
                void insert(_It _F, _It _L)
                {for (; _F != _L; ++_F)
                        insert(*_F); }
        };
_STD_END
 
#pragma namemangling(pop)
#if !(defined(__MVS__) && defined(_LP64))
#pragma object_model(pop)
#endif
 
#if (__OS400_TGTVRM__ >= 510)
   #pragma datamodel(pop)
#endif
 
#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(pop)
#endif
#pragma info(restore)
 
/*
 * Copyright (c) 1998 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V2.3:0081 */
 
                    #if defined(__MVS__)
                      #pragma checkout(resume)
                    #endif /* defined(__MVS__) */
                    ??=endif /* _MAP_ */