#include <bits/stdc++.h>
using namespace std;

/* FFT dla doubli O(n*log(n))                                                 */
/* wynik mnozenia dwoch wielomianow                                           */
/* argumenty to dwa wektory, wynik to jeden wektor                            */
/* fft() dziala bezpiecznie dla liczb do 35k                                  */
/* dla wiekszych odpalamy fft_dokladne, dziala wolniej, ale liczy dokladnie   */
/* mozna je zmodyfikowac do liczenia modulo np. 10^9+7                        */
/* sprawdzic, czy argumenty nie powinny byc wektorami long longow             */

struct fft_double
{
	double PI=3.141592653589793;

	vector < complex <double> > dftn; //poczebne
	vector < complex <double> > dfts; //poczebne

	vector < complex <double> > pom; //do zwyklego

	vector < complex <double> > a1; //do dokladnego
	vector < complex <double> > a2; //do dokladnego
	vector < complex <double> > b1; //do dokladnego
	vector < complex <double> > b2; //do dokladnego

	vector <double> cosi; //poczebne
	vector < complex <double> > omega; //poczebne
	
	fft_double(){}
	fft_double(int n, int chce_dokladne)//n to maksymalna suma rozmiarow mnozonych wielomianow
	{
		n=potenga(n);
		dftn.resize(n+1, 0);
		dfts.resize(n+1, 0);
		
		pom.resize(n+1, 0);
		
		if (chce_dokladne)
		{
			a1.resize(n+1, 0);
			a2.resize(n+1, 0);
			b1.resize(n+1, 0);
			b2.resize(n+1, 0);
		}
		
		cosi.resize(n+1, 0);
		omega.resize(n+1, 0);
	}

	inline int potenga(int v)
	{
		for (int i=1; 1; i<<=1)
		{
			if (i>=v)
			{
				return i;
			}
		}
	}

	inline void dft(int n, int kier)
	{
		int n2=n-1;
		int s=0;
		int p;
		int g;

		for (int i=2; i<=n; i<<=1)
		{
			dftn.swap(dfts);

			p=n/i;

			if (kier)
			{
				g=0;
				for (int j=0; j<n; j++)
				{
					dftn[j]=dfts[(2*(j-s)+s)&n2]+omega[g]*dfts[(2*(j-s)+p+s)&n2];
					s++;
					if (s==p)
					{
						g=j+1;
						s=0;
					}
				}
			}
			else
			{
				g=n;
				for (int j=0; j<n; j++)
				{
					dftn[j]=dfts[(2*(j-s)+s)&n2]+omega[g]*dfts[(2*(j-s)+p+s)&n2];
					s++;
					if (s==p)
					{
						g=n-j-1;
						s=0;
					}
				}
			}
		}
	}

	void licz_omegi(int n1)
	{
		double kat=2.0*PI/n1;
		int n2=n1-1;
		int dod=3*n1/4;

		for (int i=0; i<=n1; i++)
			cosi[i]=cos(kat*i);
		for (int i=0; i<=n1; i++)
			omega[i]=complex <double> (cosi[i], cosi[(i+dod)&n2]);
	}

	vector <long long> fft(vector <long long> &jed, vector <long long> &dwa)
	{
		int n1=potenga(jed.size()+dwa.size());

		licz_omegi(n1);

		for (int i=0; i<jed.size(); i++)
			dftn[i]=jed[i];
		for (int i=jed.size(); i<n1; i++)
			dftn[i]=0;
		dft(n1, 1);
		for (int i=0; i<n1; i++)
			pom[i]=dftn[i];

		for (int i=0; i<dwa.size(); i++)
			dftn[i]=dwa[i];
		for (int i=dwa.size(); i<n1; i++)
			dftn[i]=0;
		dft(n1, 1);
		for (int i=0; i<n1; i++)
			dftn[i]*=pom[i];

		dft(n1, 0);

		vector <long long> ret;

		for (int i=0; i<n1; i++)
			ret.push_back(llround(dftn[i].real()/n1));
		return ret;
	}

	vector <long long> fft_dokladne(vector <long long> &jed, vector <long long> &dwa)
	{
		long long mod=1000000007;
		int n1=potenga(jed.size()+dwa.size());

		licz_omegi(n1);

		long long M=32000;

		for (int i=0; i<jed.size(); i++)
			dftn[i]=jed[i]/M;
		for (int i=jed.size(); i<n1; i++)
			dftn[i]=0;
		dft(n1, 1);
		for (int i=0; i<n1; i++)
			a1[i]=dftn[i];

		for (int i=0; i<jed.size(); i++)
			dftn[i]=jed[i]%M;
		for (int i=jed.size(); i<n1; i++)
			dftn[i]=0;
		dft(n1, 1);
		for (int i=0; i<n1; i++)
			b1[i]=dftn[i];

		for (int i=0; i<dwa.size(); i++)
			dftn[i]=dwa[i]/M;
		for (int i=dwa.size(); i<n1; i++)
			dftn[i]=0;
		dft(n1, 1);
		for (int i=0; i<n1; i++)
			a2[i]=dftn[i];

		for (int i=0; i<dwa.size(); i++)
			dftn[i]=dwa[i]%M;
		for (int i=dwa.size(); i<n1; i++)
			dftn[i]=0;
		dft(n1, 1);
		for (int i=0; i<n1; i++)
		b2[i]=dftn[i];

		vector <long long> ret;
		for (int i=0; i<n1; i++)
		ret.push_back(0);

		for (int i=0; i<n1; i++)
			dftn[i]=a1[i]*a2[i];
		dft(n1, 0);
		for (int i=0; i<n1; i++)
			ret[i]+=(llround(dftn[i].real()/n1)%mod)*M*M;

		for (int i=0; i<n1; i++)
			dftn[i]=a1[i]*b2[i]+b1[i]*a2[i];
		dft(n1, 0);
		for (int i=0; i<n1; i++)
			ret[i]+=llround(dftn[i].real()/n1)*M;

		for (int i=0; i<n1; i++)
			dftn[i]=b1[i]*b2[i];
		dft(n1, 0);
		for (int i=0; i<n1; i++)
			ret[i]+=llround(dftn[i].real()/n1);
			
		for (int i=0; i<n1; i++)
			ret[i]%=mod;

		return ret;
	}

};

int n, m, k;
 
int s;
 
long long mod=1000000007;
 
long long sil[1000007];
long long odw[1000007];
 
vector <long long> d1, d2, d3;
 
long long wyn;
 
long long dziel(long long a, long long b)
{
    long long wyk=mod-2;
    while(wyk)
    {
        if (wyk&1)
        {
            a*=b;
            a%=mod;
        }
        b*=b;
        b%=mod;
        wyk>>=1;
    }
    return a;
}
 
inline long long komb(int a, int b)
{
    if (b<0 || b>a)
        return 0;
    return (sil[a]*((odw[b]*odw[a-b])%mod))%mod;
}
 
inline long long komz(int a, int b)
{
    return komb(a+b-1, b);
}
 
int main()
{
    //n=300000;
    //m=300000;
    //k=300000;
    scanf("%d%d%d", &n, &m, &k);
    s=n+m+k;
    sil[0]=1;
    odw[0]=1;
    for (int i=1; i<=s; i++)
        sil[i]=(sil[i-1]*i)%mod;
    odw[s]=dziel(1, sil[s]);
    for (int i=s-1; i; i--)
        odw[i]=(odw[i+1]*(i+1))%mod;
    for (int i=0; i<=m; i++)
        d1.push_back((komz(n, i)*odw[n+i-1])%mod);
    for (int i=0; i<=k; i++)
        d2.push_back(odw[i]);
    fft_double janusz=fft_double(d1.size()+d2.size(), 1);
    d3=janusz.fft_dokladne(d1, d2);
    for (int i=0; i<=m+k; i++)
    {
        wyn*=3;
        wyn+=d3[i]*sil[n+i-1];
        wyn%=mod;
    }
    printf("%lld\n", wyn%mod);
    return 0;
}


Measured memory_bytes: 166636