A tree is an undirected connected graph without cycles. The distance between two vertices is the number of edges in a simple path between them.

Limak is a little polar bear. He lives in a tree that consists of n vertices, numbered 1 through n.

Limak recently learned how to jump. He can jump from a vertex to any vertex within distance at most k.

For a pair of vertices (s, t) we define f(s, t) as the minimum number of jumps Limak needs to get from s to t. Your task is to find the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.

Input

The first line of the input contains two integers n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ 5) — the number of vertices in the tree and the maximum allowed jump distance respectively.

The next n - 1 lines describe edges in the tree. The i-th of those lines contains two integers ai and bi (1 ≤ ai, bi ≤ n) — the indices on vertices connected with i-th edge.

It's guaranteed that the given edges form a tree.

Output

Print one integer, denoting the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.

Examples

Input

6 2
1 2
1 3
2 4
2 5
4 6


Output

20


Input

13 3
1 2
3 2
4 2
5 2
3 6
10 6
6 7
6 13
5 8
5 9
9 11
11 12


Output

114


Input

3 5
2 1
3 1


Output

3

Note

In the first sample, the given tree has 6 vertices and it's displayed on the drawing below. Limak can jump to any vertex within distance at most 2. For example, from the vertex 5 he can jump to any of vertices: 1, 2 and 4 (well, he can also jump to the vertex 5 itself).

<image>

There are <image> pairs of vertices (s, t) such that s < t. For 5 of those pairs Limak would need two jumps: (1, 6), (3, 4), (3, 5), (3, 6), (5, 6). For other 10 pairs one jump is enough. So, the answer is 5·2 + 10·1 = 20.

In the third sample, Limak can jump between every two vertices directly. There are 3 pairs of vertices (s < t), so the answer is 3·1 = 3.
import java.io.*;
import java.util.*;

public class J implements Runnable {

    private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer tok = new StringTokenizer("");

    private void init() throws FileNotFoundException {
        Locale.setDefault(Locale.US);
        String fileName = "";
        if (ONLINE_JUDGE && fileName.isEmpty()) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            if (fileName.isEmpty()) {
                in = new BufferedReader(new FileReader("input.txt"));
                out = new PrintWriter("output.txt");
            } else {
                in = new BufferedReader(new FileReader(fileName + ".in"));
                out = new PrintWriter(fileName + ".out");
            }
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());

        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = readInt();
        }
        return a;
    }

    public static void main(String[] args) {
        //new Thread(null, new _Solution(), "", 128 * (1L << 20)).start();
        new J().run();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    @Override
    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            init();
            solve();
            out.close();
            time();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    int[][] convert(List<Integer>[] graph) {
        int[][] res = new int[graph.length][];
        for (int i = 0; i < graph.length; i++) {
            res[i] = new int[graph[i].size()];
            for (int j = 0; j < res[i].length; j++) {
                res[i][j] = graph[i].get(j);
            }
        }
        return res;
    }

    int[][] graph;
    int n;
    int[] size;
    long answer = 0;

    void size(int x, int parent) {
        size[x] = 1;
        for (int y : graph[x]) {
            if (y == parent) continue;
            size(y, x);
            size[x] += size[y];
        }
    }

    int[] solve(int x, int parent, int k) {
        int[] result = new int[k];
        for (int y : graph[x]) {
            if (y == parent) continue;
            int[] cr = solve(y, x, k);
            int ckm1 = cr[k - 1];
            for (int i = 0; i < k; i++) {
                answer += cr[i];
            }
            for (int i = k - 1; i > 0; i--) {
                cr[i] = cr[i - 1];
            }
            cr[0] = ckm1;
            answer += (long) ckm1 * (n - size[y] - 1);
            for (int i = 0; i < k; i++) {
                for (int j = 0; j < k; j++) {
                    int target = i + j;
                    long add = target == 0 ? 0 : (target > k ? 2 : 1);
                    answer += add * result[i] * cr[j];
                }
            }
            for (int i = 0; i < k; i++) {
                result[i] += cr[i];
            }
        }
        result[0]++;
        return result;
    }

    void solve() throws IOException {
        n = readInt();
        int k = readInt();
        List<Integer>[] graph = new List[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }
        for (int i = 1; i < n; i++) {
            int a = readInt() - 1;
            int b = readInt() - 1;
            graph[a].add(b);
            graph[b].add(a);
        }
        this.graph = convert(graph);
        size(0, 0);
        solve(0, 0, k);
        out.println(answer);


    }

}