#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()

struct SAM {
    struct state {
        int mxlen , prv , end_id ;
        map < char , int > nxt ;
        state ( ) { mxlen = end_id = 0 , prv = -1 ; nxt.clear ( ) ; }
    };
    vector < state > v ;
    int lst_vert , tp ;
    SAM ( ) {
        v.resize ( 1 ) ;
        lst_vert = tp = 0 ;
    }
    SAM ( string s ) {
        v.resize ( 1 ) ;
        lst_vert = tp = 0 ;
        int id = 0 ;
        for ( auto c : s ) {
            add_letter ( c , ++ id ) ;
        }
    }
    void add_letter ( char c , int end_id ) {
        int wh = lst_vert ;
        v.push_back ( state ( ) ) ;
        int nw = ++ tp ;
        state hh = state ( ) ;
        v[ nw ].mxlen = v[ lst_vert ].mxlen + 1 ;
        v[ nw ].end_id = end_id ;
        while ( wh >= 0 && v[ wh ].nxt.find ( c ) == v[ wh ].nxt.end ( ) ) {
            v[ wh ].nxt[ c ] = nw ;
            wh = v[ wh ].prv ;
        }
        if ( wh < 0 ) {
            v[ nw ].prv = 0 ;
        }
        else {
            int id = v[ wh ].nxt[ c ] ;
            if ( v[ id ].mxlen == v[ wh ].mxlen + 1 ) {
                v[ nw ].prv = id ;
            }
            else {
                int aux = ++ tp ;
                v.push_back ( state ( ) ) ;
                int rem = v[ id ].prv ;
                v[ id ].prv = v[ nw ].prv = aux ;
                v[ aux ].mxlen = v[ wh ].mxlen + 1 ;
                v[ aux ].prv = rem ;
                v[ aux ].nxt = v[ id ].nxt ;
                while ( wh >= 0 && v[ wh ].nxt[ c ] == id ) {
                    v[ wh ].nxt[ c ] = aux ;
                    wh = v[ wh ].prv ;
                }
            }
        }
        lst_vert = nw ;
    }
};

const int MAXN = 5e5 + 7 ;

int n ;
string a ;
SAM aux ;

struct node {
    int cnt , pl , pr ;
    node ( ) { cnt = pl = pr = 0 ; }
};
node tr[ 60 * MAXN ] ;
int tp ;
int root[ 3 * MAXN ] ;

vector < int > ord ;
bool seen[ 3 * MAXN ] ;
void get_ord ( int x , SAM &ch ) {
    seen[ x ] = true ;
    for ( auto [ c , y ] : ch.v[ x ].nxt ) {
        if ( y == 0 || seen[ y ] == true ) { continue ; }
        get_ord ( y , ch ) ;
    }
    ord.push_back ( x ) ;
}

int update ( int w , int l , int r , int pos ) {
    int ret = ++ tp ;
    tr[ ret ].cnt = tr[ w ].cnt + 1 , tr[ ret ].pl = tr[ w ].pl , tr[ ret ].pr = tr[ w ].pr ;
    if ( l == r ) { return ret ; }
    int mid = ( l + r ) / 2 ;
    if ( pos <= mid ) { tr[ ret ].pl = update ( tr[ w ].pl , l , mid , pos ) ; }
    else { tr[ ret ].pr = update ( tr[ w ].pr , mid + 1 , r , pos ) ; }
    return ret ;
}

int merge ( int x , int y , int l , int r ) {
    if ( x == 0 ) { return y ; }
    if ( y == 0 ) { return x ; }
    int ret = ++ tp ;
    tr[ ret ].cnt = tr[ x ].cnt + tr[ y ].cnt ;
    if ( l == r ) { return ret ; }
    int mid = ( l + r ) / 2 ;
    tr[ ret ].pl = merge ( tr[ x ].pl , tr[ y ].pl , l , mid ) ;
    tr[ ret ].pr = merge ( tr[ x ].pr , tr[ y ].pr , mid + 1 , r ) ;
    return ret ;
}
             
void init ( ) {
    get_ord ( 0 , aux ) ;
    for ( auto x : ord ) {
        if ( aux.v[ x ].end_id > 0 ) {
            root[ x ] = update ( root[ x ] , 1 , n , aux.v[ x ].end_id ) ;
        }
        if ( aux.v[ x ].prv != -1 ) {
            root[ aux.v[ x ].prv ] = merge ( root[ aux.v[ x ].prv ] , root[ x ] , 1 , n ) ;
        }
    }
}

int query ( int w , int l , int r , int en ) {
    if ( w == 0 ) { return 0 ; }
    if ( tr[ w ].cnt == 0 ) { return 0 ; }
    if ( l > en ) { return 0 ; }
    if ( l == r ) { return l ; }
    int mid = ( l + r ) / 2 ;
    int ret = query ( tr[ w ].pr , mid + 1 , r , en ) ;
    if ( ret != 0 ) { return ret ; }
    return query ( tr[ w ].pl , l , mid , en ) ;
}

int mx[ MAXN ] ;
int prop[ 3 * MAXN ] ;

void solve ( ) {
    cin >> a ;
    n = a.size ( ) ;
    aux = SAM ( a ) ;
    init ( ) ;
    int q ; cin >> q ;
    while ( q -- ) {
        string s ;
        int l , r ;
        cin >> s >> l >> r ;
        int sz = s.size ( ) ;
        int wh = 0 ;
        int val = 0 ;
        for ( int i = 0 ; i < sz ; ++ i ) {
            while ( wh >= 0 && aux.v[ wh ].nxt.find ( s[ i ] ) == aux.v[ wh ].nxt.end ( ) ) {
                wh = aux.v[ wh ].prv ;
            }
            if ( wh == -1 ) {
                mx[ i + 1 ] = 0 ;
                wh = val = 0 ;
            }
            else {
                val = min ( val , aux.v[ wh ].mxlen ) + 1 ;
                wh = aux.v[ wh ].nxt[ s[ i ] ] ;
                while ( wh >= 0 ) {
                    int sr = query ( root[ wh ] , 1 , n , r ) ;
                    int lo = 1 ;
                    if ( aux.v[ wh ].prv != -1 ) { lo = aux.v[ aux.v[ wh ].prv ].mxlen + 1 ; }
                    if ( l + lo - 1 > sr ) {
                        wh = aux.v[ wh ].prv ;
                    }
                    else { break ; }
                }
                if ( wh < 0 ) {
                    mx[ i + 1 ] = 0 ;
                    wh = val = 0 ;
                }
                else {
                    int hh = query ( root[ wh ] , 1 , n , r ) ;
                    val = mx[ i + 1 ] = min ( { aux.v[ wh ].mxlen , val , hh - l + 1 } ) ;
                }
            }
        }
        SAM hh = SAM ( s ) ;
        for ( int i = 1 ; i <= hh.tp ; ++ i ) {
            prop[ i ] = 0 ;
            if ( hh.v[ i ].end_id > 0 ) {
                prop[ i ] = mx[ hh.v[ i ].end_id ] ;
            }
        }
        ord.clear ( ) ;
        for ( int j = 0 ; j <= hh.tp ; ++ j ) { seen[ j ] = false ; }
        get_ord ( 0 , hh ) ;
        for ( auto x : ord ) {
            if ( hh.v[ x ].prv != -1 ) { 
                prop[ hh.v[ x ].prv ] = max ( prop[ hh.v[ x ].prv ] , prop[ x ] ) ;
            }
        }
        ll ans = 0 ;
        for ( int j = 1 ; j <= hh.tp ; ++ j ) {
            int lo = 1 ;
            if ( hh.v[ j ].prv != -1 ) {
                lo = hh.v[ hh.v[ j ].prv ].mxlen + 1 ;
            }
            if ( hh.v[ j ].mxlen > prop[ j ] ) {
                ans += hh.v[ j ].mxlen - max ( lo - 1 , prop[ j ] ) ;
            }
        }
        cout << ans << "\n" ;
    }
}

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