package main

import (
	"bufio"
	"fmt"
	"os"
)

const (
	mod1  = int64(1000000007)
	mod2  = int64(1000000009)
	base1 = int64(911382323)
	base2 = int64(972663749)
)

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) nextInt() int {
	sign := 1
	val := 0
	b, _ := fs.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		b, _ = fs.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, _ = fs.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int(b-'0')
		b, _ = fs.r.ReadByte()
	}
	return val * sign
}

type BIT struct {
	n   int
	bit []int
}

func NewBIT(n int) *BIT {
	return &BIT{n: n, bit: make([]int, n+2)}
}

func (f *BIT) add(i, delta int) {
	for i <= f.n {
		f.bit[i] += delta
		i += i & -i
	}
}

func (f *BIT) sum(i int) int {
	s := 0
	for i > 0 {
		s += f.bit[i]
		i -= i & -i
	}
	return s
}

var pow1 []int64
var pow2 []int64

type Node struct {
	l, r *Node
	pr   uint64
	sz   int
	val  int64
	h1   int64
	h2   int64
}

var seed uint64 = 88172645463393265

func rng() uint64 {
	seed ^= seed << 7
	seed ^= seed >> 9
	return seed
}

func sz(t *Node) int {
	if t == nil {
		return 0
	}
	return t.sz
}

func upd(t *Node) {
	if t == nil {
		return
	}
	ls := sz(t.l)
	rs := sz(t.r)
	t.sz = ls + 1 + rs

	var lh1, rh1 int64
	if t.l != nil {
		lh1 = t.l.h1
	}
	if t.r != nil {
		rh1 = (t.r.h1 * pow1[ls+1]) % mod1
	}
	v1 := (t.val % mod1) * pow1[ls] % mod1
	t.h1 = (lh1 + v1 + rh1) % mod1

	var lh2, rh2 int64
	if t.l != nil {
		lh2 = t.l.h2
	}
	if t.r != nil {
		rh2 = (t.r.h2 * pow2[ls+1]) % mod2
	}
	v2 := (t.val % mod2) * pow2[ls] % mod2
	t.h2 = (lh2 + v2 + rh2) % mod2
}

func newNode(v int64) *Node {
	return &Node{pr: rng(), sz: 1, val: v, h1: v % mod1, h2: v % mod2}
}

func split(t *Node, k int) (*Node, *Node) {
	if t == nil {
		return nil, nil
	}
	if sz(t.l) >= k {
		l, r := split(t.l, k)
		t.l = r
		upd(t)
		return l, t
	} else {
		l, r := split(t.r, k-sz(t.l)-1)
		t.r = l
		upd(t)
		return t, r
	}
}

func merge(a, b *Node) *Node {
	if a == nil {
		return b
	}
	if b == nil {
		return a
	}
	if a.pr < b.pr {
		a.r = merge(a.r, b)
		upd(a)
		return a
	} else {
		b.l = merge(a, b.l)
		upd(b)
		return b
	}
}

func insertAt(t *Node, k int, v int64) *Node {
	l, r := split(t, k)
	m := newNode(v)
	return merge(merge(l, m), r)
}

func removeAt(t *Node, k int) *Node {
	l, r := split(t, k)
	_, r2 := split(r, 1)
	return merge(l, r2)
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	n := in.nextInt()
	m := in.nextInt()

	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = in.nextInt()
	}
	b := make([]int, m+1)
	pos := make([]int, m+1)
	for i := 1; i <= m; i++ {
		b[i] = in.nextInt()
		pos[b[i]] = i
	}

	pow1 = make([]int64, n+5)
	pow2 = make([]int64, n+5)
	pow1[0] = 1
	pow2[0] = 1
	for i := 1; i < len(pow1); i++ {
		pow1[i] = (pow1[i-1] * base1) % mod1
		pow2[i] = (pow2[i-1] * base2) % mod2
	}

	var A1, A2, B1, B2 int64
	for i := 0; i < n; i++ {
		A1 = (A1 + pow1[i]) % mod1
		A2 = (A2 + pow2[i]) % mod2
		B1 = (B1 + pow1[i]*int64(a[i]-1)) % mod1
		B2 = (B2 + pow2[i]*int64(a[i]-1)) % mod2
	}

	seq := make([]int, 0, n)
	for i := 1; i <= m; i++ {
		if b[i] >= 1 && b[i] <= n {
			seq = append(seq, b[i])
		}
	}

	var root *Node
	for _, v := range seq {
		root = merge(root, newNode(int64(v)))
	}

	bit := NewBIT(m)
	for x := 1; x <= n; x++ {
		bit.add(pos[x], 1)
	}

	windows := m - n + 1
	ans := 0
	for L := 1; L <= windows; L++ {
		t1 := (A1*int64(L) + B1) % mod1
		t2 := (A2*int64(L) + B2) % mod2
		if root != nil && root.h1 == t1 && root.h2 == t2 {
			ans++
		}
		if L == windows {
			break
		}
		u := L
		v := L + n

		ru := bit.sum(pos[u] - 1)
		root = removeAt(root, ru)
		bit.add(pos[u], -1)

		rv := bit.sum(pos[v] - 1)
		root = insertAt(root, rv, int64(v))
		bit.add(pos[v], 1)
	}

	fmt.Fprintln(out, ans)
}