macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn brute_force(a: &String, b: &String, c: &String) -> u64 {
    let n = a.len();
    let mut result = 0;

    for i in 0..n {
        for j in i..n {
            let an: u64 = a[i..j + 1].parse().unwrap();
            let bn: u64 = b[i..j + 1].parse().unwrap();
            let cn: u64 = c[i..j + 1].parse().unwrap();

            if an + bn == cn {
                result += 1;
            }
        }
    }

    result
}

fn get_valid_minimal_sum_length(
    a: &Vec<u32>,
    b: &Vec<u32>,
    c: &Vec<u32>,
    start: usize,
) -> (usize, bool) {
    let mut start = start - 1;
    let mut length = 1;
    let mut reminder = 0;

    loop {
        let an = a[start];
        let bn = b[start];
        let cn = c[start];
        let current_reminder = (an + bn + reminder) / 10;

        // eprintln!(
        //     "start = {}, length = {}, reminder = {}",
        //     start, length, reminder
        // );

        if an + bn + reminder == cn {
            // println!("{an} + {bn} == {cn}");
            return (length, true);
        } else {
            if (an + bn + reminder) % 10 == cn {
                if current_reminder == 0 {
                    return (length, true);
                }
            } else {
                // eprintln!(
                //     "start = {}, length = {}, reminder = {}",
                //     start, length, reminder
                // );
                return (length, false);
            }
        }

        if start == 0 {
            return (length, false);
        }

        start -= 1;
        length += 1;
        reminder = current_reminder;
    }
}

fn solve(a: &Vec<u32>, b: &Vec<u32>, c: &Vec<u32>) -> u64 {
    let n = a.len();
    let mut end = n;
    let mut sequences: Vec<(usize, usize)> = Vec::with_capacity(1_000_000);

    loop {
        let (length, is_valid) = get_valid_minimal_sum_length(a, b, c, end);
        let sequence_start = end - length;

        // eprintln!(
        //     "start = {}, end = {}, is_valid = {}",
        //     sequence_start, end, is_valid
        // );

        if is_valid {
            sequences.push((sequence_start, end));
            end = sequence_start;
        } else {
            end -= 1;
        }

        if end == 0 {
            break;
        }

        // eprint!("{end} {length}");
    }

    sequences.reverse();

    let mut sequence_length = 1;
    let mut result = 0;

    if sequences.is_empty() {
        return 0;
    }

    for i in 0..sequences.len() - 1 {
        if sequences[i].1 == sequences[i + 1].0 {
            sequence_length += 1;
        } else {
            result += sequence_length * (sequence_length + 1) / 2;
            sequence_length = 1;
        }
    }

    // eprintln!("{:?}", sequences);

    result + sequence_length * (sequence_length + 1) / 2
}

fn main() {
    input! {
        a: String,
        b: String,
        c: String,
    }
    // eprintln!(
    //     "brute_force({}, {}, {}) = {}",
    //     a,
    //     b,
    //     c,
    //     brute_force(&a, &b, &c)
    // );

    let a = a
        .chars()
        .map(|c| c.to_digit(10).unwrap())
        .collect::<Vec<_>>();
    let b = b
        .chars()
        .map(|c| c.to_digit(10).unwrap())
        .collect::<Vec<_>>();
    let c = c
        .chars()
        .map(|c| c.to_digit(10).unwrap())
        .collect::<Vec<_>>();

    // eprintln!("{:?}, {:?}, {:?}", a, b, c);

    // eprintln!("solve({}, {}, {}) = {}", a, b, c, solve(&a, &b, &c));
    //

    println!("{}", solve(&a, &b, &c));

    // let n = 1000;

    // for i in 0..n {
    //     eprintln!("{i}");
    //     for j in 0..n {
    //         for k in 0..n {
    //             let a = format!("{:03}", i);
    //             let b = format!("{:03}", j);
    //             let c = format!("{:03}", k);

    //             let av = a
    //                 .chars()
    //                 .map(|c| c.to_digit(10).unwrap())
    //                 .collect::<Vec<_>>();
    //             let bv = b
    //                 .chars()
    //                 .map(|c| c.to_digit(10).unwrap())
    //                 .collect::<Vec<_>>();
    //             let cv = c
    //                 .chars()
    //                 .map(|c| c.to_digit(10).unwrap())
    //                 .collect::<Vec<_>>();

    //             // eprintln!("{a} {b} {c}");

    //             let result = brute_force(&a, &b, &c);
    //             let result2 = solve(&av, &bv, &cv);

    //             if result != result2 {
    //                 println!(
    //                     "brute_force({:?}, {:?}, {:?}) = {}, solve({:?}, {:?}, {:?}) = {}",
    //                     a, b, c, result, av, bv, cv, result2
    //                 );
    //             }
    //         }
    //     }
    // }
}