/*
                    __
                   /\ \
 _ __   ___     ___\ \ \/'\     ___      __      ___     ___      __
/\`'__\/ __`\  /'___\ \ , <    / __`\  /'__`\  /' _ `\ /' _ `\  /'__`\
\ \ \//\ \L\ \/\ \__/\ \ \\`\ /\ \L\ \/\ \L\.\_/\ \/\ \/\ \/\ \/\ \L\.\_
 \ \_\\ \____/\ \____\\ \_\ \_\ \____/\ \__/.\_\ \_\ \_\ \_\ \_\ \__/.\_\
  \/_/ \/___/  \/____/ \/_/\/_/\/___/  \/__/\/_/\/_/\/_/\/_/\/_/\/__/\/_/


*/

#ifndef __AHA__HEADER
#define __AHA__HEADER

#include <bits/stdc++.h>
using namespace std;
#define g0 get<0>
#define g1 get<1>
#define g2 get<2>
#define ft first
#define sd second
#define sz(x) (i6) x.size()
#define psb(x) push_back(x)
#define ppb() pop_back()
#define bg(x) x.begin()
#define ed(x) x.end()
#define col(x) x.begin(), x.end()
#define srt(x) sort(x.begin(), x.end())

#define pq priority_queue
#define fn function
#ifdef LOCAL
#define git stauDBG_MACRO_NO_WARNING
#include <dbg.h>
#else
#define dbg(...)
#endif
#define endl '\n'

template <typename T>
using vec = vector<T>;
template <typename T>
using deq = deque<T>;
template <typename K, typename V>
using hmap = unordered_map<K, V>;

using str = string;
using vb = vec<bool>;

using byte = int8_t;
using i3 = int32_t;
using i6 = int64_t;
using i64 = int64_t;
using u3 = uint32_t;
using u6 = uint64_t;

using d6 = long double;

using p3 = pair<i3, i3>;
using vi3 = vec<i3>;
using vp3 = vec<p3>;

using p6 = pair<i6, i6>;
using vi6 = vec<i6>;
using vd6 = vec<d6>;
using vp6 = vec<p6>;
using vv = vec<vi6>;

using dp6 = deq<p6>;
using di6 = deq<i6>;

using mi6 = map<i6, i6>;
using mp6 = map<p6, i6>;
using si6 = set<i6>;
using hi6 = hmap<i6, i6>;

using bs = bitset<64>;

using graph = vv;
using matrix = vv;

const d6 EPS = 1 / 1000000.0;
const i6 ZERO = 0;
const i6 _0 = ZERO;
const i6 ONE = 1;
const i6 _1 = ONE;
const i6 INF = INT64_MAX / 4;
const i6 NINF = -INF;

namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2>> {
  std::size_t operator()(const pair<T1, T2>& pair) const noexcept {
    return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
  }
};
}  // namespace std

template <typename T1, typename T2>
istream& operator>>(istream& stream, pair<T1, T2>& p) {
  stream >> p.ft;
  stream >> p.sd;
  return stream;
}

template <typename T1, typename T2>
ostream& operator<<(ostream& stream, const pair<T1, T2>& p) {
  return stream << p.ft << " " << p.sd;
}

template <typename T>
istream& operator>>(istream& stream, vec<T>& v) {
  if (v.empty()) {
    u6 len;
    stream >> len;
    v.assign(len, T());
  }
  for (auto i = 0; i < sz(v); i++) {
    stream >> v[i];
  }
  return stream;
}

template <typename T>
ostream& operator<<(ostream& stream, const vec<T>& v) {
  if (!v.empty()) {
    stream << v[0];
  }
  for (auto i = 1; i < sz(v); i++) {
    stream << " " << v[i];
  }
  return stream;
}

template <typename T>
istream& operator>>(istream& stream, deq<T>& v) {
  if (v.empty()) {
    u6 len;
    stream >> len;
    v.assign(len, T());
  }
  for (auto i = 0; i < sz(v); i++) {
    stream >> v[i];
  }
  return stream;
}

template <typename T>
ostream& operator<<(ostream& stream, const deq<T>& v) {
  if (!v.empty()) {
    stream << v[0];
  }
  for (auto i = 1; i < sz(v); i++) {
    stream << " " << v[i];
  }
  return stream;
}
#endif

int MOD = 3210121;
int k, s, n;
int v[21][31];
int c[31][10001];

void init_c() {
  // all expirements possible if there are i expirements and we need to add a
  // total of j or less units ( in all possible combinations )

  c[0][0] = 1;
  for (int i = 1; i <= k; i++) {
    for (int j = 0; j <= s; j++) {
      if (j == 0) {
        c[i][j] = 1;
      } else {
        c[i][j] = (c[i - 1][j] + c[i][j - 1]) % MOD;
      }
    }
  }

  for (int j = 1; j <= s; j++) {
    c[k][j] = (c[k][j] + c[k][j - 1]) % MOD;
  }
}

int mx[31];
int solve() {
  int res = 0;
  for (int mask = 0; mask < (1 << n); mask++) {
    for (int i = 0; i < k; i++) {
      mx[i] = 0;
    }

    int nr = 0;
    for (int i = 0; i < n; i++) {
      if ((1 << i) & mask) {
        nr++;
        for (int j = 0; j < k; j++) {
          mx[j] = max(mx[j], v[i][j]);
        }
      }
    }

    int sum = 0;
    for (int i = 0; i < k; i++) {
      sum += mx[i];
    }
    if (sum > s) {
      continue;
    }

    if (nr % 2 == 0) {
      res = (res + c[k][s - sum]) % MOD;
    } else {
      res = (res - c[k][s - sum] + MOD) % MOD;
    }

    // cout << mask << " " << c[k][s - sum] << " " << sum << endl;
  }

  res = (res - (k * s + 1) % MOD + MOD) % MOD;

  return res;
}

int rr = 0;
int maxx[30][40];
int idk[30];
void solve2(int crt) {
  if (crt != 0) {
    int ss = 0;
    for (int i = 1; i <= k; i++) {
      maxx[crt][i] = max(maxx[crt - 1][i], v[idk[crt]][i]);
      ss += maxx[crt][i];
    }

    if (ss <= s) {
      if (crt % 2) {
        rr = (rr - c[k][s - ss] + MOD) % MOD;
      } else {
        rr = (rr + c[k][s - ss]) % MOD;
      }
    }
  }

  if (crt < n) {
    for (int i = idk[crt] + 1; i <= n; i++) {
      idk[crt + 1] = i;
      solve2(crt + 1);
    }
  }
}

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  // #ifdef LOCAL
  ifstream cin{"cowfood.in"};
  ofstream cout{"cowfood.out"};
  // #endif

  cin >> k >> s >> n;

  init_c();  // initializing beoforehand for any time issues

  for (int i = 1; i <= n; i++) {  // changed to indexing from 1 cuz its easier
    for (int j = 1; j <= k; j++) {
      cin >> v[i][j];
    }
  }

  // cout << solve();

  rr = (c[k][s] - (k * s + 1) % MOD + MOD) % MOD;
  solve2(0);
  cout << rr;

  return 0;
}