#[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 ( std :: io :: BufReader :: new ( 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 , $ 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" ) } ; }

fn main() {
    input! {
        n: u64, m: u64,
        x: [i64;n],
        y: [i64;m]
    }

    let xs = calc(&x);
    let ys = calc(&y);
    println!("{}", xs * ys);
}

fn calc(x: &[i64]) -> Co {
    let n = x.len() as u64;
    let mut ret = Co(0);
    for i in 0..n {
        ret += (Co(2) * Co(i) + Co(1) - Co(n)) * Co::new(x[i as usize]);
    }
    ret
}

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

#[allow(dead_code)]
use std::ops::*;
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Co(pub u64);
#[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
    }
    fn new(n: i64) -> Self {
        fn i(n: u64) -> i64 {
            n as i64
        }
        Co((((n % i(M)) + i(M)) % i(M)) as u64)
    }
}
#[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_assign {
    ( $ op : ident ,$ tr : ident ,$ name : ident ) => {
        impl $tr for Co {
            fn $name(&mut self, other: Self) {
                *self = self.$op(other);
            }
        }
    };
}
impl_assign!(add, AddAssign, add_assign);
impl_assign!(sub, SubAssign, sub_assign);
impl_assign!(mul, MulAssign, mul_assign);
impl_assign!(div, DivAssign, div_assign);
#[allow(dead_code)]
impl Add for Co {
    type Output = Self;
    fn add(self, rhs: Self) -> Self {
        Co((self.0 + rhs.0) % M)
    }
}
#[allow(dead_code)]
impl Div for Co {
    type Output = Self;
    fn div(self, rhs: Self) -> Self {
        self * rhs.pow(M - 2)
    }
}
#[allow(dead_code)]
impl Mul for Co {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self {
        Co(self.0 * rhs.0 % M)
    }
}
#[allow(dead_code)]
impl Sub for Co {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self {
        fn i(n: u64) -> i64 {
            n as i64
        }
        Co((((i(self.0) - i(rhs.0)) % i(M) + i(M)) % i(M)) as u64)
    }
}

Measured memory_bytes: 6396