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

#include <stdio.h>


    
int v, k;
int a1, a2;
int b1, b2;
int c1, c2;

int A[202][202][7];
int p;

void input ()
{
   scanf ("%d%d", &v, &k);
                             
   scanf ("%d%d", &a1, &a2);
   scanf ("%d%d", &b1, &b2);
   scanf ("%d%d", &c1, &c2);
}          

void init ()
{
   int i, j, q;
   
   for (i=0; i<=v; i++)
      for (j=0; j<=v; j++)
         for (q=0; q<7; q++)
            A[i][j][q] = -1;
}                       

int check (int *T, int l, int a)
{
   int i;              
   
   if (a<=0) return 0;
   
   for (i=0; i<l; i++)
      if (T[i] == a) return 0;
      
   return 1;
}

int solve (int a, int b, int level)
{
   int c=v-(a+b);

   if (a==1 || b==1 || c==1) A[a][b][level] = 1; 
   if (A[a][b][level] != -1) return A[a][b][level];

   if (level>=k) return 0;
   A[a][b][level] = 0;

   int T[10], l;
      
   // ot 1-vata kum 2-rata menzura
   l=0;
   if (check(T, l, p=(a-a1)) && b+p<=v) { A[a][b][level] += solve (a1, b+p, level+1); T[l++]=p; }
   if (check(T, l, p=(a-a2)) && b+p<=v) { A[a][b][level] += solve (a2, b+p, level+1); T[l++]=p; }        
   if (check(T, l, p=(b1-b)) && a>=p)   { A[a][b][level] += solve (a-p, b1, level+1); T[l++]=p; }
   if (check(T, l, p=(b2-b)) && a>=p)   { A[a][b][level] += solve (a-p, b2, level+1); T[l++]=p; }        
   if (check(T, l, a)        && b+a<=v) { A[a][b][level] += solve (0,  b+a, level+1); T[l++]=a; }       
   
   // ot 1-vata kum 3-rata menzura
   l=0;
   if (check(T, l, p=(a-a1)) && c+p<=v) { A[a][b][level] += solve (a1, b,  level+1); T[l++]=p; }
   if (check(T, l, p=(a-a2)) && c+p<=v) { A[a][b][level] += solve (a2, b,  level+1); T[l++]=p; }        
   if (check(T, l, p=(c1-c)) && a>=p)   { A[a][b][level] += solve (a-p, b, level+1); T[l++]=p; }
   if (check(T, l, p=(c2-c)) && a>=p)   { A[a][b][level] += solve (a-p, b, level+1); T[l++]=p; }        
   if (check(T, l, a)        && c+a<=v) { A[a][b][level] += solve (0,  b,  level+1); T[l++]=a; }      
   
   // ot 2-rata kum 1-vata menzura
   l=0;
   if (check(T, l, p=(b-b1)) && a+p<=v) { A[a][b][level] += solve (a+p, b1, level+1); T[l++]=p; }        
   if (check(T, l, p=(b-b2)) && a+p<=v) { A[a][b][level] += solve (a+p, b2, level+1); T[l++]=p; }        
   if (check(T, l, p=(a1-a)) && b>=p)   { A[a][b][level] += solve (a1, b-p, level+1); T[l++]=p; }
   if (check(T, l, p=(a2-a)) && b>=p)   { A[a][b][level] += solve (a2, b-p, level+1); T[l++]=p; }        
   if (check(T, l, b)        && a+b<=v) { A[a][b][level] += solve (a+b,  0, level+1); T[l++]=b; }       
   
   // ot 2-rata kum 3-tata menzura
   l=0;
   if (check(T, l, p=(b-b1)) && c+p<=v) { A[a][b][level] += solve (a, b1,  level+1); T[l++]=p; }        
   if (check(T, l, p=(b-b2)) && c+p<=v) { A[a][b][level] += solve (a, b2,  level+1); T[l++]=p; }        
   if (check(T, l, p=(c1-c)) && b>=p)   { A[a][b][level] += solve (a, b-p, level+1); T[l++]=p; }
   if (check(T, l, p=(c2-c)) && b>=p)   { A[a][b][level] += solve (a, b-p, level+1); T[l++]=p; }        
   if (check(T, l, b)        && c+b<=v) { A[a][b][level] += solve (a,  0,  level+1); T[l++]=b; }
   
   // ot 3-tata kum 1-vata menzura
   l=0;
   if (check(T, l, p=(c-c1)) && a+p<=v) { A[a][b][level] += solve (a+p, b, level+1); T[l++]=p; }        
   if (check(T, l, p=(c-c2)) && a+p<=v) { A[a][b][level] += solve (a+p, b, level+1); T[l++]=p; }        
   if (check(T, l, p=(a1-a)) && c>=p)   { A[a][b][level] += solve (a1,  b, level+1); T[l++]=p; }
   if (check(T, l, p=(a2-a)) && c>=p)   { A[a][b][level] += solve (a2,  b, level+1); T[l++]=p; }        
   if (check(T, l, c)        && c+a<=v) { A[a][b][level] += solve (c+a,   b, level+1); T[l++]=c; }       
   
   // ot 3-tata kum 2-rata menzura
   l=0;
   if (check(T, l, p=(c-c1)) && b+p<=v) { A[a][b][level] += solve (a, b+p, level+1); T[l++]=p; }        
   if (check(T, l, p=(c-c2)) && b+p<=v) { A[a][b][level] += solve (a, b+p, level+1); T[l++]=p; }        
   if (check(T, l, p=(b1-b)) && c>=p)   { A[a][b][level] += solve (a, b1,  level+1); T[l++]=p; }
   if (check(T, l, p=(b2-b)) && c>=p)   { A[a][b][level] += solve (a, b2,  level+1); T[l++]=p; }        
   if (check(T, l, c)        && c+b<=v) { A[a][b][level] += solve (a, b+c, level+1); T[l++]=c; }      
   
   return A[a][b][level];
}

int main ()
{ 
   //freopen ("water.in",  "r", stdin);

   input ();
   init (); 
   int p = solve (v,0,0);
   printf ("%d\n", p);

   return 0;
}
