func_code_string: #include <bits/stdc++.h>   const long long INF = 0x3f3f3f3f3f3f3f3fLL;   const int inf = 0x3f3f3f3f;   const int mod = 998244353;   const double eps = 1e-6;   void err() { puts(  ); }   template <typename T, typename... Args>   void err(const T &arg, const Args &...args) {     std::cout << arg <<    ;     err(args...);   }   template <typename T>   void read(T &x) {     x = 0;     char ch = getchar();     long long f = 1;     while (!isdigit(ch)) {       if (ch ==  - ) f *= -1;       ch = getchar();     }     while (isdigit(ch)) {       x = x * 10 + ch - 48;       ch = getchar();     }     x *= f;   }   template <typename T, typename... Args>   void read(T &first, Args &...args) {     read(first);     read(args...);   }   using namespace std;   const int maxn = 710;   struct BigInteger {     static const int BASE = 100000000;     static const int WIDTH = 8;     bool sign;     size_t length;     std::vector<int> num;     BigInteger(long long x = 0) { *this = x; }     BigInteger(const std::string &x) { *this = x; }     BigInteger(const BigInteger &x) { *this = x; }     void cutLeadingZero() {       while (num.back() == 0 && num.size() != 1) {         num.pop_back();       }     }     void setLength() {       cutLeadingZero();       int tmp = num.back();       if (tmp == 0) {         length = 1;       } else {         length = (num.size() - 1) * WIDTH;         while (tmp > 0) {           ++length;           tmp /= 10;         }       }     }     BigInteger &operator=(long long x) {       num.clear();       if (x >= 0)         sign = true;       else {         sign = false;         x = -x;       }       do {         num.emplace_back(x % BASE);         x /= BASE;       } while (x > 0);       setLength();       return *this;     }     BigInteger &operator=(const std::string &str) {       num.clear();       sign = (str[0] !=  - );       int x, len = (str.size() - 1 - (!sign)) / WIDTH + 1;       for (int i = 0; i < len; i++) {         int End = str.length() - i * WIDTH;         int start = std::max((int)(!sign), End - WIDTH);         sscanf(str.substr(start, End - start).c_str(),  %d , &x);         num.push_back(x);       }       setLength();       return *this;     }     BigInteger &operator=(const BigInteger &tmp) {       num = tmp.num;       sign = tmp.sign;       length = tmp.length;       return *this;     }     size_t size() const { return length; }     BigInteger e(size_t n) const {       int tmp = n % WIDTH;       BigInteger ans;       ans.length = n + 1;       n /= WIDTH;       while (ans.num.size() <= n) ans.num.push_back(0);       ans.num[n] = 1;       while (tmp--) ans.num[n] *= 10;       return ans * (*this);     }     BigInteger abs() const {       BigInteger ans(*this);       ans.sign = true;       return ans;     }     const BigInteger &operator+() const { return *this; }     BigInteger operator+(const BigInteger &b) const {       if (!b.sign) {         return *this - (-b);       }       if (!sign) {         return b - (-*this);       }       BigInteger ans;       ans.num.clear();       for (int i = 0, g = 0;; i++) {         if (g == 0 && i >= num.size() && i >= b.num.size()) break;         int x = g;         if (i < num.size()) x += num[i];         if (i < b.num.size()) x += b.num[i];         ans.num.push_back(x % BASE);         g = x / BASE;       }       ans.setLength();       return ans;     }     BigInteger operator-() const {       BigInteger ans(*this);       if (ans != 0) ans.sign = !ans.sign;       return ans;     }     BigInteger operator-(const BigInteger &b) const {       if (!b.sign) {         return *this + (-b);       }       if (!sign) {         return -((-*this) + b);       }       if (*this < b) {         return -(b - *this);       }       BigInteger ans;       ans.num.clear();       for (int i = 0, g = 0;; i++) {         if (g == 0 && i >= num.size() && i >= b.num.size()) break;         int x = g;         g = 0;         if (i < num.size()) x += num[i];         if (i < b.num.size()) x -= b.num[i];         if (x < 0) {           x += BASE;           g = -1;         }         ans.num.push_back(x);       }       ans.setLength();       return ans;     }     BigInteger operator*(const BigInteger &b) const {       int lena = num.size(), lenb = b.num.size();       std::vector<long long> ansLL;       for (int i = 0; i < lena + lenb; i++) ansLL.push_back(0);       for (int i = 0; i < lena; i++) {         for (int j = 0; j < lenb; j++) {           ansLL[i + j] += (long long)num[i] * (long long)b.num[j];         }       }       while (ansLL.back() == 0 && ansLL.size() != 1) ansLL.pop_back();       int len = ansLL.size();       long long g = 0, tmp;       BigInteger ans;       ans.sign = (ansLL.size() == 1 && ansLL[0] == 0) || (sign == b.sign);       ans.num.clear();       for (int i = 0; i < len; i++) {         tmp = ansLL[i];         ans.num.emplace_back((tmp + g) % BASE);         g = (tmp + g) / BASE;       }       if (g > 0) ans.num.emplace_back(g);       ans.setLength();       return ans;     }     BigInteger operator/(const long long &b) const {       BigInteger c;       c.num.clear();       for (int i = 0; i < num.size(); i++) {         c.num.push_back(0);       }       long long g = 0;       for (int i = num.size() - 1; i >= 0; i--) {         c.num[i] = int((num[i] + g * BASE) / b);         g = num[i] + g * BASE - c.num[i] * b;       }       for (int i = num.size() - 1; c.num[i] == 0; i--) {         c.num.pop_back();       }       return c;     }     BigInteger operator/(const BigInteger &b) const {       BigInteger aa((*this).abs());       BigInteger bb(b.abs());       if (aa < bb) return 0;       char *str = new char[aa.size() + 1];       memset(str, 0, sizeof(char) * (aa.size() + 1));       BigInteger tmp;       int lena = aa.length, lenb = bb.length;       for (int i = 0; i <= lena - lenb; i++) {         tmp = bb.e(lena - lenb - i);         while (aa >= tmp) {           ++str[i];           aa = aa - tmp;         }         str[i] +=  0 ;       }       BigInteger ans(str);       delete[] str;       ans.sign = (ans == 0 || sign == b.sign);       return ans;     }     BigInteger operator%(const long long &b) const {       long long ans = 0;       for (int i = num.size() - 1; i >= 0; i--) ans = (ans * BASE + num[i]) % b;       return ans;     }     BigInteger operator%(const BigInteger &b) const {       return *this - *this / b * b;     }     BigInteger &operator++() {       *this = *this + 1;       return *this;     }     BigInteger &operator--() {       *this = *this - 1;       return *this;     }     BigInteger &operator+=(const BigInteger &b) {       *this = *this + b;       return *this;     }     BigInteger &operator-=(const BigInteger &b) {       *this = *this - b;       return *this;     }     BigInteger &operator*=(const BigInteger &b) {       *this = *this * b;       return *this;     }     BigInteger &operator/=(const long long &b) {       *this = *this / b;       return *this;     }     BigInteger &operator/=(const BigInteger &b) {       *this = *this / b;       return *this;     }     BigInteger &operator%=(const long long &b) {       *this = *this % b;       return *this;     }     BigInteger &operator%=(const BigInteger &b) {       *this = *this % b;       return *this;     }     bool operator<(const BigInteger &b) const {       if (sign && !b.sign) {         return false;       } else if (!sign && b.sign) {         return true;       } else if (!sign && !b.sign) {         return -b < -*this;       }       if (num.size() != b.num.size()) return num.size() < b.num.size();       for (int i = num.size() - 1; i >= 0; i--)         if (num[i] != b.num[i]) return num[i] < b.num[i];       return false;     }     bool operator>(const BigInteger &b) const { return b < *this; }     bool operator<=(const BigInteger &b) const { return !(b < *this); }     bool operator>=(const BigInteger &b) const { return !(*this < b); }     bool operator!=(const BigInteger &b) const { return b < *this || *this < b; }     bool operator==(const BigInteger &b) const {       return !(b < *this) && !(*this < b);     }     bool operator||(const BigInteger &b) const { return *this != 0 || b != 0; }     bool operator&&(const BigInteger &b) const { return *this != 0 && b != 0; }     bool operator!() { return (bool)(*this == 0); }     friend std::ostream &operator<<(std::ostream &out, const BigInteger &x) {       if (!x.sign) out <<  - ;       out << x.num.back();       for (int i = x.num.size() - 2; i >= 0; i--) {         char buf[10];         sprintf(buf,  %08d , x.num[i]);         for (int j = 0; j < strlen(buf); j++) out << buf[j];       }       return out;     }     friend std::istream &operator>>(std::istream &in, BigInteger &x) {       std::string str;       in >> str;       size_t len = str.size();       int start = 0;       if (str[0] ==  - ) start = 1;       if (str[start] ==   0 ) return in;       for (int i = start; i < len; i++) {         if (str[i] <  0  || str[i] >  9 ) return in;       }       x.sign = !start;       x = str.c_str();       return in;     }     BigInteger pow(int n) {       BigInteger ans = 1, base = *this;       while (n) {         if (n & 1) ans = ans * base;         base = base * base;         n >>= 1;       }       return ans;     }   } dp[maxn][maxn], cur[maxn];   struct EDGE {     int next, to;   } edge[maxn << 1];   int head[maxn], tot;   inline void addedge(int u, int v) {     edge[tot] = {head[u], v};     head[u] = tot++;   }   int sz[maxn];   void dfs(int u, int pre) {     sz[u] = 1;     dp[u][1] = 1;     for (int i = head[u]; ~i; i = edge[i].next) {       int v = edge[i].to;       if (v == pre) continue;       dfs(v, u);       for (int j = 1; j <= sz[u]; ++j) cur[j] = dp[u][j];       for (int j = 1; j <= sz[u]; ++j) {         for (int k = 1; k <= sz[v]; ++k) {           dp[u][j + k] = max(dp[u][j + k], cur[j] / j * dp[v][k] / k * (j + k));           dp[u][j] = max(dp[u][j], cur[j] * dp[v][k]);         }       }       sz[u] += sz[v];     }   }   int main() {     memset(head, -1, sizeof head);     int n;     read(n);     for (int i = 1; i < n; ++i) {       int u, v;       read(u, v);       addedge(u, v);       addedge(v, u);     }     dfs(1, 0);     BigInteger ans = 0;     for (int i = 1; i <= sz[1]; ++i) ans = max(ans, dp[1][i]);     cout << ans << endl;   }   