#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>

using namespace std;

typedef long long ll;
// constexpr ll MOD = 998244353;
constexpr ll MOD = 1000000007;

// struct UnionFind {
//     vector<ll> par;
//     vector<ll> siz;
    
//     UnionFind(ll N): par(N), siz(N,1) {
//         for (ll i=0;i<N;i++) par[i] = i;
//     }

//     ll root(ll x) {
//         if (par[x] == x) return x;
//         else return par[x] = root(par[x]);
//     }

//     void unite(ll x, ll y) {
//         ll rx = root(x);
//         ll ry = root(y);
//         if (rx == ry) return;
//         // if (siz[rx] < siz[ry]) swap(rx,ry);
//         par[rx] = ry;
//         siz[ry] += siz[rx];
//     }

//     bool same(ll x, ll y) {
//         ll rx = root(x);
//         ll ry = root(y);
//         return rx == ry;
//     }

//     ll size(ll x) {
//         return siz[root(x)];
//     }
// };

//     vector<ll> par;
//     vector<ll> siz;
    
//     UnionFind(ll N): par(N), siz(N,1LL) {
//         for (ll i=0;i<N;i++) par[i] = i;
//     }

//     ll root(ll x) {
//         if (par[x] == x) return x;
//         else return par[x] = root(par[x]);
//     }

//     void unite(ll x, ll y) {
//         ll rx = root(x);
//         ll ry = root(y);
//         if (rx == ry) return;
//         par[rx] = ry;
//         siz[ry] += siz[rx];
//     }

//     bool same(ll x, ll y) {
//         ll rx = root(x);
//         ll ry = root(y);
//         return rx == ry;
//     }

//     ll size(ll x) {
//         return siz[root(x)];
//     }
// };

int main(void) {
    int N, M, X;
    cin >> N >> M >> X;
    vector<int> C(20);
    vector<vector<int>> A(20,vector<int>(20));
    for (int i=0;i<N;i++) {
        cin >> C[i];
        for (int j=0;j<M;j++) cin >> A[i][j];
    }

    int res = 100100100;
    for (int k=1;k<(1<<N);k++) {
        vector<int> U(20,0);
        int cost = 0;
        for (int i=0;i<N;i++) if (k&(1<<i)) {
            for (int j=0;j<M;j++) U[j] += A[i][j];
            cost += C[i];
        }
        bool flag = true;
        for (int j=0;j<M;j++) if (U[j] < X) flag = false;
        if (flag) res = min(res,cost);
    }
    if (res < 100100100) cout << res << endl;
    else cout << -1 << endl;

    // int res = 0;
    // for (int j=0;j<M;j++) {
    //     vector<vector<pair<int,int>>> dp(20,vector<pair<int,int>>(20));
    //     for (int k=0;k<=N;k++) dp[k][0] = make_pair(0,0);
    //     for (int k=1;k<=N;k++) {
    //         for (int l=1;l<k;l++) {
    //             if (dp[k-1][l-1].second + A[k-1][j] > dp[k-1][l].second) {
    //                 dp[k][l].first = dp[k-1][l-1].first + C[k-1];
    //                 dp[k][l].second = dp[k-1][l-1].second + A[k-1][j];
    //             } else if (dp[k-1][l-1].second + A[k-1][j] == dp[k-1][l].second && dp[k-1][l-1].first + C[k-1] < dp[k-1][l].first) {
    //                 dp[k][l].first = dp[k-1][l-1].first + C[k-1];
    //                 dp[k][l].second = dp[k-1][l-1].second + A[k-1][j];
    //             } else dp[k][l] = dp[k-1][l];
    //         }
    //         dp[k][k].first = dp[k-1][k-1].first + C[k-1];
    //         dp[k][k].second = dp[k-1][k-1].second + A[k-1][j];
    //     }
    //     int tmp = dp[N][N].first;
    //     for (int k=0;k<=N;k++) {
    //         for (int l=0;l<=k;l++) cout << "<" << dp[k][l].first << "," << dp[k][l].second << ">\t";
    //         cout << endl;
    //     }
    //     if (dp[N][N].second < X) tmp = -1;
    //     else for (int l=N-1;l>=0;l--) if (dp[N][l].second >= X && dp[N][l].first < tmp) tmp = dp[N][l].first;
    //     cout << tmp << endl;
    //     if (tmp<0) res = tmp;
    //     else if (res>=0) res = max(res,tmp);
    // }

    // cout << res << endl;

    return 0;
}


Measured memory_bytes: 3612