from sys import stdin
from collections import deque
# https://codeforces.com/contest/1354/status/D
mod = 10**9 + 7
import sys
import random
# sys.setrecursionlimit(10**6)
from queue import PriorityQueue
from collections import Counter as cc
# def rl():
#     return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
# input = lambda: sys.stdin.readline().rstrip()
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

# def ncr(x, y):
#     return f(x) // (f(y) * f(x - y))
def ncr(n, r, p):
    num = den = 1
    for i in range(r):
        num = (num * (n - i)) % p
        den = (den * (i + 1)) % p
    return (num * pow(den,
                      p - 2, p)) % p

import sys

# input = sys.stdin.readline
# LCA
# def bfs(na):
#
#     queue = [na]
#     boo[na] = True
#     level[na] = 0
#
#     while queue!=[]:
#
#         z = queue.pop(0)
#
#         for i in hash[z]:
#
#             if not boo[i]:
#
#                 queue.append(i)
#                 level[i] = level[z] + 1
#                 boo[i] = True
#                 dp[i][0] = z
#
#
#
# def prec(n):
#
#     for i in range(1,20):
#
#         for j in range(1,n+1):
#             if dp[j][i-1]!=-1:
#                 dp[j][i] = dp[dp[j][i-1]][i-1]
#
#
# def lca(u,v):
#     if level[v] < level[u]:
#         u,v = v,u
#
#     diff = level[v] - level[u]
#
#
#     for i in range(20):
#         if ((diff>>i)&1):
#             v = dp[v][i]
#
#
#     if u == v:
#         return u
#
#
#     for i in range(19,-1,-1):
#         # print(i)
#         if dp[u][i] != dp[v][i]:
#
#             u = dp[u][i]
#             v = dp[v][i]
#
#
#     return dp[u][0]
#
# dp = []
#
#
# n = int(input())
#
# for i in range(n + 10):
#
#     ka = [-1]*(20)
#     dp.append(ka)


# class FenwickTree:
#     def __init__(self, x):
#         """transform list into BIT"""
#         self.bit = x
#         for i in range(len(x)):
#             j = i | (i + 1)
#             if j < len(x):
#                 x[j] += x[i]
#
#     def update(self, idx, x):
#         """updates bit[idx] += x"""
#         while idx < len(self.bit):
#             self.bit[idx] += x
#             idx |= idx + 1
#
#     def query(self, end):
#         """calc sum(bit[:end])"""
#         x = 0
#         while end:
#             x += self.bit[end - 1]
#             end &= end - 1
#         return x
#
#     def find_kth_smallest(self, k):
#         """Find largest idx such that sum(bit[:idx]) <= k"""
#         idx = -1
#         for d in reversed(range(len(self.bit).bit_length())):
#             right_idx = idx + (1 << d)
#             if right_idx < len(self.bit) and k >= self.bit[right_idx]:
#                 idx = right_idx
#                 k -= self.bit[idx]
#         return idx + 1



# import sys
# def rs(): return sys.stdin.readline().strip()
# def ri(): return int(sys.stdin.readline())
# def ria(): return list(map(int, sys.stdin.readline().split()))
# def prn(n): sys.stdout.write(str(n))
# def pia(a): sys.stdout.write(' '.join([str(s) for s in a]))
#
#
# import gc, os
#
# ii = 0
# _inp = b''
#
#
# def getchar():
#     global ii, _inp
#     if ii >= len(_inp):
#         _inp = os.read(0, 100000)
#         gc.collect()
#         ii = 0
#     if not _inp:
#         return b' '[0]
#     ii += 1
#     return _inp[ii - 1]
#
#
# def input():
#     c = getchar()
#     if c == b'-'[0]:
#         x = 0
#         sign = 1
#     else:
#         x = c - b'0'[0]
#         sign = 0
#     c = getchar()
#     while c >= b'0'[0]:
#         x = 10 * x + c - b'0'[0]
#         c = getchar()
#     if c == b'\r'[0]:
#         getchar()
#     return -x if sign else x

# fenwick Tree

# n,q = map(int,input().split())
#
#
# l1 = list(map(int,input().split()))
#
# l2 = list(map(int,input().split()))
#
# bit = [0]*(10**6 + 1)
#
# def update(i,add,bit):
#
#     while i>0 and i<len(bit):
#
#         bit[i]+=add
#         i = i + (i&(-i))
#
#
# def sum(i,bit):
#     ans = 0
#     while i>0:
#
#         ans+=bit[i]
#         i = i - (i & ( -i))
#
#
#     return ans
#
# def find_smallest(k,bit):
#
#     l = 0
#     h = len(bit)
#     while l<h:
#
#         mid = (l+h)//2
#         if k <= sum(mid,bit):
#             h = mid
#         else:
#             l = mid + 1
#
#
#     return l
#
#
# def insert(x,bit):
#     update(x,1,bit)
#
# def delete(x,bit):
#     update(x,-1,bit)
# fa = set()
#
# for i in l1:
#     insert(i,bit)
#
#
# for i in l2:
#     if i>0:
#         insert(i,bit)
#
#     else:
#         z = find_smallest(-i,bit)
#
#         delete(z,bit)
#
#
# # print(bit)
# if len(set(bit)) == 1:
#     print(0)
# else:
#     for i in range(1,n+1):
#         z = find_smallest(i,bit)
#         if z!=0:
#             print(z)
#             break
#

# service time problem


# def solve2(s,a,b,hash,z,cnt):
#     temp = cnt.copy()
#     x,y = hash[a],hash[b]
#     i = 0
#     j = len(s)-1
#
#     while z:
#
#         if s[j] - y>=x-s[i]:
#             if temp[s[j]]-1 == 0:
#                 j-=1
#             temp[s[j]]-=1
#             z-=1
#
#
#         else:
#             if temp[s[i]]-1 == 0:
#                 i+=1
#
#             temp[s[i]]-=1
#             z-=1
#
#     return s[i:j+1]
#
#
#
#
#
# def solve1(l,s,posn,z,hash):
#
#     ans = []
#     for i in l:
#         a,b = i
#         ka = solve2(s,a,b,posn,z,hash)
#         ans.append(ka)
#
#         return ans
#
# def consistent(input, window, min_entries, max_entries, tolerance):
#
#     l = input
#     n = len(l)
#     l.sort()
#     s = list(set(l))
#     s.sort()
#
#     if min_entries<=n<=max_entries:
#
#         if s[-1] - s[0]<window:
#             return True
#         hash = defaultdict(int)
#         posn = defaultdict(int)
#         for i in l:
#             hash[i]+=1
#
#         z = (tolerance*(n))//100
#         poss_window = set()
#
#
#         for i in range(len(s)):
#                 posn[i] = l[i]
#                 for j in range(i+1,len(s)):
#                     if s[j]-s[i] == window:
#                         poss_window.add((s[i],s[j]))
#
#         if poss_window!=set():
#             print(poss_window)
#             ans = solve1(poss_window,s,posn,z,hash)
#             print(ans)
#
#
#         else:
#             pass
#
#     else:
#         return False
#
#
#
#
# l = list(map(int,input().split()))
#
# min_ent,max_ent = map(int,input().split())
# w = int(input())
# tol = int(input())
# consistent(l, w, min_ent, max_ent, tol)

# t = int(input())
#
# for i in range(t):
#
#     n,x = map(int,input().split())
#
#     l = list(map(int,input().split()))
#
#     e,o = 0,0
#
#     for i in l:
#         if i%2 == 0:
#             e+=1
#         else:
#             o+=1
#
#     if e+o>=x and o!=0:
#         z = e+o - x
#         if z == 0:
#             if o%2 == 0:
#                 print('No')
#             else:
#                 print('Yes')
#             continue
#         if o%2 == 0:
#             o-=1
#             z-=1
#             if e>=z:
#                 print('Yes')
#             else:
#                 z-=e
#                 o-=z
#                 if o%2!=0:
#                     print('Yes')
#                 else:
#                     print('No')
#
#         else:
#
#             if e>=z:
#                 print('Yes')
#             else:
#                 z-=e
#                 o-=z
#                 if o%2!=0:
#                     print('Yes')
#                 else:
#                     print('No')
#     else:
#         print('No')
#
#
#
#
#
#
#
# def dfs(n):
#     boo[n] = True
#     dp2[n] = 1
#     for i in hash[n]:
#         if not boo[i]:
#
#             dfs(i)
#             dp2[n] += dp2[i]




































#
#
# n = int(input())
# x = 0
# l = list(map(int,input().split()))
# for i in range(n):
#
#      x = l[i]|x
#
# z = list(bin(x)[2:])
# ha = z.copy()
# k = z.count('1')
# ans = 0
# # print(z)
# cnt = 0
# for i in range(20):
#
#
#         maxi = 0
#         idx = -1
#
#         for j in range(n):
#             k = bin(l[j])[2:]
#             k = '0'*(len(z) -len(k)) + k
#             cnt = 0
#             for i in range(len(z)):
#                 if k[i] == z[i] == '1':
#                     cnt+=1
#
#             maxi = max(maxi,cnt)
#             if maxi == cnt:
#                 idx = j
#         if idx!=-1:
#
#             k = bin(l[idx])[2:]
#             k = '0'*(len(z) -len(k)) + k
#
#             for i in range(len(z)):
#                 if k[i] == z[i] == '1':
#                     z[i] = '0'
#             l[idx] = 0
#
#
# ans = 0
# for i in range(len(z)):
#     if z[i] == '0' and ha[i] == '1':
#         ans+=1
# flip = 0
# for i in range(ans):
#     flip+=2**i
#
#
#
# print(flip)

# def search(k,l,low):
#
#     high = len(l)-1
#     z = bisect_left(l,k,low,high)
#
#     return z
#
#
#
#
#
#
# n,x = map(int,input().split())
#
# l = list(map(int,input().split()))
#
# prefix = [0]
# ha = [0]
# for i in l:
#     prefix.append(i + prefix[-1])
#     ha.append((i*(i+1))//2 + ha[-1])
# fin = 0
# print(prefix)
# for i in range(n):
#     ans = 0
#     if l[i]<x:
#
#
#         if prefix[-1]-prefix[i]>=x:
#
#             z = search(x+prefix[i],prefix,i+1)
#             print(z)
#             z+=i+1
#             k1 = x-(prefix[z-1]-prefix[i])
#             ans+=ha[z-1]
#             ans+=(k1*(k1+1))//2
#
#
#         else:
#             z1 = x - (prefix[-1]-prefix[i])
#             z = search(z1,prefix,1)
#
#             k1 = x-prefix[z-1]
#             ans+=ha[z-1]
#             ans+=(k1*(k1+1))//2
#
#
#
#
#     elif l[i]>x:
#         z1 = ((l[i])*(l[i]+1))//2
#         z2 = ((l[i]-x)*(l[i]-x+1))//2
#         ans+=z1-z2
#     else:
#         ans+=(x*(x+1))//2





# t = int(input())
#
# for _ in range(t):
#
#     s = list(input())
#     ans = [s[0]]
#
#     for i in range(1,len(s)-1,2):
#         ans.append(s[i])
#
#     ans.append(s[-1])
#     print(''.join(ans))
#
#
#
# t = int(input())
#
# for _ in range(t):
#
#     n = int(input())
#     l = list(map(int,input().split()))
#     ans = 0
#     for i in range(n):
#         if l[i]%2!=i%2:
#             ans+=1
#
#     if ans%2 == 0:
#         print(ans//2)
#     else:
#        print(-1)


# t = int(input())
#
# for _ in range(t):
#
#     n,k = map(int,input().split())
#     s = input()
#
#
#     ans = 0
#     ba = []
#     for i in range(n):
#         if s[i] == '1':
#             ba.append(i)
#     if ba == []:
#         for i in range(0,n,k+1):
#             ans+=1
#
#         print(ans)
#         continue
#
#     i = s.index('1')
#     c = 0
#     for x in range(i-1,-1,-1):
#         if c == k:
#             c = 0
#             ans+=1
#         else:
#             c+=1
#
#
#     while i<len(s):
#         count = 0
#         dis = 0
#         while s[i] == '0':
#             dis+=1
#             if dis == k:
#                 dis = 0
#                 count+=1
#             if dis<k and s[i] == '1':
#                 count-=1
#                 break
#             i+=1
#             if i == n:
#                 break
#         i+=1
#
#     print(ans)
#
#
#
#

# q1

# def poss1(x):
#     cnt = 1
#     mini = inf
#     for i in l:
#         if cnt%2 != 0:
#           cnt+=1
#         else:
#             if i<=x:
#                 cnt+=1
#                 mini = min()
#         if cnt  == k:
#             return
#
#     return -1
#
#
#
#
# def poss2(x):
#     cnt = 1
#     for i in l:
#         if cnt%2 == 0:
#             cnt+=1
#         else:
#             if i<=x:
#                 cnt+=1
#         if cnt  == k:
#             return
#
#     return -1
#
#
#
# n,k = map(int,input().split())
# l = list(map(int,input().split()))
#
# z1 = min(l)
# z2 = max(l)







# t = int(input())
#
# for _ in range(t):
#
#     n,k = map(int,input().split())
#     l = list(map(int,input().split()))
#
#     for i in range(n):
#         z = l[i]%k
#
#         if z!=0:
#
#             l[i] = k-z
#         else:
#             l[i] = 0
#
#     l.sort()
#     count = 0
#     ans = 0
#     x = 0
#     print(l)
#     for i in range(n):
#
#             z = l[i]
#             if z == 0:
#                 continue
#             if x>z:
#                 z2 = ceil((x-l[i])/k)
#                 z1 = l[i] + k*z2
#                 # print(x,z1)
#                 ans += z1-x + 1
#                 x = z1+1
#             elif z == x:
#                 ans+=1
#                 x+=1
#             else:
#
#                 ans += z-x + 1
#                 x = z+1
#             # print(i,x)
#             print(ans)
#
#
#
#     print(ans)






n,k = map(int,input().split())
ha = k
la1 = []
la2 = []
la3 = []
for i in range(n):
    t,a,b = map(int,input().split())
    if a == 1 and b == 0:
        la1.append(t)
    elif a == 0 and b == 1:
        la2.append(t)
    elif a == 1 and b == 1:
         la3.append(t)

la1.sort()
la2.sort()
la3.sort()
ans = 0
count1 = 0
count2 = 0
i,j,k = 0,0,0
z = max(len(la1),len(la2),len(la3))
# print(la1,la2,la3)
while True:
    if i>=z and j>=z and k>=z:
        break
    if count1 >= ha and count2>=ha:
        break
    t1,t2,t3 = 10**18,10**18,10**18
    try:
        t1 = la1[i]
    except:
        pass
    try:
        t2 = la2[j]
    except:
        pass
    try:
        t3 = la3[k]
    except:
        pass

    if count1>=ha and count2>=ha:
        break
    elif count1<ha and count2<ha:
        if t1+t2<=t3:
            count1+=1
            count2+=1
            ans+=t1+t2
            i+=1
            j+=1
        else:
            count1+=1
            count2+=1
            ans+=t3
            k+=1

    elif count1<ha and count2>=ha:
        if t1<=t3:
            i+=1
            ans+=t1
        else:
            k+=1
            ans+=t3

    elif count2<ha and count1>=ha:
        if t2<=t3:
            j+=1
            ans+=t2
        else:
            k+=1
            ans+=t3


if ans>=10**18:
    print(-1)
else:
    print(ans)



