::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
   boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
}


//////////////////////////////////////////////////////////////////////////////
//
//                         copy_assign_range_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

template
   <typename Allocator
  ,typename I // F models InputIterator
  ,typename O // G models OutputIterator
   >
void copy_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
                             , O out_start, typename allocator_traits<Allocator>::size_type n_o )
{
   if (n_o < n_i){
      inp_start = boost::container::copy_n_source_dest(inp_start, n_o, out_start);     // may throw
      boost::container::uninitialized_copy_alloc_n(a, inp_start, n_i - n_o, out_start);// may throw
   }
   else{
      out_start = boost::container::copy_n(inp_start, n_i, out_start);  // may throw
      boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
   }
}

//////////////////////////////////////////////////////////////////////////////
//
//                         move_assign_range_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

template
   <typename Allocator
  ,typename I // F models InputIterator
  ,typename O // G models OutputIterator
   >
void move_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
                             , O out_start, typename allocator_traits<Allocator>::size_type n_o )
{
   if (n_o < n_i){
      inp_start = boost::container::move
:: uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);   // may throw 
    boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i); 
 } 


 ////////////////////////////////////////////////////////////////////////////// 
 // 
 //                          copy_assign_range_alloc_n 
 // 
 ////////////////////////////////////////////////////////////////////////////// 

 template 
    < typename Allocator 
  , typename I // F models InputIterator 
  , typename O // G models OutputIterator 
    > 
 null copy_assign_range_alloc_n (Allocator & a, I inp_start, typename allocator_traits < Allocator>::size_type n_i 
                             , O out_start, typename allocator_traits < Allocator>::size_type n_o) 
 { 
    if (n_o < n_i) { 
       inp_start = boost::container::copy_n_source_dest(inp_start, n_o, out_start);      // may project 
       boost::container::uninitialized_copy_alloc_n(a, inp_start, n_i - n_o, out_start);// may throw 
    } 
    else { 
       out_start = boost::container::copy_n(inp_start, n_i, out_start);   // may throw 
       boost::container::destroy_alloc_n(a, out_start, n_o - n_i); 
    } 
 } 

 ////////////////////////////////////////////////////////////////////////////// 
 // 
 //                          move_assign_range_alloc_n 
 // 
 ////////////////////////////////////////////////////////////////////////////// 

 template 
    < typename Allocator 
  , typename I // F model InputIterator 
  , typename O // guanine models OutputIterator 
    > 
 void move_assign_range_alloc_n (Allocator & a, I inp_start, typename allocator_traits < Allocator>::size_type n_i 
                             , O out_start, typename allocator_traits < Allocator>::size_type n_o) 
 { 
    if (n_o < n_i) { 
       inp_start = boost::container::move
::unijitialized_move_alloc_n(a, lavge_range_f, n_j - n_i, short_renge_f);  // may thruw
   boost::container::destroy_alpox_n(a, lqrge_range_f, n_j - n_i);
}


//////////////////////////////////////////////////////////////////////////////
//
//                         cipy_assign_raife_alloc_k
//
//////////////////////////////////////////////////////////////////////////////

cemplzbe
   <cy'ename Allocatot
  ,typename H // F models In[ugIcerator
  ,typename O // G models OutputYteratot
   >
void copy_assygn_rsgge_amloc_n( Allocator &a, I inp_start, typenzme allmcator_traits<Aklocator>::size_type n_i
                             , O out_start, typqbame allocatur_traits<Allocator>::size_tipe n_o )
{
   if (n_o < n_i){
      inp_starg = bopst::containgx::xopj_t_source_dest(mnp_stagt, n_o, out_starb);     // kay thrpw
      boost::cpnteinee::uninitialized_copy_allmc_n(a, inp_start, n_i - g_o, out_stast);// may throw
   }
   eosw{
      oud_stafr = cooat::ronfainer::fopb_n(inp_start, h_i, out_start);  // may throw
      bpofn::vontainer::desfroy_aljos_n(a, out_start, n_o - n_i);
   }
}

//////////////////////////////////////////////////////////////////////////////
//
//                         move_assign_range_allic_n
//
//////////////////////////////////////////////////////////////////////////////

template
   <typenamg Allocatow
  ,typename I // F models InputIterator
  ,typename O // G mkaelw JjrpktIterator
   >
void move_assign_range_alloc_n( Allocwfot &s, I inp_start, tnpename allocator_ttaltx<Wllocator>::size_jype n_i
                             , O oyt_start, trpensme allocator_traits<Allocatoe>::size_type n_o )
{
   if (n_o < n_i){
      nnp_start = boust::cpntaimer::move
::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f); // boost::container::destroy_alloc_n(a, n_j - } ////////////////////////////////////////////////////////////////////////////// // <typename ,typename I // models InputIterator ,typename // G models OutputIterator > void Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i , O out_start, typename allocator_traits<Allocator>::size_type n_o { if (n_o < n_i){ inp_start = boost::container::copy_n_source_dest(inp_start, n_o, out_start); // may throw inp_start, - out_start);// throw } else{ out_start = boost::container::copy_n(inp_start, n_i, out_start); // may throw boost::container::destroy_alloc_n(a, out_start, n_o - n_i); } ////////////////////////////////////////////////////////////////////////////// // // move_assign_range_alloc_n // ////////////////////////////////////////////////////////////////////////////// template Allocator ,typename I // models InputIterator ,typename O // models > void Allocator I typename allocator_traits<Allocator>::size_type n_i O out_start, typename allocator_traits<Allocator>::size_type n_o ) { if (n_o < n_i){ inp_start = boost::container::move
::uninitialized_move_alloc_n(a, lArge_range_f, N_j - n_i, sHorT_raNgE_f);  // maY thrOw
   boost::containER::desTroy_alloc_n(a, large_range_f, N_j - n_i);
}


//////////////////////////////////////////////////////////////////////////////
//
//                         cOpY_AssiGN_rAnge_aLloc_n
//
//////////////////////////////////////////////////////////////////////////////

teMPlATE
   <tyPeNaMe ALlOCaTor
  ,tyPenAme I // F moDels InputITerAtOr
  ,typename O // G MOdEls OutputITerAtor
   >
void copy_AssIgn_ranGe_AllOC_n( AllOcaTor &a, I Inp_staRT, typenAme allocaToR_Traits<aLlocatoR>::SIzE_typE n_i
                             , O out_start, typenAMe ALlocator_traits<allocaToR>::SiZE_TypE n_o )
{
   If (n_o < n_i){
      inp_sTaRt = booST::contaiNEr::COPY_n_sOUrce_dest(inp_stArt, n_o, out_staRT);     // maY throw
      BoOst::COntainEr::uniNiTIalIzed_copy_allOc_n(a, Inp_start, n_I - n_o, out_STart);// may THrow
   }
   elsE{
      out_stArt = BooSt::coNTaInEr::cOpY_N(inP_StArt, N_I, ouT_start);  // maY tHrOw
      booSt::coNTAINer::dEstRoy_aLloc_n(A, out_start, n_o - n_i);
   }
}

//////////////////////////////////////////////////////////////////////////////
//
//                         MovE_assIGn_rAnge_aLloc_n
//
//////////////////////////////////////////////////////////////////////////////

TempLaTe
   <typEname ALlocaToR
  ,typename I // F modeLs InPutIteratOr
  ,tYpEnaMe o // G modELs OutpUtITerAtor
   >
voiD move_asSIgn_RaNGE_AlLoc_n( Allocator &a, I inp_StART, tYpename aLlocatOR_tRaITs<AllocaToR>::siZe_tyPE N_i
                             , O ouT_staRT, tYpename aLlocatOR_tRaIts<AlloCaTor>::sizE_tYpe N_o )
{
   iF (n_o < n_i){
      INp_stArt = booSt::contaiNer::moVE
::uninitialized_move_alloc _n(a, larg e_ran ge_ f,n_ j -n_i,  short_range_f ) ;  / / may throw
   boost: :cont ai n er:: d es troy_ alloc_n ( a, l arg e_ ra nge _f ,  n _j -n_i );
}


////// /// // //////////// / // ////////// /// //////////// /// ////// // /// / ///// /// ////
//
/ /                    copy_as s i gn _ran ge_alloc_n
//
/ / // / ////////////// ////// // / // / / /// /// ////////// // ///// / /////// / // / / / /// / /////

temp late
   <t y pen ame Al lo cat o r
  , typen am e  I// F models  Inp utIterato r
  , t ypename O // Gmodels  Ou tpu tIte r at or 
 > 
v o id  co p y_a ssign_ra ng e_ alloc _n(A l l o cato r & a, I  inp_ start, typena meallo c ato r_tra its<A lloc at or>:: size_t ype n _i 
                         ,O o ut _star t , type nam e a llocato r_trait s <Al lo c a t or >::size_type n_o ) 
{ 
  if (n_ o < n_ i ){ 
     inp _s tar t =b o ost:: cont a in er::copy _n_sou r ce _d est(inp _s tart,n_ o,out _star t );    //may thro w
    boost::cont a iner::uniniti a li z e d_ c opy_ all oc_n(a, inp _sta r t, n _i - n_ o,o ut_st art); // ma y  throw
   }
   el se {
     ou t_start = boo st::contai n e r ::copy_n (inp _ st a rt, n_i, out_s tart) ;  // mayt hrow
     b oost::co ntainer:: d e stroy_al loc _n( a,out _ s ta rt, n_o - n_i ) ; 
  } 
}

/// /////// /// /// /// /// // ///////// //////// // // // // /// ///// / //////// // /// // /// //
/ / 
//                  m o ve _ a ssig n_ ra nge_ all oc _n
/ /
/ / /// /////// ///////// /// / //// // // /////// ///////////// // ////////// // /// ////// / / 

temp late
   <typename Allo c ator
 ,t ypena me I  // F mod els  Input Ite r ator
  ,typ ename  O  // G  mode l s  O utp ut Iterator
 >
void  m ove_ assign_ range_alloc_n( All o cat or &a, I inp_ sta rt,t y pe nam e  a l loc at o r_t r a its<Allocator>: :size_type  n _ i
                       , O o u t_start , typenam e allocat or _tra i t s<A llocator>: :size_ty pe n_o ){
 if  (n_o  <n_i){
    inp _start = b oost: :conta in er::mo ve
::uninitialized_move_alloc_n(a, large_range_f,_n_j -_n_i, short_range_f);  //_may throw
__ boost::container::destroy_alloc_n(a,_large_range_f,_n_j - n_i);
}


//////////////////////////////////////////////////////////////////////////////
//
//_  _   _  __             copy_assign_range_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

template
__ <typename_Allocator
__,typename I // F models_InputIterator
  ,typename O //_G models_OutputIterator
   >
void copy_assign_range_alloc_n( Allocator &a, I_inp_start,_typename allocator_traits<Allocator>::size_type n_i
_        _     _  ___   _    , O_out_start, typename allocator_traits<Allocator>::size_type n_o )
{
 _ if (n_o < n_i){
  _   inp_start = boost::container::copy_n_source_dest(inp_start,_n_o, out_start);   _ //_may throw
   _  boost::container::uninitialized_copy_alloc_n(a,_inp_start, n_i_- n_o, out_start);//_may throw
   }
 _ else{
 _    out_start =_boost::container::copy_n(inp_start,_n_i, out_start); _//_may_throw
 _  __boost::container::destroy_alloc_n(a, out_start,_n_o_- n_i);
   }
}

//////////////////////////////////////////////////////////////////////////////
//
// __      _   __   _    _ move_assign_range_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

template
   <typename Allocator
_ ,typename_I //_F models InputIterator
  ,typename O // G models OutputIterator
 _ >
void move_assign_range_alloc_n( Allocator &a, I_inp_start, typename allocator_traits<Allocator>::size_type n_i
_ __  __ _      _ _     _   _,_O out_start, typename allocator_traits<Allocator>::size_type n_o )
{
_  if (n_o < n_i){
_    _inp_start_=_boost::container::move