Sereja has two sequences a and b and number p. Sequence a consists of n integers a1, a2, ..., an. Similarly, sequence b consists of m integers b1, b2, ..., bm. As usual, Sereja studies the sequences he has. Today he wants to find the number of positions q (q + (m - 1)·p ≤ n; q ≥ 1), such that sequence b can be obtained from sequence aq, aq + p, aq + 2p, ..., aq + (m - 1)p by rearranging elements.

Sereja needs to rush to the gym, so he asked to find all the described positions of q.

Input

The first line contains three integers n, m and p (1 ≤ n, m ≤ 2·105, 1 ≤ p ≤ 2·105). The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109).

Output

In the first line print the number of valid qs. In the second line, print the valid values in the increasing order.

Examples

Input

5 3 1
1 2 3 2 1
1 2 3


Output

2
1 3


Input

6 3 2
1 3 2 2 3 1
1 2 3


Output

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

/**
 * Created by 875k on 12/25/13.
 */
public class CF215D {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tok = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(tok.nextToken());
        int m = Integer.parseInt(tok.nextToken());
        int p = Integer.parseInt(tok.nextToken());
        if(m > n / p) {
            System.out.println(0);
            System.exit(0);
        }
        int[] a = new int[n];
        HashMap<Integer, Integer> b = new HashMap<Integer, Integer>();
        tok = new StringTokenizer(br.readLine());
        for(int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(tok.nextToken());
        }
        tok = new StringTokenizer(br.readLine());
        for(int i = 0; i < m; i++) {
            addcount(b, Integer.parseInt(tok.nextToken()));
        }
        Set<Integer> bkeys = b.keySet();
        //printhm(b);
        ArrayList<Integer> sol = new ArrayList<Integer>();
        for(int i = 0; i < p; i++) {
            HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
            for(int j = n - 1 - i; j >= 0; j -= p) {
                //System.out.print(a[j]);
                addcount(hm, a[j]);
                if(j + (m - 1) * p < n) {
                    //printhm(hm);
                    boolean found = true;
                    for(int k : bkeys) {
                        if(b.get(k) == null) {
                            System.exit(0);
                        }
                        if(!b.get(k).equals(hm.get(k))) {
                            found = false;
                            //System.out.println("nope" + " " + k);
                            break;
                        }
                    }
                    if(b.size() != hm.size()) {
                        found = false;
                    }
                    if(found)
                        sol.add(j + 1);
                    deccount(hm, a[j + (m - 1) * p]);
                }
            }
            //System.out.println();
        }
        System.out.println(sol.size());
        Collections.sort(sol);
        for(int i = 0; i < sol.size(); i++) {
            System.out.print(sol.get(i) + " ");
        }
        System.out.println();
    }
    public static void addcount(HashMap<Integer, Integer> hm, int n) {
        if(hm.get(n) == null) {
            hm.put(n, 1);
        }
        else {
            hm.put(n, hm.get(n) + 1);
        }
    }
    public static void deccount(HashMap<Integer, Integer> hm, int n) {
        int x = hm.get(n) - 1;
        if(x == 0) {
            hm.remove(n);
        }
        else {
            hm.put(n, x);
        }
    }
    public static void printhm(HashMap<Integer, Integer> hm) {
        System.out.println("=========");
        for(int k : hm.keySet()) {
            System.out.println(k + ": " + hm.get(k));
        }
        System.out.println("=========");
    }
}
