/*
TASK:water
LANG:C++
*/
#include <stdio.h>
#include <time.h>
#include <algorithm>
#include <vector>

using namespace std;

#define pb push_back
#define out(a) printf("%d\n",a)
#define IN "water.in"
#define OUT "water.out"

#define MAXN 256

#define MAXQ (MAXN*MAXN*MAXN)

#define ALL(i) for(int (i)=0; (i)<3; (i)++)

//int queue[MAXQ] = {};
//char vis[MAXQ] = {};
int s[3] = {};
int lim[3][2] = {};
int V,L;
int ans = 0;

int code () {
    int ret = s[0];
    ret = ret*MAXN + s[1];
    ret = ret*MAXN + s[2];
    return ret;
}

int output() {
    ALL (i) {
        printf("%d ",s[i]);
    }
    printf("\n");
    return 0;
}
int decode (int ret) {
    s[2] = ret % MAXN;
    ret /= MAXN;
    s[1] = ret % MAXN;
    ret /= MAXN;
    s[0] = ret;
    return 0;
}

int end_state () {
    ALL(i) {
        if (s[i] == 1) return 1;
    }
    return 0;
}

vector <int> get_next (int a,int b) {
       vector<int> ret;
       vector<int> v;
       v.clear();
       ret.clear();

       if (s[a] > lim[a][1]) {
          v.pb(s[a] - lim[a][1]);
       }
       if (s[a] > lim[a][0]) {
          v.pb(s[a] - lim[a][0]);
       }
       v.pb(s[a]);

       if (s[b] < lim[b][0]) {
          v.pb(lim[b][0] - s[b]);
       }
       if (s[b] < lim[b][1]) {
          v.pb(lim[b][1] - s[b]);
       }

       sort(v.begin(),v.end());
       unsigned i=0;
       unsigned j=0;
       
       for (i=0; i<v.size();) {
           v[j] = v[i];
           while (i<v.size() && v[j]==v[i]) i++;
           j++;
       }
       
       for (unsigned k=0; k<j; k++) {
           if (s[a] < v[k]) continue;
           s[a] -= v[k];
           s[b] += v[k];
           if (end_state()) {
              ans++;
           } else {
              ret.pb(code());
           }
           s[a] += v[k];
           s[b] -= v[k];

       }
       return ret;
}

int cur[16] = {};

int dfs (int state,int l) {
    vector<int> v;
    v.clear();
    
    for (int i=1; i<l; i++) {
        if (cur[i] == state) return 0;
    }

    if (l == L+1) {
       if (end_state()) {
          ans++;
       }
       return 0;
    }
    
    cur[l] = state;

    decode(state);
    ALL(i) {
           if (s[i] == 0) continue;
           ALL(j) {
                  if (i==j) continue;
                  decode(state);
                  v.clear();
                  v = get_next(i,j);
                  for (unsigned k=0; k<v.size(); k++) {
                      dfs(v[k],l+1);
                  }
           }
    }

    cur[l] = 0;
    return 0;
}
int main () {
//    clock();
//    freopen(IN,"r",stdin);
//    freopen(OUT,"w",stdout);

    scanf("%d%d",&V,&L);
    ALL(i) {
        scanf("%d%d",&lim[i][0],&lim[i][1]);
        if (lim[i][0] > lim[i][1]) {
           swap(lim[i][0],lim[i][1]);
        }
    }
    s[0] = V;
    s[1] = 0;
    s[2] = 0;

    int t = code();
    
    dfs(t,1);

/*    int QueueE = 1;
    int LevelV = 1;
    int Level = 0;
    int CurrentV = 0;
    int p;


    queue[0] = code();


    
    while (CurrentV < QueueE && Level < L) {
          for (p=CurrentV; p<LevelV; p++) {
              decode(queue[p]);
              
              ALL(i) {
                     if (s[i] == 0) continue;
                     ALL(j) {
                           if (i==j) continue;
                           vector<int> v;
                           v.clear();
                           v = get_next(i,j);
                           for (unsigned k=0; k<v.size(); k++) {
                               queue[QueueE] = v[k];
                               QueueE++;
                           }
                     }
              }
          }
          CurrentV = LevelV;
          LevelV = QueueE;
          Level++;
    }
    */
    printf("%d\n",ans);

//    printf("%lf\n",(double)clock()/CLOCKS_PER_SEC);
    return 0;
}
