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

#include <queue>
#include <cstdio>
#include <vector>

typedef signed int ind;
typedef unsigned int volume;
typedef unsigned int hashval;
typedef unsigned int counter;

void read_ind(ind& n) {std::scanf("%d", &n);}
void write_ind(const ind& n) {std::printf("%d", n);}
void read_volume(volume& n) {std::scanf("%u", &n);}
void write_volume(const volume n) {std::printf("%u", n);}
void read_counter(counter& n) {std::scanf("%u", &n);}
void write_counter(const counter n) {std::printf("%u", n);}
void write(char *s) {std::printf("%s", s);}

const hashval hash_base = 201;

inline hashval hash(const volume& a, const volume& b, const volume& c)
{
	return hash_base*hash_base*a + hash_base*b + c;
}

class state
{
public:
	state() {}
	state(const std::vector<hashval>& v, const volume& _a, const volume& _b, const volume& _c, const ind& d)
		: visited(v), a(_a), b(_b), c(_c), depth(d) {}

	std::vector<hashval> visited;
	volume a, b, c;
	ind depth;
};

inline bool valid(const state& s)
{
	hashval h = hash(s.a, s.b, s.c);
	for (ind i = 0; i < (ind)s.visited.size()-1; i++)
		if (s.visited[i] == h)
			return false;

	return true;
}

state moveab(const state& s, const volume& v)
{
	state ns = s;
	ns.a -= v;
	ns.b += v;
	ns.visited.push_back(hash(ns.a, ns.b, ns.c));
	ns.depth++;
	return ns;
}

state moveba(const state& s, const volume& v)
{
	state ns = s;
	ns.b -= v;
	ns.a += v;
	ns.visited.push_back(hash(ns.a, ns.b, ns.c));
	ns.depth++;
	return ns;
}

state moveac(const state& s, const volume& v)
{
	state ns = s;
	ns.a -= v;
	ns.c += v;
	ns.visited.push_back(hash(ns.a, ns.b, ns.c));
	ns.depth++;
	return ns;
}

state moveca(const state& s, const volume& v)
{
	state ns = s;
	ns.c -= v;
	ns.a += v;
	ns.visited.push_back(hash(ns.a, ns.b, ns.c));
	ns.depth++;
	return ns;
}

state movebc(const state& s, const volume& v)
{
	state ns = s;
	ns.b -= v;
	ns.c += v;
	ns.visited.push_back(hash(ns.a, ns.b, ns.c));
	ns.depth++;
	return ns;
}

state movecb(const state& s, const volume& v)
{
	state ns = s;
	ns.c -= v;
	ns.b += v;
	ns.visited.push_back(hash(ns.a, ns.b, ns.c));
	ns.depth++;
	return ns;
}

int main()
{
	volume a, b = 0, c = 0, a1, a2, b1, b2, c1, c2;
	ind max_depth;
	read_volume(a); read_ind(max_depth);
	read_volume(a1); read_volume(a2);
	read_volume(b1); read_volume(b2);
	read_volume(c1); read_volume(c2);

	counter answer = 0;
	state start = state(std::vector<hashval>(1, hash(a, b, c)), a, b, c, 0);
	start.visited.push_back(hash(a, b, c));
	std::queue<state> q;
	q.push(start);
	while (!q.empty())
	{
		state s = q.front(); q.pop();
		/*write_volume(s.a); write(" ");
		write_volume(s.b); write(" ");
		write_volume(s.c); write("\n");*/

		if (s.a == 1 || s.b == 1 || s.c == 1) {answer++; continue;}
		if (s.depth == max_depth) continue;
		a = s.a; b = s.b; c = s.c;
	
		if (a && valid(moveab(s, a))) q.push(moveab(s, a));
		if (a && valid(moveac(s, a))) q.push(moveac(s, a));
		if (b && valid(moveba(s, b))) q.push(moveba(s, b));
		if (b && valid(movebc(s, b))) q.push(movebc(s, b));
		if (c && valid(moveca(s, c))) q.push(moveca(s, c));
		if (c && valid(movecb(s, c))) q.push(movecb(s, c));

		if (a > a1 && valid(moveab(s, a-a1))) q.push(moveab(s, a-a1));
		if (a > a1 && valid(moveac(s, a-a1))) q.push(moveac(s, a-a1));
		if (b > b1 && valid(moveba(s, b-b1))) q.push(moveba(s, b-b1));
		if (b > b1 && valid(movebc(s, b-b1))) q.push(movebc(s, b-b1));
		if (c > c1 && valid(moveca(s, c-c1))) q.push(moveca(s, c-c1));
		if (c > c1 && valid(movecb(s, c-c1))) q.push(movecb(s, c-c1));

		if (a > a2 && valid(moveab(s, a-a2))) q.push(moveab(s, a-a2));
		if (a > a2 && valid(moveac(s, a-a2))) q.push(moveac(s, a-a2));
		if (b > b2 && valid(moveba(s, b-b2))) q.push(moveba(s, b-b2));
		if (b > b2 && valid(movebc(s, b-b2))) q.push(movebc(s, b-b2));
		if (c > c2 && valid(moveca(s, c-c2))) q.push(moveca(s, c-c2));
		if (c > c2 && valid(movecb(s, c-c2))) q.push(movecb(s, c-c2));

		if (a < a1 && b > a1-a && valid(moveba(s, a1-a))) q.push(moveba(s, a1-a));
		if (a < a1 && c > a1-a && valid(moveca(s, a1-a))) q.push(moveca(s, a1-a));
		if (b < b1 && a > b1-b && valid(moveab(s, b1-b))) q.push(moveab(s, b1-b));
		if (b < b1 && c > b1-b && valid(movecb(s, b1-b))) q.push(movecb(s, b1-b));
		if (c < c1 && a > c1-c && valid(moveac(s, c1-c))) q.push(moveac(s, c1-c));
		if (c < c1 && b > c1-c && valid(movebc(s, c1-c))) q.push(movebc(s, c1-c));

		if (a < a2 && b > a2-a && valid(moveba(s, a2-a))) q.push(moveba(s, a2-a));
		if (a < a2 && c > a2-a && valid(moveca(s, a2-a))) q.push(moveca(s, a2-a));
		if (b < b2 && a > b2-b && valid(moveab(s, b2-b))) q.push(moveab(s, b2-b));
		if (b < b2 && c > b2-b && valid(movecb(s, b2-b))) q.push(movecb(s, b2-b));
		if (c < c2 && a > c2-c && valid(moveac(s, c2-c))) q.push(moveac(s, c2-c));
		if (c < c2 && b > c2-c && valid(movebc(s, c2-c))) q.push(movebc(s, c2-c));
	}

	write_counter(answer);
	write("\n");

	return 0;
}
