Аварийное завершение программы при использовании метода merge для list

int _tmain(int argc, _TCHAR* argv[])
{
    list<int> l(10);
    list<int> :: iterator p,k,t;
    int i=0;
    cout<<"size = "<<l.size()<<endl;
    for (p=l.begin();p!=l.end();p++,i++) *p = (i+10);
    list<int> l2(5);
    for (i=0,p=l2.begin();p!=l2.end();p++,i++) *p = 20-i;
    l.merge(l2);
    
    return 0;
}

list<int> l2(5);

l.sort();
l2.sort()
l.merge(l2);

sort(l.begin(),l.end());

vector<point> v(l.begin(),l.end());
l.clear();
    sort(v.begin(),v.end());
    copy(v.begin(),v.end(),l.begin());
v.clear();

//Title of this code
//g++  4.9.2
 
#include <iostream>
#include <algorithm>
#include <list>
#include <iterator>
 
 
 
template<typename Cont>
class BItoRA : std::random_access_iterator_tag
{
public:
    using Iterator = typename Cont::iterator ;
    using difference_type = typename Iterator::difference_type ;
    using value_type = typename Iterator::value_type ;
    using pointer = typename Iterator::pointer ;
    using reference = typename Iterator::reference ;
    using iterator_category = typename Iterator::iterator_category ;
    
    BItoRA(const Iterator& it, const Iterator& it_end)
        : it_end_(it_end)
        , it_(it)
    {}
       
    
    BItoRA operator+(difference_type d) const
    {
        Iterator it(it_) ;
        std::advance(it, d) ;
        return BItoRA(it, it_end_) ;
    }
    
    BItoRA operator-(difference_type d) const
    {
        Iterator it(it_) ;
        std::advance(it, -d) ;
        return BItoRA(it, it_end_) ;
    } 
    
    BItoRA operator++(int) 
    {
        return BItoRA(it_++, it_end_) ;
    } 
    
    
    BItoRA & operator++() 
    {
        ++it_ ;
        return *this ;
    } 
    
    
    BItoRA operator--(int) 
    {
        return BItoRA(it_--, it_end_) ;
    } 
    
    
    BItoRA & operator--() 
    {
        --it_ ;
        return *this ;
    } 
    
    
    difference_type operator-(const BItoRA& rhv) 
    {
        if( *this<rhv )
            return -std::distance(it_, rhv.it_) ;
        return std::distance(rhv.it_, it_) ;
    } 
 
    
    bool operator<(const BItoRA& rhv) 
    {
        return std::distance(rhv.it_, rhv.it_end_) < std::distance(it_, it_end_) ;
    } 
 
    
    bool operator==(const BItoRA& rhv) const
    {
        return it_ == rhv.it_ ;
    }
    
    
    bool operator!=(const BItoRA& rhv) const
    {
        return it_ != rhv.it_ ;
    }
    
    reference operator*()
    {
        return *it_ ;
    }
    
    pointer operator->()
    {
        return &*it_ ;
    }
    
    
    
private:
    Iterator it_end_ ;
    Iterator it_ ;
} ;
 
 
 
int main()
{
    std::list<int> lst {3, 7, 8, 9, 3, 1, 7, 8, 2, 4, 6, 5, 8} ;
    auto iter_beg = lst.begin() ;
    auto iter_end = lst.end() ;
    std::advance(iter_beg, 5) ;
    std::advance(iter_end, -2) ;
    auto beg = BItoRA<std::list<int>>(iter_beg, lst.end()) ;
    auto end = BItoRA<std::list<int>>(iter_end, lst.end()) ;
    std::sort(beg, end) ;
    for(auto e: lst)
        std::cout << e << ' ' ;
}

//Title of this code
//g++  4.9.2
 
#include <iostream>
#include <list>
#include <iterator>
 
int main()
{
    std::list<int> lst {3, 7, 8, 9, 3, 1, 7, 8, 2, 4, 6, 5, 8} ;
    auto iter_beg = lst.begin() ;
    auto iter_end = lst.end() ;
    std::advance(iter_beg, 5) ;
    std::advance(iter_end, -2) ;
    std::list<int> tmp_lst ;
    tmp_lst.splice(tmp_lst.begin(), lst, iter_beg, iter_end) ;
    tmp_lst.sort() ;
    iter_beg = lst.begin() ;
    std::advance(iter_beg, 5) ;
    lst.splice(iter_beg, tmp_lst) ;
    for(auto e: lst)
        std::cout << e << ' ' ;
}