//#include <bits/stdc++.h>

#include <cstdio>

#include <algorithm>

#include <vector>

#include <queue>

#include <cstring>

using namespace std;

const int maxn=, INF=1e9;

struct Edge{

    int u,v,dis;

};

vector<Edge> edges; vector<int> G[maxn];

void Addedge(int u,int v,int dis){

    edges.push_back((Edge){u,v,dis}); G[u].push_back(edges.size()-);

}

int l[maxn], L, R, val[maxn];

struct HeapNode{

    int x,dis;

    bool operator < (const HeapNode& a) const{ return dis>a.dis; }

};

priority_queue<HeapNode> que;

int d[maxn],vis[maxn], n;

int dijkstra(int s ){

    if(l[s]<L || l[s]>R) return val[s];

    memset(d,,sizeof(d)); memset(vis,,sizeof(vis));

    d[s]=; que.push((HeapNode){s,}); //vis[s]=1;

    while(!que.empty()){

        HeapNode x=que.top(); que.pop();

        if(vis[x.x]) continue; vis[x.x]=;

        int u=x.x;

        for(int i=;i<G[u].size();i++){

            Edge& e=edges[G[u][i]];

            if(l[e.v]>=L && l[e.v]<=R && d[e.v]>d[u]+e.dis){

                d[e.v]=d[u]+e.dis;

                que.push((HeapNode){e.v,d[e.v]});

            }

        }

    }

    int ans=1e9;

    for(int i=;i<=n;i++){

        ans=min(ans,d[i]+val[i]);

    }

    return ans;

}

int main(){

    int  m; scanf("%d%d",&m,&n);

    int x, q=,b,c;

    for(int i=;i<=n;i++){

        scanf("%d%d%d",&val[i],&l[i],&x);

        while(x--){

            scanf("%d%d",&b,&c); Addedge(i,b,c);

        }

        q=max(q,l[i]);

    }

    int ans=INF;

    for(int i=;i<=max(q-m,n);i++){

        L=i; R=i+m;

        ans=min(ans,dijkstra());

    }

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

    return ;

}