#include<fstream>
#include<vector>
using namespace std;

ifstream fin("arbore4.in");
ofstream fout("arbore4.out");

#define nmax 100010
#define mod 666013


vector<vector<int> > G;

void Read();
void Solve();
void Df(int x);
void Bf1(int x);
long long Comb(int n1, int k);
long long Putere(long long a, int b);

int n;
int nrn[nmax];
long long fact[nmax], invmod[nmax], sol[nmax];   //fact 
bool s[nmax];
vector<vector<int> > F;

int main()
{
    Read();
    Solve();
    
    fin.close();
    fout.close();
    
    return 0;
}

void Read()
{
    fin >> n;
    G.resize(n+10);
    F.resize(n+10);
    
    int a, b;
    for( int i = 1; i <= n; ++i )
    {
        fin >> a >> b;
        G[a].push_back(b);
        G[b].push_back(a);
    }
}

void Solve()
{
    Df(1);
    fact[0] = 1;
    invmod[0] = 1;
    for( int i = 1; i <= n; ++i )
    {
         fact[i] = (fact[i-1] * i)%mod;
         invmod[i] = Putere(fact[i], mod-2);
    } 
                     
    Bf1(1);
   
    fout << sol[1] << '\n';
}

void Df( int x )
{
    nrn[x] = 1;
    s[x] = true;
    
    for( int i = 0; i < G[x].size(); ++i )
        if( !s[G[x][i]] )
        {  
            Df( G[x][i] );
            F[x].push_back(G[x][i]);
            nrn[x] += nrn[ G[x][i] ];
        }
}

void Bf1( int x )
{
     sol[x] = 1;
     int ramase = nrn[x] - 1;
     for( int i = 0; i < F[x].size(); ++i )
     {
          int fiu = F[x][i];
          Bf1( fiu );
          sol[x] = (((sol[x] * sol[fiu]) % mod) * Comb(ramase, nrn[fiu])) % mod; 
          ramase = ramase - nrn[fiu];
     }
}

long long Putere( long long a, int b )
{
    if( b == 0 )
        return 1;
    
    if( b % 2 == 0 )
        return Putere ( (a * a )%mod, b/2 )%mod;
    else
        return  (a * Putere( (a*a)%mod, b/2 ))%mod;
} 

long long Comb(int n1, int k)
{
     return (((fact[n1] * invmod[k])%mod) * invmod[n1 - k]) % mod;
     //return (fact[n1]/((fact[k] * fact[n1-k] )%mod))%mod;
}