#include <bits/stdc++.h>
#define MAX 101
#define pb push_back
#define pc putchar
#define gc getchar
#define FOR(i, n) for(;i<n;i++)
#define mm(a, n) memset(a, n, sizeof(a))
#define ini1(a) scanf("%d", &a)
#define ini2(a, b) ini1(a); ini1(b);
#define ini3(a, b, c) ini2(a, b); ini1(c);
#define ini4(a, b, c, d) ini3(a, b, c); ini1(d);
#define VALID(a) (a.r<r)&&(a.r>=0)&&(a.c<c)&&(a.c>=0)
#define REST(a) rest[a.r][a.c]
#define VIS(a) vis[a.r][a.c][a.l]
using namespace std;

typedef struct {int r, c, l;} State;
typedef struct {int od[4];} Dir;

int r, c, rest[MAX][MAX], vis[MAX][MAX][MAX];

Dir openDir[MAX][MAX]; //Holds the left, right, up, down open direction

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #else
    #endif
    while(scanf("%d %d", &r, &c)!=EOF)
    {
        int i=0, n; ini1(n);
        mm(rest, 0);
        memset(&openDir, 0, sizeof openDir); //EXprecting to work
        FOR(i, n)
        {
            State a, b;
            ini4(a.r, a.c, b.r, b.c);
            if(a.r==b.r)
            {
                int k=min(a.c, b.c), j=max(a.c, b.c);
                openDir[a.r][k++]={0, 0, 1, 0};
                FOR(k, j)
                {
                    openDir[a.r][k]={0, 0, 1, 1};
                }
                openDir[a.r][k]={0, 0, 0, 1};
            }
            else if(a.c==b.c)
           {
               int k=min(a.r, b.r), j=max(a.r, b.r);
               openDir[k++][a.c]={1, 0, 0, 0};
               FOR(k, j)
               {
                   openDir[k][a.c]={1, 1, 0, 0};
               }
               openDir[k][a.c]={0, 1, 0, 0};
           }
       }

       mm(vis, 0);
       ini1(n);

       i=0; FOR(i, n)
       {
           State x;
           ini3(x.l, x.r, x.c);

           vis[x.r][x.c][x.l]=1;
           //VIS(x)=1;
           //printf("Input: (%d, %d, %d)\n", x.r, x.c, x.l);

       }
       //printf(" VIS(adx)=%d\n", vis[2][1][4] );
       State src={0, 0, 0};
       REST(src)=1;
       queue<State> q;  q.push(src);
       while(!q.empty())
       {
                  //printf(" VIS(adx)=%d\n", vis[2][1][4] );
            src=q.front(); q.pop();
            if((src.r==r-1)&&(src.c==c-1))
            {
                 printf("%d\n", src.l);
                 break;
            }

            //printf("From (%d, %d)\n", src.r, src.c);

            int dr[]={1, -1, 0, 0};
            int dc[]={0, 0, 1, -1};
            int k=0; FOR(k, 4)
            {
                if(openDir[src.r][src.c].od[k]==0) //0 means open
                {
                    State t={src.r+dr[k], src.c+dc[k], src.l+1};
                    if(VALID(t))
                    {
                        if(!REST(t))
                        {
                            //printf("  To (%d, %d) and time %d\n", t.r, t.c, t.l);
                            //printf("  VIS(%d, %d)=%d\n", t.r, t.c, vis[t.r][t.c][t.l]);

                            if(VIS(t)==0)
                            {
                                q.push(t);
                                REST(t)=1;
                            }
                            else
                            {
                                t.l++;
                                q.push(t);
                                REST(t)=1;
                            }
                        }
                    }
                }
            }
       }
    }
    return 0;
}