#include<cstdio>

 #include<cctype>

 #include<vector>

 inline int getint() {

     register char ch;

     while(!isdigit(ch=getchar()));

     register int x=ch^'';

     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');

     return x;

 }

 const int N=;

 std::vector<int> e[N];

 inline void add_edge(const int &u,const int &v) {

     e[u].push_back(v);

     e[v].push_back(u);

 }

 class SegmentTree {

     #define _left <<1

     #define _right <<1|1

     private:

         int max[N<<],tag[N<<];

         void push_down(const int &p) {

             max[p _left]+=tag[p];

             max[p _right]+=tag[p];

             tag[p _left]+=tag[p];

             tag[p _right]+=tag[p];

             tag[p]=;

         }

         void push_up(const int &p) {

             max[p]=std::max(max[p _left],max[p _right]);

         }

     public:

         void modify(const int &p,const int &b,const int &e,const int &l,const int &r) {

             if(b==l&&e==r) {

                 max[p]++;

                 tag[p]++;

                 return;

             }

             push_down(p);

             const int mid=(b+e)>>;

             if(l<=mid) modify(p _left,b,mid,l,std::min(mid,r));

             if(r>mid) modify(p _right,mid+,e,std::max(mid+,l),r);

             push_up(p);

         }

         int query() const {

             return max[];

         }

     #undef _left

     #undef _right

 };

 SegmentTree t;

 int n,par[N],dep[N],top[N],low[N],size[N],son[N],id[N];

 void dfs1(const int &x,const int &par) {

     ::par[x]=par;

     dep[x]=dep[par]+;

     size[x]=;

     for(unsigned i=;i<e[x].size();i++) {

         const int &y=e[x][i];

         if(y==par) continue;

         dfs1(y,x);

         size[x]+=size[y];

         if(size[y]>size[son[x]]) son[x]=y;

     }

 }

 void dfs2(const int &x) {

     id[x]=++id[];

     if(x==son[par[x]]) {

         top[x]=top[par[x]];

     } else {

         top[x]=x;

     }

     if(son[x]) dfs2(son[x]);

     for(unsigned i=;i<e[x].size();i++) {

         const int &y=e[x][i];

         if(y==par[x]||y==son[x]) continue;

         dfs2(y);

     }

 }

 inline void modify(int u,int v) {

     while(top[u]!=top[v]) {

         if(dep[top[u]]<dep[top[v]]) std::swap(u,v);

         t.modify(,,n,id[top[u]],id[u]);

         u=par[top[u]];

     }

     if(dep[u]<dep[v]) std::swap(u,v);

     t.modify(,,n,id[v],id[u]);

 }

 int main() {

     n=getint();

     const int m=getint();

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

         add_edge(getint(),getint());

     }

     dfs1(,);

     dfs2();

     for(register int i=;i<m;i++) {

         const int s=getint(),t=getint();

         modify(s,t);

     }

     printf("%d\n",t.query());

     return ;

 }