#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll MOD = 1000000007;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(50 + 5);
const double EPS = 1e-10;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define ALL(v) (v).begin(), (v).end()

ll n, k, h, w, d;
ll X1[MAX_N], X2[MAX_N], Y1[MAX_N], Y2[MAX_N], D1[MAX_N], D2[MAX_N];
ll field[MAX_N*2][MAX_N*2][MAX_N*2];
vector<ll> xs, ys, ds, xunzip, yunzip, dunzip;
map<ll,ll> xzip, yzip, dzip;

void compress(vector<ll> &x, map<ll, ll> &zip, vector<ll> &unzip) {
    sort(x.begin(), x.end());
    x.erase(unique(x.begin(), x.end()), x.end());
    unzip.resize(x.size());
    for (int i = 0; i < x.size(); i++) {
        zip[x[i]] = i;
        unzip[i] = x[i];
    }
}

int main() {
    cin >> n >> k;
    REP(i,n){
        cin >> X1[i] >> Y1[i] >> D1[i] >> X2[i] >> Y2[i] >> D2[i];
        xs.push_back(X1[i]);
        xs.push_back(X2[i]);
        ys.push_back(Y1[i]);
        ys.push_back(Y2[i]);
        ds.push_back(D1[i]);
        ds.push_back(D2[i]);
    }

    compress(xs, xzip, xunzip);
    compress(ys, yzip, yunzip);
    compress(ds, dzip, dunzip);

    w = xzip.size();
    h = yzip.size();
    d = dzip.size();

    REP(i,n){
        field[yzip[Y1[i]]][xzip[X1[i]]][dzip[D1[i]]]++;
        field[yzip[Y1[i]]][xzip[X2[i]]][dzip[D1[i]]]--;
        field[yzip[Y2[i]]][xzip[X1[i]]][dzip[D1[i]]]--;
        field[yzip[Y2[i]]][xzip[X2[i]]][dzip[D1[i]]]++;
        field[yzip[Y1[i]]][xzip[X1[i]]][dzip[D2[i]]]--;
        field[yzip[Y1[i]]][xzip[X2[i]]][dzip[D2[i]]]++;
        field[yzip[Y2[i]]][xzip[X1[i]]][dzip[D2[i]]]++;
        field[yzip[Y2[i]]][xzip[X2[i]]][dzip[D2[i]]]--;
    }
    REP(i,h+1)REP(j,w)REP(m,d){
        field[i][j+1][m] += field[i][j][m];
    }
    REP(j,w+1)REP(i,h)REP(m,d){
        field[i+1][j][m] += field[i][j][m];
    }
    REP(m,d+1)REP(i,h)REP(j,w){
        field[i][j][m+1] += field[i][j][m]; 
    }
    ll ans = 0;
    REP(i,h)REP(j,w)REP(m,d){
        if(field[i][j][m]>=k) 
            ans += (yunzip[i+1]-yunzip[i])*(xunzip[j+1]-xunzip[j])*(dunzip[m+1]-dunzip[m]);
    }
    cout << ans << endl;

    return 0;
}

