// luogu-judger-enable-o2

// luogu-judger-enable-o2

#include<cstdio>

#include<iostream>

#include<cctype>

#include<cstring>

#include<cstdlib>

#include<algorithm>

#define maxl 120

#define maxn 702

#define check(x) if(x==0)    x=++tot;

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

struct BigInteger{

    int s[maxl],len;

    BigInteger(){len=;memset(s,,sizeof(s));}

    BigInteger operator =(const char *c){

        len=;

        for(int i=strlen(c+);i;--i)    s[++len]=c[i]-'';

        return *this;

    }

    BigInteger operator =(const int num){

        char c[maxl];

        sprintf(c+,"%d",num);

        (*this)=c;

        return *this;

    }

    BigInteger operator *(BigInteger a){

        BigInteger ans;

        ans.len=len+a.len;

        for(int i=;i<=len;++i)

            for(register int j=;j<=a.len;++j)

                ans.s[i+j-]+=s[i]*a.s[j];

        int g=;

        for(int i=;i<=(len+a.len)||g;++i){

            ans.s[i]+=g;

            g=ans.s[i]/;

            ans.s[i]%=;

            if(ans.len<i)    ans.len=i;

        }

        while(ans.len&&ans.s[ans.len]==)    ans.len--;

        return ans;

    }

    BigInteger operator *(const int a){

        BigInteger ans=(*this);

        int g=,lim=ans.len;

        for(int i=;(i<=lim)||g;++i){

            ans.s[i]=ans.s[i]*a+g;

            g=ans.s[i]/;

            ans.s[i]%=;

            if(i>ans.len)    ans.len=i;

        }

        while(ans.len&&ans.s[ans.len]==)    ans.len--;

        return ans;

    }

    bool operator <(const BigInteger a)const{

        if(len!=a.len)    return len<a.len;

        for(int i=len;i;--i)

            if(s[i]!=a.s[i])    return s[i]<a.s[i];

        return ;

    }

};

inline void print(BigInteger a){

    if(a.len==)    putchar('');

    for(int i=a.len;i;--i)    putchar(a.s[i]+'');

}

BigInteger f[maxn*];

int tot;

int size[maxn];

int pos[maxn][maxn];

BigInteger ans;

struct Edge{

    int next,to;

}edge[maxn*];

int head[maxn],num;

inline void add(int from,int to){

    edge[++num]=(Edge){head[from],to};

    head[from]=num;

}

void dfs(int x,int fa){

    check(pos[x][]);    check(pos[x][]);

    f[pos[x][]]=;f[pos[x][]]=;    size[x]=;

    for(int i=head[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(to==fa)    continue;

        dfs(to,x);

        size[x]+=size[to];

        for(int j=size[x];j>=;--j){

            check(pos[x][j]);

            for(int k=min(j,size[x]-size[to]);k>=min(,size[x]-size[to]);--k)

                if(f[pos[x][j]]<f[pos[to][j-k]]*f[pos[x][k]]){

                    f[pos[x][j]]=f[pos[to][j-k]]*f[pos[x][k]];

                }

        }

    }

    for(int j=;j<=size[x];++j){

        if(f[pos[x][]]<f[pos[x][j]]*j){

            f[pos[x][]]=f[pos[x][j]]*j;

            if(ans<f[pos[x][]])    ans=f[pos[x][]];

        }

    }

}

int main(){

    int n=read();

    for(int i=;i<n;++i){

        int x=read(),y=read();

        add(x,y);

        add(y,x);

    }

    dfs(,);

    print(ans);

}