beci pacer

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
        String[]parts= buff.readLine().split(" ");
        int zbir=0;
        List<String>lista1= new LinkedList<String>();
        List<String>lista2= new LinkedList<String>();
        List<String>lista3= new LinkedList<String>();

        String txt = buff.readLine();
        Set<String> set = new HashSet<>();


        for (int i = 0; i < Integer.parseInt(parts[0]); i++) {
            zbir+=search(txt.toCharArray(),buff.readLine().toCharArray());
        }
        for (int i = 0; i < Integer.parseInt(parts[1]); i++) {
            zbir+=search(txt.toCharArray(),buff.readLine().toCharArray());
        }
        for (int i = 0; i < Integer.parseInt(parts[2]); i++) {
            zbir+=search(txt.toCharArray(),buff.readLine().toCharArray());
        }


        System.out.println(zbir);
    }


    static int NO_OF_CHARS = 256;

    //A utility function to get maximum of two integers
    static int max (int a, int b) { return (a > b)? a: b; }

    //The preprocessing function for Boyer Moore's
    //bad character heuristic
    static void badCharHeuristic( char []str, int size,int badchar[])
    {
        int i;

        // Initialize all occurrences as -1
        for (i = 0; i < NO_OF_CHARS; i++)
            badchar[i] = -1;

        // Fill the actual value of last occurrence
        // of a character
        for (i = 0; i < size; i++)
            badchar[(int) str[i]] = i;
    }

    /* A pattern searching function that uses Bad
    Character Heuristic of Boyer Moore Algorithm */
    static int search( char txt[],  char pat[])
    {
        int zbir=0;
        int m = pat.length;
        int n = txt.length;

        int badchar[] = new int[NO_OF_CHARS];

      /* Fill the bad character array by calling
         the preprocessing function badCharHeuristic()
         for given pattern */
        badCharHeuristic(pat, m, badchar);

        int s = 0;  // s is shift of the pattern with
        // respect to text
        while(s <= (n - m))
        {
            int j = m-1;

          /* Keep reducing index j of pattern while
             characters of pattern and text are
             matching at this shift s */
            while(j >= 0 && pat[j] == txt[s+j])
                j--;

          /* If the pattern is present at current
             shift, then index j will become -1 after
             the above loop */
            if (j < 0)
            {
                //System.out.println("Patterns occur at shift = " + s);
                zbir++;

              /* Shift the pattern so that the next
                 character in text aligns with the last
                 occurrence of it in pattern.
                 The condition s+m < n is necessary for
                 the case when pattern occurs at the end
                 of text */
                s += (s+m < n)? m-badchar[txt[s+m]] : 1;

            }

            else
              /* Shift the pattern so that the bad character
                 in text aligns with the last occurrence of
                 it in pattern. The max function is used to
                 make sure that we get a positive shift.
                 We may get a negative shift if the last
                 occurrence  of bad character in pattern
                 is on the right side of the current
                 character. */
                s += max(1, j - badchar[txt[s+j]]);
        }
        return zbir;
    }
}