#include <bits/stdc++.h>
using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); i--)
#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const int N = 1 << 22;
const int INF = 1.1e9;

struct SegTree
{
	int t[2 * N], lazy[2 * N];
	void build(int v, int tl, int tr, int l, int r)
	{
		t[v] = INF;	
		lazy[v] = 0;	
		if(tl + 1 == tr)
		{
			if(l <= tl && tr <= r)
			{
				t[v] = 0;
			}
			return;
		}
		int tm = (tl + tr) / 2;
		build(2 * v, tl, tm, l, r);
		build(2 * v + 1, tm, tr, l, r);
		
		t[v] = min(t[2 * v], t[2 * v + 1]);
	}
	
	void push(int v, int tl, int tr)
	{
		t[v] = min(INF, t[v] + lazy[v]);
		
		if(tl + 1 != tr)
		{
			lazy[2 * v] += lazy[v];
			lazy[2 * v + 1] += lazy[v];
		}
		lazy[v] = 0;
	}
	
	void add(int v, int tl, int tr, int l, int r) //add 1 on seg
	{
		push(v, tl, tr);
		if(tr <= l || r <= tl)
			return;
		
		if(l <= tl && tr <= r)
		{
			lazy[v] = 1;
			push(v, tl, tr);
			return;
		}
		
		int tm = (tl + tr) / 2;
		add(2 * v, tl, tm, l, r);
		add(2 * v + 1, tm, tr, l, r);
		

		t[v] = min(t[2 * v], t[2 * v + 1]);
	}
	
	void upd(int v, int tl, int tr, int pos, int val)
	{
		push(v, tl, tr);
		if(pos < tl || tr <= pos)
			return;
			
		if(tl + 1 == tr)
		{
			t[v] = min(t[v], val);
			return;
		}
		
		int tm = (tl + tr) / 2;
		upd(2 * v, tl, tm, pos, val);
		upd(2 * v + 1, tm, tr, pos, val);
		
		t[v] = min(t[2 * v], t[2 * v + 1]);
	}
	
	int query(int v, int tl, int tr, int l, int r)
	{
		push(v, tl, tr);
		if(tr <= l || r <= tl)
			return INF;
				
		if(l <= tl && tr <= r)
		{
			return t[v];
		}
		int tm = (tl + tr) / 2;
		return min(query(2 * v, tl, tm, l, r),
			query(2 * v + 1, tm, tr, l, r));
	}
	
}T;


LL globalX;

struct Line
{
	LL A, B, C;//Ax + By + C = 0
	int index;
	
	Line(){}
	Line(LL y, int i) : A(0), B(1), C(-y), index(i) {}
	Line(LL x0, LL y0, LL x1, LL y1, int i) : index(i)
	{
		A = y1 - y0;
		B = x0 - x1;
		C = -x0 * A - y0 * B;
		
		assert(B != 0);
		if(B < 0)
		{
			A *= -1;
			B *= -1;
			C *= -1;
		}
	}
	
	bool operator<(const Line& L) const
	{
		//return (-C - A * globalX) * L.B < (-L.C - L.A * globalX) * B;
		return (-C - A * globalX) * (__int128)L.B < (-L.C - L.A * globalX) * (__int128)B;
	}
}lines[N];

LL x[2][N], y[2][N];


set<int> g[N], rg[N];


int main()
{
    ios::sync_with_stdio(0); 
    cin.tie(0);
	cout << fixed << setprecision(15);
	int l, r, n;
	cin >> l >> r >> n;
	VI xs = {l, r};
	
	
	vector<PII> events;
	FOR(i, 0, n)
	{
		FOR(t, 0, 2)
			cin >> x[t][i] >> y[t][i];
		if(x[0][i] > x[1][i])
		{
			swap(x[0][i], x[1][i]);
			swap(y[0][i], y[1][i]);
		}
			
		xs.PB(x[0][i]);
		xs.PB(x[1][i]);
			
		lines[i] = Line(x[0][i], y[0][i], x[1][i], y[1][i], i);

		events.PB(MP(x[0][i], i + 1));
		events.PB(MP(x[1][i], -i - 1));
	}
	
	
	
	sort(ALL(xs));
	
	set<Line> curLines;
	sort(ALL(events));
	
	FOR(i, 0, SZ(events))
	{
		globalX = events[i].F;
		int ind = events[i].S;
		if(ind > 0)
		{
			ind--;
			
			auto it = curLines.lower_bound(Line(y[0][ind], ind));
			
			if(it != curLines.end())
			{
				g[ind].insert(it->index);
				rg[it->index].insert(ind);
			}
			if(it != curLines.begin())
			{
				g[prev(it)->index].insert(ind);
				rg[ind].insert(prev(it)->index);
			}
			curLines.insert(lines[ind]);
		}
		else
		{
			ind = -ind - 1;
			curLines.erase(lines[ind]);
		
			auto it = curLines.lower_bound(Line(y[1][ind], ind));
			
			if(it != curLines.end())
			{
				g[ind].insert(it->index);
				rg[it->index].insert(ind);
			}
			if(it != curLines.begin())
			{
				g[prev(it)->index].insert(ind);
				rg[ind].insert(prev(it)->index);
			}
		}
	}
	
	
	
	VI q;
	FOR(i, 0, n)
		if(SZ(g[i]) == 0)
			q.PB(i);
	
	l = lower_bound(ALL(xs), l) - xs.begin();
	r = upper_bound(ALL(xs), r) - xs.begin() - 1;
	T.build(1, 0, SZ(xs), l, r + 1);
	
	FOR(i, 0, SZ(q))
	{
		int v = q[i];
		for(int to : rg[v])
		{
			g[to].erase(v);
			if(SZ(g[to]) == 0)
				q.PB(to);
		}
		int L = lower_bound(ALL(xs), x[0][v]) - xs.begin();	
		int R = upper_bound(ALL(xs), x[1][v]) - xs.begin() - 1;
	
	
		
		int to = (y[0][v] < y[1][v]) ? L : R;	
		int mn = T.query(1, 0, SZ(xs), L, R + 1);

		T.add(1, 0, SZ(xs), L, R + 1);
		T.upd(1, 0, SZ(xs), to, mn);
	}
	assert(SZ(q) == n);
	cout << T.query(1, 0, SZ(xs), l, r + 1) << endl;
	
	return 0;
}