using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static string InputPattern = "InputX";
static List<string> GetInputList()
{
var WillReturn = new List<string>();
if (InputPattern == "Input1") {
WillReturn.Add("8 4");
WillReturn.Add("0 6");
WillReturn.Add("0 6");
WillReturn.Add("1 3");
WillReturn.Add("1 5");
WillReturn.Add("1 15");
WillReturn.Add("2 1");
WillReturn.Add("2 10");
WillReturn.Add("2 100");
//27
}
else if (InputPattern == "Input2") {
WillReturn.Add("5 5");
WillReturn.Add("1 5");
WillReturn.Add("1 5");
WillReturn.Add("1 5");
WillReturn.Add("1 5");
WillReturn.Add("1 5");
//0
}
else if (InputPattern == "Input3") {
WillReturn.Add("12 6");
WillReturn.Add("2 2");
WillReturn.Add("0 1");
WillReturn.Add("0 9");
WillReturn.Add("1 3");
WillReturn.Add("1 5");
WillReturn.Add("1 3");
WillReturn.Add("0 4");
WillReturn.Add("2 1");
WillReturn.Add("1 8");
WillReturn.Add("2 1");
WillReturn.Add("0 1");
WillReturn.Add("0 4");
//30
}
else {
string wkStr;
while ((wkStr = Console.ReadLine()) != null) WillReturn.Add(wkStr);
}
return WillReturn;
}
struct TXInfoDef
{
internal long Type;
internal long X;
}
static List<TXInfoDef> mTXInfoList = new List<TXInfoDef>();
static void Main()
{
List<string> InputList = GetInputList();
long[] wkArr = { };
Action<string> SplitAct = pStr =>
wkArr = pStr.Split(' ').Select(pX => long.Parse(pX)).ToArray();
SplitAct(InputList[0]);
long M = wkArr[1];
foreach (string EachStr in InputList.Skip(1)) {
SplitAct(EachStr);
TXInfoDef WillAdd;
WillAdd.Type = wkArr[0];
WillAdd.X = wkArr[1];
mTXInfoList.Add(WillAdd);
}
var Ins_AVL_Set_MultiSet = new AVL_Set_MultiSet<long>();
Ins_AVL_Set_MultiSet.IsMultiSet = true;
var List0 = new List<long>();
var List1 = new List<long>();
var List2 = new List<long>();
foreach (TXInfoDef EachTXInfo in mTXInfoList) {
if (EachTXInfo.Type == 0) { List0.Add(EachTXInfo.X); }
if (EachTXInfo.Type == 1) { List1.Add(EachTXInfo.X); }
if (EachTXInfo.Type == 2) { List2.Add(EachTXInfo.X); }
}
var Que1 = new Queue<long>(List1.OrderByDescending(pX => pX));
var Que2 = new Queue<long>(List2.OrderByDescending(pX => pX));
var AnswerKouho = new List<long>();
long CurrSum = 0;
foreach (long EachA in List0.OrderByDescending(pX => pX)) {
Ins_AVL_Set_MultiSet.Add(EachA);
CurrSum += EachA;
if (Ins_AVL_Set_MultiSet.Count == M) {
break;
}
}
AnswerKouho.Add(CurrSum);
long CanEatCnt = M;
while (true) {
if (Que2.Count == 0) {
break;
}
long OpenCnt = Que2.Dequeue();
CanEatCnt--;
for (long I = 1; I <= OpenCnt; I++) {
if (Que1.Count > 0) {
long Dequeued = Que1.Dequeue();
Ins_AVL_Set_MultiSet.Add(Dequeued);
CurrSum += Dequeued;
while (Ins_AVL_Set_MultiSet.Count > CanEatCnt) {
long RemoveVal = Ins_AVL_Set_MultiSet[0];
CurrSum -= RemoveVal;
Ins_AVL_Set_MultiSet.RemoveAt(0);
}
AnswerKouho.Add(CurrSum);
}
else { // ここでbreakで枝切りしないとTLE
break;
}
}
}
Console.WriteLine(AnswerKouho.Max());
}
}
#region AVL_Set_MultiSet
/// <summary>
/// 要素の追加、削除、検索、取得が可能な集合を表します.
/// </summary>
/// <typeparam name="T">優先度付きキュー内の要素の型を指定します.</typeparam>
/// <remarks>内部的にはAVL木によって実装されています.</remarks>
internal class AVL_Set_MultiSet<T>
{
Node root;
readonly IComparer<T> comparer;
readonly Node nil;
/// <summary>
/// 多重集合かどうかを表します.
/// </summary>
internal bool IsMultiSet { get; set; }
internal AVL_Set_MultiSet(IComparer<T> comparer)
{
nil = new Node(default(T));
root = nil;
this.comparer = comparer;
}
internal AVL_Set_MultiSet() : this(Comparer<T>.Default) { }
/// <summary>
/// 要素をコレクションに追加します.
/// </summary>
/// <remarks>この操作は計算量 O(log N) で実行されます.</remarks>
internal bool Add(T v)
{
return insert(ref root, v);
}
/// <summary>
/// v が存在するならコレクションから削除します.
/// </summary>
/// <remarks>この操作は計算量 O(log N) で実行されます.</remarks>
internal bool Remove(T v)
{
return remove(ref root, v);
}
/// <summary>
/// 0-indexed で index 番目の要素をコレクションから取得します.
/// </summary>
/// <remarks>この操作は計算量 O(log N) で実行されます.</remarks>
internal T this[int index] { get { return find(root, index); } }
internal int Count { get { return root.Count; } }
internal void RemoveAt(int k)
{
if (k < 0 || k >= root.Count) throw new ArgumentOutOfRangeException();
removeAt(ref root, k);
}
/// <summary>
/// このコレクションに含まれる要素を昇順に並べて返します.
/// </summary>
/// <remarks>この操作は計算量 O(N) で実行されます.</remarks>
internal T[] Items
{
get
{
T[] ret = new T[root.Count];
int k = 0;
walk(root, ret, ref k);
return ret;
}
}
private void walk(Node t, T[] a, ref int k)
{
if (t.Count == 0) return;
walk(t.lst, a, ref k);
a[k++] = t.Key;
walk(t.rst, a, ref k);
}
private bool insert(ref Node t, T key)
{
if (t.Count == 0) { t = new Node(key); t.lst = t.rst = nil; t.Update(); return true; }
int cmp = comparer.Compare(t.Key, key);
bool res;
if (cmp > 0)
res = insert(ref t.lst, key);
else if (cmp == 0) {
if (IsMultiSet) res = insert(ref t.lst, key);
else return false;
}
else res = insert(ref t.rst, key);
balance(ref t);
return res;
}
private bool remove(ref Node t, T key)
{
if (t.Count == 0) return false;
int cmp = comparer.Compare(key, t.Key);
bool ret;
if (cmp < 0) ret = remove(ref t.lst, key);
else if (cmp > 0) ret = remove(ref t.rst, key);
else {
ret = true;
var k = t.lst.Count;
if (k == 0) { t = t.rst; return true; }
if (t.rst.Count == 0) { t = t.lst; return true; }
t.Key = find(t.lst, k - 1);
removeAt(ref t.lst, k - 1);
}
balance(ref t);
return ret;
}
private void removeAt(ref Node t, int k)
{
int cnt = t.lst.Count;
if (cnt < k) removeAt(ref t.rst, k - cnt - 1);
else if (cnt > k) removeAt(ref t.lst, k);
else {
if (cnt == 0) { t = t.rst; return; }
if (t.rst.Count == 0) { t = t.lst; return; }
t.Key = find(t.lst, k - 1);
removeAt(ref t.lst, k - 1);
}
balance(ref t);
}
private void balance(ref Node t)
{
int balance = t.lst.Height - t.rst.Height;
if (balance == -2) {
if (t.rst.lst.Height - t.rst.rst.Height > 0) { rotR(ref t.rst); }
rotL(ref t);
}
else if (balance == 2) {
if (t.lst.lst.Height - t.lst.rst.Height < 0) rotL(ref t.lst);
rotR(ref t);
}
else t.Update();
}
private T find(Node t, int k)
{
if (k < 0 || k > root.Count) throw new ArgumentOutOfRangeException();
while (true) {
if (k == t.lst.Count) return t.Key;
else if (k < t.lst.Count) t = t.lst;
else { k -= t.lst.Count + 1; t = t.rst; }
}
}
/// <summary>
/// コレクションに含まれる要素であって、 v 以上の最小の要素の番号を返します。
/// </summary>
/// <remarks>この操作は計算量 O(log N) で実行されます.</remarks>
internal int LowerBound(T v)
{
// 追加機能 件数が0なら-1を返す
if (this.Count == 0) {
return -1;
}
// 追加機能 v 以上な要素が無い場合は-1を返す
T MaxVal = this[this.Count - 1];
int cmp = comparer.Compare(MaxVal, v);
if (cmp == -1) return -1;
int k = 0;
Node t = root;
while (true) {
if (t.Count == 0) return k;
if (comparer.Compare(v, t.Key) <= 0) t = t.lst;
else { k += t.lst.Count + 1; t = t.rst; }
}
}
/// <summary>
/// コレクションに含まれる要素であって、 v より真に大きい、最小の要素の番号を返します。
/// </summary>
/// <remarks>この操作は計算量 O(log N) で実行されます.</remarks>
internal int UpperBound(T v)
{
// 追加機能 件数が0なら-1を返す
if (this.Count == 0) {
return -1;
}
// 追加機能 v 超えな要素が無い場合は-1を返す
T MaxVal = this[this.Count - 1];
int cmp = comparer.Compare(MaxVal, v);
if (cmp <= 0) return -1;
int k = 0;
Node t = root;
while (true) {
if (t.Count == 0) return k;
if (comparer.Compare(t.Key, v) <= 0) { k += t.lst.Count + 1; t = t.rst; }
else t = t.lst;
}
}
// 追加機能 V未満で最大の要素の番号を返す
internal int Lower_Max(T v)
{
// 件数が0なら-1を返す
if (this.Count == 0) {
return -1;
}
// v 未満な要素が無い場合は-1を返す
T MinVal = this[0];
int cmp = comparer.Compare(MinVal, v);
if (cmp >= 0) return -1;
// v 以上の件数を調べる
int More_Or_Equal_cnt = this.Count;
int UB = this.Count - 1;
int LowerB = LowerBound(v);
if (IsValidInd(LowerB)) {
More_Or_Equal_cnt -= (UB - LowerB + 1);
}
return More_Or_Equal_cnt - 1;
}
// 追加機能 V以下で最大の要素の番号を返す
internal int LowerOrEqual_Max(T v)
{
// 件数が0なら-1を返す
if (this.Count == 0) {
return -1;
}
// v 以下な要素が無い場合は-1を返す
T MinVal = this[0];
int cmp = comparer.Compare(MinVal, v);
if (cmp > 0) return -1;
// v 超えの件数を調べる
int More_cnt = this.Count;
int UB = this.Count - 1;
int UpperB = UpperBound(v);
if (IsValidInd(UpperB)) {
More_cnt -= (UB - UpperB + 1);
}
return More_cnt - 1;
}
// 追加機能 LowerBoundなどで返したIndが、有効範囲かを判定
internal bool IsValidInd(int pInd)
{
if (pInd < 0) return false;
if (this.Count <= pInd) return false;
return true;
}
// 追加機能 Vを含むかを返す
internal bool Contains(T v)
{
int LowerB = LowerBound(v);
if (IsValidInd(LowerB) == false) {
return false;
}
int cmp = comparer.Compare(this[LowerB], v);
return cmp == 0;
}
private void rotR(ref Node t)
{
Node l = t.lst;
t.lst = l.rst;
l.rst = t;
t.Update();
l.Update();
t = l;
}
private void rotL(ref Node t)
{
Node r = t.rst;
t.rst = r.lst;
r.lst = t;
t.Update();
r.Update();
t = r;
}
class Node
{
internal Node(T key)
{
Key = key;
}
internal int Count { get; private set; }
internal int Height { get; private set; }
internal T Key { get; set; }
internal Node lst, rst;
internal void Update()
{
Count = 1 + lst.Count + rst.Count;
Height = 1 + Math.Max(lst.Height, rst.Height);
}
public override string ToString()
{
return string.Format("Count = {0}, Key = {1}", Count, Key);
}
}
}
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static string InputPattern = "InputX";
static List<string> GetInputList()
{
var WillReturn = new List<string>();
string wkStr;
while ((wkStr = Console.ReadLine()) != null) WillReturn.Add(wkStr);
return WillReturn;
}
struct TXInfoDef
{
internal long Type;
internal long X;
}
static List<TXInfoDef> mTXInfoList = new List<TXInfoDef>();
static void Main()
{
List<string> InputList = GetInputList();
long[] wkArr = { };
Action<string> SplitAct = pStr =>
wkArr = pStr.Split(' ').Select(pX => long.Parse(pX)).ToArray();
SplitAct(InputList[0]);
long M = wkArr[1];
foreach (string EachStr in InputList.Skip(1)) {
SplitAct(EachStr);
TXInfoDef WillAdd;
WillAdd.Type = wkArr[0];
WillAdd.X = wkArr[1];
mTXInfoList.Add(WillAdd);
}
long[] T0Arr = mTXInfoList.Where(pX => pX.Type == 0).Select(pX => pX.X).ToArray();
T0Arr = T0Arr.OrderByDescending(pX => pX).ToArray();
var Ins_Fenwick_Tree_T0 = new Fenwick_Tree(T0Arr);
long[] T1Arr = mTXInfoList.Where(pX => pX.Type == 1).Select(pX => pX.X).ToArray();
T1Arr = T1Arr.OrderByDescending(pX => pX).ToArray();
var Ins_Fenwick_Tree_T1 = new Fenwick_Tree(T1Arr);
long[] T2Arr = mTXInfoList.Where(pX => pX.Type == 2).Select(pX => pX.X).ToArray();
T2Arr = T2Arr.OrderByDescending(pX => pX).ToArray();
long[] T2RunSum = (long[])T2Arr.Clone();
for (long I = 1; I <= T2RunSum.GetUpperBound(0); I++) {
T2RunSum[I] += T2RunSum[I - 1];
}
// T1から取る個数を全探索
var AnswerList = new List<long>();
for (long I = 0; I <= T1Arr.Length; I++) {
long RestM = M - I;
if (RestM < 0) continue;
if (I > 0) {
// 缶切りを入手
long ResultInd = ExecNibunhou_LowerBound(I, T2RunSum);
if (ResultInd == -1) continue;
RestM -= ResultInd + 1;
if (RestM < 0) continue;
}
long SumVal = 0;
long RangeSta = 0;
long RangeEnd = I - 1;
if (RangeSta <= RangeEnd) {
SumVal += Ins_Fenwick_Tree_T1.GetSum(RangeSta, RangeEnd);
}
RangeSta = 0;
RangeEnd = RestM - 1;
RangeEnd = Math.Min(RangeEnd, Ins_Fenwick_Tree_T0.GetUB());
if (RangeSta <= RangeEnd) {
SumVal += Ins_Fenwick_Tree_T0.GetSum(RangeSta, RangeEnd);
}
AnswerList.Add(SumVal);
}
Console.WriteLine(AnswerList.Max());
}
// 二分法で、Val以上で最小の値を持つ、添字を返す
static int ExecNibunhou_LowerBound(long pVal, long[] pArr)
{
if (pArr.Length == 0) return -1;
// 最後の要素がVal未満の特殊ケース
if (pVal > pArr.Last()) {
return -1;
}
// 最初の要素がVal以上の特殊ケース
if (pVal <= pArr[0]) {
return 0;
}
int L = 0;
int R = pArr.GetUpperBound(0);
while (L + 1 < R) {
int Mid = (L + R) / 2;
if (pArr[Mid] >= pVal) {
R = Mid;
}
else {
L = Mid;
}
}
return R;
}
}
// フェニック木
#region Fenwick_Tree
internal class Fenwick_Tree
{
private long[] mBitArr;
private long mExternalArrUB;
// ノードのIndexの列挙を返す
internal IEnumerable<long> GetNodeIndEnum()
{
for (long I = 0; I <= mExternalArrUB; I++) {
yield return I;
}
}
// 木のノードのUBを返す
internal long GetUB()
{
return mExternalArrUB;
}
// コンストラクタ(外部配列のUBのみ指定)
internal Fenwick_Tree(long pExternalArrUB)
{
mExternalArrUB = pExternalArrUB;
// フェニック木の外部配列は0オリジンで、
// フェニック木の内部配列は1オリジンなため、2を足す
mBitArr = new long[pExternalArrUB + 2];
}
// コンストラクタ(初期化用の配列指定)
internal Fenwick_Tree(long[] pArr)
: this(pArr.GetUpperBound(0))
{
for (long I = 0; I <= pArr.GetUpperBound(0); I++) {
this.Add(I, pArr[I]);
}
}
// コンストラクタ(初期化用のList指定)
internal Fenwick_Tree(List<long> pList)
: this(pList.Count - 1)
{
for (int I = 0; I <= pList.Count - 1; I++) {
this.Add(I, pList[I]);
}
}
// [pSta,pEnd] のSumを返す
internal long GetSum(long pSta, long pEnd)
{
return GetSum(pEnd) - GetSum(pSta - 1);
}
// [0,pEnd] のSumを返す
internal long GetSum(long pEnd)
{
pEnd++; // 1オリジンに変更
long Sum = 0;
while (pEnd >= 1) {
Sum += mBitArr[pEnd];
pEnd -= pEnd & -pEnd;
}
return Sum;
}
// [I] に Xを加算
internal void Add(long pI, long pX)
{
pI++; // 1オリジンに変更
while (pI <= mBitArr.GetUpperBound(0)) {
mBitArr[pI] += pX;
pI += pI & -pI;
}
}
}
#endregion