Problem:
Square Route

スクウェア・ルート

English text is not available in this practice contest.

このたび新しい豪邸を建てることを決めた大富豪の品田氏は，どの街に新邸を建てようかと悩んでいる．実は，品田氏は正方形がとても好きという変わった人物であり，そのため少しでも正方形の多い街に住みたいと思っている．

品田氏は，碁盤目状に道路の整備された街の一覧を手に入れて，それぞれの街について，道路により形作られる正方形の個数を数えることにした．ところが，道と道の間隔は一定とは限らないため，手作業で正方形を数えるのは大変である．そこであなたには，碁盤目状の道路の情報が与えられたときに，正方形の個数を数えるプログラムを書いて欲しい．

Input

入力は複数のデータセットから構成されており，各データセットは以下のような構成になっている．

N M

h1

h2

...

hN

w1

w2

...

wM

1 行目には 2 つの正の整数 N, M (1 ≦ N, M ≦ 1500) が与えられる．続く N 行 h1, h2, ..., hN (1 ≦ hi ≦ 1000）は，道路と道路の南北方向の間隔を表す．ここで hi は北から i 番目の道路と北から i + 1 番目の道路の間隔である．同様に，続く M 行 w1, ..., wM (1 ≦ wi ≦ 1000）は，道路と道路の東西方向の間隔を表す．ここで wi は西から i 番目の道路と西から i + 1 番目の道路の間隔である．道路自体の幅は十分細いため考慮する必要はない．

図 D-1: 最初のデータセット

N = M = 0 は入力の終端を示しており，データセットには含めない．

Output

各データセットに対して，正方形の個数を 1 行に出力しなさい．たとえば，Sample Input の最初のデータセットにおいては，以下のとおり 6 個の正方形を含むので，このデータセットに対する出力は 6 となる．

図 D-2: 最初のデータセットに含まれる正方形

Sample Input

3 3
1
1
4
2
3
1
1 2
10
10
10
0 0

Output for the Sample Input

6
2

Solution in Rust (judge verdict: Accepted)

use std::cmp::*;
use std::collections::*;
use std::fmt::Debug;
use std::io::{stdin, Read};
use std::str::FromStr;

//mod lib;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();

    return token.parse().ok().expect("failed to parse token");
}

static MOD: i64 = 1_000_000_007;

fn read_vec1<T: FromStr>(n: usize) -> Vec<T> {
    return (0..n).map(|_| read()).collect();
}

fn read_vec2<T: FromStr>(n: usize, m: usize) -> Vec<Vec<T>> {
    return (0..n).map(|_| read_vec1(m)).collect();
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Rev<T>(pub T);

impl<T: PartialOrd> PartialOrd for Rev<T> {
    fn partial_cmp(&self, other: &Rev<T>) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl<T: Ord> Ord for Rev<T> {
    fn cmp(&self, other: &Rev<T>) -> Ordering {
        other.0.cmp(&self.0)
    }
}

fn add_by_mod(a: &i64, b: &i64) -> i64 {
    return (a % MOD + b % MOD) % MOD;
}

fn solve(n: usize, m: usize) -> i64 {
    let mut h: Vec<i64> = read_vec1(n);
    let mut w: Vec<i64> = read_vec1(m);
    let mut hash_x = HashMap::new();
    let mut hash_y = HashMap::new();

    for i in 0..n {
        let mut sum = 0;
        for j in i..n {
            sum += h[j];
            let count = hash_y.entry(sum).or_insert(0i64);
            *count += 1;
        }
    }


    for i in 0..m {
        let mut sum = 0;
        for j in i..m {
            sum += w[j];
            let count = hash_x.entry(sum).or_insert(0);
            *count += 1;
        }
    }

    let mut ans = 0;

    for (k, v) in hash_x.iter() {
        let count = hash_y.get(k);
        match count {
            Some(c) => ans += c * *v,
            None => (),
        }
    }

    return ans;
}

fn main() {
    let mut n: usize = read();
    let mut m: usize = read();

    while n != 0 && m != 0 {
        println!("{}", solve(n, m));
        n = read();
        m = read();
    }
}