#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
#include <vector>
#include <set>
#define pb push_back
using namespace std;
typedef long long ll;
const int maxn = 2e3 + 50;
const int mod = 1000000009;
const int inf = 1 << 29;
typedef struct Edge
{
 int v,w;
 Edge(int v,int w)
  {
       this->v = v ,this->w = w;
  }    
};

vector<Edge>E[maxn];

int n,m,ans = 1,mincost[maxn][2];
bool inqueue[maxn][2];


typedef struct updatastatus
{
  int pos;
  int passzero;
  updatastatus(int pos,int passzero)
   {
      this->pos = pos , this->passzero = passzero ;
   }    
};

queue<updatastatus>q;

void spfa()
{
   q.push(updatastatus(1,0));
   mincost[1][0] = 0;
   mincost[1][1] = 1 << 28;
   while(!q.empty())
    {
       int pos = q.front().pos , zero = q.front().passzero;q.pop();
       for(int i = 0 ; i < E[pos].size() ; ++ i)
        {
            int nextnode = E[pos][i].v;
            int newcost = mincost[pos][zero] + E[pos][i].w;
            if (zero || !E[pos][i].w)
             {
                 if (mincost[nextnode][1] == -1 || mincost[nextnode][1] > newcost)
                  {
                      mincost[nextnode][1] = newcost;
                      if (!inqueue[nextnode][1])
                       {
                         q.push(updatastatus(nextnode,1));
                         inqueue[nextnode][1] = false;
                     }
                 }
             }
            else
             {
                 if (mincost[nextnode][0] == -1 || mincost[nextnode][0] > newcost)
                   {
                     mincost[nextnode][0] = newcost;
                    if (!inqueue[nextnode][0])
                       {
                         q.push(updatastatus(nextnode,0));
                         inqueue[nextnode][0] = false;
                     }
                  }
             }
        }
    }
}

typedef struct tnode
{
  int u,d;
  friend bool operator < (const tnode & x,const tnode & y)
   {
      return x.d > y.d;    
   }    
  tnode(int u,int d)
   {
         this->u = u , this->d = d;
   }
};

int times[maxn];
priority_queue<tnode>dq;

void dijkstra()
{
   bool vis[maxn];
   int  dis[maxn];
   memset(vis,false,sizeof(vis));
   for(int i = 1 ; i <= n ; ++ i) dis[i] = inf;
   dis[1] = 0;
   times[1] = 1;
   dq.push(tnode(1,0));
   while(!dq.empty())
    {
       int u = dq.top().u , d = dq.top().d;dq.pop();
       if (vis[u]) continue;
       vis[u] = true;
       for(int i = 0 ; i < E[u].size() ; ++ i)
        {
            int nextnode = E[u][i].v;
            int newcost = E[u][i].w;
            if (dis[nextnode] > dis[u] + newcost)
             {
                 dis[nextnode] = dis[u] + newcost;
                 times[nextnode] = times[u];
                 times[nextnode] %= mod;
                 dq.push(tnode(nextnode,dis[nextnode]));
             }
            else if(dis[nextnode] == dis[u] + newcost)
             {
                 times[nextnode] = (times[nextnode] + times[u]) % mod;
             }
        }
    }
}


int main(int argc,char *argv[])
{
  scanf("%d%d",&n,&m);
  for(int i = 0 ; i < m ; ++ i)
   {
         int u,v,w;
         scanf("%d%d%d",&u,&v,&w);
         E[u].pb(Edge(v,w));
         E[v].pb(Edge(u,w));
   }
  memset(mincost,-1,sizeof(mincost));
  memset(inqueue,false,sizeof(inqueue));
  memset(times,0,sizeof(times));
  spfa();
  if (mincost[n][1] <= mincost[n][0] && mincost[n][1] != -1)
   printf("-1\n");
  else if (mincost[n][0] != -1)
   {
        dijkstra();
        printf("%d\n",times[n] % mod);
   }
  else
   printf("-1\n");
  return 0;
}