#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef tuple<int, int> duo;
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000 + 0;
//{{{ templates
#define TT_ template<typename T>inline
#define TTF_ template<typename T,typename F>inline
TT_ T sq(T x){return x*x;}
TT_ T In(){T x;cin>>x;return x;}
TT_ void Out(T&x){cout<<x;}
TT_ void sort(T&v){sort(begin(v),end(v));}
TT_ void revs(T&v){reverse(begin(v),end(v));}
TT_ void uniq(T&v){sort(v);v.erase(unique(begin(v),end(v)),end(v));}
TT_ int ubnd(T&v,typename T::value_type x){return upper_bound(begin(v),end(v),x)-begin(v);}
TT_ int lbnd(T&v,typename T::value_type x){return lower_bound(begin(v),end(v),x)-begin(v);}
TTF_ void inpt(T&v,int n,F f){for(v.reserve(n);n--;v.emplace_back(f()));}
TTF_ void show(T&v,F f,string d=" ",string e="\n"){int i=0;for(auto&x:v)i++&&(cout<<d),f(x);cout<<e;}
TT_ typename T::iterator minel(T&v){return min_element(begin(v),end(v));}
TT_ typename T::iterator maxel(T&v){return max_element(begin(v),end(v));}

inline void fast_io(){ios_base::sync_with_stdio(0);cin.tie(0);}
inline int in(){int x;scanf("%d",&x);return x;}
inline ll pow_mod(ll a,ll k,ll m){ll r=1;for(;k>0;a=a*a%m,k>>=1)if(k&1)r=r*a%m;return r;}
inline ll mod_inv(ll a,ll p){return pow_mod(a,p-2,p);}
//}}} priority_queue queue deque front stringstream max_element min_element insert count make_tuple

struct Cube {
  int sx, sy, sd;
  int ex, ey, ed;
  Cube(int sx, int sy, int sd, int ex, int ey, int ed) :
    sx(sx), sy(sy), sd(sd), ex(ex), ey(ey), ed(ed) {}
};

int imos[128][128][128];

int main()
{
  int N, K;
  cin >> N >> K;

  vector<Cube> cs;
  vector<int> X, Y, D;
  for (int i = 0; i < N; i++){
    int sx, sy, sd, ex, ey, ed;
    cin >> sx >> sy >> sd >> ex >> ey >> ed;
    cs.emplace_back(sx, sy, sd, ex, ey, ed);
    X.push_back(sx);
    X.push_back(ex);
    Y.push_back(sy);
    Y.push_back(ey);
    D.push_back(sd);
    D.push_back(ed);
  }
  sort(X), sort(Y), sort(D);
  map<int, int> CX, CY, CD;
  N *= 2;
  for (int i = 0; i < N; i++){
    CD[D[i]] = CY[Y[i]]= CX[X[i]] = i;
  }
  for (auto& c : cs){
    int csx = CX[c.sx], csy = CY[c.sy], csd = CD[c.sd];
    int cex = CX[c.ex], cey = CY[c.ey], ced = CD[c.ed];
    // x -> y -> d
    imos[csy][csx][csd]++;
    imos[csy][cex][csd]--;
    imos[cey][csx][csd]--;
    imos[cey][cex][csd]++;
    imos[csy][csx][ced]--;
    imos[csy][cex][ced]++;
    imos[cey][csx][ced]++;
    imos[cey][cex][ced]--;
  }
  for (int d = 0; d < N; d++){
    for (int y = 0; y < N; y++){
      for (int x = 1; x < N; x++){
        imos[y][x][d] += imos[y][x - 1][d];
      }
    }
    for (int y = 1; y < N; y++){
      for (int x = 0; x < N; x++){
        imos[y][x][d] += imos[y - 1][x][d];
      }
    }
  }
  for (int d = 1; d < N; d++){
    for (int y = 0; y < N; y++){
      for (int x = 0; x < N; x++){
        imos[y][x][d] += imos[y][x][d - 1];
      }
    }
  }
  ll ans = 0;
  for (int d = 0; d < N; d++){
    for (int y = 0; y < N; y++){
      for (int x = 0; x < N; x++){
        if (imos[y][x][d] >= K){
          ans += (ll)(X[x + 1] - X[x]) * (Y[y + 1] - Y[y]) * (D[d + 1] - D[d]);
        }
      }
    }
  }
  printf("%lld\n", ans);
  return 0;
}

Measured memory_bytes: 9148