#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

#include <bits/stdc++.h>
using namespace std;

const int M = 5e5 + 5;

int n, m, ans;

int rt, tot, fa[M], son[M][2], cnt[M], sz[M], val[M];
unsigned int a[M], b[M], A[M], B[M];

void clear(int x) {
    fa[x] = son[x][0] = son[x][1] = cnt[x] = sz[x] = val[x] = 0;
}

void pushup(int x) {
    sz[x] = sz[son[x][0]] + sz[son[x][1]] + cnt[x];
    a[x] = a[son[x][0]] + a[son[x][1]] + A[x];
    b[x] = b[son[x][0]] + b[son[x][1]] + B[x];
}

bool get(int x) {
    return x == son[fa[x]][1];
}

void rotate(int x) {
    int y = fa[x];
    int z = fa[y];
    bool c = get(x);
    son[y][c] = son[x][c ^ 1];
    if (son[x][c ^ 1]) {
        fa[son[x][c ^ 1]] = y;
    }
    son[x][c ^ 1] = y;
    fa[y] = x;
    fa[x] = z;
    if (z) {
        son[z][y == son[z][1]] = x;
    }
    pushup(y);
}

void splay(int x, int t) {
    for (int f = fa[x]; f != t; rotate(x), f = fa[x]) {
        if (fa[f] != t) {
            rotate(get(f) == get(x) ? f : x);
        }
    }
    if (t == 0) {
    	rt = x;
    }
    pushup(x);
}

void insert(int k, unsigned int v) {
    if (!rt) {
        val[++tot] = k;
        A[tot] = v;
        B[tot] += (unsigned)k * v;
        cnt[tot]++;
        rt = tot;
        pushup(rt);
        return;
    }
    int cur = rt, f = 0;
    while (1) {
        if (val[cur] == k) {
            cnt[cur]++;
            A[cur] += v;
            B[cur] += (unsigned)k * v;
            pushup(cur);
            pushup(f);
            splay(cur, 0);
            break;
        }
        f = cur;
        cur = son[cur][k > val[cur]];
        if (!cur) {
            val[++tot] = k;
            cnt[tot]++;
            A[tot] = v;
            B[tot] = (unsigned)k * v;
            fa[tot] = f;
            son[f][k > val[f]] = tot;
            pushup(tot);
            pushup(f);
            splay(tot, 0);
            break;
        }
    }
}

int find(int k) {
    int cur = rt;
    while (cur) {
        if (k == val[cur]) {
        	return cur;
        } else if (k < val[cur]) {
        	cur = son[cur][0];
        } else {
        	cur = son[cur][1];
        }
    }
    return cur;
}

signed main() {
	ios::sync_with_stdio(0); cin.tie(0);
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		int l, r;
		cin >> l >> r;
		l = (l + ans) & (1 << m) - 1;
		r = (r + ans) & (1 << m) - 1;
		if (l > r) {
			swap(l, r);
		}
		insert(l, i);
		if (r + 1 < 1 << m) {
			insert(r + 1, 0u - (unsigned)i);
		}
        int u = find(l), v = find(r + 1);
        splay(v, 0);
        splay(u, v);
        ans += (a[u] - a[son[u][0]]) * (unsigned)(r + 1) - (b[u] - b[son[u][0]]) + a[son[u][0]] * (unsigned)(r - l + 1);
	}
	cout << (ans & (1 << 30) - 1) << '\n';

	return 0;
}