// Skyqwq
// The additional problem!
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <vector>
#define ls (p << 1)
#define rs (p << 1 | 1)
using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

set<PII> st;

const int N = 5e5 + 5, M = N * 4, INF = 1e9;

int L, R, n, d[M], tot, ans = 2e9, q[N], len, in[N];

vector<int> g[N];

struct E{
	int x1, y1, x2, y2, v;
} e[N];

void inline addEdge(int x, int y) {
	in[y]++, g[x].push_back(y);
}

struct Node {
	int i;
	bool operator < (const Node &b) const {
		int j = b.i;
		int x = max(e[i].x1, e[j].x1);
		double k1 = ((double)e[i].y2 - e[i].y1) / (e[i].x2 - e[i].x1), b1 = e[i].y1 - k1 * e[i].x1;
		double k2 = ((double)e[j].y2 - e[j].y1) / (e[j].x2 - e[j].x1), b2 = e[j].y1 - k2 * e[j].x1;
		return k1 * x + b1 < k2 * x + b2;
	}
};

set<Node> s;

typedef set<Node>::iterator SIT;

struct Line { 
	int x, i, c;
	bool operator < (const Line &b) const { 
		if (x == b.x) return c < b.c;
		return x < b.x;
	} 
} a[N * 2];

int inline get(int x) { return lower_bound(d + 1, d + 1 + tot, x) - d; }

int mx[M << 2], mn[M << 2], add[M << 2], cov[M << 2];
int asc[M << 2], desc[M << 2];

void inline pushup(int p) {
	mx[p] = max(mx[ls], mx[rs]), mn[p] = min(mn[ls], mn[rs]);
	asc[p] = asc[ls] && asc[rs] && mx[ls] <= mn[rs];
	desc[p] = desc[ls] && desc[rs] && mn[ls] >= mx[rs];
}

void inline Add(int p, int k) {
	add[p] += k, mx[p] += k, mn[p] += k;
}

void inline cover(int p, int k) {
	mx[p] = mn[p] = cov[p] = k, asc[p] = desc[p] = true;
	add[p] = 0;
}

void inline pushdown(int p) {
	if (cov[p] != -1) {
		cover(ls, cov[p]);
		cover(rs, cov[p]);
		cov[p] = -1;
	}
	if (add[p]) {
		Add(ls, add[p]), Add(rs, add[p]);
		add[p] = 0;
	}
}

void build(int p, int l, int r) {
	cov[p] = -1;
	if (l == r) {
		mx[p] = mn[p] = (L <= l && l <= R) ? 0 : INF;
		asc[p] = desc[p] = true;
		return;
	}
	int mid = (l + r) >> 1;
	build(p << 1, l, mid);
	build(p << 1 | 1, mid + 1, r);
	pushup(p);
}

void change(int p, int l, int r, int x, int y) {
	if (x > y) return;
	if (x <= l && r <= y) { Add(p, 1); return; }
	pushdown(p);
	int mid = (l + r) >> 1;
	if (x <= mid) change(p << 1, l, mid, x, y);
	if (mid < y) change(p << 1 | 1, mid + 1, r, x, y);
	pushup(p);
}

int V;

void changeDesc(int p, int l, int r, int x, int y) {
	if (x > y) return;
	if (x <= l && r <= y) {
		if (V <= mn[p]) {
			cover(p, V);
			return;
		} else if (desc[p] && mx[p] <= V) {
			V = mn[p]; 
			return;
		}
	}

	pushdown(p);
	int mid = (l + r) >> 1;
	if (x <= mid) changeDesc(p << 1, l, mid, x, y);
	if (mid < y) changeDesc(p << 1 | 1, mid + 1, r, x, y);
	pushup(p);
}

void changeAsc(int p, int l, int r, int x, int y) {
	if (x > y) return;
	if (x <= l && r <= y) {
		if (V <= mn[p]) {
			cover(p, V);
			return;
		} else if (asc[p] && mx[p] <= V) {
			V = mn[p]; 
			return;
		}
	}

	pushdown(p);
	int mid = (l + r) >> 1;
	if (mid < y) changeAsc(p << 1 | 1, mid + 1, r, x, y);
	if (x <= mid) changeAsc(p << 1, l, mid, x, y);
	pushup(p);
}

void work(int p, int l, int r) {
	if (l == r) {
		if (L <= r && r <= R) ans = min(ans, mn[p]);
		return;
	}
	pushdown(p);
	int mid = (l + r) >> 1;
	work(p << 1, l, mid);
	work(p << 1 | 1, mid + 1, r);
}


void inline toposort() {
	int hh = 1, tt = 0;
	for (int i = 1; i <= n; i++) if (!in[i]) q[++tt] = i;
	while (hh <= tt) {
		int u = q[hh++];
		for (int i = 0; i < g[u].size(); i++) {
			int v = g[u][i];
			if (--in[v] == 0) q[++tt] = v;
		}
	}
}

int main() {
	scanf("%d%d%d", &L, &R, &n);
	d[1] = L, d[2] = R, tot = 2;
	for (int i = 1; i <= n; i++) {
		scanf("%d%d%d%d", &e[i].x1, &e[i].y1, &e[i].x2, &e[i].y2);
		e[i].v = e[i].x1;
		if (e[i].x1 > e[i].x2) swap(e[i].x1, e[i].x2), swap(e[i].y1, e[i].y2);
		int x = e[i].x1, y = e[i].x2;
		d[++tot] = x, d[++tot] = y;
		d[++tot] = x + 1, d[++tot] = y - 1;
		a[++len] = (Line) { x, i, 1 };
		a[++len] = (Line) { y, i, -1 };
	}

	sort(a + 1, a + 1 + len);

	for (int i = 1; i <= len; i++) {
		if (a[i].c == -1) {
			s.erase((Node) { a[i].i });
		} else {
			SIT it = s.lower_bound((Node) { a[i].i });
			if (it != s.end()) addEdge(a[i].i, it -> i);
			if (it != s.begin()) {
				--it;
				addEdge(it -> i, a[i].i);
			}
			s.insert((Node) { a[i].i });
		}
	}

	toposort();

	sort(d + 1, d + 1 + tot);
	tot = unique(d + 1, d + 1 + tot) - d - 1;
	L = get(L), R = get(R);
	build(1, 1, tot);

	for (int j = 1; j <= n; j++) {
		int i = q[j], t = get(e[i].v);
		V = INF;
		int a = get(e[i].x1 + 1), b = get(e[i].x2 - 1);
		change(1, 1, tot, a, b);
		if (e[i].v == e[i].x1) changeDesc(1, 1, tot, t, b);
		else changeAsc(1, 1, tot, a, t);
	}
	work(1, 1, tot);
	printf("%d\n", ans);
	return 0;
}