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;
}

    static int luckBalance(int k, int[][] c) {
        PriorityQueue<Integer> imp = new PriorityQueue<>(Collections.reverseOrder());
        int luck = 0;
        for(int row = 0; row < c.length; row++){
            if(c[row][1] == 0) luck += c[row][0]; else imp.offer(c[row][0]);
        }
        boolean decreaseLuck = false;
        while(!imp.isEmpty()){
            if(k == 0) decreaseLuck = true;
            if(decreaseLuck == true) luck -= imp.poll(); else luck += imp.poll();
            k--;
        }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):
    total_luck = 0
    for luck,important in sorted(contests, reverse=True):
        if not important:
            total_luck += luck
        elif k:
            total_luck += luck
            k -= 1
        else:
            total_luck -= luck
    return total_luck

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)