using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

namespace ABC137.D
{
	using static Util;

	//public class PriorityQueue<T>
	//{
	//	private readonly List<T> m_list;
	//	private readonly Func<T, T, int> m_compare;
	//	private int m_count;
	//	public PriorityQueue(int capacity, Func<T, T, int> compare) {
	//		m_list = new List<T>(capacity);
	//		m_compare = compare;
	//		m_count = 0;
	//	}
	//	int Add(T value) {
	//		if (m_count == m_list.Count) {
	//			m_list.Add(value);
	//		} else {
	//			m_list[m_count] = value;
	//		}
	//		return m_count++;
	//	}
	//	void Swap(int a, int b) {
	//		T tmp = m_list[a];
	//		m_list[a] = m_list[b];
	//		m_list[b] = tmp;
	//	}

	//	public void Enqueue(T value) {
	//		int c = Add(value);
	//		while (c > 0) {
	//			int p = (c - 1) / 2;
	//			if (m_compare(m_list[c], m_list[p]) < 0) { Swap(p, c); } else { break; }
	//			c = p;
	//		}
	//	}
	//	public T Dequeue() {
	//		if (m_list.Count == 0)
	//			return default(T);
	//		else if (m_list.Count == 1) {
	//			--m_count;
	//			var ret = m_list[0];
	//			m_list.Clear();
	//			return ret;
	//		}

	//		T value = m_list[0];
	//		m_list[0] = m_list[--m_count];
	//		int p = 0;
	//		while (true) {
	//			int c1 = p * 2 + 1;
	//			int c2 = p * 2 + 2;
	//			if (c1 >= m_count) { break; }
	//			int c = (c2 >= m_count || m_compare(m_list[c1], m_list[c2]) < 0) ? c1 : c2;
	//			if (m_compare(m_list[c], m_list[p]) < 0) { Swap(p, c); } else { break; }
	//			p = c;
	//		}
	//		return value;
	//	}
	//}

	//public class PriorityQueue<T>
	//{
	//	List<T> list = new List<T>();
	//	IComparer<T> comp = Comparer<T>.Default;
	//	class Comparer : IComparer<T>
	//	{
	//		Comparison<T> comparison;
	//		public Comparer(Comparison<T> comparison) { this.comparison = comparison; }
	//		public int Compare(T x, T y) { return comparison(x, y); }
	//	}
	//	public PriorityQueue() { }
	//	public PriorityQueue(Comparison<T> comp) { this.comp = new Comparer(comp); }
	//	public void Enqueue(T item) { int i = list.BinarySearch(item, comp); list.Insert(i < 0 ? ~i : i, item); }
	//	public T Dequeue() {
	//		if (list.Count == 0) return default(T);
	//		T r = list[0];
	//		list.RemoveAt(0);
	//		return r;
	//	}
	//	public T Peek() { return list[0]; }
	//	public int Count { get { return list.Count; } }
	//	public T this[int i] { get { return list[i]; } set { list[i] = value; } }
	//}

	class PriorityQueue<T> where T : IComparable<T>
	{
		public T[] heap;
		public int size;
		public int sign;
		public PriorityQueue(int N, bool descend = false) {
			heap = new T[N];
			if (descend) sign = -1;
		}
		public int Compare(T x, T y) {
			return x.CompareTo(y) * sign;
		}
		public void Push(T x) {
			int i = size++;
			while (i > 0) {
				int p = (i - 1) / 2;
				if (Compare(x, heap[p]) >= 0) {
					break;
				}
				heap[i] = heap[p];
				i = p;
			}
			heap[i] = x;
		}
		public T Pop() {
			T ret = heap[0];
			T x = heap[--size];
			int i = 0;
			while (i * 2 + 1 < size) {
				int a = i * 2 + 1;
				int b = i * 2 + 2;
				if (b < size && Compare(heap[a], heap[b]) > 0) {
					a = b;
				}
				if (Compare(heap[a], x) >= 0) {
					break;
				}
				heap[i] = heap[a];
				i = a;
			}
			heap[i] = x;
			return ret;
		}
		public T Pop(T defaultValue) {
			if (Count() == 0)
				return defaultValue;
			else
				return Pop();
		}
		public int Count() {
			return size;
		}
	}


	public class Solver : SolverBase
	{
		public void Run() {
			var ary = ReadIntArray();
			var N = ary[0];
			var M = ary[1];

			var list = new List<int>[M];

			for (int i = 0; i < N; i++) {
				var ar = ReadIntArray();
				var day = ar[0]-1;
				var fee = ar[1];

				if (M <= day) continue;
				if (list[day] == null)
					list[day] = new List<int>();
				list[day].Add(fee);
			}

			// 降順用優先度付きキュー
			PriorityQueue<int> pq = new PriorityQueue<int>(100000, true);

			long ans = 0;
			for (int cday = 0; cday < M; cday++) {
				var fees = list[cday];
				if (fees != null) {
					foreach (var fee in fees) {
						pq.Push(fee);
					}
				}

				ans += pq.Pop(0);
			}

			WriteLine(ans);
		}

#if !MYHOME
		static void Main(string[] args) {
			new Solver().Run();
		}
#endif
	}

	public static class Util
	{
		public static int Gcd(int a, int b) {
			if (a < b)
				// 引数を入替えて自分を呼び出す
				return Gcd(b, a);
			while (b != 0) {
				var remainder = a % b;
				a = b;
				b = remainder;
			}
			return a;
		}
		public readonly static int IMOD = 1000000007;
		public readonly static long MOD = 1000000007;

		public static string DumpToString<T>(IEnumerable<T> array) where T : IFormattable {
			var sb = new StringBuilder();
			foreach (var item in array) {
				sb.Append(item);
				sb.Append(", ");
			}
			return sb.ToString();
		}

		public static void InitArray<T>(T[] ary, T value) {
			for (int i = 0; i < ary.Length; i++) {
				ary[i] = value;
			}
		}
		public static void InitDP2<T>(T[,] dp, T value) {
			for (int i = 0; i < dp.GetLength(0); i++) {
				for (int j = 0; j < dp.GetLength(1); j++) {
					dp[i, j] = value;
				}
			}
		}
		public static void InitDP3<T>(T[,,] dp, T value) {
			for (int i = 0; i < dp.GetLength(0); i++) {
				for (int j = 0; j < dp.GetLength(1); j++) {
					for (int k = 0; k < dp.GetLength(2); k++) {
						dp[i, j, k] = value;
					}
				}
			}
		}

		public static T Max<T>(params T[] nums) where T : IComparable {
			if (nums.Length == 0) return default(T);

			T max = nums[0];
			for (int i = 1; i < nums.Length; i++) {
				max = max.CompareTo(nums[i]) > 0 ? max : nums[i];
			}
			return max;
		}
		public static T Min<T>(params T[] nums) where T : IComparable {
			if (nums.Length == 0) return default(T);

			T min = nums[0];
			for (int i = 1; i < nums.Length; i++) {
				min = min.CompareTo(nums[i]) < 0 ? min : nums[i];
			}
			return min;
		}

		/// <summary>
		/// ソート済み配列 ary に同じ値の要素が含まれている？
		/// ※ソート順は昇順/降順どちらでもよい
		/// </summary>
		public static bool HasDuplicateInSortedArray<T>(T[] ary) where T : IComparable, IComparable<T> {
			if (ary.Length <= 1) return false;

			var lastNum = ary[ary.Length - 1];

			foreach (var n in ary) {
				if (lastNum.CompareTo(n) == 0) {
					return true;
				} else {
					lastNum = n;
				}
			}
			return false;
		}

		public static bool ReplaceIfBigger<T>(ref T r, T v) where T : IComparable {
			if (r.CompareTo(v) < 0) {
				r = v;
				return true;
			} else {
				return false;
			}
		}
		public static bool ReplaceIfSmaller<T>(ref T r, T v) where T : IComparable {
			if (0 < r.CompareTo(v)) {
				r = v;
				return true;
			} else {
				return false;
			}
		}

		/// <summary>
		/// 二分探索
		/// ※条件を満たす最小のidxを返す
		/// ※満たすものがない場合は ary.Length を返す
		/// ※『aryの先頭側が条件を満たさない、末尾側が条件を満たす』という前提
		/// ただし、IsOK(...)の戻り値を逆転させれば、逆でも同じことが可能。
		/// </summary>
		/// <param name="ary">探索対象配列 ★ソート済みであること</param>
		/// <param name="key">探索値 ※これ以上の値を持つ（IsOKがtrueを返す）最小のindexを返す</param>
		public static int BinarySearch<T>(T[] ary, T key) where T : IComparable, IComparable<T> {
			int left = -1;
			int right = ary.Length;

			while (1 < right - left) {
				var mid = left + (right - left) / 2;

				if (IsOK(ary, mid, key)) {
					right = mid;
				} else {
					left = mid;
				}
			}

			// left は条件を満たさない最大の値、right は条件を満たす最小の値になっている
			return right;
		}
		public static bool IsOK<T>(T[] ary, int idx, T key) where T : IComparable, IComparable<T> {
			// key <= ary[idx] と同じ意味
			return key.CompareTo(ary[idx]) <= 0;
		}
	}

	public class SolverBase
	{
		virtual protected string ReadLine() => Console.ReadLine();
		virtual protected int ReadInt() => int.Parse(ReadLine());
		//virtual protected void ReadInt2(out int x, out int y) {
		//	var aryS = ReadLine().Split(' ');
		//	x = int.Parse(aryS[0]);
		//	y = int.Parse(aryS[1]);
		//}
		virtual protected long ReadLong() => long.Parse(ReadLine());
		virtual protected string[] ReadStringArray() => ReadLine().Split(' ');
		virtual protected int[] ReadIntArray() => ReadLine().Split(' ').Select<string, int>(s => int.Parse(s)).ToArray();
		virtual protected long[] ReadLongArray() => ReadLine().Split(' ').Select<string, long>(s => long.Parse(s)).ToArray();
		virtual protected double[] ReadDoubleArray() => ReadLine().Split(' ').Select<string, double>(s => double.Parse(s)).ToArray();
		virtual protected void WriteLine(string line) => Console.WriteLine(line);
		virtual protected void WriteLine(double d) => Console.WriteLine($"{d:F9}");
		virtual protected void WriteLine<T>(T value) where T : IFormattable => Console.WriteLine(value);

		[Conditional("DEBUG")]
		protected void Dump(string s) => Console.WriteLine(s);
		[Conditional("DEBUG")]
		protected void Dump(char c) => Console.WriteLine(c);
		[Conditional("DEBUG")]
		protected void Dump(int x) => Console.WriteLine(x);
		[Conditional("DEBUG")]
		protected void Dump(double d) => Console.WriteLine($"{d:F9}");
		[Conditional("DEBUG")]
		protected void Dump<T>(IEnumerable<T> array) where T : IFormattable {
			string s = Util.DumpToString(array);
			// Consoleに出力すると、UnitTestの邪魔をしないというメリットあり。
			Console.WriteLine(s);
			//_writer.WriteLine(s);
		}
		[Conditional("DEBUG")]
		protected void DumpGrid<T>(IEnumerable<IEnumerable<T>> arrayOfArray) where T : IFormattable {
			var sb = new StringBuilder();
			foreach (var a in arrayOfArray) {
				sb.AppendLine(Util.DumpToString(a));
			}
			// Consoleに出力すると、UnitTestの邪魔をしないというメリットあり。
			Console.WriteLine(sb.ToString());
			//_writer.WriteLine(sb.ToString());
		}
		[Conditional("DEBUG")]
		protected void DumpDP<T>(T[,] dp) where T : IFormattable {
			var sb = new StringBuilder();
			for (int i = 0; i < dp.GetLength(0); i++) {
				for (int j = 0; j < dp.GetLength(1); j++) {
					sb.Append(dp[i, j]);
					sb.Append(", ");
				}
				sb.AppendLine();
			}
			Console.WriteLine(sb.ToString());
		}
	}
}


Measured memory_bytes: 29060