using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace AtCoder.ABC
{
    class QuestionA
    {
        public class AB
        {
            public int A;
            public int B;

            public AB(int[] ab)
            {
                A = ab[0];
                B = ab[1];
            }
        }

        public static void Main(string[] args)
        {
            var nm = Console.ReadLine().Split(" ").Select(x => int.Parse(x)).ToArray();
            var n = nm[0];
            var m = nm[1];

            var ab = new List<AB>();

            for (int i = 0; i < n; i++) {
                ab.Add(new AB(Console.ReadLine().Split(" ").Select(x => int.Parse(x)).ToArray()));
            }

            ab.Sort((x, y) => x.A - y.A);

            var temp = new PriorityQueue<AB>((x, y) => x.B.CompareTo(y.B));
            var sum = 0L;

            int index = 0;

            for (int remain = 1; remain <= m; remain++) {
                for (; index < n; index++) {
                    if (ab[index].A <= remain) {
                        temp.Enqueue(ab[index]);
                    } else {
                        break;
                    }
                }

                if (temp.Count != 0) {
                    sum += temp.Dequeue().B;
                }
            }

            Console.WriteLine(sum);
        }
        public class PriorityQueue<T>
        {
            private readonly List<T> data_ = new List<T>();
            private readonly IComparer<T> comparer_;
            private readonly bool isDescending_;

            public PriorityQueue(IComparer<T> comparer, bool isDescending = true)
            {
                comparer_ = comparer;
                isDescending_ = isDescending;
            }

            public PriorityQueue(Comparison<T> comparison, bool isDescending = true)
                : this(Comparer<T>.Create(comparison), isDescending)
            {
            }

            public PriorityQueue(bool isDescending = true)
                : this(Comparer<T>.Default, isDescending)
            {
            }

            public void Enqueue(T item)
            {
                data_.Add(item);
                var childIndex = data_.Count - 1;
                while (childIndex > 0) {
                    var parentIndex = (childIndex - 1) / 2;

                    if (Compare(data_[childIndex], data_[parentIndex]) >= 0) {
                        break;
                    }

                    Swap(childIndex, parentIndex);
                    childIndex = parentIndex;
                }
            }

            public T Dequeue()
            {
                var lastIndex = data_.Count - 1;
                var firstItem = data_[0];
                data_[0] = data_[lastIndex];
                data_.RemoveAt(lastIndex--);
                var parentIndex = 0;
                while (true) {
                    var childIndex = parentIndex * 2 + 1;

                    if (childIndex > lastIndex) {
                        break;
                    }

                    var rightChild = childIndex + 1;

                    if (rightChild <= lastIndex && Compare(data_[rightChild], data_[childIndex]) < 0) {
                        childIndex = rightChild;
                    }

                    if (Compare(data_[parentIndex], data_[childIndex]) <= 0) {
                        break;
                    }

                    Swap(parentIndex, childIndex);
                    parentIndex = childIndex;
                }
                return firstItem;
            }

            public T Peek()
            {
                return data_[0];
            }

            private void Swap(int a, int b)
            {
                var tmp = data_[a];
                data_[a] = data_[b];
                data_[b] = tmp;
            }

            private int Compare(T a, T b)
            {
                return isDescending_ ? comparer_.Compare(b, a) : comparer_.Compare(a, b);
            }

            public int Count => data_.Count;
        }
    }
}



Measured memory_bytes: 46424