#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair < int , int > pii ;
typedef vector < int > vi ;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()

const int MAXN = 1e5 + 7 ;
const int MOD = 1e9 + 7 ;
const ll inf = 1e18 + 7 ;

int n ;
ll init_val ;
struct elem {
    ll targ , spec_add , spec_move ;
    ll add , move ;
};
elem a[ MAXN ] ;
vector < int > v[ MAXN ] ;
vector < int > cycles[ MAXN ] ;
int cycle_id[ MAXN ] ;
ll cycle_len[ MAXN ] ;
ll dist_to_ori[ MAXN ] ;
int used[ MAXN ] ;

int subtree[ MAXN ] , heavy[ MAXN ] ,  lvl[ MAXN ] , lst[ MAXN ] ;
int pos[ MAXN ] , root[ MAXN ] , rv[ MAXN ] ;

void dfs ( int x , ll sm ) {
    subtree[ x ] = 1 ; 
    for ( auto y : v[ x ] ) {
        if ( cycle_id[ y ] > 0 ) { continue ; }
        dist_to_ori[ y ] = sm + a[ y ].add ;
        lvl[ y ] = lvl[ x ] + 1 ;
        lst[ y ] = x ;
        dfs ( y , sm + a[ y ].add ) ;
        subtree[ x ] += subtree[ y ] ;
        if ( subtree[ heavy[ x ] ] < subtree[ y ] ) {
            heavy[ x ] = y ;
        }
    }
}

class Tree {
public :
    vector < ll > tr[ 4 * MAXN ] ;
    void unite ( int w ) {
        int l = 2 * w , r = 2 * w + 1 ;
        int sz1 = tr[ l ].size ( ) , sz2 = tr[ r ].size ( ) ;
        int pos1 = 0 , pos2 = 0 ;
        while ( pos1 < sz1 || pos2 < sz2 ) {
            if ( pos1 == sz1 ) {
                tr[ w ].push_back ( tr[ r ][ pos2 ++ ] ) ;
            }
            else if ( pos2 == sz2 ) {
                tr[ w ].push_back ( tr[ l ][ pos1 ++ ] ) ;
            }
            else {
                if ( tr[ l ][ pos1 ] <= tr[ r ][ pos2 ] ) {
                    tr[ w ].push_back ( tr[ l ][ pos1 ++ ] ) ;
                }
                else {
                    tr[ w ].push_back ( tr[ r ][ pos2 ++ ] ) ;
                }
            }
        }
    }
    void init ( int w , int l , int r ) {
        if ( l == r ) {
            if ( cycle_id[ rv[ l ] ] == 0 ) { 
                tr[ w ].push_back ( a[ rv[ l ] ].targ + dist_to_ori[ rv[ l ] ] ) ;
            }
            else {
                tr[ w ].push_back ( a[ rv[ l ] ].targ ) ;
            }
            return ;
        }
        int mid = ( l + r ) / 2 ;
        init ( 2 * w , l , mid ) ;
        init ( 2 * w + 1 , mid + 1 , r ) ;
        unite ( w ) ;
    }
    int getr ( int w , int l , int r , int st , int en , ll sr ) {
        if ( l > r || st > en ) { return -1 ; }
        if ( r < st || en < l ) { return -1 ; }
        if ( st <= l && r <= en ) { 
            auto it = lower_bound ( tr[ w ].begin ( ) , tr[ w ].end ( ) , sr ) ;
            if ( it == tr[ w ].end ( ) || *it != sr ) {
                return -1 ;
            }
        }
        if ( l == r ) { return l ; }
        int mid = ( l + r ) / 2 ;
        int ret = getr ( 2 * w + 1 , mid + 1 , r , st , en , sr ) ;
        if ( ret != -1 ) { return ret ; }
        return getr ( 2 * w , l , mid , st , en , sr ) ;
    }
};
Tree w ;

bool seen[ MAXN ] ;

struct cycle_elem {
    ll rem , stval , id ;
};

bool cmp ( cycle_elem p1 , cycle_elem p2 ) {
    if ( p1.rem != p2.rem ) { return p1.rem < p2.rem ; }
    if ( p1.stval != p2.stval ) { return p1.stval < p2.stval ; }
    return p1.id < p2.id ;
}
int at_pos[ MAXN ] ;
vector < cycle_elem > srt[ MAXN ] ;

bool leq ( cycle_elem p1 , cycle_elem p2 ) {
    if ( p1.rem != p2.rem ) { return p1.rem < p2.rem ; }
    if ( p1.stval != p2.stval ) { return p1.stval < p2.stval ; }
    return p1.id <= p2.id ;
}

pair < int , ll > get_nxt ( int x , ll val ) {
    ll ret = 0 ;
    int y = x ;
    while ( cycle_id[ y ] == 0 ) {
        int hh = w.getr ( 1 , 1 , n + 1 , pos[ root[ y ] ] , pos[ y ] , val + dist_to_ori[ x ] ) ;
        if ( hh == -1 ) {
            if ( lst[ root[ y ] ] == 0 ) { y = root[ y ] ; }
            else { y = lst[ root[ y ] ] ; }
        }
        else {
            int act = rv[ hh ] ;
            return { act , lvl[ x ] - lvl[ act ] } ;
        }
    }
    ret = lvl[ x ] - lvl[ y ] ;
    if ( cycle_id[ x ] == 0 ) { 
        val += dist_to_ori[ x ] ;
    }
    int wtf = x ;
    x = y ;
    if ( x == n + 1 ) {
        return { x , ret } ;
    }
    cycle_elem sr ;
    int id = cycle_id[ x ] ;
    sr.rem = sr.stval = val - dist_to_ori[ x ] ;
    if ( abs ( cycle_len[ id ] ) > 0 ) { 
        sr.rem %= abs ( cycle_len[ id ] ) ;
        sr.rem = ( sr.rem + abs ( cycle_len[ id ] ) ) % abs ( cycle_len[ id ] ) ;
    }
    else { sr.rem = 0 ; }
    sr.id = at_pos[ x ] ;
    int l , r , mid ;
    l = 0 , r = srt[ id ].size ( ) - 1 ;
    while ( l < r ) {
        mid = ( l + r ) / 2 ;
        if ( leq ( sr , srt[ id ][ mid ] ) == true ) { r = mid ; }
        else { l = mid + 1 ; }
    }
    if ( sr.rem == srt[ id ][ l ].rem && sr.stval == srt[ id ][ l ].stval ) {
        return { cycles[ id ][ srt[ id ][ l ].id ] , ret + srt[ id ][ l ].id - at_pos[ x ] } ;
    }
    if ( cycle_len[ id ] > 0 ) {
        if ( sr.rem != srt[ id ][ l ].rem ) { return { -1 , -1 } ; }
        ll full = ( ( srt[ id ][ l ].stval - sr.stval ) / cycle_len[ id ] ) % MOD ;
        return { cycles[ id ][ srt[ id ][ l ].id ] , ret + full * cycles[ id ].size ( ) - at_pos[ x ] + srt[ id ][ l ].id } ;
    }
    int lo , hi ;
    lo = 0 , hi = srt[ id ].size ( ) - 1 ;
    cycle_elem foo = { sr.rem , sr.stval + cycle_len[ id ] , MAXN } ;
    while ( lo < hi ) {
        mid = ( lo + hi ) / 2 ;
        if ( leq ( foo , srt[ id ][ mid ] ) == true ) { hi = mid ; }
        else { lo = mid + 1 ; }
    }
    l = lo ;
    -- l ;
    if ( l < 0 ) { return { -1 , -1 } ; }
    if ( sr.rem != srt[ id ][ l ].rem ) { return { -1 , -1 } ; }
    if ( cycle_len[ id ] == 0 && sr.stval != srt[ id ][ l ].stval ) { return { -1 , -1 } ; }
    sr.stval = srt[ id ][ l ].stval ;
    sr.id = -MAXN ;
    l = 0 , r = srt[ id ].size ( ) - 1 ;
    while ( l < r ) {
        mid = ( l + r ) / 2 ;
        if ( leq ( sr , srt[ id ][ mid ] ) == true ) { r = mid ; }
        else { l = mid + 1 ; }
    }
    sr.id = at_pos[ x ] ;
    sr.stval = val - dist_to_ori[ x ] ;
    if ( cycle_len[ id ] < 0 ) {
        ll full = ( ( srt[ id ][ l ].stval - sr.stval ) / cycle_len[ id ] ) % MOD ;
        return { cycles[ id ][ srt[ id ][ l ].id ] , ret + full * cycles[ id ].size ( ) - at_pos[ x ] + srt[ id ][ l ].id } ;
    }    
    else {
        ll full = 1 ;
        return { cycles[ id ][ srt[ id ][ l ].id ] , ret + full * cycles[ id ].size ( ) - at_pos[ x ] + srt[ id ][ l ].id } ;
    }
}


void solve ( ) {
    cin >> n >> init_val ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        cin >> a[ i ].targ >> a[ i ].spec_add >> a[ i ].spec_move >> a[ i ].add >> a[ i ].move ;
        v[ a[ i ].move ].push_back ( i ) ;
    }
    a[ n + 1 ] = { 0 , 1 , n + 1 , 1 , n + 1 } ;
    int tp = 0 ;
    for ( int i = 1 ; i <= n + 1 ; ++ i ) {
        if ( used[ i ] > 0 ) { continue ; }
        vector < int > hist ;
        int x = i ;
        while ( used[ x ] == 0 ) {
            hist.push_back ( x ) ;
            used[ x ] = i ;
            x = a[ x ].move ;
        }
        if ( used[ x ] != i ) { continue ; }
        ++ tp ;
        while ( 1 ) {
            cycle_id[ hist.back ( ) ] = tp ;
            cycles[ tp ].push_back ( hist.back ( ) ) ;
            if ( hist.back ( ) == x ) { break ; }
            hist.pop_back ( ) ;
        }
        reverse ( cycles[ tp ].begin ( ) , cycles[ tp ].end ( ) ) ;
        ll sm = 0 ;
        for ( auto wh : cycles[ tp ] ) {
            dist_to_ori[ wh ] = sm ;
            sm += a[ wh ].add ;
        }
        cycle_len[ tp ] = sm ;
        int act = 0 ;
        for ( auto wh : cycles[ tp ] ) {
            at_pos[ wh ] = act ;
            ll md_val = a[ wh ].targ - dist_to_ori[ wh ] ;
            ll rem = md_val ;
            if ( abs ( cycle_len[ tp ] ) > 0 )  {
                md_val %= abs ( cycle_len[ tp ] ) ;
                md_val = ( md_val + abs ( cycle_len[ tp ] ) ) % abs ( cycle_len[ tp ] ) ;
            }
            else { md_val = 0 ; }
            srt[ tp ].push_back ( { md_val , rem , act } ) ;
            ++ act ;
        }
        sort ( srt[ tp ].begin ( ) , srt[ tp ].end ( ) , cmp ) ;
        srt[ tp ].push_back ( { inf , inf , n + 2 } ) ;
    }
    for ( int i = 1 ; i <= n + 1 ; ++ i ) {
        if ( cycle_id[ i ] > 0 ) {
            dfs ( i , 0 ) ;
        }
    }
    tp = 0 ;
    for ( int i = 1 ; i <= n + 1 ; ++ i ) {
        if ( heavy[ lst[ i ] ] != i ) {
            int x = i ;
            while ( x > 0 ) {
                pos[ x ] = ++ tp ;
                rv[ tp ] = x ;
                root[ x ] = i ;
                x = heavy[ x ] ; 
            }
        }
    }
    w.init ( 1 , 1 , n + 1 ) ;
    ll steps = 0 ;
    int wh = 1 ;
    ll val = init_val ;
    while ( 1 ) {
        auto [ nxt , add ] = get_nxt ( wh , val ) ;
        if ( nxt == -1 ) {
            cout << "-1\n" ;
            return ;
        }
        steps = ( steps + add ) % MOD ;
        wh = nxt ;
        if ( wh == n + 1 ) { break ; }
        if ( seen[ wh ] == true ) {
            cout << "-1\n" ;
            return ;
        }
        seen[ wh ] = true ;
        steps = ( steps + 1 ) % MOD ;
        val = a[ wh ].targ + a[ wh ].spec_add ;
        wh = a[ wh ].spec_move ;
        if ( wh == n + 1 ) { break ; }
    }
    cout << steps << "\n" ;
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; // cin >> t ;
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}