int totalLuckBalance = 0;
        int impContestCount = 0;
        List<int> tempList = new List<int>();
        int index = 0;

        for(int i = 0; i < contests.Length; i++){
            if(contests[i][1] == 0)
                totalLuckBalance += contests[i][0];
            else{
                impContestCount ++;
                tempList.Add(contests[i][0]);
                totalLuckBalance += contests[i][0];
            }
        }

        if(impContestCount > k){
            tempList.Sort();
            int n = impContestCount - k;
            for(int j = 0; j < n; j++){
                totalLuckBalance -= 2 * tempList[j];
            }
        }

        return totalLuckBalance;

int luckBalance(int k, vector<vector<int>> contests) {
    vector<int> imp;
    int luck=0;
    for (int i=0;i<contests.size();i++)
    {
        if (contests[i][1])
        {
            imp.push_back(contests[i][0]);
            luck-=contests[i][0];
        }
        else    luck+=contests[i][0];
    }
    sort(imp.begin(), imp.end(), greater<int>());
    for (int i=0;i<min(k, (int)imp.size());i++)   luck+=2*imp[i];

    return luck;
}

var temp = Console.ReadLine().Split(' ');
var arr = Array.ConvertAll(temp, Int32.Parse);
var N = arr[0];
var K = arr[1];
List<Tuple<int, int>> luckBalance = new List<Tuple<int, int>>();
for (var contest = 0; contest < N ; contest++){
    var ln_temp = Console.ReadLine().Split(' ');
    var ln = Array.ConvertAll(ln_temp, Int32.Parse);
    var luck = ln[0];
    var importance = ln[1];
    luckBalance.Add(Tuple.Create(luck, importance));
}
var importanContests = luckBalance.Where(u => u.Item2 == 1).Select(u => u.Item1).OrderBy(u=>u).ToList();
var luckSum = luckBalance.Select(u => u.Item1).Sum();
int luckToFlip = 0;
int mustWinImprCount = importanContests.Count() - K;
for (int i = 0; i < mustWinImprCount; i++)
{
    luckToFlip += importanContests[i];
}
int result = luckSum - 2 * luckToFlip;        
Console.Write(result);

Iterator<Integer> iter = list.iterator();
while(list.size() > k) {
	totalLuck -= 2*iter.next();
	k++;
}
return totalLuck;

int mustWinImprCount = importantContests.size() - k;

   // Complete the luckBalance function below.
    static int luckBalance(int k, int[][] contests) {
        int numLuck = 0;
        int totalImportant = 0;
        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>(new Comparator<Integer>(){
            @Override
            public int compare(Integer obj1, Integer obj2){
                return obj1 - obj2;
            }
        });
        for(int[] contest : contests){
            numLuck += contest[0];
            if(contest[1] == 1){
                minHeap.offer(contest[0]);
                totalImportant++;
            }
        }
        for(int i = 0; i < totalImportant - k; i++){
            numLuck -= 2 * minHeap.poll();
        }
        return numLuck;
    }

def luck_balance(k, contests):
    # group important and unimportant contests
    sorted_contests = sorted(contests, key=itemgetter(1))
    groups = tuple(list(g) for k, g in it.groupby(sorted_contests, key=itemgetter(1)))
    if len(groups) > 1:
        unimportant, important = groups
    elif groups[0][0][1] == 0:
        unimportant, important = groups[0], []
    else:
        unimportant, important = [], groups[0]

    # calculate how many matches we need to throw

    throws = len(important) - k
        
    if throws < 1:
        return sum(luck for luck, _ in important + unimportant)

    # start by sorting important contests to throw the smallest in terms of luck
    sorted_important = sorted(important)
    # group wins and losses
    losses, wins = sorted_important[:throws], sorted_important[throws:]
    # do math
    total = sum(luck for luck, _ in wins + unimportant)
    net = total - sum(luck for luck, _ in losses)
    return net

def luckBalance(k, contests):
    heap = []
    heapq.heapify(heap)
    luck = 0
    for L,T in contests:
        if not T:
            luck = luck + L
        elif k < 1:
            luck = luck - L
        elif len(heap) < k:
            heapq.heappush(heap, L)
        else:
            luck = luck - heapq.heappushpop(heap, L)
    return luck + sum(heap)

function luckBalance(k, contests) {
  const importantContestsVals = []
  let val = 0;
  
  for (let i = 0; i < contests.length; i++) { 
    if (contests[i][1]) {
      importantContestsVals.push(contests[i][0])
    } else { 
      val += contests[i][0]
    }
  }
  
  importantContestsVals.sort((a, b) => a - b)
  const negativeArr = importantContestsVals.splice(0, importantContestsVals.length - k)
  const largestArr = negativeArr.length >= importantContestsVals.length ? negativeArr.length : importantContestsVals.length

  for (let j = 0; j < largestArr; j++) { 
    if (negativeArr[j]) { 
      val -= negativeArr[j]
    }
    if (importantContestsVals[j]) { 
      val += importantContestsVals[j]
    }
  }

  return val
}