import java.io.*;
import java.util.*;
import java.math.BigInteger;
import java.util.Map.Entry;

import static java.lang.Math.*;

public class Main extends PrintWriter {

    void run() {

        String s = next();
        Map<String, List<Integer>> f = new HashMap<String, List<Integer>>(1 << 21);
        int n = s.length();

        int m = nextInt();

        int[] l = new int[m];
        int[] r = new int[m];

        String[] p = new String[m];

        for (int j = 0; j < m; j++) {
            l[j] = nextInt() - 1;
            r[j] = nextInt() - 0;

            String str = p[j] = next();
            int k = str.length();

            int li = 0;

            while (li < k) {
                while (li < k && str.charAt(li) == '*') {
                    ++li;
                }
                int ri = li;

                while (ri < k && str.charAt(ri) != '*') {
                    ++ri;
                }

                if (li < ri) {
                    String sub = str.substring(li, ri);
                    f.put(sub, new ArrayList<Integer>());
                }
                li = ri;
            }
        }

        for (int i = 0; i < n; i++) {
            for (int len = min(10, n - i); len >= 1; len--) {
                List<Integer> list = f.get(s.substring(i, i + len));
                if (list != null) {
                    list.add(i);
                }
            }
        }

        for (int j = 0; j < m; j++) {
            boolean ok = true;
            int i = l[j];

            String str = p[j];
            int k = str.length();

            int li = 0;

            while (ok && li < k) {
                while (li < k && str.charAt(li) == '*') {
                    ++li;
                }
                int ri = li;

                while (ri < k && str.charAt(ri) != '*') {
                    ++ri;
                }

                if (li < ri) {
                    String sub = str.substring(li, ri);
                    List<Integer> list = f.get(sub);

                    if (list.isEmpty()) {
                        ok = false;
                        break;
                    }

                    int index = Collections.binarySearch(list, i);

                    if (index < 0) {
                        index = ~index;
                    }

                    if (index >= list.size()) {
                        ok = false;
                        break;
                    }

                    i = list.get(index);

                    if (li == 0) {
                        ok &= i == l[j];
                    }

                    i += sub.length();

                    if (ri == k) {
                        ok &= i == r[j];
                    }

                    ok &= i <= r[j];
                }
                li = ri;
            }

            println(ok ? "Yes" : "No");
        }

    }

    public static boolean nextPermutation(int[] permutation) {
        int n = permutation.length, a = n - 2;
        while (0 <= a && permutation[a] >= permutation[a + 1]) {
            a--;
        }
        if (a == -1) {
            return false;
        }

        int b = n - 1;
        while (permutation[b] <= permutation[a]) {
            b--;
        }

        swap(permutation, a, b);
        for (int i = a + 1, j = n - 1; i < j; i++, j--) {
            swap(permutation, i, j);
        }
        return true;
    }

    public static void swap(int[] array, int i, int j) {
        if (i == j) {
            return;
        }
        array[i] ^= array[j];
        array[j] ^= array[i];
        array[i] ^= array[j];
    }

    int[][] nextMatrix(int n, int m) {
        int[][] matrix = new int[n][m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                matrix[i][j] = nextInt();
        return matrix;
    }

    String next() {
        while (!tokenizer.hasMoreTokens())
            tokenizer = new StringTokenizer(nextLine());
        return tokenizer.nextToken();
    }

    boolean hasNext() {
        while (!tokenizer.hasMoreTokens()) {
            String line = nextLine();
            if (line == null) {
                return false;
            }
            tokenizer = new StringTokenizer(line);
        }
        return true;
    }

    int[] nextArray(int n) {
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = nextInt();
        }
        return array;
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException err) {
            return null;
        }
    }

    public Main(OutputStream outputStream) {
        super(outputStream);
    }

    static BufferedReader reader;
    static StringTokenizer tokenizer = new StringTokenizer("");
    static Random rnd = new Random();

    public static void main(String[] args) throws IOException {
        reader = new BufferedReader(new InputStreamReader(System.in));
        Main Main = new Main(System.out);

        Main.run();
        Main.close();
        reader.close();
    }
}