#[allow(unused_macros)]
macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( stdin . lock ( ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }
#[allow(unused_macros)]
macro_rules ! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , mut $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let mut $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }
#[allow(unused_macros)]
macro_rules ! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }

#[allow(unused_macros)]
macro_rules ! vec_md { ( $ init : expr ; $ ( $ dim : expr ) ;* ) => { vec_md ! ( $ ( $ dim ) ;* => $ init ) } ; ( $ head : expr ; $ ( $ tail : expr ) ;* => $ init : expr ) => { vec ! [ vec_md ! ( $ ( $ tail ) ;* => $ init ) ; $ head ] } ; ( $ head : expr => $ init : expr ) => { vec ! [ $ init ; $ head ] } ; }

fn main() {
    input! {
        n: usize, m: usize,
        s: [u64;n],
        t: [u64;m]
    }

    let mut dp = vec_md![Co(0);n+1;m+1];
    dp[0][0] = Co(1);
    let mut sum = vec_md![Co(0);n+2;m+2];
    for i in 0..n {
        for j in 0..m {
            sum[i+1][j+1] = sum[i][j+1] + sum[i+1][j] - sum[i][j] + dp[i][j];
            if s[i] == t[j] {
                dp[i+1][j+1] = sum[i+1][j+1];
            }
        }
    }
    let mut ret = Co(0);
    for i in 0..n+1 {
        for j in 0..m+1 {
            ret += dp[i][j];
        }
    }
    println!("{}", ret);
}

#[allow(dead_code)]
const M: i64 = 1_000_000_007;

#[allow(dead_code)]
use std::ops::*;
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Co(pub i64);
#[allow(dead_code)]
impl Co {
    pub fn pow(self, mut n: u64) -> Self {
        let mut a = self;
        let mut res = Co(1);
        while n > 0 {
            if n & 1 == 1 {
                res *= a;
            }
            a = a * a;
            n >>= 1;
        }
        res
    }
}
#[allow(dead_code)]
impl std::fmt::Display for Co {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}
macro_rules ! impl_from { ( $ ( $ tpe : ident ) ,* ) => { $ ( impl From <$ tpe > for Co { fn from ( value : $ tpe ) -> Self { Co ( ( value as i64 % M + M ) % M ) } } ) * } }
impl_from!(i64, u64, usize);
macro_rules ! impl_binop { ( $ op : ident ,$ atr : ident ,$ assign : ident $ ( ,$ optr : ident ) * ) => { impl $ atr for Co { fn $ assign ( & mut self , other : Self ) { * self = self .$ op ( other ) ; } } $ ( impl $ optr for Co { type Output = Self ; fn $ op ( self , other : Self ) -> Self { Co :: from ( ( self . 0 ) .$ op ( other . 0 ) ) } } ) * } }
impl_binop!(add, AddAssign, add_assign, Add);
impl_binop!(sub, SubAssign, sub_assign, Sub);
impl_binop!(mul, MulAssign, mul_assign, Mul);
impl_binop!(div, DivAssign, div_assign);
#[allow(dead_code)]
impl Div for Co {
    type Output = Self;
    fn div(self, rhs: Self) -> Self {
        self * rhs.pow((M - 2) as u64)
    }
}

Measured memory_bytes: 86268