import java.util.Scanner;
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.LinkedList;

class MaxFlow
{
    public int V; //Number of vertices in graph

    /* Returns true if there is a path from source 's' to sink
      't' in residual graph. Also fills parent[] to store the
      path */
    boolean bfs(int rGraph[][], int s, int t, int parent[])
    {
        // Create a visited array and mark all vertices as not
        // visited
        boolean visited[] = new boolean[V];
        for(int i=0; i<V; ++i)
            visited[i]=false;

        // Create a queue, enqueue source vertex and mark
        // source vertex as visited
        LinkedList<Integer> queue = new LinkedList<Integer>();
        queue.add(s);
        visited[s] = true;
        parent[s]=-1;

        // Standard BFS Loop
        while (queue.size()!=0)
        {
            int u = queue.poll();

            for (int v=0; v<V; v++)
            {
                if (visited[v]==false && rGraph[u][v] > 0)
                {
                    queue.add(v);
                    parent[v] = u;
                    visited[v] = true;
                }
            }
        }

        // If we reached sink in BFS starting from source, then
        // return true, else false
        return (visited[t] == true);
    }

    // Returns tne maximum flow from s to t in the given graph
    int fordFulkerson(int graph[][], int s, int t)
    {
        int u, v;

        // Create a residual graph and fill the residual graph
        // with given capacities in the original graph as
        // residual capacities in residual graph

        // Residual graph where rGraph[i][j] indicates
        // residual capacity of edge from i to j (if there
        // is an edge. If rGraph[i][j] is 0, then there is
        // not)
        int rGraph[][] = new int[V][V];

        for (u = 0; u < V; u++)
            for (v = 0; v < V; v++)
                rGraph[u][v] = graph[u][v];

        // This array is filled by BFS and to store path
        int parent[] = new int[V];

        int max_flow = 0;  // There is no flow initially

        // Augment the flow while tere is path from source
        // to sink
        while (bfs(rGraph, s, t, parent))
        {
            // Find minimum residual capacity of the edhes
            // along the path filled by BFS. Or we can say
            // find the maximum flow through the path found.
            int path_flow = Integer.MAX_VALUE;
            for (v=t; v!=s; v=parent[v])
            {
                u = parent[v];
                path_flow = Math.min(path_flow, rGraph[u][v]);
            }

            // update residual capacities of the edges and
            // reverse edges along the path
            for (v=t; v != s; v=parent[v])
            {
                u = parent[v];
                rGraph[u][v] -= path_flow;
                rGraph[v][u] += path_flow;
            }

            // Add path flow to overall flow
            max_flow += path_flow;
        }

        // Return the overall flow
        return max_flow;
    }
}
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       Scanner in = new Scanner(System.in);
       String[] cubes = in.nextLine().split(" ");
       String[] words = in.nextLine().split(" ");

       int counter = 0;
       for (String word : words){

           int[][] mat = new int[cubes.length + word.length() + 2][cubes.length + word.length() + 2];
           //System.out.println("N" + (cubes.length + word.length() + 2));
           //System.out.println("M" + (cubes.length + word.length() + 2));
           for (int i = 1; i <= cubes.length; i++){
               mat[0][i] = 1;
           }

           char[] characters = word.toCharArray();
           for (int i = 1; i <= cubes.length; i++){
               for (int j = 0; j < characters.length; j++){
                   if (cubes[i - 1].indexOf(characters[j]) >= 0){ // contains
                       mat[i][cubes.length + j + 1] = 1;
                   }
               }

           }

           for (int i = cubes.length + 1; i <= cubes.length + word.length(); i++){
               mat[i][cubes.length + word.length() + 1] = 1;
           }
           MaxFlow mf = new MaxFlow();
           mf.V = cubes.length + word.length() + 2;
           if (word.length() == mf.fordFulkerson(mat, 0, cubes.length + word.length() + 1)){
               System.out.println(counter);
           }
           counter++;
       }
    }
}