#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

void insert(pnode &root, pnode &t) {
    if(root == NULL) {
        root = t;
        //update(root);
        return;
    }
    if(root->prior > t->prior) {
        if(t->key < root->key)
            insert(root->left, t);
        else
            insert(root->right, t);
        update(root);
        return;
    }
    pair<pnode, pnode> temp = split(root, t->key);
    t->left = temp.first;
    t->right = temp.second;
    root = t;
    update(root);
}

void addnode(pnode &root, int key) {
    pnode t = new node(key);
    insert(root, t);
}

/*
//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}
*/

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

void erase(pnode &root, int k) {
    if(root == NULL) return;
    else if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
    update(root);
}

/*

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}
*/

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) addnode(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) addnode(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  srand(clock());

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

///////////////////////////////////////////////////////

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

/*
pnode erase(pnode root, int k) {
    if(root == NULL) return root;
    else if(k < root->key) root->left = erase(root->left, k);
    else if(k > root->key) root->right = erase(root->right, k);
    else root = merge(root->left, root->right);
}
*/

//��������� �������� � ������ �
void erase(pnode &root, int k) {

	if (root->key == k)
		root = merge(root->left, root->right);
	else if(k < root->key) erase(root->left, k);
	else erase(root->right, k);

	return;

/*
    if(root == NULL) return;
    if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
return;
*/

/*
    pnode v = root;
    while(v != NULL && v->key != k) {
        if(k < v->key) v = v->left;
        else v = v->right;
    }
    if(v != NULL) v = merge(v->left, v->right);
return;
*/

    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) insert(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) insert(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);
/*
    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, R, a[L], 1);
*/

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);
/*
  int t1,t2,t3;

  t2 = clock();
  for(int i = 1; i <= 2000000; i++) insert(T[0], i);

  t3 = clock();

  cout<<t2-t1<<endl<<t3-t2<<endl;

  return 0;
*/
  int xx, yy, m, res, oldxx, oldyy;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    /*
    oldxx = a[xx]; oldyy = a[yy];
    res += changepoint(xx,oldyy);
    res += changepoint(yy, oldxx);
    */
    printf("%d\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

///////////////////////////////////////////////////////

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

/*
pnode erase(pnode root, int k) {
    if(root == NULL) return root;
    else if(k < root->key) root->left = erase(root->left, k);
    else if(k > root->key) root->right = erase(root->right, k);
    else root = merge(root->left, root->right);
}
*/

//��������� �������� � ������ �
void erase(pnode &root, int k) {
/*
	if (root->key == k)
		root = merge(root->left, root->right);
	else if(k < root->key) erase(root->left, k);
	else erase(root->right, k);

	return;
*/

/*
    if(root == NULL) return;
    if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
return;
*/

/*
    pnode v = root;
    while(v != NULL && v->key != k) {
        if(k < v->key) v = v->left;
        else v = v->right;
    }
    if(v != NULL) v = merge(v->left, v->right);
return;
*/

    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    //dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) insert(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) insert(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);
/*
    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, R, a[L], 1);
*/

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);
/*
  int t1,t2,t3;

  t2 = clock();
  for(int i = 1; i <= 2000000; i++) insert(T[0], i);

  t3 = clock();

  cout<<t2-t1<<endl<<t3-t2<<endl;

  return 0;
*/
  int xx, yy, m, res, oldxx, oldyy;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    /*
    oldxx = a[xx]; oldyy = a[yy];
    res += changepoint(xx,oldyy);
    res += changepoint(yy, oldxx);
    */
    printf("%d\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define DIM 200007
#define MAXNUMBER 200003

#define NUMBLOCK 507

#define BSIZE 4000

using namespace std;

int a[DIM];
int n;
int F[NUMBLOCK][MAXNUMBER+7];
int bs[NUMBLOCK];

int sumprefix(int bnum, int y) {
    y++;
    int res = 0;
    for(int i = y; i > 0; i -= i & -i)
        res += F[bnum][i];
    return res;
}

void add(int bnum, int y, int delta) {
    y++;
    for(int i = y; i <= MAXNUMBER; i += i & -i)
        F[bnum][i] += delta;
}

void changevalue(int pos, int newval) {
    add(pos/BSIZE, a[pos], -1);
    add(pos/BSIZE, newval, 1);
    a[pos] = newval;
}

int query(int x1, int x2, int yy) {

    if(x1 > x2) return 0;

    int b1,b2,res = 0;
    b1 = x1 / BSIZE;
    b2 = x2 / BSIZE;

    if(b1 == b2) {
        for(int j = x1; j <= x2; j++)
            if(a[j] < yy) res++;
    } else {
        for(int j = x1; j < (b1+1)*BSIZE; j++)
            if(a[j] < yy) res++;

        for(int j = b1+1; j <= b2-1; j++)
            res += sumprefix(j, yy-1);

        for(int j = (b2*BSIZE); j <= x2; j++)
            if(a[j] < yy) res++;

    }
    return res;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(L+1, R-1, a[L]);
    t2 = R-L-1 - t1;

    t4 = query(L+1, R-1, a[R]);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    changevalue(L, oldr);
    changevalue(R, oldl);
    //swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  for(int i = 1; i <= n; i++) {
    add(i / BSIZE, a[i], 1);
    bs[i/BSIZE]++;
  }

  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

const long long DIM = 1<<18;

int a[DIM];
my_super_set T[2*DIM];
int n,shift;

void buildtree() {
    shift = 1;
    while(shift < n) shift *= 2;
    shift--;
    for(int i = 1; i <= n; i++) T[shift+i].insert({a[i],i});
    for(int i = shift; i >= 1; i--) {
        for(auto t : T[2*i]) T[i].insert(t);
        for(auto t : T[2*i+1]) T[i].insert(t);
    }
}

void addpoint(int pos, int val, int type) {
    int v = shift + pos;
    while(v != 0) {
        if(type == 1) T[v].insert({val,pos});
        else T[v].erase({val,pos});
        v /= 2;
    }
}

void printset(my_super_set s) {
    for(auto p : s) cout<<p.first<<' ';
    cout<<endl;
}

int query(int L, int R, int x) {
    L += shift;
    R += shift;
    int res = 0;
    while(L<=R) {
        /*
        printset(T[L]);
        printset(T[R]);
        cout<<endl;
        */
        if(L%2 == 1) res += T[L].order_of_key({x,0});
        if(R%2 == 0) res += T[R].order_of_key({x,0});
        L = (L+1) / 2;
        R = (R-1) / 2;
    }
    return res;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(L+1, R-1, a[L]);
    t2 = R-L-1 - t1;

    t4 = query(L+1, R-1, a[R]);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(L, a[L], 2);
    addpoint(R, a[R], 2);
    addpoint(L, a[R], 1);
    addpoint(R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree();
  //for(int i = 1; i <= shift+n; i++) printset(T[i]);
  //cout<<endl;
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

///////////////////////////////////////////////////////

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

/*
pnode erase(pnode root, int k) {
    if(root == NULL) return root;
    else if(k < root->key) root->left = erase(root->left, k);
    else if(k > root->key) root->right = erase(root->right, k);
    else root = merge(root->left, root->right);
}
*/

//��������� �������� � ������ �
void erase(pnode &root, int k) {

	if (root->key == k)
		root = merge(root->left, root->right);
	else if(k < root->key) erase(root->left, k);
	else erase(root->right, k);

	return;

/*
    if(root == NULL) return;
    if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
return;
*/

/*
    pnode v = root;
    while(v != NULL && v->key != k) {
        if(k < v->key) v = v->left;
        else v = v->right;
    }
    if(v != NULL) v = merge(v->left, v->right);
return;
*/

    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) insert(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) insert(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);
/*
    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, R, a[L], 1);
*/

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);
/*
  int t1,t2,t3;

  t2 = clock();
  for(int i = 1; i <= 2000000; i++) insert(T[0], i);

  t3 = clock();

  cout<<t2-t1<<endl<<t3-t2<<endl;

  return 0;
*/
  int xx, yy, m, res, oldxx, oldyy;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    /*
    oldxx = a[xx]; oldyy = a[yy];
    res += changepoint(xx,oldyy);
    res += changepoint(yy, oldxx);
    */
    //printf("%d\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

void insert(pnode &root, pnode &t) {
    if(root == NULL) {
        root = t;
        update(root);
        return;
    }
    if(root->prior > t->prior) {
        if(t->key < root->key)
            insert(root->left, t);
        else
            insert(root->right, t);
        update(root);
        return;
    }
    pair<pnode, pnode> temp = split(root, t->key);
    t->left = temp.first;
    t->right = temp.second;
    root = t;
    update(root);
}

void addnode(pnode &root, int key) {
    pnode t = new node(key);
    insert(root, t);
}

/*
//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}
*/

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

void erase(pnode &root, int k) {
    if(root == NULL) return;
    else if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
    update(root);
}

/*

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}
*/

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) addnode(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) addnode(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  srand(clock());

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

const long long DIM = 1<<18;

int a[DIM];
my_super_set T[2*DIM];
int n,shift;

void buildtree(int v, int tl, int tr) {
    shift = 1;
    while(shift < n) shift *= 2;
    shift--;
    for(int i = 1; i <= n; i++) T[shift+i].insert({a[i],i});
    for(int i = shift; i >= 1; i--) {
        for(auto t : T[2*v]) T[v].insert(t);
        for(auto t : T[2*v+1]) T[v].insert(t);
    }
}

void addpoint(int pos, int val, int type) {
    int v = shift + pos;
    while(v != 0) {
        if(type == 1) T[v].insert({val,pos});
        else T[v].erase({val,pos});
        v /= 2;
    }
}

int query(int L, int R, int x) {
    L += shift;
    R += shift;
    int res = 0;
    while(L<=R) {
        if(L%2 == 1) res += T[L].order_of_key({x,0});
        if(R%2 == 0) res += T[R].order_of_key({x,0});
        L = (L+1) / 2;
        R = (R-1) / 2;
    }
    return res;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(L+1, R-1, a[L]);
    t2 = R-L-1 - t1;

    t4 = query(L+1, R-1, a[R]);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(L, a[L], 2);
    addpoint(R, a[R], 2);
    addpoint(L, a[R], 1);
    addpoint(R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

///////////////////////////////////////////////////////

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    if(root == NULL) return;
    if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
return;
/*
    pnode v = root;
    while(v != NULL && v->key != k) {
        if(k < v->key) v = v->left;
        else v = v->right;
    }
    if(v != NULL) v = merge(v->left, v->right);
return;

    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �
*/
}

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) insert(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) insert(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);
/*
    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, R, a[L], 1);
*/

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);
/*
  int t1,t2,t3;

  t2 = clock();
  for(int i = 1; i <= 2000000; i++) insert(T[0], i);

  t3 = clock();

  cout<<t2-t1<<endl<<t3-t2<<endl;

  return 0;
*/
  int xx, yy, m, res, oldxx, oldyy;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    /*
    oldxx = a[xx]; oldyy = a[yy];
    res += changepoint(xx,oldyy);
    res += changepoint(yy, oldxx);
    */
    printf("%d\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

///////////////////////////////////////////////////////

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �
}

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) insert(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) insert(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);
/*
    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, R, a[L], 1);
*/

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);
/*
  int t1,t2,t3;

  t2 = clock();
  for(int i = 1; i <= 2000000; i++) insert(T[0], i);

  t3 = clock();

  cout<<t2-t1<<endl<<t3-t2<<endl;

  return 0;
*/
  int xx, yy, m, res, oldxx, oldyy;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    /*
    oldxx = a[xx]; oldyy = a[yy];
    res += changepoint(xx,oldyy);
    res += changepoint(yy, oldxx);
    */
    printf("%d\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define DIM 200007
#define MAXNUMBER 200003

#define NUMBLOCK 507

#define BSIZE 3000

using namespace std;

int a[DIM];
int n;
int F[NUMBLOCK][MAXNUMBER+7];
int bs[NUMBLOCK];

int sumprefix(int bnum, int y) {
    y++;
    int res = 0;
    for(int i = y; i > 0; i -= i & -i)
        res += F[bnum][i];
    return res;
}

void add(int bnum, int y, int delta) {
    y++;
    for(int i = y; i <= MAXNUMBER; i += i & -i)
        F[bnum][i] += delta;
}

void changevalue(int pos, int newval) {
    add(pos/BSIZE, a[pos], -1);
    add(pos/BSIZE, newval, 1);
    a[pos] = newval;
}

int query(int x1, int x2, int yy) {

    if(x1 > x2) return 0;

    int b1,b2,res = 0;
    b1 = x1 / BSIZE;
    b2 = x2 / BSIZE;

    if(b1 == b2) {
        for(int j = x1; j <= x2; j++)
            if(a[j] < yy) res++;
    } else {
        for(int j = x1; j < (b1+1)*BSIZE; j++)
            if(a[j] < yy) res++;

        for(int j = b1+1; j <= b2-1; j++)
            res += sumprefix(j, yy-1);

        for(int j = (b2*BSIZE); j <= x2; j++)
            if(a[j] < yy) res++;

    }
    return res;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(L+1, R-1, a[L]);
    t2 = R-L-1 - t1;

    t4 = query(L+1, R-1, a[R]);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    changevalue(L, oldr);
    changevalue(R, oldl);
    //swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  for(int i = 1; i <= n; i++) {
    add(i / BSIZE, a[i], 1);
    bs[i/BSIZE]++;
  }

  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

void insert(pnode &root, pnode &t) {
    if(root == NULL) {
        root = t;
        update(root);
        return;
    }
    if(root->prior > t->prior) {
        if(t->key < root->key)
            insert(root->left, t);
        else
            insert(root->right, t);
        //update(root);
        return;
    }
    pair<pnode, pnode> temp = split(root, t->key);
    t->left = temp.first;
    t->right = temp.second;
    root = t;
    update(root);
}

void addnode(pnode &root, int key) {
    pnode t = new node(key);
    insert(root, t);
}

/*
//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}
*/

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

void erase(pnode &root, int k) {
    if(root == NULL) return;
    else if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
    update(root);
}

/*

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}
*/

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) addnode(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) addnode(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  srand(clock());

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

///////////////////////////////////////////////////////

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

/*
pnode erase(pnode root, int k) {
    if(root == NULL) return root;
    else if(k < root->key) root->left = erase(root->left, k);
    else if(k > root->key) root->right = erase(root->right, k);
    else root = merge(root->left, root->right);
}
*/

//��������� �������� � ������ �
void erase(pnode &root, int k) {
/*
	if (root->key == k)
		root = merge(root->left, root->right);
	else if(k < root->key) erase(root->left, k);
	else erase(root->right, k);

	return;
*/

/*
    if(root == NULL) return;
    if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
return;
*/

/*
    pnode v = root;
    while(v != NULL && v->key != k) {
        if(k < v->key) v = v->left;
        else v = v->right;
    }
    if(v != NULL) v = merge(v->left, v->right);
return;
*/

    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) insert(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) insert(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);
/*
    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, R, a[L], 1);
*/

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);
/*
  int t1,t2,t3;

  t2 = clock();
  for(int i = 1; i <= 2000000; i++) insert(T[0], i);

  t3 = clock();

  cout<<t2-t1<<endl<<t3-t2<<endl;

  return 0;
*/
  int xx, yy, m, res, oldxx, oldyy;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    /*
    oldxx = a[xx]; oldyy = a[yy];
    res += changepoint(xx,oldyy);
    res += changepoint(yy, oldxx);
    */
    printf("%d\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define DIM 200007
#define MAXNUMBER 200003

#define NUMBLOCK 507

#define BSIZE 3500

using namespace std;

int a[DIM];
int n;
int F[NUMBLOCK][MAXNUMBER+7];
int bs[NUMBLOCK];

int sumprefix(int bnum, int y) {
    y++;
    int res = 0;
    for(int i = y; i > 0; i -= i & -i)
        res += F[bnum][i];
    return res;
}

void add(int bnum, int y, int delta) {
    y++;
    for(int i = y; i <= MAXNUMBER; i += i & -i)
        F[bnum][i] += delta;
}

void changevalue(int pos, int newval) {
    add(pos/BSIZE, a[pos], -1);
    add(pos/BSIZE, newval, 1);
    a[pos] = newval;
}

int query(int x1, int x2, int yy) {

    if(x1 > x2) return 0;

    int b1,b2,res = 0;
    b1 = x1 / BSIZE;
    b2 = x2 / BSIZE;

    if(b1 == b2) {
        for(int j = x1; j <= x2; j++)
            if(a[j] < yy) res++;
    } else {
        for(int j = x1; j < (b1+1)*BSIZE; j++)
            if(a[j] < yy) res++;

        for(int j = b1+1; j <= b2-1; j++)
            res += sumprefix(j, yy-1);

        for(int j = (b2*BSIZE); j <= x2; j++)
            if(a[j] < yy) res++;

    }
    return res;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(L+1, R-1, a[L]);
    t2 = R-L-1 - t1;

    t4 = query(L+1, R-1, a[R]);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    changevalue(L, oldr);
    changevalue(R, oldl);
    //swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  for(int i = 1; i <= n; i++) {
    add(i / BSIZE, a[i], 1);
    bs[i/BSIZE]++;
  }

  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

void insert(pnode &root, pnode &t) {
    if(root == NULL) {
        root = t;
        return;
    }
    if(root->prior > t->prior) {
        if(t->key < root->key)
            insert(root->left, t);
        else
            insert(root->right, t);
        return;
    }
    pair<pnode, pnode> temp = split(root, t->key);
    root = t;
    root->left = temp.first;
    root->right = temp.second;
    update(root);
}

void addnode(pnode &root, int key) {
    pnode t = new node(key);
    insert(root, t);
}

/*
//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}
*/

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

void erase(pnode &root, int k) {
    if(root == NULL) return;
    else if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
    update(root);
}

/*

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}
*/

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) addnode(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) addnode(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define DIM 200007
#define MAXNUMBER 200003

#define NUMBLOCK 507

#define BSIZE 1000

using namespace std;

int a[DIM];
int n;
int F[NUMBLOCK][MAXNUMBER+7];
int bs[NUMBLOCK];

int sumprefix(int bnum, int y) {
    y++;
    int res = 0;
    for(int i = y; i > 0; i -= i & -i)
        res += F[bnum][i];
    return res;
}

void add(int bnum, int y, int delta) {
    y++;
    for(int i = y; i <= MAXNUMBER; i += i & -i)
        F[bnum][i] += delta;
}

void changevalue(int pos, int newval) {
    add(pos/BSIZE, a[pos], -1);
    add(pos/BSIZE, newval, 1);
    a[pos] = newval;
}

int query(int x1, int x2, int yy) {

    if(x1 > x2) return 0;

    int b1,b2,res = 0;
    b1 = x1 / BSIZE;
    b2 = x2 / BSIZE;

    if(b1 == b2) {
        for(int j = x1; j <= x2; j++)
            if(a[j] < yy) res++;
    } else {
        for(int j = x1; j < (b1+1)*BSIZE; j++)
            if(a[j] < yy) res++;

        for(int j = b1+1; j <= b2-1; j++)
            res += sumprefix(j, yy-1);

        for(int j = (b2*BSIZE); j <= x2; j++)
            if(a[j] < yy) res++;

    }
    return res;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(L+1, R-1, a[L]);
    t2 = R-L-1 - t1;

    t4 = query(L+1, R-1, a[R]);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    changevalue(L, oldr);
    changevalue(R, oldl);
    //swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  for(int i = 1; i <= n; i++) {
    add(i / BSIZE, a[i], 1);
    bs[i/BSIZE]++;
  }

  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}


#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef pair<int,int> pii;

typedef tree<pii, null_type, less<pii>, rb_tree_tag, tree_order_statistics_node_update> my_super_set;

#define DIM 200007

#define MAXNUMBER 1000000003

int a[DIM];
//my_super_set T[4*DIM];
int n;

const int INF = 1000000009;

//��������� "�������" ������
struct node{
    node *left, *right; //��������� �� ����
    int key, prior, cnt; //���� �� �������, ������� �������� � �������

    node(int newkey) { //����������� ����������� ���� ���������
        key = newkey; //�������� ��������� ����
        cnt = 1; //������� �������� � �������
        prior = (long long)(rand()) % 10 * 100000 + (long long)rand(); //������� ������� ��������
        left = right = NULL; //��� � ����� ������
    }
};

typedef node* pnode; //��������� ��� ����� pnode - �������� �� node, ��� �� ������ ����� node*

//������� ������� ������ � ������� � ������� root
int get_cnt(pnode root) {
    if(root == NULL) return 0;
    else return root->cnt;
}

//������� �������� � ������ ���� ��������� ����
void update(pnode root) {
    if(root != NULL) root->cnt = 1 + get_cnt(root->left) + get_cnt(root->right);
}

//split ������ ����� ������ ��� ����� �������� � ���� �� ����� ��������. ������� ���� � ���� ��������� �����.
pair<pnode, pnode> split(pnode root, int key){
    if(root == NULL) return {NULL,NULL}; //���� ������  �����,  �� ��������� ��������� ������

    if(root->key < key) { //���� ���� ����� ����� ����� ������ - �� �������� ������� ����
        pair<pnode, pnode> sp = split(root->right, key); //�������� ����� ����������� �� �������� �����
        root->right = sp.first; //������ ��� ����� ������� ������� ������ ������
        update(root); //���������  �������� ���� ����������� ����
        return {root, sp.second}; //��������� ��������� ���������
    } else { //����������� ������� ��� ��� �������
        pair<pnode, pnode> sp = split(root->left, key);
        root->left = sp.second;
        update(root); //���������  �������� ���� ����������� ����
        return {sp.first,  root}; //��� ��� �� ������, �� ������� ���������� ��� �����������
    }
}

//����� ��� ���������� ������ L,R ����� �� �Ѳ ����� � L �� ����� �� ����� � R
pnode merge(pnode L, pnode R) {
    if(L == NULL) return R; //���� ��� ������ ����� - �� ��������� ������  ������� �������
    if(R == NULL) return L; //���������
    //����� ������� ���� ������ ������ �� ����. ������� �� ����� �� ������� � ��� ������ �������
    if(L->prior > R->prior) { //���� ������� ������ � ����� ������,
        L->right = merge(L->right, R); //�� ������� ������� ���� L � ������ �������
        update(L); //���������  �������� ���� ����������� ����
        return L; //��������� ����� ������� ������
    } else { //����������� ������
        R->left = merge(L, R->left);
        update(R); //���������  �������� ���� ����������� ����
        return R;
    }
}

void insert(pnode &root, pnode &t) {
    if(root == NULL) {
        root = t;
        update(root);
        return;
    }
    if(root->prior > t->prior) {
        if(t->key < root->key)
            insert(root->left, t);
        else
            insert(root->right, t);
        update(root);
        return;
    }
    pair<pnode, pnode> temp = split(root, t->key);
    t->left = temp.first;
    t->right = temp.second;
    root = t;
    update(root);
}

void addnode(pnode &root, int key) {
    pnode t = new node(key);
    insert(root, t);
}

/*
//���������� ���� ������� � ������ (����� ���� �������� �� ������ ���� ��������������)
void insert(pnode &root,  int  key) { // &root - �� ����� ��������
    pair<pnode, pnode> sp = split(root, key); //�������� ������ �� ����� ���� ���� ��������
    //����� sp.first �� ����� �� ����� �� key , � ����� ������ � sp.second
    //������� sp.first, ������ � ���� ���� �������, � sp.second
    root = merge(merge(sp.first, new node(key)), sp.second);
}
*/

//����� ��� �������� � ������� root, ��������� ������� ���'��� (���� �� �����)
void dispose(pnode root) {
    if(root == NULL) return;
    dispose(root->left); //������� ����
    dispose(root->right);
    delete(root); //���������� ���'��� ��� ������. (������������  root = new node()
}

void erase(pnode &root, int k) {
    if(root == NULL) return;
    else if(k < root->key) erase(root->left, k);
    else if(k > root->key) erase(root->right, k);
    else root = merge(root->left, root->right);
    update(root);
}

/*

//��������� �������� � ������ �
void erase(pnode &root, int k) {
    pair<pnode, pnode> sp1, sp2;
    sp1 = split(root, k); //������� ������ �� ����� �
    sp2 = split(sp1.second, k+1); //�������� ����� ������ �� ����� �+1

    dispose(sp2.first);//��������� ���'��� � ������ � ������� �

    root = merge(sp1.first, sp2.second); //����� ������ �� �� ������ ������ �

}
*/

int find_kth(pnode root, int k) {
    if(get_cnt(root) < k) return -INF;

    int inright = get_cnt(root->right);

    if(inright + 1 == k) return root->key;

    if(inright >= k) return find_kth(root->right, k);

    return find_kth(root->left, k - (inright + 1));

}

int order_of_key(pnode root, int k) {
    if(root == NULL) return 0;
    if(root->key == k) return get_cnt(root->left);
    else if(k < root->key) return order_of_key(root->left, k);
    else return get_cnt(root->left) + 1 + order_of_key(root->right, k);
}
///////////////////////////////////////////////////////

pnode T[4*DIM];

void buildtree(int v, int tl, int tr) {

    for(int i = tl ; i <= tr; i++) addnode(T[v], a[i]);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr) / 2;
    buildtree(2*v+1, tl, tm);
    buildtree(2*v+2, tm+1, tr);
}

void addpoint(int v, int tl, int tr, int pos, int val, int type) {
    if(pos < tl || tr < pos) return;

    if(type == 1) addnode(T[v], val);
    else erase(T[v], val);

    if(tl == tr) {
        return;
    }

    int tm = (tl+tr)/2;
    if(pos <= tm) addpoint(2*v+1, tl, tm, pos, val, type);
    else addpoint(2*v+2, tm+1, tr, pos, val, type);
}

int query(int v, int tl, int tr, int L, int R, int x, int type) {
    if(R < tl || tr < L) return 0;

    if(L <= tl && tr <= R) {
        if(type == 1)return order_of_key(T[v],x);
        else return (tr-tl+1) - order_of_key(T[v], x+1);
    }

    int tm = (tl+tr) / 2;
    return query(2*v+1, tl, tm, L, R, x, type) + query(2*v+2, tm+1, tr, L, R, x, type);
}

int changepoint(int pos, int newval) {
    int c = 0;
    c -= query(0, 1, n, 1, pos-1, a[pos], 2);
    c -= query(0, 1, n, pos+1, n, a[pos], 1);
    addpoint(0, 1, n, pos, a[pos], 2);
    a[pos] = newval;
    addpoint(0, 1, n, pos, newval, 1);
    c += query(0, 1, n, 1, pos-1, a[pos], 2);
    c += query(0, 1, n, pos+1, n, a[pos], 1);
    return c;
}

int makeswap(int L, int R) {
    if(L == R) return 0;
    int t1,t2,t3,t4,add;
    t1 = query(0, 1, n, L+1, R-1, a[L], 1);
    t2 = R-L-1 - t1;

    t4 = query(0, 1, n, L+1, R-1, a[R], 1);
    t3 = R-L-1 - t4;
    add = -t1 + t2 + - t3 + t4;
    if(a[L] < a[R]) add++;
    else add--;

    int oldl = a[L], oldr = a[R];

    addpoint(0, 1, n, L, a[L], 2);
    addpoint(0, 1, n, R, a[R], 2);
    addpoint(0, 1, n, L, a[R], 1);
    addpoint(0, 1, n, R, a[L], 1);

    swap(a[L], a[R]);

    return add;
}

int main() {
  //freopen("input.txt", "r", stdin);

  srand(clock());

  int xx, yy, m, oldxx, oldyy;
  long long res;

  scanf("%d %d", &n, &m);
  //n = 200000; m = 50000;
  for(int i = 1; i <= n; i++) a[i] = i;
  buildtree(0, 1, n);
//return 0;
  res = 0;

  for(int i = 1; i <= m; i++) {
    scanf("%d %d", &xx, &yy);
/*
    xx = rand() % 200000 + 1;
    yy = rand() % 200000 + 1;
*/
    if(xx > yy) swap(xx,yy);
    res += makeswap(xx,yy);
    printf("%lld\n", res);
  }

  return 0;
}