/*
TASK:water
LANG:C
*/
#include <stdio.h>
#include <string.h>

#define MAX_V 200
#define MAX_K 7

int states[MAX_K][(MAX_V * (MAX_V - 1)) / 2] = {0};
int a1, a2, b1, b2, c1, c2, a, b, c;
int v, k;
int count;
int max_states;

int is_unique(r, s) {
	int i ;

	for (i=r-1;i>=0;i--) {
		if (states[i][s]) return 0;
	}

	return 1;
}

int get_a(int s) {
	return (s >> 8);
}

int get_b(int s) {
	return (s & 0x00ff);
}

int get_c(int s) {
	return v - (get_a(s) + get_b(s));
}

int is_solution(int s) {
	return ( (get_a(s) == 1) || (get_b(s) == 1) || (get_c(s) == 1));
}

int encode(int a, int b, int c) {
	return ((a << 8) + b);
}

int from_a(int i, int r, int q, char where) {
	int code;

	if (where == 'b') {
		code = encode(a - q, b + q, c);
	} else {
		code = encode(a - q, b, c + q);
	}

	//if (is_unique(r, code) || is_solution(code)) {
		if (is_solution(code)) {
//			printf("  %4d%4d%4d came from %4d%4d%4d (%d ways)\n", get_a(code), get_b(code), get_c(code), get_a(i), get_b(i), get_c(i), states[r-1][i]);
		}

		states[r][code] += states[r-1][i];
	//}


	return 0;
}

int from_b(int i, int r, int q, char where) {
	int code;

	if (where == 'a') {
		code = encode(a + q, b - q, c);
	} else {
		code = encode(a, b - q, c + q);
	}

//	if (is_unique(r, code) || is_solution(code)) {
		if (is_solution(code)) {
//			printf("  %4d%4d%4d came from %4d%4d%4d (%d ways)\n", get_a(code), get_b(code), get_c(code), get_a(i), get_b(i), get_c(i), states[r-1][i]);
		}

		states[r][code] += states[r-1][i];
//	}

	return 0;
}

int from_c(int i, int r, int q, char where) {
	int code;

	if (where == 'a') {
		code = encode(a + q, b, c - q);
	} else {
		code = encode(a, b + q, c - q);
	}

//	if (is_unique(r, code) || is_solution(code)) {
		if (is_solution(code)) {
//			printf("  %4d%4d%4d came from %4d%4d%4d (%d ways)\n", get_a(code), get_b(code), get_c(code), get_a(i), get_b(i), get_c(i), states[r-1][i]);
		}

		states[r][code] += states[r-1][i];
//	}

	return 0;
}

int fill_next(int r) {
	int i; 

	for (i = 0; i < max_states; i++) {
		if (states[r][i]) {

			if (is_solution(i)) {
				//count += states[r][i];
				continue;
			}

			a = get_a(i);
			b = get_b(i);
			c = get_c(i);			

			// measure a
			if (a > 0) {
				from_a(i, r + 1, a, 'b');
				from_a(i, r + 1, a, 'c');

				//a1
				if (a > a1) {
					from_a(i, r + 1, a - a1, 'b');
					from_a(i, r + 1, a - a1, 'c');
				}
				//a2
				if (a > a2) {
					from_a(i, r + 1, a - a2, 'b');
					from_a(i, r + 1, a - a2, 'c');
				}
				//b1
				if (a > (b1 - b) && (b < b1) ) {
					from_a(i, r + 1, (b1 - b), 'b');
				}
				//b2
				if (a > (b2 - b) && (b < b2) ) {
					from_a(i, r + 1, (b2 - b), 'b');
				}
				//c1
				if (a > (c1 - c) && (c < c1) ) {
					from_a(i, r + 1, (c1 - c), 'c');
				}
				//c2
				if (a > (c2 - c) && (c < c2) ) {
					from_a(i, r + 1, (c2 - c), 'c');
				}
			}

			// measure b
			if (b > 0) {
				from_b(i, r + 1, b, 'a');
				from_b(i, r + 1, b, 'c');


				//a1
				if (b > b1) {
					from_b(i, r + 1, b - b1, 'a');
					from_b(i, r + 1, b - b1, 'c');
				}
				//a2
				if (b > b2) {
					from_b(i, r + 1, b - b2, 'a');
					from_b(i, r + 1, b - b2, 'c');
				}
				//b1
				if (b > (a1 - a) && (a < a1) ) {
					from_b(i, r + 1, (a1 - a), 'a');
				}
				//b2
				if (b > (a2 - a) && (a < a2) ) {
					from_b(i, r + 1, (a2 - a), 'a');
				}
				//c1
				if (b > (c1 - c) && (c < c1) ) {
					from_b(i, r + 1, (c1 - c), 'c');
				}
				//c2
				if (b > (c2 - c) && (c < c2) ) {
					from_b(i, r + 1, (c2 - c), 'c');
				}
			}

			// measure c
			if (c > 0) {
				from_c(i, r + 1, c, 'a');
				from_c(i, r + 1, c, 'b');

				//a1
				if (c > c1) {
					from_c(i, r + 1, c - c1, 'b');
					from_c(i, r + 1, c - c1, 'a');
				}
				//a2
				if (c > c2) {
					from_c(i, r + 1, c - c2, 'b');
					from_c(i, r + 1, c - c2, 'a');
				}
				//b1
				if (c > (b1 - b) && (b < b1) ) {
					from_c(i, r + 1, (b1 - b), 'b');
				}
				//b2
				if (c > (b2 - b) && (b < b2) ) {
					from_c(i, r + 1, (b2 - b), 'b');
				}
				//c1
				if (c > (a1 - a) && (a < a1) ) {
					from_c(i, r + 1, (a1 - a), 'a');
				}
				//c2
				if (c > (a2 - a) && (a < a2) ) {
					from_c(i, r + 1, (a2 - a), 'a');
				}
			}
		}
	}

	return 0;
}

int main() {

	int i, j;

	scanf("%d %d", &v, &k);
	scanf("%d %d %d %d %d %d", &a1, &a2, &b1, &b2, &c1, &c2);
	count = 0;
	//max_states = (v * (v - 1)) / 2;
	max_states = (MAX_V * (MAX_V - 1)) / 2;

	states[0][encode(v, 0, 0)] = 1;
	for (i = 0; i < k; i++) {
		fill_next(i);

//		printf("------- round %d (count = %d)\n", i+1, count);

		for (j=0; j<max_states; j++) {
			if (states[i+1][j] > 0) {
//				printf("%4d%4d%4d (%4d)", get_a(j), get_b(j), get_c(j), states[i+1][j]);

				if (is_solution(j)) {
					count += states[i+1][j];
//					printf("    SOLUTION");
				}


//				printf("\n");
			}
		}
	}

	printf("%d\n", count);

	return 0;
}