#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define debug(x) cerr << #x << " = " << x << "\n"
#define debugv(x) rep(i, x.size()) cerr << x[i] << (i == x.size() - 1 ? "\n" : " ")
#define all(x) x.begin(), x.end()
#define int long long
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = ((1LL << 30) + (1LL << 29));
const int MOD = 1000000007;

//=============================
int N, M, K;
string S, T;
vector<int> A;
vector<int> B;
vector<pii> W;
//=============================
void input()
{
    cin >> N >> M;
    W.resize(N);
    rep(i, N)
    {
        cin >> W[i].first >> W[i].second;
    }
}
//=============================
void func() {}
//=============================
vector<int> dp(111111, 0);
void solve()
{
    priority_queue<int> q;
    int i = 0;
    int ans = 0;
    int insind = 0;
    sort(all(W));

    for (int i = 1; i <= M; ++i)
    {
        for (; insind < N; ++insind)
        {
            if (W[insind].first <= i)
            {
                q.push(W[insind].second);
            }
            else
                break;
        }
        if (q.size())
        {
            ans += q.top();
            q.pop();
        }
    }

    // sort(all(W), [](const pii &a, const pii &b){
    //     return a.second>b.second;
    // });
    // // sort(all(W), [](const pii &a, const pii &b) {
    // //     return ((double)a.second / a.first) > ((double)b.second / b.first);
    // // });
    // sort(all(W), [](const pii &a, const pii &b){
    //     return (a.first==b.first ? a.second>b.second : a.first < b.first);
    // });
    // vector<int> mx(N);
    // vector<pii> np;
    // int i=0;
    // int ans=0;
    // int insind=0;
    // for(int j=1; j<= M; ++j){
    //     for(;insind<N;++insind){
    //         if (W[insind].first<=j){
    //             np.push_back(W[insind]);
    //         }
    //         else break;
    //     }
    // sort(all(np), [](const pii &a, const pii &b){
    //     return (a.first==b.first ? a.second>b.second : a.first < b.first);
    // });

    // ans += np[0].second;
    // np[0] = make_pair(INF,-1);
    // }
    cout << ans << endl;
}

//     vector<pii> erabu;
//     int mcount=0;
//     int maxmcount = M*(M+1)/2;
//     for(auto x : W){
//         if (mcount>=maxmcount)break;
//         else {
//             erabu.push_back(x);
//             mcount += x.first;
//         }
//     }
//     sort(erabu.rbegin(),erabu.rend());

//     int wind = 0;
//     int ans = 0;
//     rrep(i, M + 1)
//     {
//         if (i == 0)
//             break;

//         for (; wind < erabu.size(); ++wind)
//         {
//             debug(wind);
//             if (W[wind].first <= i)
//             {
//                 ans += W[wind].second;
//                 debug(ans);
//                 wind++;
//                 break;
//             }
//         }
//     }
//     cout<<ans<<endl;
// }

// // sort(all(W), [](const pii &a, const pii &b){
// //     return ((double)a.second/a.first)>((double)b.second/b.first);
// // });

// // rep(i,N){
// //     cout<<W[i].first<< " " <<W[i].second<<endl;
// // }
// // int i=0;
// // int mm=M;
// // int ans = 0;

// // for(;mm>0 && i != N-1;){
// //     for(; i<N; ++i){
// //         if(W[i].first <= mm){
// //             mm -= W[i].first;
// //             ans += W[i].second;
// //             break;
//         }
//     }

// }
// cout<<ans<<endl;

// sort(all(W));
// // rep(i, 111111)
// // {
// //     dp[i] = -INF;
// // }
// dp[0] = 0;

// rep(i, M+1)
// {
//     if(i>0)dp[i]=dp[i-1];
//     rep(j, N)
//     {
//         if (dp[i + W[j].first] < dp[i] + W[j].second)
//         {
//             dp[i + W[j].first] = dp[i] + W[j].second;
//         }
//     }
// }

// int ans = -INF;
// rep(i, M + 1)
// {
//     if (ans < dp[i])
//         ans = dp[i];
// }
// cout << ans << endl;
//}
//=============================
signed main()
{
    input();
    solve();
    return 0;
}

Measured memory_bytes: 3832