#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define int long long
#define all(x) begin(x), end(x)
#define sz(x) (int) (x).size()

int k,n;
vector<array<int,2>> bg;
vector<int> dcd;
int ans=0;

bool ccb(const array<int,2> &a, const array<int,2> &b) {
	return (dcd[a[0]]+dcd[a[1]] < dcd[b[0]] + dcd[b[1]]);
}

struct FT {
	vector<int> s;
	FT(int n) : s(n,0) {}
	void update(int pos, int dif) { // a[pos] += dif
		for (; pos < sz(s); pos |= pos + 1) s[pos] += dif;
	}
	int query(int pos) { // sum of values in [0, pos)
		int res = 0;
		for (; pos > 0; pos &= pos - 1) res += s[pos-1];
		return res;
	}
	int query(int l, int r) {
		if (l) {
			return query(r+1)-query(l);
		} else {
			return query(r+1);
		}
	}
};

void solve1() {
	if (!sz(bg)) {
		cout<<ans;
		return;
	}
	FT amt(sz(dcd)+1);
	FT val(sz(dcd)+1);
	vector<int> pt;
	for (auto i : bg) {
		pt.push_back(i[0]); pt.push_back(i[1]);
		amt.update(i[0],1); val.update(i[0],dcd[i[0]]);
		amt.update(i[1],1); val.update(i[1],dcd[i[1]]);
	}
	sort(all(pt));
	int m = pt[sz(pt)/2];
	int mv = dcd[m];
	int pmt = amt.query(0,m), pvl = val.query(0,m);
	int nmt = amt.query(m+1,sz(dcd)), nvl = val.query(m+1,sz(dcd));
	cout<< ans+pmt*mv-pvl+nvl-nmt*mv;
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr);
	
	cin>>k>>n;
	for (int i=0; i<n; i++) {
		char t1,t2; int p1,p2;
		cin>>t1>>p1>>t2>>p2;
		if (t1==t2) {
			ans+=abs(p1-p2);
		} else {
			ans+=1;
			bg.push_back({p1,p2});
			dcd.push_back(p1);
			dcd.push_back(p2);
		}
	}
	n = sz(bg);
	sort(all(dcd));
	dcd.erase(unique(all(dcd)),dcd.end());
	for (int i=0; i<n; i++) {
		bg[i][0] = lower_bound(all(dcd),bg[i][0]) - dcd.begin();
		bg[i][1] = lower_bound(all(dcd),bg[i][1]) - dcd.begin();
	}
	sort(all(bg),ccb);
	
	if (k==1) {
		solve1();
	}
	
	return 0;
}