using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace AtCoder
{
	public class ABC
	{
		static int mod = 1000000007;  // 10^9+7

		static void Main(string[] args)
		{
			Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });


			//int n = int.Parse(Console.ReadLine());
			//string s = Console.ReadLine();
			int[] vs = Console.ReadLine().Split().Select(int.Parse).ToArray();
			int n = vs[0];
			int k = vs[1];
			PriorityQueue<Sushi> queue = new PriorityQueue<Sushi>((x, y) => y.value.CompareTo(x.value));
			for (int i = 0; i < n; i++) {
				vs = Console.ReadLine().Split().Select(int.Parse).ToArray();
				queue.Enqueue(new Sushi() { neta = vs[0], value = vs[1] });
			}

			HashSet<int> neta = new HashSet<int>();
			Stack<Sushi> sushi = new Stack<Sushi>();
			long sum = 0, ans = 0;
			for (int i = 0; i < n; i++) {
				Sushi item = queue.Dequeue();
				if (i < k) {
					if (!neta.Contains(item.neta)) {
						neta.Add(item.neta);
					} else {
						sushi.Push(item);
					}
					sum += item.value;
					ans = sum + (long)neta.Count * neta.Count;
					//System.Diagnostics.Debug.WriteLine($"({item.neta},{item.value}) {ans}={sum}+{neta.Count}^2");
				} else {
					if (!neta.Contains(item.neta)) {
						if (sushi.Count == 0) {
							break;
						}
						neta.Add(item.neta);
						sum += item.value;
						Sushi item2 = sushi.Pop();
						sum -= item2.value;
						ans = Math.Max(ans, sum + (long)neta.Count * neta.Count);
						//System.Diagnostics.Debug.WriteLine($"-({item2.neta},{item2.value})+({item.neta},{item.value}) {sum + neta.Count * neta.Count}={sum}+{neta.Count}^2");
					}
				}
			}
			Console.WriteLine(ans);


			Console.Out.Flush();
		}
	}

	public class Sushi
	{
		public int neta;
		public int value;
	}

	#region 優先度付きキュー PriorityQueue<T>
	public class PriorityQueue<T> // where T : IComparable
	{
		private readonly List<T> _Heap;
		private readonly Func<T, T, int> _Compare;

		public int Count { get { return _Heap.Count; } }

		public PriorityQueue() : this(Comparer<T>.Default.Compare) { }
		public PriorityQueue(bool reverse) : this((x, y) => Comparer<T>.Default.Compare(reverse ? y : x, reverse ? x : y)) { }
		public PriorityQueue(Comparer<T> comparer) : this(comparer.Compare) { }
		public PriorityQueue(Func<T, T, int> compare)
		{
			_Heap = new List<T>();
			_Compare = compare;
		}

		public void Enqueue(T item)
		{
			_Heap.Add(item);
			int i = _Heap.Count - 1;
			while (i > 0) {
				int p = (i - 1) / 2;
				if (_Compare(_Heap[p], item) <= 0) {
					break;
				}
				_Heap[i] = _Heap[p];
				i = p;
			}
			_Heap[i] = item;
		}

		public T Dequeue()
		{
			int size = _Heap.Count - 1;
			T ret = _Heap[0];
			T x = _Heap[size];
			int i = 0;
			while (i * 2 + 1 < size) {
				var a = i * 2 + 1;
				var b = i * 2 + 2;
				if (b < size && _Compare(_Heap[b], _Heap[a]) < 0) {
					a = b;
				}
				if (_Compare(_Heap[a], x) >= 0) {
					break;
				}
				_Heap[i] = _Heap[a];
				i = a;
			}
			_Heap[i] = x;
			_Heap.RemoveAt(size);
			return ret;
		}

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

		public void Clear()
		{
			_Heap.Clear();
		}

		public List<T>.Enumerator GetEnumerator()
		{
			return _Heap.GetEnumerator();
		}

		public override string ToString()
		{
			return string.Join(" ", _Heap);
		}
	}
	#endregion

}


Measured memory_bytes: 26424