#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <limits>
#include <numeric>
#include <cmath>

using namespace std;

template<class T>
class Input {
public:
    auto operator()() const {
        T v;
        cin >> v;
        return v;
    }
};

template<class L, class R>
class Input<pair<L, R>> {
public:
    auto operator()() const {
        L l;
        R r;
        cin >> l >> r;
        return make_pair(l, r);
    }
};

template<class U>
class Input<vector<U>> {
public:
    auto operator()() const {
        Input<size_t> in{};
        auto n = in();
        return (*this)(n);
    }
    auto operator()(size_t n) const {
        vector<U> v;
        v.reserve(n);
        Input<U> in{};
        for (size_t i = 0; i < n; ++i) {
            auto u = in();
            v.emplace_back(move(u));
        }
        return v;
    }
};

template<class U>
class Input<vector<vector<U>>> {
public:
    auto operator()() const {
        Input<size_t> in{};
        auto n = in();
        auto m = in();
        return (*this)(n, m);
    }
    auto operator()(size_t n, size_t m) const {
        vector<vector<U>> v;
        v.reserve(n);
        Input<vector<U>> in{};
        for (size_t i = 0; i < n; ++i) {
            auto u = in(m);
            v.emplace_back(move(u));
        }
        return v;
    }
};

class InputType
{
public:
    template<class T>
    operator T() const {
        Input<T> i{};
        return i();
    }
};

class InputType2
{
public:
    InputType2(size_t n)
        : n_(n)
    {}
    template<class T>
    operator T() const {
        Input<T> i{};
        return i(n_);
    }
private:
    size_t n_;
};

auto input() {
    return InputType();
}

template<class... Args>
auto input(Args&&... args) {
    return InputType2(std::forward<Args>(args)...);
}

size_t bitcount(size_t n) {
    size_t c = 0;
    while (n) {
        if (n & 1ull)
            ++c;
        n >>= 1;
    }
    return c;
}

auto make_order(size_t n) {
    vector<size_t> a(n, 0);
    iota(begin(a), end(a), 0);
    return a;
}

template<class T>
auto next_permutation(T&& x) {
    using std::begin;
    using std::end;
    return next_permutation(begin(x), end(x));
}

using ll = long long;
using ull = unsigned long long;

auto gcd(size_t l, size_t r) {
    if (r == 0)
        return l;
    return gcd(r, l % r);
}

auto gcd(size_t a, size_t b, size_t c) {
    return gcd(a, gcd(b, c));
}

int main() {
    size_t n = input();
    size_t m = input();
    size_t x = input();
    vector<pair<size_t, vector<size_t>>> ca{};
    for (size_t i = 0; i < n; ++i) {
        size_t c = input();
        vector<size_t> a{};
        a.reserve(m);
        for (size_t j = 0; j < m; ++j) {
            a.push_back(input());
        }
        ca.emplace_back(c, move(a));
    }
    size_t c = numeric_limits<size_t>::max();;
    for (size_t i = 1; i < (1ull << n); ++i) {
        bool f = true;
        for (size_t j = 0; j < m; ++j) {
            size_t z = 0;
            for (size_t k = 0; k < n; ++k) {
                if (i & (1ull << k)) {
                    z += ca[k].second[j];
                }
            }
            if (z < x) {
                f = false;
                break;
            }
        }
        if (f) {
            size_t y = 0;
            for (size_t k = 0; k < n; ++k) {
                if (i & (1ull << k)) {
                    y += ca[k].first;
                }
            }
            c = min(c, y);
        }
    }
    if (c == numeric_limits<size_t>::max())
        cout << -1 << endl;
    else
        cout << c << endl;
    return 0;
}


Measured memory_bytes: 3624