using System;
using System.Collections.Generic;
using System.Text;
using System.Numerics;
using System.IO;

namespace SolutionCS
{
    class Program
    {
        public class TestElem : IComparable
        {
            public long value;

            public TestElem(long v)
            {
                value = v;
            }

            public int CompareTo(object o)
            {
                TestElem e = o as TestElem;
                if ( null == e)
                {
                    return 0;
                }

                return -value.CompareTo(e.value);
            }
        }
        // 昇順のPriorityQueue
        // 降順にしたい場合はTのCompareToの符号を反転させる
        public class PriorityQueue<T> where T : IComparable
        {
            T[] heap;
            int count = 0;

            public PriorityQueue(int maxSize)
            {
                heap = new T[maxSize];
                count = 0;
            }

            public void Push(T elem)
            {
                // 要素をPushするインデックス(枝の末尾部分)
                int i = count;

                // 要素数を増やす
                count++;

                // 親(i=0)に向かってたどる
                while (i > 0)
                {
                    // 親のインデックス
                    int p = (i - 1) / 2;

                    // elemのほうが大きいか同一の場合、Pushするインデックス確定
                    if (heap[p].CompareTo(elem) <= 0)
                    {
                        break;
                    }

                    // 親→子にコピーして再度親との比較を行う
                    heap[i] = heap[p];
                    i = p;
                }

                // 要素を決まったインデックスに入れる
                heap[i] = elem;
            }

            public T Pop()
            {
                // 要素なしの場合、Exception
                if (count == 0)
                {
                    throw new InvalidOperationException();
                }

                // 要素数減らす
                count--;

                // 返す要素を保存
                T result = heap[0];

                // 一番末端の要素(これを親から比較して配列に配置する)
                T x = heap[count];

                // 親から末尾に向かって子→親入れ替えを行う
                int i = 0;
                while (i * 2 + 1 < count)
                {
                    int l = i * 2 + 1;      // 子の左枝のインデックス
                    int r = i * 2 + 2;      // 子の右枝のインデックス

                    // 右が範囲外ではない、右のほうが小さいか検証
                    if (r < count && heap[r].CompareTo(heap[l]) < 0)
                    {
                        // 右のほうが小さい場合、上に上がっていくのは右のインデックス
                        l = r;
                    }

                    // x(配列の一番最後の要素)と比べて、大きければおわり
                    if (heap[l].CompareTo(x) >= 0)
                    {
                        break;
                    }

                    // 一個親側に繰り上げ
                    heap[i] = heap[l];

                    // 処理した枝のインデックスを与え、再度入れ替え
                    i = l;
                }

                // 一番末尾の要素を新たに保存
                heap[i] = x;

                // 最初に保存していた結果を返す
                return result;
            }

            public int Count { get { return count; } }
            public T Peek { get { return heap[0]; } }
        }


        class work : IComparable<work>
        {
            public long days;
            public long money;

            public int CompareTo(work e)
            {
                return days.CompareTo(e.days);
            }
        }

        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split(' ');
            int N = int.Parse(s[0]);
            int M = int.Parse(s[1]);

            List<work> lists = new List<work>();
            for (int i = 0; i < N; i++)
            {
                s = Console.ReadLine().Split(' ');
                work w = new work();
                w.days = long.Parse(s[0]);
                w.money = long.Parse(s[1]);

                lists.Add(w);
            }
            lists.Sort();

            PriorityQueue<TestElem> pq = new PriorityQueue<TestElem>(N);

            long ans = 0;
            int ind = 0;
            for (int i = 1; i <= M; i++)
            {
                while(ind < lists.Count && lists[ind].days <= i)
                {
                    pq.Push(new TestElem(lists[ind].money));
                    ind++;
                }

                if ( pq.Count > 0)
                {
                    ans += pq.Pop().value;
                }
            }

            Console.WriteLine(ans);
        }
    }
}



Measured memory_bytes: 26564