use std::str::FromStr;
use std::io::*;
use std::cmp::*;
use utils::*;

pub fn main() {
    let i = stdin();
    let mut o = Vec::new();
    run(i.lock(), &mut o);
    stdout().write_all(&o).unwrap();
}

fn run<R: BufRead, W: Write>(i: R, o: &mut W) {
    let mut i = AtRead::from(i);
    let nmk = i.read3::<usize, usize, usize>();
    writeln!(o, "{}", solve(nmk)).unwrap();
}
fn solve(n: (usize, usize, usize)) -> usize {
    let mut pows = Vec::new();
    let mut p = ModInt(1);
    for _ in 0..n.1 + n.2 + 1 {
        pows.push(p);
        p *= 3;
    }

    let n0_ex = n.0 - 1;
    let n12 = n.1 + n.2;
    let facts = ModIntFacts::new(n0_ex + n12);
    let mut result = ModInt(0);
    let mut c = ModInt(1);

    for i12 in 0..n12 + 1 {
        let c0 = c * facts.comb(n0_ex + i12, n0_ex) * pows[n12 - i12];
        result += c0;
        c *= 2;
        if i12 >= n.1 {
            c -= facts.comb(i12, i12 - n.1);
        }
        if i12 >= n.2 {
            c -= facts.comb(i12, i12 - n.2);
        }
    }

    result.0
}

mod utils {
    use super::*;
    use std::ops::*;

    pub struct AtRead<R: BufRead> {
        r: R,
        s: String,
    }

    macro_rules! fn_read {
        {$f:ident($($v:ident: $t:ident),*)} => {
            pub fn $f<$($t: FromStr),*>(&mut self) -> ($($t),*) {
                let i = &mut self.read_line().split(' ');
                $(
                    let $v = next(i);
                )*
                ($($v),*)
            }
        };
    }

    impl<R: BufRead> AtRead<R> {
        pub fn from(r: R) -> Self {
            AtRead {
                r: r,
                s: String::new(),
            }
        }
        pub fn read_line(&mut self) -> &str {
            self.s.clear();
            self.r.read_line(&mut self.s).unwrap();
            self.s.trim()
        }

        fn_read! { read3(v1: T1, v2: T2, v3: T3) }
    }

    fn next<'a, T: FromStr, I: std::iter::Iterator<Item = &'a str>>(i: &mut I) -> T {
        i.next().unwrap().parse().ok().unwrap()
    }

    #[derive(Debug, Clone, Copy)]
    pub struct ModInt(pub usize);

    const MOD_BASE: usize = 1000000007;
    const MOD_INV_POW: usize = 1000000005;

    impl ModInt {
        pub fn new(n: usize) -> Self {
            ModInt(n % MOD_BASE)
        }
        pub fn pow(self, mut exp: usize) -> Self {
            let mut b = self;
            let mut r = ModInt(1);
            while exp != 0 {
                if exp % 2 == 1 {
                    r *= b;
                }
                exp /= 2;
                b = b * b;
            }
            r
        }
        pub fn inverse_element(self) -> Self {
            self.pow(MOD_INV_POW)
        }
    }

    macro_rules! ModInt_op {
        (($ot:ident, $f:ident), ($ot_a:ident, $f_a:ident), $($rhs:ty, $e:expr,)*) => {
            $(
            impl $ot<$rhs> for ModInt {
                type Output = Self;
                fn $f(self, rhs: $rhs) -> Self {
                    Self::new(($e)(self, rhs))
                }
            }
            impl $ot_a<$rhs> for ModInt {
                fn $f_a(&mut self, rhs: $rhs) {
                    *self = Self::new(($e)(*self, rhs))
                }
            }
            )*
        }
    }

    ModInt_op!(
        (Add, add),
        (AddAssign, add_assign),
        ModInt,
        |l: ModInt, r: ModInt| l.0 + r.0,
        usize,
        |l: ModInt, r: usize| l.0 + r,
    );

    ModInt_op!(
        (Mul, mul),
        (MulAssign, mul_assign),
        ModInt,
        |l: ModInt, r: ModInt| l.0 * r.0,
        usize,
        |l: ModInt, r: usize| l.0 * r,
    );

    ModInt_op!(
        (Sub, sub),
        (SubAssign, sub_assign),
        ModInt,
        |l: ModInt, r: ModInt| MOD_BASE + l.0 - r.0,
        usize,
        |l: ModInt, r: usize| MOD_BASE + l.0 - r,
    );

    pub struct ModIntFacts {
        f: Vec<ModInt>,
        rf: Vec<ModInt>,
    }
    impl ModIntFacts {
        pub fn new(n: usize) -> Self {
            let mut s = ModIntFacts {
                f: vec![ModInt(0); n + 1],
                rf: vec![ModInt(0); n + 1],
            };

            let v = ModInt(1);
            s.f[0] = v;
            for i in 1..n + 1 {
                s.f[i] = s.f[i - 1] * i;
            }
            s.rf[n] = s.f[n].inverse_element();
            for i in (1..n + 1).rev() {
                s.rf[i - 1] = s.rf[i] * i;
            }
            s
        }
        pub fn comb(&self, n: usize, c: usize) -> ModInt {
            self.f[n] * self.rf[c] * self.rf[n - c]
        }
    }
}

Measured memory_bytes: 25848