#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;
/*
#include <atcoder/all>
using namespace atcoder;
*/
/*
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
using bll = boost::multiprecision::cpp_int;
using bdouble = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>>;
using namespace boost::multiprecision;
*/
#if defined(LOCAL_TEST) || defined(LOCAL_DEV)
	#define BOOST_STACKTRACE_USE_ADDR2LINE
	#define BOOST_STACKTRACE_ADDR2LINE_LOCATION /usr/local/opt/binutils/bin/addr2line
	#define _GNU_SOURCE 1
	#include <boost/stacktrace.hpp>
#endif
#ifdef LOCAL_TEST
	namespace std {
		template <typename T> class dvector : public std::vector<T> {
		public:
			using std::vector<T>::vector;
			template <typename T_ = T, typename std::enable_if_t<std::is_same_v<T_, bool>, std::nullptr_t> = nullptr>
			std::vector<bool>::reference operator[](std::size_t n) {
				if (this->size() <= n) { std::cerr << boost::stacktrace::stacktrace() << '\n' << "vector::_M_range_check: __n (which is " << n << ") >= this->size() (which is " << this->size() << ")" << '\n'; } return this->at(n);
			}
			template <typename T_ = T, typename std::enable_if_t<std::is_same_v<T_, bool>, std::nullptr_t> = nullptr>
			const T_ operator[](std::size_t n) const {
				if (this->size() <= n) { std::cerr << boost::stacktrace::stacktrace() << '\n' << "vector::_M_range_check: __n (which is " << n << ") >= this->size() (which is " << this->size() << ")" << '\n'; } return this->at(n);
			}
			template <typename T_ = T, typename std::enable_if_t<!std::is_same_v<T_, bool>, std::nullptr_t> = nullptr>
			T_& operator[](std::size_t n) {
				if (this->size() <= n) { std::cerr << boost::stacktrace::stacktrace() << '\n' << "vector::_M_range_check: __n (which is " << n << ") >= this->size() (which is " << this->size() << ")" << '\n'; } return this->at(n);
			}
			template <typename T_ = T, typename std::enable_if_t<!std::is_same_v<T_, bool>, std::nullptr_t> = nullptr>
			const T_& operator[](std::size_t n) const {
				if (this->size() <= n) { std::cerr << boost::stacktrace::stacktrace() << '\n' << "vector::_M_range_check: __n (which is " << n << ") >= this->size() (which is " << this->size() << ")" << '\n'; } return this->at(n);
			}
		};
		template <typename T, typename Compare = std::less<T>, typename Allocator = std::allocator<T>> class dmultiset : public std::multiset<T,Compare,Allocator> {
		public:
			using std::multiset<T,Compare,Allocator>::multiset;
			const typename std::multiset<T,Compare,Allocator>::iterator erase(const typename std::multiset<T,Compare,Allocator>::iterator it) {
				return std::multiset<T,Compare,Allocator>::erase(it);
			}
			std::size_t erase([[maybe_unused]] const T& x) {
				std::cerr << boost::stacktrace::stacktrace() << '\n'; assert(false);
			}
			std::size_t erase_all_elements(const T& x) {
				return std::multiset<T,Compare,Allocator>::erase(x);
			}
		};
	}
	#define vector dvector
	#define multiset dmultiset
	class SIGFPE_exception : std::exception {};
	class SIGSEGV_exception : std::exception {};
	void catch_SIGFPE([[maybe_unused]] int e) { std::cerr << boost::stacktrace::stacktrace() << '\n'; throw SIGFPE_exception(); }
	void catch_SIGSEGV([[maybe_unused]] int e) { std::cerr << boost::stacktrace::stacktrace() << '\n'; throw SIGSEGV_exception(); }
	signed convertedmain();
	signed main() { signal(SIGFPE, catch_SIGFPE); signal(SIGSEGV, catch_SIGSEGV); return convertedmain(); }
	#define main() convertedmain()
#else
	#define erase_all_elements erase
#endif
#ifdef LOCAL_DEV
	template <typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::pair<T1, T2>& p) {
		return s << "(" << p.first << ", " << p.second << ")"; }
	template <typename T, std::size_t N> std::ostream& operator<<(std::ostream& s, const std::array<T, N>& a) {
		s << "{ "; for (std::size_t i = 0; i < N; ++i){ s << a[i] << "\t"; } s << "}"; return s; }
	template <typename T> std::ostream& operator<<(std::ostream& s, const std::set<T>& se) {
		s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
	template <typename T> std::ostream& operator<<(std::ostream& s, const std::multiset<T>& se) {
		s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
	template <typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::map<T1, T2>& m) {
		s << "{\n"; for (auto itr = m.begin(); itr != m.end(); ++itr){ s << "\t" << (*itr).first << " : " << (*itr).second << "\n"; } s << "}"; return s; }
	template <typename T> std::ostream& operator<<(std::ostream& s, const std::deque<T>& v) {
		for (std::size_t i = 0; i < v.size(); ++i){ s << v[i]; if (i < v.size() - 1) s << "\t"; } return s; }
	template <typename T> std::ostream& operator<<(std::ostream& s, const std::vector<T>& v) {
		for (std::size_t i = 0; i < v.size(); ++i){ s << v[i]; if (i < v.size() - 1) s << "\t"; } return s; }
	template <typename T> std::ostream& operator<<(std::ostream& s, const std::vector<std::vector<T>>& vv) {
		s << "\\\n"; for (std::size_t i = 0; i < vv.size(); ++i){ s << vv[i] << "\n"; } return s; }
	template <typename T, std::size_t N, typename std::enable_if_t<!std::is_same_v<T, char>, std::nullptr_t> = nullptr> std::ostream& operator<<(std::ostream& s, const T (&v)[N]) {
		for (std::size_t i = 0; i < N; ++i){ s << v[i]; if (i < N - 1) s << "\t"; } return s; }
	#if __has_include(<ext/pb_ds/assoc_container.hpp>)
		template <typename Key, typename Compare> std::ostream& operator<<(std::ostream& s, const __gnu_pbds::tree<Key, __gnu_pbds::null_type, Compare, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>& se) {
			s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
		template <typename Key, typename T, typename Hash> std::ostream& operator<<(std::ostream& s, const __gnu_pbds::gp_hash_table<Key, T, Hash>& m) {
			s << "{\n"; for (auto itr = m.begin(); itr != m.end(); ++itr){ s << "\t" << (*itr).first << " : " << (*itr).second << "\n"; } s << "}"; return s; }
	#endif
	void debug_impl() { std::cerr << '\n'; }
	template <typename Head, typename... Tail> void debug_impl(const Head& head, const Tail&... tail) { std::cerr << " " << head << (sizeof...(tail) ? "," : ""); debug_impl(tail...); }
	#define debug(...) do { std::cerr << ":" << __LINE__ << " (" << #__VA_ARGS__ << ") ="; debug_impl(__VA_ARGS__); } while (false)
	constexpr inline long long prodlocal([[maybe_unused]] long long prod, [[maybe_unused]] long long local) { return local; }
#else
	#define debug(...) do {} while (false)
	constexpr inline long long prodlocal([[maybe_unused]] long long prod, [[maybe_unused]] long long local) { return prod; }
#endif
//#define int long long
using ll = long long;
//INT_MAX = (1<<31)-1 = 2147483647, INT64_MAX = (1LL<<63)-1 = 9223372036854775807
constexpr ll INF = std::numeric_limits<ll>::max() == INT_MAX ? (ll)1e9 + 7 : (ll)1e18;
constexpr ll MOD = (ll)1e9 + 7; //primitive root = 5
//constexpr ll MOD = 998244353; //primitive root = 3
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
#define rep(i, n)   for(ll i=0, i##_length=(n); i< i##_length; ++i)
#define repeq(i, n) for(ll i=1, i##_length=(n); i<=i##_length; ++i)
#define rrep(i, n)   for(ll i=(n)-1; i>=0; --i)
#define rrepeq(i, n) for(ll i=(n)  ; i>=1; --i)
#define all(v) std::begin(v), std::end(v)
#define rall(v) std::rbegin(v), std::rend(v)
void p() { std::cout << '\n'; }
template <typename Head, typename... Tail> void p(const Head& head, const Tail&... tail) { std::cout << head << (sizeof...(tail) ? " " : ""); p(tail...); }
template <typename T> inline void pv(const std::vector<T>& v) { for(ll i=0, N=v.size(); i<N; i++) std::cout << v[i] << " \n"[i==N-1]; }
template <typename T> inline bool chmax(T& a, T b) { return a < b && (a = b, true); }
template <typename T> inline bool chmin(T& a, T b) { return a > b && (a = b, true); }
template <typename T> inline void uniq(std::vector<T>& v) { std::sort(v.begin(), v.end()); v.erase(std::unique(v.begin(), v.end()), v.end()); }
template <typename T> inline ll sz(const T& v) { return std::size(v); }
template <typename T, std::size_t N> std::vector<T> make_vector_impl(std::vector<ll>& sizes, typename std::enable_if<(N==1), const T&>::type x) { return std::vector<T>(sizes.front(),x); }
template <typename T, std::size_t N> auto make_vector_impl(std::vector<ll>& sizes, typename std::enable_if<(N>1), const T&>::type x) { ll size=sizes.back(); sizes.pop_back(); return std::vector<decltype(make_vector_impl<T,N-1>(sizes,x))>(size,make_vector_impl<T,N-1>(sizes,x)); }
template <typename T, std::size_t N> auto make_vector(const ll (&sizes)[N], const T& x=T()) { std::vector<ll> s(N); for(std::size_t i=0; i<N; ++i)s[i]=sizes[N-1-i]; return make_vector_impl<T,N>(s,x); }
template <typename T> struct Indexer {
	struct iterator {
		ll _pos;
		typename T::iterator _it;
		iterator(typename T::iterator it): _pos(0), _it(it) {}
		std::pair<ll, typename std::iterator_traits<typename T::iterator>::reference> operator*() const { return {_pos, *_it}; }
		iterator& operator++() { ++_pos; ++_it; return *this; }
		iterator operator++(int) { iterator tmp(*this); ++*this; return tmp; }
		bool operator==(iterator const& it) const { return _it == it._it; }
		bool operator!=(iterator const& it) const { return !(*this == it); }
	};
	T& _container;
	Indexer(T& t): _container(t) {}
	iterator begin() const { return iterator(_container.begin()); }
	iterator end() const { return iterator(_container.end()); }
};
template <typename T> Indexer<T> indexer(const T& t) { return Indexer<T>(t); }
#define repv(i, val, v) for(auto&& [i, val] : indexer(v))
#if __has_include(<ext/pb_ds/assoc_container.hpp>)
	template <typename Key, typename Mapped, typename Hash = std::hash<Key>, typename std::enable_if_t<std::is_integral_v<Key>, std::nullptr_t> = nullptr> struct fmap : public __gnu_pbds::gp_hash_table<Key, Mapped, Hash> {
		using __gnu_pbds::gp_hash_table<Key, Mapped, Hash>::gp_hash_table;
		template <typename T> fmap(std::initializer_list<std::initializer_list<T>> il) : __gnu_pbds::gp_hash_table<Key, Mapped, Hash>() {
			for (auto&& x : il) __gnu_pbds::gp_hash_table<Key, Mapped, Hash>::insert(std::pair<Key, Mapped>(*x.begin(), *(x.begin() + 1)));
		}
		template <typename T> ll count(const T& x) const {
			return __gnu_pbds::gp_hash_table<Key, Mapped, Hash>::find(x) != __gnu_pbds::gp_hash_table<Key, Mapped, Hash>::end();
		}
	};
#else
	template <typename Key, typename Mapped> using fmap = std::map<Key, Mapped>;
#endif

/*-----8<-----template-----8<-----*/

//[lib]最小費用流Primal-Dual.cpp
/*
最小費用流(Primal-Dual)
計算量：O(FElogV)
PrimalDual(V):= 頂点数 V で初期化する。
add_edge(from, to, cap, cost):= 頂点 from から to に容量 cap, 
　　　　　　　　　　　　　　　　　　　コスト cost の辺を張る。
min_cost_flow(s, t, flow):= 頂点 s から t に流量 flow の最小費用流を流す。
　　　　　　　　　　　　　　　流せた場合はそのコスト, 流せない場合は −1 を返す。
*/
template< typename flow_t, typename cost_t >
class PrimalDual {
public:
	struct edge {
		ll to;
		flow_t cap;
		cost_t cost;
		ll rev;
		bool isrev;
	};

	vector< vector< edge > > graph;
	vector< cost_t > potential, min_cost;
	vector< ll > prevv, preve;
	const cost_t inf;

	PrimalDual(ll V, ll inf = INF) : graph(V), inf(inf) {}

	void add_edge(ll from, ll to, flow_t cap, cost_t cost) {
		graph[from].emplace_back((edge) {to, cap, cost, (ll) graph[to].size(), false});
		graph[to].emplace_back((edge) {from, 0, -cost, (ll) graph[from].size() - 1, true});
	}

	cost_t min_cost_flow(ll s, ll t, flow_t f, const vector<cost_t> &pv={}) {
		ll V = (ll) graph.size();
		cost_t ret = 0;
		using Pi = pair< cost_t, ll >;
		priority_queue< Pi, vector< Pi >, greater< Pi > > que;
		if(pv.size()) potential = pv;
		else potential.assign(V, 0);
		preve.assign(V, -1);
		prevv.assign(V, -1);

		while(f > 0) {
			min_cost.assign(V, inf);
			que.emplace(0, s);
			min_cost[s] = 0;
			while(!que.empty()) {
				Pi p = que.top();
				que.pop();
				if(min_cost[p.second] < p.first) continue;
				for(ll i = 0; i < (ll)graph[p.second].size(); i++) {
					edge &e = graph[p.second][i];
					cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] - potential[e.to];
					if(e.cap > 0 && min_cost[e.to] > nextCost) {
						min_cost[e.to] = nextCost;
						prevv[e.to] = p.second, preve[e.to] = i;
						que.emplace(min_cost[e.to], e.to);
					}
				}
			}
			if(min_cost[t] == inf) return -INF;
			for(ll v = 0; v < V; v++) potential[v] += min_cost[v];
			flow_t addflow = f;
			for(ll v = t; v != s; v = prevv[v]) {
				addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
			}
			f -= addflow;
			ret += addflow * potential[t];
			for(ll v = t; v != s; v = prevv[v]) {
				edge &e = graph[prevv[v]][preve[v]];
				e.cap -= addflow;
				graph[v][e.rev].cap += addflow;
			}
		}
		return ret;
	}

	void output() const {
		for(ll i = 0; i < (ll)graph.size(); i++) {
			for(auto &e : graph[i]) {
				if(e.isrev) continue;
				auto &rev_e = graph[e.to][e.rev];
				cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/" << rev_e.cap + e.cap << ")" << endl;
			}
		}
	}
};
template<typename flow_t, typename cost_t> std::ostream& operator<<(std::ostream& s, const PrimalDual<flow_t,cost_t>& pd) {
	s << "\\\n"; pd.output(); return s;
}

//グラフ負辺除去のためのポテンシャルを計算する
//計算量: isDAG ? O(E+V) : O(EV)
template <typename flow_t, typename cost_t>
vector<cost_t> calcPotential(const PrimalDual<flow_t, cost_t> pd, ll start) {
	bool allPositive = [&]{
		for(auto&& v : pd.graph) for(auto&& e : v) if(!e.isrev && e.cost<0) return false;
		return true;
	}();
	if(allPositive){
		return vector<cost_t>(pd.graph.size(), 0);
	}

	vector<cost_t> isDAG = [&] {
		ll N = pd.graph.size();
		vector<cost_t> dist(N, numeric_limits<cost_t>::max()>>1); dist[start] = 0;
		vector<ll> indegree(N, 0);
		for(ll from=0; from<N; from++){
			for(auto&& e : pd.graph[from]){
				if(!e.isrev)indegree[e.to]++;
			}
		}
		vector<ll> que;
		for(ll i=0; i<N; i++){
			if(indegree[i]==0)que.emplace_back(i);
		}
		ll anscount = 0;
		while(!que.empty()){
			ll v=que.back();
			que.pop_back();
			anscount++;
			for(auto &&e : pd.graph[v]){
				if (e.isrev) continue;
				dist[e.to] = min(dist[e.to], dist[v] + e.cost);
				indegree[e.to]--;
				if(indegree[e.to]==0)que.emplace_back(e.to);
			}
		}
		return anscount == N ? dist : vector<cost_t>();
	}();
	if (isDAG.size()) return isDAG;

	ll edgesize = 0;
	for (auto&& v : pd.graph) edgesize += v.size();
	edgesize >>= 1;
	if (edgesize * pd.graph.size() > (ll)1e8) {
		return vector<cost_t>(pd.graph.size(), 0);
	}
	auto bellman_ford = [&](ll start, vector<cost_t> &dist) {
		ll gsize = pd.graph.size();
		const cost_t inf = numeric_limits<cost_t>::max();
		const cost_t minusinf = numeric_limits<cost_t>::min();
		dist.assign(gsize, inf); dist[start] = 0;
		bool negative_cycle = false;
		for(ll k=0; k<(gsize<<1); k++) for(ll from=0; from<gsize; from++) {
			if (dist[from] == inf) continue;
			for(auto &&e : pd.graph[from]) {
				if (!e.isrev && dist[e.to] > dist[from] + e.cost) {
					dist[e.to] = dist[from] + e.cost;
					if (k >= gsize-1) {
						dist[e.to] = minusinf>>1;
						negative_cycle = true;
					}
				}
			}
		}
		return negative_cycle;
	};
	vector<cost_t> dist;
	bool negativecycle = bellman_ford(start, dist);
	assert(!negativecycle);
	return dist;
}

/*-----8<-----library-----8<-----*/

void solve() {
	ll N, K;
	cin >> N >> K;
	vector<ll> a(N), m(N);
	vector<vector<ll>> b(N);
	rep(i,N){
		cin >> a[i] >> m[i];
		b[i].resize(m[i]);
		rep(j, m[i]) cin >> b[i][j], b[i][j]--;
	}


	ll start = 0;
	ll goal = N - 1;
	PrimalDual<ll, ll> pd(N<<1);

	rep(i,N-1){
		pd.add_edge(i, i+1, K, 0);
		pd.add_edge(i, i+N, K, a[i]);
	}
	rep(i,N){
		for(auto&& j:b[i]){
			pd.add_edge(j+N, i, 1, -a[i]);
		}
	}

	vector<ll> potential = calcPotential(pd, start);
	//ポテンシャルを事前計算して渡すことが可能
	//サイクルがあると動かないのでSCCでサイクル除去する
	ll mincost = pd.min_cost_flow(start, goal, K, potential);
	cout << -mincost << '\n';
	//debug(pd);
}

signed main() {
#ifndef LOCAL_DEV
	std::cin.tie(nullptr);
	std::ios::sync_with_stdio(false);
#endif
	//ll Q; cin >> Q; while(Q--)solve();
	solve();
	return 0;
}