/*
TASK:water
LANG:C++
*/

#include <cstdio>
#include <algorithm>

const int MAXN = 1 << 16;
const int MAXm = 1 << 5;


int N;
int K;
int d[3][3];

int V;
int vec[MAXN][MAXm];
int vc[MAXN];
bool is_final[MAXN];
int fin[MAXN];

void swap (int &a, int &b) {a ^= b ^= a ^= b;}

void input () {
	scanf ("%d %d", &V, &K);
	scanf ("%d %d %d %d %d %d", &d[0][0], &d[0][1], &d[1][0], &d[1][1], &d[2][0], &d[2][1]);
	if (d[0][0] > d[0][1]) swap (d[0][0], d[0][1]);
	if (d[1][0] > d[1][1]) swap (d[1][0], d[1][1]);
	if (d[2][0] > d[2][1]) swap (d[2][0], d[2][1]);
	d[0][2] = d[1][2] = d[2][2] = V;
}

inline int code (int a, int b) {
	return a * (V + 1) + b;
}

void decode (int a, int *b, int *d) {
	*b = a / (V + 1);
	*d = a % (V + 1);
}


inline void calct (int b[3], int t[3][4]) {
	static int i, j;
	for (i = 0; i < 3; ++i) {
		t[i][0] = -b[i];
		for (j = 0; j < 3; ++j)
			t[i][j+1] = d[i][j] - b[i];
	}
}

void remove_to_final () {
	N = (V + 1) * (V + 1) + 1;
	for (int i = 0; i < N; ++i)
		for (int j = 0; j < vc[i]; ++j)
			if (is_final[vec[i][j]]) {
				++fin[i];
				vec[i][j] = vec[i][--vc[i]];
			}
}

void build_graph () {
	int b[3], t[3][4], bb[3];
	int cadd[24];
	int cap;
	int cel;
	int i, j, k;
//	int tb1, tb2;
	for (b[0] = 0; b[0] <= V; ++b[0])
		for (b[1] = 0; b[1] + b[0] <= V; ++b[1]) {
			b[2] = V - b[0] - b[1];
			calct (b, t);
			cap = 0;
			for (i = 0; i < 2; ++i)
				for (j = i + 1; j < 3; ++j) {
					for (k = 0; k < 4; ++k) {
						bb[0] = b[0]; bb[1] = b[1]; bb[2] = b[2];
						if (t[j][0] <= -t[i][k] && -t[i][k] <= t[j][3]) {
							bb[i] += t[i][k];
							bb[j] -= t[i][k];
							cadd[cap++] = code (bb[0], bb[1]);
//							printf ("\t%d %d %d -- %d %d %d(%d)1\n", b[0], b[1], b[2], bb[0], bb[1], bb[2], k);
						}
					}

					for (k = 0; k < 4; ++k) {
						bb[0] = b[0]; bb[1] = b[1]; bb[2] = b[2];
						if (t[i][0] <= -t[j][k] && -t[j][k] <= t[i][3]) {
							bb[j] += t[j][k];
							bb[i] -= t[j][k];
							cadd[cap++] = code (bb[0], bb[1]);
//							printf ("\t%d %d %d -- %d %d %d(%d)2\n", b[0], b[1], b[2], bb[0], bb[1], bb[2], k);
						}
					}
				}

			std::sort (cadd, cadd + cap);
			cap = std::unique (cadd, cadd + cap) - cadd;
			cel = code (b[0], b[1]);
			if (b[0] == 1 || b[1] == 1 || b[2] == 1) {is_final[cel] = 1; vc[cel] = 0;}
			else {
//			if (cap) printf ("%d %d %d(%d)\n", b[0], b[1], b[2], cel);
				for (i = 0; i < cap; ++i) {
					if (cadd[i] == cel) continue;//do not add ourselves
					vec[cel][i] = cadd[i];
//					decode (cadd[i], &tb1, &tb2);
//					printf ("\t%d %d %d\n", tb1, tb2, V - tb1 - tb2);
				}
				vc[cel] = cap;
			}
		}
	remove_to_final ();
}

void prnt (int a, int d, bool f = 0) {
	static int b1, b2;
	decode (a, &b1, &b2);
	printf ("(%d)%d %d %d(%d)", fin[a], b1, b2, V - b1 - b2, d);
	if (f) printf ("<-");
	printf ("\n");
}

bool used[MAXN];

int res;
void bf (int v, int depth) {
	if (used[v]) return;
	used[v] = 1;
//	prnt (v, depth);
	res += fin[v];
	if (depth == K - 1) {used[v] = 0; return;}
	for (int i = 0; i < vc[v]; ++i)
		bf (vec[v][i], depth + 1);

	used[v] = 0;
//	prnt(v, depth, 1);
}

void prnt_graph () {
	int t1, t2;
	int i, j;
	for (i = 0; i < N; ++i) {
		decode (i, &t1, &t2);
		printf ("--%d %d %d\n", t1, t2, V - t1 - t2);
		for (j = 0; j < vc[i]; ++j) {
			decode (vec[i][j], &t1, &t2);
			printf ("\t%d %d %d\n", t1, t2, V - t1 - t2);
		}
	}
}

int main () {
	input ();
	if (V == 1) {printf ("1\n"); return 0;}
	build_graph ();
//	prnt_graph ();
	bf (code (V, 0), 0);
	printf ("%d\n", res);

	return 0;
}
