// Original C++ solution (slower):
#include "bits/stdc++.h"

#pragma GCC optimize("Ofast")



// Begin Header {{{

using namespace std;



#ifndef DEBUG

#define dump(...)

#endif



#define all(x) x.begin(), x.end()

#define rall(x) x.rbegin(), x.rend()

#define rep(i, n) for (intmax_t i = 0, i##_limit = (n); i < i##_limit; ++i)

#define reps(i, b, e) for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)

#define repr(i, b, e) for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)

#define var(Type, ...) Type __VA_ARGS__; input(__VA_ARGS__)



constexpr size_t    operator""_zu(unsigned long long value) { return value; };

constexpr intmax_t  operator""_jd(unsigned long long value) { return value; };

constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };



constexpr int INF = 0x3f3f3f3f;

constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;



namespace moke {



template <class T> using MaxHeap = priority_queue<T, vector<T>, less<T>>;

template <class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;



inline void input() {}

template <class Head, class... Tail> inline void input(Head&& head, Tail&&... tail) {

    cin >> head;

    input(forward<Tail>(tail)...);

}



inline void outs() { cout << "\n"; }

template <class Head, class... Tail> inline void outs(Head&& head, Tail&&... tail) {

    cout << head << (sizeof...(tail) ? " " : "");

    outs(forward<Tail>(tail)...);

}



template <class T> inline void outs(vector<T> &vec) {

    for (auto &e : vec) cout << e << " \n"[&e == &vec.back()];

}



template <class T> inline void outs(vector<vector<T>> &df) {

    for (auto &vec : df) outs(vec);

}



inline void outl() { cout << "\n"; }

template <class Head, class... Tail> inline void outl(Head&& head, Tail&&... tail) {

    cout << head << (sizeof...(tail) ? "\n" : "");

    outl(forward<Tail>(tail)...);

}



template <class T> inline void outl(vector<T> &vec) {

    for (auto &e : vec) cout << e << "\n";

}



inline void outn() {}

template <class Head, class... Tail> inline void outn(Head&& head, Tail&&... tail) {

    cout << head;

    outn(forward<Tail>(tail)...);

}



template <class T> inline void outn(vector<T> &vec) {

    for (auto &e : vec) cout << e;

}



template <class T> inline vector<T> make_v(const T &initValue, size_t sz) {

    return vector<T>(sz, initValue);

}



template <class T, class... Args> inline auto make_v(const T &initValue, size_t sz, Args... args) {

    return vector<decltype(make_v<T>(initValue, args...))>(sz, make_v<T>(initValue, args...));

}



template <class A, class B> inline bool chmax(A &a, const B &b) noexcept {

    return b > a && (a = b, true);

}



template <class A, class B> inline bool chmin(A &a, const B &b) noexcept {

    return b < a && (a = b, true);

}



template <class A, class B> inline common_type_t<A, B> min(const A &a, const B &b) noexcept {

    return a < b ? a : b;

}



template <class A, class B, class... Args>

inline common_type_t<A, B, Args...> min(const A &a, const B &b, const Args&... args) noexcept {

    return moke::min(a < b ? a : b, args...);

}



template <class A, class B> inline common_type_t<A, B> max(const A &a, const B &b) noexcept {

    return a > b ? a : b;

}



template <class A, class B, class... Args>

inline common_type_t<A, B, Args...> max(const A &a, const B &b, const Args&... args) noexcept {

    return moke::max(a > b ? a : b, args...);

}



template <class A, class B> inline common_type_t<A, B> diff(const A &a, const B &b) noexcept {

    return a < b ? b - a : a - b;

}



} // namespace moke



// }}} End Header



namespace moke {



int main_() {

    ios_base::sync_with_stdio(false);

    cin.tie(nullptr);



    var(int, N);



    auto F = make_v<int>(0, N, 10);

    rep(i, N) rep(j, 10) {

        input(F[i][j]);

    }



    auto P = make_v<int>(0, N, 11);

    rep(i, N) rep(j, 11) {

        input(P[i][j]);

    }



    int maxv = -INF;

    rep(bit, (1 << 10)) {

        if (bit == 0) continue;

        vector<int> cnt(N);

        rep(i, N) {

            rep(j, 10) {

                if (bit & (1 << j)) {

                    cnt[i] += F[i][j];

                }

            }

        }



        int res = 0;

        rep(i, N) {

            res += P[i][cnt[i]];

        }



        chmax(maxv, res);

    }



    outl(maxv);



    return 0;

}



} // namespace moke



signed main() { // {{{



    moke::main_();



    return 0;

} // }}}


// Optimized solution to the same problem (faster):
#include "bits/stdc++.h"



// Begin Header {{{

using namespace std;



#ifndef DEBUG

#define dump(...)

#endif



#define all(x) x.begin(), x.end()

#define rep(i, b, e) for (intmax_t i = (b), i##_limit = (e); i < i##_limit; ++i)

#define reps(i, b, e) for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)

#define repr(i, b, e) for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)

#define var(Type, ...) Type __VA_ARGS__; input(__VA_ARGS__)



constexpr size_t    operator""_zu(unsigned long long value) { return value; };

constexpr intmax_t  operator""_jd(unsigned long long value) { return value; };

constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };



constexpr int INF = 0x3f3f3f3f;

constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;



template <class T, class Compare = less<>>

using MaxHeap = priority_queue<T, vector<T>, Compare>;

template <class T, class Compare = greater<>>

using MinHeap = priority_queue<T, vector<T>, Compare>;



inline void input() {}

template <class Head, class... Tail>

inline void input(Head&& head, Tail&&... tail) {

    cin >> head;

    input(forward<Tail>(tail)...);

}



template <class T>

inline istream& operator>>(istream &is, vector<T> &vec) {

    for (auto &e: vec) {

        is >> e;

    }

    return is;

}



inline void output() { cout << "\n"; }

template <class Head, class... Tail>

inline void output(Head&& head, Tail&&... tail) {

    cout << head;

    if (sizeof...(tail)) {

        cout << " ";

    }

    output(forward<Tail>(tail)...);

}



template <class T>

inline ostream& operator<<(ostream &os, const vector<T> &vec) {

    static constexpr const char *delim[] = {" ", ""};

    for (const auto &e: vec) {

        os << e << delim[&e == &vec.back()];

    }

    return os;

}



template <class T>

inline vector<T> makeVector(const T &initValue, size_t sz) {

    return vector<T>(sz, initValue);

}



template <class T, class... Args>

inline auto makeVector(const T &initValue, size_t sz, Args... args) {

    return vector<decltype(makeVector<T>(initValue, args...))>(sz, makeVector<T>(initValue, args...));

}



template <class Func>

class FixPoint : Func {

public:

    explicit constexpr FixPoint(Func&& f) noexcept : Func(forward<Func>(f)) {}



    template <class... Args>

    constexpr decltype(auto) operator()(Args&&... args) const {

        return Func::operator()(*this, std::forward<Args>(args)...);

    }

};



template <class Func>

static inline constexpr decltype(auto) makeFixPoint(Func&& f) noexcept {

    return FixPoint<Func>{forward<Func>(f)};

}



template <class Container>

struct reverse_t {

    Container &c;

    reverse_t(Container &c) : c(c) {}

    auto begin() { return c.rbegin(); }

    auto end() { return c.rend(); }

};



template <class Container>

auto reversed(Container &c) {

    return reverse_t<Container>(c);

}



template <class T>

inline bool chmax(T &a, const T &b) noexcept {

    return b > a && (a = b, true);

}



template <class T>

inline bool chmin(T &a, const T &b) noexcept {

    return b < a && (a = b, true);

}



template <class T>

inline T diff(const T &a, const T &b) noexcept {

    return a < b ? b - a : a - b;

}

// End Header }}}



signed main() {

    ios_base::sync_with_stdio(false);

    cin.tie(nullptr);



    var(size_t, N);



    auto F = makeVector<intmax_t>(0, N, 10);

    rep(i, 0, N) rep(j, 0, 10) input(F[i][j]);



    auto P = makeVector<intmax_t>(0, N, 15);

    rep(i, 0, N) reps(j, 0, 10) input(P[i][j]);



    intmax_t maxv = -INF;

    rep(bit, 1, 1 << 10) {

        intmax_t res = 0;

        rep(i, 0, N) {

            size_t cnt = 0;

            rep(j, 0, 10) {

                cnt += (bit >> j & F[i][j]);

            }

            res += P[i][cnt];

        }

        chmax(maxv, res);

    }



    output(maxv);



    return 0;

}


// Fastest known solution for this problem: