#include <cstring>

#include <cstdio>

#include <vector>

#include <queue>

#define Max 100

#define Mod 1000000007LL

void read (int &now)

{

    now = ;

    register char word = getchar ();

    while (word < '' || word > '')

        word = getchar ();

    while (word >= '' && word <= '')

    {

        now = now *  + word - '';

        word = getchar ();

    }

}

int N, M;

struct T_D

{

    T_D *child[];

    T_D *Fail;

    int number;

    long long value;

    T_D ()

    {

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

            this->child[i] = NULL;

        Fail = NULL;

        value = ;

        number = ;

    }

};

inline int swap (int &x, int &y)

{

    int now = x;

    x = y;

    y = now;

}

std :: vector <int> List[Max << ];

T_D *map[Max];

class Tree_Chain_Get_Type

{

    private :

        int size[Max];

        int deep[Max];

        int father[Max];

        int __to[Max];

        int __next[Max];

        int Edge_Count;

        int edge_list[Max];

        int top[Max];

        int Count;

    public :

        inline void Add_Edge (int from, int to)

        {

            Edge_Count ++;

            __to[Edge_Count] = to;

            __next[Edge_Count] = edge_list[from];

            edge_list[from] = Edge_Count;

            Edge_Count ++;

            __to[Edge_Count] = from;

            __next[Edge_Count] = edge_list[to];

            edge_list[to] = Edge_Count;

        }

        void Dfs_1 (int now, int __father)

        {

            int pos = Count ++;

            deep[now] = deep[__father] + ;

            father[now] = __father;

            for (int i = edge_list[now]; i; i = __next[i])

                if (__to[i] != __father)

                    Dfs_1 (__to[i], now);

            size[now] = Count - pos;

        }

        void Dfs_2 (int now, int chain)

        {

            int pos = ;

            top[now] = chain;

            for (int i = edge_list[now]; i; i = __next[i])

                if (__to[i] != father[now] && size[pos] < size[__to[i]])

                    pos = __to[i];

            if (!pos)

                return ;

            Dfs_2 (pos, chain);

            for (int i = edge_list[now]; i; i = __next[i])

                if (__to[i] != father[now] && __to[i] != pos)

                    Dfs_2 (__to[i], __to[i]);

        }

        int Get_Lca (int x, int y)

        {

            for (; top[x] != top[y]; x = father[top[x]])

                if (deep[top[x]] < deep[top[y]])

                    swap (x, y);

            return deep[x] < deep[y] ? x : y;

        }

        inline void Prepare ()

        {

            Count = ;

            Dfs_1 (, );

            Count = ;

            Dfs_2 (, );

            Count = ;

        }

};

Tree_Chain_Get_Type Make;

class AC_Type

{

    private :

        T_D *Root;

        int Count;

    public :

        AC_Type ()

        {

            Root = new T_D;

            Count = ;

            Root->number = ++ Count;

            map[Root->number] = Root;

        }

        void Insert (char *key)

        {

            T_D *now = Root, *pos;

            int Len = strlen (key);

            int Id;

            for (int i = ; i < Len; i ++)

            {

                Id = key[i] - 'a';

                if (now->child[Id] == NULL)

                {

                    now->child[Id] = new T_D;

                    now->child[Id]->number = ++ Count;

                    map[Count] = now->child[Id];

                    now->child[Id]->value = (now->value * 26LL + Id) % Mod;

                }

                List[i].push_back (now->child[Id]->number);

                now = now->child[Id];

            }

        }

        void Build_AC ()

        {

            std :: queue <T_D *> Queue;

            Queue.push (Root);

            T_D *now, *pos;

            while (!Queue.empty ())

            {

                now = Queue.front ();

                Queue.pop ();

                pos = NULL;

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

                {

                    if (now->child[i] == NULL)

                        continue;

                    if (now == Root)

                        now->child[i]->Fail = Root;

                    else

                    {

                        for (pos = now->Fail; pos; pos = pos->Fail)

                            if (pos->child[i])

                            {

                                now->child[i]->Fail = pos->child[i];

                                break;

                            }

                        if (pos == NULL)

                            now->child[i]->Fail = Root;

                    }

                    Queue.push (now->child[i]);

                    Make.Add_Edge (now->child[i]->number, now->child[i]->Fail->number);

                }

            }

        }

};

AC_Type AC;

char line[Max];

int main (int argc, char *argv[])

{

    int x, y;

    read (N);

    for (int i = ; i <= N; i ++)

    {

        scanf ("%s", line);

        AC.Insert (line);

    }

    AC.Build_AC ();

    Make.Prepare ();

    int x_1, y_1, x_2, y_2;

    for (read (M); M --; )

    {

        read (x_1);

        read (y_1);

        read (x_2);

        read (y_2);

        int now = Make.Get_Lca (List[x_1][y_1 - ], List[x_2][y_2 - ]);

        printf ("%lld\n", map[now]->value);

    }

    return ;

}