#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<cstring>
#include<functional>
using namespace std;
#define ll long long
const ll linf = 1e15;
struct node{
    int h, w;
    ll cost;
    bool operator<(const node &n1) const {
        return n1.cost < cost;
    }
};

struct edge{
    int h, w, k;
    ll cost;
    bool operator<(const edge &e1) const {
        return e1.cost < cost;
    }
};

int H, W, N;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
ll A, B, C;
ll D[501][501][5], near[501][501];
int ph[100010], pw[100010];

void dijk(){
    for(int i = 0; i <= H; i++){
        for(int j = 0; j <= W; j++){
            near[i][j] = linf;
        }
    }
    priority_queue<node> pq;
    for(int i = 1; i <= N; i++){
        near[ph[i]][pw[i]] = 0;
        pq.push(node{ph[i], pw[i], 0});
    }
    
    while(!pq.empty()){
        int h = pq.top().h;
        int w = pq.top().w;
        ll cost = pq.top().cost;
        pq.pop();
        if(near[h][w] < cost) continue;
        
        cost++;
        for(int i = 0; i < 4; i++){
            int nh = h + dx[i];
            int nw = w + dy[i];
            if(nh < 0 || H < nh) continue;
            if(nw < 0 || W < nw) continue;
            if(near[nh][nw] > cost){
                near[nh][nw] = cost;
                pq.push(node{nh, nw, cost});
            }
        }
    }
}

ll solve(){
    dijk();
    for(int i = 0; i <= H; i++){
        for(int j = 0; j <= W; j++){
            for(int k = 0; k <= 4; k++){
                D[i][j][k] = linf;
            }
        }
    }
    priority_queue<edge> pq;
    pq.push(edge{ph[1], pw[1], 4, 0});
    D[ph[1]][pw[1]][4] = 0;

    while(!pq.empty()){
        int h = pq.top().h;
        int w = pq.top().w;
        int k = pq.top().k;
        ll cost = pq.top().cost;
        pq.pop();

        if(D[h][w][k] < cost) continue;

        if(k == 4){
            for(int i = 0; i < 4; i++){
                int nh = h + dx[i];
                int nw = w + dy[i];
                if(nh < 0 || H < nh) continue;
                if(nw < 0 || W < nw) continue;
                if(D[nh][nw][k] > cost + C){
                    D[nh][nw][k] = cost + C;
                    pq.push(edge{nh, nw, k, cost + C});
                }
            }
            for(int i = 0; i < 4; i++){
                ll new_c = cost + B;
                if(D[h][w][i] > new_c){
                    D[h][w][i] = new_c;
                    pq.push(edge{h, w, i, new_c});
                }
            }
        }else{
            ll new_c = cost + near[h][w] * C;
            if(D[h][w][4] > new_c){
                D[h][w][4] = new_c;
                pq.push(edge{h, w, 4, new_c});
            }
            
            new_c = cost + A;
            int nh = h + dx[k];
            int nw = w + dy[k];
            if(nh < 0 || H < nh) continue;
            if(nw < 0 || W < nw) continue;
            if(D[nh][nw][k] > new_c){
                D[nh][nw][k] = new_c;
                pq.push(edge{nh, nw, k, new_c});
            }
        }
    }
    ll ans = linf;
    for(int i = 0; i <= 4; i++){
        ans = min(ans, D[ph[N]][pw[N]][i]);
    }
    return ans;
}

void init(){
    cin >> H >> W >> A >> B >> C >> N;
    for(int i = 1; i <= N; i++){
        cin >> ph[i] >> pw[i];
    }
}

int main(){
    init();
    cout << solve() << endl;
    return 0;
}


Measured memory_bytes: 24584