#include <bits/stdc++.h>

using namespace std;

#define nn "\n"
#define pb push_back

// N = 10005 để an toàn cho 1e4
const int N = 10005;
const int INF = 1e9; // Dùng int lớn thay cho 1e18 để tiết kiệm bộ nhớ

// Sử dụng mảng tĩnh 2 chiều. 
// d[u][v] lưu khoảng cách ngắn nhất về đích. 
// Vì chi phí đi cạnh và chéo là cố định, ta có thể rút gọn 2 trạng thái thành 1.
int d[N][N]; 

int n, k;
vector<pair<int, int>> K;
int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};

struct node {
    int kc, u, v;
    bool operator>(const node& other) const {
        return kc > other.kc; 
    }
}; 

void dijkstra(int sx, int sy) {
    priority_queue<node, vector<node>, greater<node>> pq;
    
    // Khởi tạo mảng d bằng INF
    for(int i = 1; i <= n; i++) 
        for(int j = 1; j <= n; j++) d[i][j] = INF;

    d[sx][sy] = 0;
    pq.push({0, sx, sy});

    while(!pq.empty()){
        auto [kc, u, v] = pq.top(); pq.pop();
        
        if(kc > d[u][v]) continue;

        // Tính toán lân cận trực tiếp, không dùng danh sách kề
        for(int dir = 0; dir < 8; dir++){
            int nx = u + dx[dir];
            int ny = v + dy[dir];
            int cost = (dir < 4) ? 10 : 15;

            if(nx >= 1 && nx <= n && ny >= 1 && ny <= n){
                if(d[nx][ny] > d[u][v] + cost){
                    d[nx][ny] = d[u][v] + cost;
                    pq.push({d[nx][ny], nx, ny});
                }
            }
        }
    }
}

void solve(){
    int mid = (n + 1) / 2;
    dijkstra(mid, mid);
    
    long long sum = 0;
    for(auto [x, y] : K){
        sum += d[x][y];
    }
    cout << sum << nn;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> n >> k;
    for(int i = 0; i < k; i++){
        int x, y;
        cin >> x >> y;
        K.pb({x, y});
    }   
    
    solve();
    return 0;
}