#include <bits/stdc++.h>

#define ndl '\n'
#define ll long long
#define INF 1000000007
#define st first
#define nd second
#define debug(x) cout << #x << ": " << x << ndl
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define lb lower_bound
#define ub upper_bound
#define all(x) (x).begin(), (x).end()

using namespace std;

inline void dfs_fill_depths_and_subtree_sizes(int v, vector<vector<int>> &jump_table, vector<int> &subtree_size, vector<int> &depth, const vector<vector<int>> &G){
    subtree_size[v] = 1;
    for(auto x:G[v]){
        if(x==jump_table[v][0]) continue;
        jump_table[x][0] = v;
        depth[x] = depth[v] + 1;
        dfs_fill_depths_and_subtree_sizes(x, jump_table, subtree_size, depth, G);
        subtree_size[v] += subtree_size[x];
    }
}

inline void fill_jump_table(vector<vector<int>> &jump_table){
    for(int j=1;j<jump_table[0].size();j++)
        for(int i=2;i<jump_table.size();i++)
            jump_table[i][j] = jump_table[jump_table[i][j-1]][j-1];
}

int find_lca(const vector<vector<int>> &jump_table, const vector<int> &depth, int a, int b){
    if(depth[a] < depth[b]) swap(a, b);
    int depth_diff = depth[a] - depth[b];
    for(int i=0;(1<<i)<=depth_diff;i++)
        if((1<<i)&depth_diff)
            a = jump_table[a][i];
    if(a == b) return a;
    for(int i=jump_table[0].size()-1;i>=0;i--)
        while(jump_table[a][i] != jump_table[b][i]) {
            a = jump_table[a][i];
            b = jump_table[b][i];
        }
    return jump_table[a][0];
}

vector<ll> find_subtree_sizes_for_cycle(int a, int b, const int lca, const vector<vector<int>> &jump_table,
                                        const vector<int> &subtree_size, const vector<int> &depth, const vector<vector<int>> &G){
    vector<int> cycle_indices;
    vector<ll> cycle_subtrees;
    if(depth[a] < depth[b]) swap(a, b);
    while(a != lca){
        cycle_indices.push_back(a);
        a = jump_table[a][0];
    }
    cycle_indices.push_back(lca);
    int a_side_size = cycle_indices.size();
    while(b != lca){
        cycle_indices.push_back(b);
        b = jump_table[b][0];
    }
    reverse(cycle_indices.begin() + a_side_size, cycle_indices.end());
    cycle_subtrees.assign(cycle_indices.size(), 0);
    for(int i=0;i<cycle_indices.size();i++){
        int lower = (i != 0 ? cycle_indices[i-1] : -1), upper = (i != cycle_indices.size()-1 ? cycle_indices[i+1] : -1);
        cycle_subtrees[i] = 1;
        if(cycle_indices[i] == lca)
            cycle_subtrees[i] += subtree_size[1] - subtree_size[cycle_indices[i]];
        for(auto x: G[cycle_indices[i]])
            if(x != upper && x != lower && x != jump_table[cycle_indices[i]][0])
                cycle_subtrees[i] += subtree_size[x];
    }

    return cycle_subtrees;
}

int main(){
    ios_base::sync_with_stdio(0); cin.tie(0);
    int n, q; cin>>n>>q;
    vector<vector<int>> G(n+1);
    for(int i=0;i<n-1;i++){
        int x, y; cin>>x>>y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    vector<int> depth(n+1), subtree_size(n+1);
    vector<vector<int>> jump_table(n+1, vector<int>(log2(n)+1));

    dfs_fill_depths_and_subtree_sizes(1, jump_table, subtree_size, depth, G);
    fill_jump_table(jump_table);

    while(q--){
        int x, y, lca; cin>>x>>y; lca = find_lca(jump_table, depth, x, y);
        vector<ll> subtree_cycle = find_subtree_sizes_for_cycle(x, y, lca, jump_table, subtree_size, depth, G);
        ll left_sum = 0, ans = 0;
        int cycle_half_len = (subtree_cycle.size()-1)/2;
        for(int i=0;i<cycle_half_len;i++) left_sum += subtree_cycle[i];
        for(int i=0;cycle_half_len-1-i>=0;i++){
            ans += left_sum * subtree_cycle[subtree_cycle.size()-1-i];
            left_sum -= subtree_cycle[cycle_half_len-1-i];
        }
        cout<<ans<<'\n';
    }
    
}