// Original C++ solution (slower):
#include<algorithm>

#include<cstring>

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<stack>

using namespace std;



const int maxn = 300010,inf = 1<<29;

int W,H,N,ans,tree[maxn*4],tag[maxn*4];



inline int gi()

{

	char ch; int ret = 0,f = 1;

	do ch = getchar(); while (!(ch >= '0'&&ch <= '9')&&ch != '-');

	if (ch == '-') f = -1,ch = getchar();

	do ret = ret*10+ch-'0',ch = getchar(); while (ch >= '0'&&ch <= '9');

	return ret*f;

}



struct node

{

	int x,y;

	inline node(int _x = 0,int _y = 0):x(_x),y(_y) {}

	inline void read() { x = gi(); y = gi(); }

	friend inline bool operator <(const node &a,const node &b) { return a.x < b.x; }

}P[maxn];



inline void build(int now,int l,int r)

{

	tree[now] = -inf; tag[now] = 0; if (l == r) return;

	int mid = (l+r) >> 1;

	build(now<<1,l,mid); build(now<<1|1,mid+1,r);

}



inline void pushdown(int now,int l,int r)

{

	if (l != r)

	{

		tree[now<<1] += tag[now]; tag[now<<1] += tag[now];

		tree[now<<1|1] += tag[now]; tag[now<<1|1] += tag[now];

	}

	tag[now] = 0;

}



inline void modify(int now,int l,int r,int ql,int qr,int key)

{

	if (tag[now]) pushdown(now,l,r);

	if (l == ql&&r == qr) { tree[now] += key; tag[now] = key; return; }

	int mid = (l+r) >> 1;

	if (qr <= mid) modify(now<<1,l,mid,ql,qr,key);

	else if (ql > mid) modify(now<<1|1,mid+1,r,ql,qr,key);

	else modify(now<<1,l,mid,ql,mid,key),modify(now<<1|1,mid+1,r,mid+1,qr,key);

	tree[now] = max(tree[now<<1],tree[now<<1|1]);

}



inline void change(int now,int l,int r,int pos,int key)

{

	if (tag[now]) pushdown(now,l,r);

	if (l == r) { tree[now] = key; return; }

	int mid = (l+r) >> 1;

	if (pos <= mid) change(now<<1,l,mid,pos,key);

	else change(now<<1|1,mid+1,r,pos,key);

	tree[now] = max(tree[now<<1],tree[now<<1|1]);

}



inline void work()

{

	sort(P+1,P+N+1); build(1,1,N+1);

	stack <node> S1,S2; int mid = H>>1;

	change(1,1,N+1,1,H); S1.push(node(mid,0)); S2.push(node(H-mid,0));

	for (int i = 1;i <= N;++i)

	{

		ans = max(ans,(P[i].x+tree[1])<<1); int h,last;

		if (P[i].y <= mid)

		{

			for (h = mid,last = i;!S1.empty()&&mid-P[i].y < (S1.top()).x;h = (S1.top()).x,last = (S1.top()).y,S1.pop())

				modify(1,1,N+1,(S1.top()).y+1,last,mid-P[i].y-h);

			if (S1.empty()) S1.push(node(mid-P[i].y,0));

			else modify(1,1,N+1,(S1.top()).y+1,last,mid-P[i].y-h);

			S1.push(node(mid-P[i].y,i));

		}

		else

		{

			for (h = H-mid,last = i;!S2.empty()&&P[i].y-mid < (S2.top()).x;h = (S2.top()).x,last = (S2.top()).y,S2.pop())

				modify(1,1,N+1,(S2.top()).y+1,last,P[i].y-mid-h);

			if (S2.empty()) S2.push(node(P[i].y-mid,0));

			else modify(1,1,N+1,(S2.top()).y+1,last,P[i].y-mid-h);

			S2.push(node(P[i].y-mid,i));

		}

		change(1,1,N+1,i+1,H-P[i].x);

	}

	ans = max(ans,(W+tree[1])<<1);

}



int main()

{

//	freopen("D.in","r",stdin);

//	freopen("D.out","w",stdout);

	W = gi(); H = gi(); N = gi();

	for (int i = 1;i <= N;++i) P[i].read();

	ans = max((H+1)<<1,(W+1)<<1);

	work();

	for (int i = 1;i <= N;++i) swap(P[i].x,P[i].y); swap(H,W);

	work();

	cout << ans << endl;

	return 0;

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



typedef long long ll;

typedef pair<int, int> pii;

typedef pair<int, pii> pipii;

typedef pair<pii, int> piipi;

typedef pair<pii, pii> piipii;



#define mp make_pair

#define fi first

#define se second

#define all(a) (a).begin(), (a).end()

#define sz(a) (int)(a).size()

#define eb emplace_back



int w, h, n;

int x[300005], y[300005];

pii p[300005];

ll ans = 0;



ll st[1200010], lazy[1200010];

void push(int n, int s, int e, ll val){

    st[n] += val;

    if(s != e){

        lazy[n+n] += val;

        lazy[n+n+1] += val;

    }

    lazy[n] = 0;

}

void update(int n, int s, int e, int l, int r, ll v){

    push(n, s, e, lazy[n]);

    if(s > r || l > e) return;

    if(l <= s && e <= r){

        push(n, s, e, v);

        return;

    }

    int mid = (s+e)/2;

    update(n+n, s, mid, l, r, v);

    update(n+n+1, mid+1, e, l, r, v);

    st[n] = max(st[n+n], st[n+n+1]);

}

ll query(int n, int s, int e, int l, int r){

    push(n, s, e, lazy[n]);

    if(s > r || l > e) return 0;

    if(l <= s && e <= r) return st[n];

    int mid = (s+e)/2;

    return max(query(n+n, s, mid, l, r), query(n+n+1, mid+1, e, l, r));

}



void solve(){

    for(int i=1;i<=4*n;i++){

        st[i] = h;

        lazy[i] = 0;

    }



    stack<pii> st1, st2;

    st1.push(mp(0, 0)), st2.push(mp(0, h));

    for(int i=1;i<=n;i++){

        update(1, 0, n, 0, i-1, p[i].fi-p[i-1].fi);

        if(i-1 >= 1) ans = max(ans, query(1, 0, n, 0, i-1));



        if(p[i].se <= h/2){

            int r = i;

            while(!st1.empty() && st1.top().se <= p[i].se){

                int l = st1.top().fi;

                update(1, 0, n, l, r-1, -(p[i].se-st1.top().se));

                r = l;

                st1.pop();

            }

            st1.push(mp(r, p[i].se));

            st1.push(mp(i, 0));

        }

        else{

            int r = i;

            while(!st2.empty() && st2.top().se >= p[i].se){

                int l = st2.top().fi;

                update(1, 0, n, l, r-1, -(st2.top().se-p[i].se));

                r = l;

                st2.pop();

            }

            st2.push(mp(r, p[i].se));

            st2.push(mp(i, h));

        }

    }

}



int main(){

    scanf("%d%d%d", &w, &h, &n);   

    for(int i=1;i<=n;i++){

        scanf("%d%d", &x[i], &y[i]);

        p[i] = mp(x[i], y[i]);

    }

    p[0] = mp(0, 0);

    p[++n] = mp(w, h);

    sort(p+1, p+1+n);

    solve();



    for(int i=1;i<=n;i++) swap(p[i].fi, p[i].se);

    swap(w, h);

    sort(p+1, p+1+n);

    solve();

    printf("%lld\n", ans*2);

}

// Fastest known solution for this problem: