using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using System.IO; using System.Text; using static util; using P = pair; using Binary = System.Func; using Unary = System.Func; class Program { static StreamWriter sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false }; static Scan sc = new Scan(); const int M = 1000000007; const int M2 = 998244353; const long LM = (long)1e18; const double eps = 1e-11; static readonly int[] dd = { 0, 1, 0, -1, 0 }; const string dstring = "RDLU"; static void Main() { int n = sc.Int; int q = sc.Int; Func agg = (x, y) => x + y; Func upd = (x, y, l) => y * l; Func cmp = (x, y) => y; var sga = new LazySegtree(n, agg, upd, cmp, 0, -M); var sgb = new LazySegtree(n, agg, upd, cmp, 0, -M); long suma = 0, sumb = 0; for (int i = 0; i < q; i++) { int x, l, r; sc.Multi(out x, out l, out r); ++r; if (x == 0) { int sa = sga.run(l, r), sb = sgb.run(l, r); if (sa > sb) suma += sa; if (sa < sb) sumb += sb; } else if (x == 1) { sga.update(l, r, 1); sgb.update(l, r, 0); } else { sga.update(l, r, 0); sgb.update(l, r, 1); } } Prt(suma + sga.run(0, n), sumb + sgb.run(0, n)); sw.Flush(); } static void DBG(string a) => Console.WriteLine(a); static void DBG(IEnumerable a) => DBG(string.Join(" ", a)); static void DBG(params object[] a) => DBG(string.Join(" ", a)); static void Prt(string a) => sw.WriteLine(a); static void Prt(IEnumerable a) => Prt(string.Join(" ", a)); static void Prt(params object[] a) => Prt(string.Join(" ", a)); } class pair : IComparable> { public T v1; public U v2; public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; } public int CompareTo(pair a) { int c = Comparer.Default.Compare(v1, a.v1); return c != 0 ? c : Comparer.Default.Compare(v2, a.v2); } public override string ToString() => v1 + " " + v2; public void Deconstruct(out T a, out U b) { a = v1; b = v2; } } static class util { public static pair make_pair(this IList l) => make_pair(l[0], l[1]); public static pair make_pair(T v1, U v2) => new pair(v1, v2); public static T sq(T a) => Operator.Multiply(a, a); public static T Max(params T[] a) => a.Max(); public static T Min(params T[] a) => a.Min(); public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w; public static void swap(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; } public static void swap(this IList a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; } public static T[] copy(this IList a) { var ret = new T[a.Count]; for (int i = 0; i < a.Count; i++) ret[i] = a[i]; return ret; } } static class Operator { static readonly ParameterExpression x = Expression.Parameter(typeof(T), "x"); static readonly ParameterExpression y = Expression.Parameter(typeof(T), "y"); public static readonly Func Add = Lambda(Expression.Add); public static readonly Func Subtract = Lambda(Expression.Subtract); public static readonly Func Multiply = Lambda(Expression.Multiply); public static readonly Func Divide = Lambda(Expression.Divide); public static readonly Func Plus = Lambda(Expression.UnaryPlus); public static readonly Func Negate = Lambda(Expression.Negate); public static Func Lambda(Binary op) => Expression.Lambda>(op(x, y), x, y).Compile(); public static Func Lambda(Unary op) => Expression.Lambda>(op(x), x).Compile(); } class Scan { public int Int => int.Parse(Str); public long Long => long.Parse(Str); public double Double => double.Parse(Str); public string Str => Console.ReadLine().Trim(); public pair Pair() where T : IComparable where U : IComparable { T a; U b; Multi(out a, out b); return new pair(a, b); } public P P { get { int a, b; Multi(out a, out b); return new P(a, b); } } public int[] IntArr => StrArr.Select(int.Parse).ToArray(); public long[] LongArr => StrArr.Select(long.Parse).ToArray(); public double[] DoubleArr => StrArr.Select(double.Parse).ToArray(); public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries); bool eq() => typeof(T).Equals(typeof(U)); T ct(U a) => (T)Convert.ChangeType(a, typeof(T)); T cv(string s) => eq() ? ct(int.Parse(s)) : eq() ? ct(long.Parse(s)) : eq() ? ct(double.Parse(s)) : eq() ? ct(s[0]) : ct(s); public void Multi(out T a) => a = cv(Str); public void Multi(out T a, out U b) { var ar = StrArr; a = cv(ar[0]); b = cv(ar[1]); } public void Multi(out T a, out U b, out V c) { var ar = StrArr; a = cv(ar[0]); b = cv(ar[1]); c = cv(ar[2]); } public void Multi(out T a, out U b, out V c, out W d) { var ar = StrArr; a = cv(ar[0]); b = cv(ar[1]); c = cv(ar[2]); d = cv(ar[3]); } public void Multi(out T a, out U b, out V c, out W d, out X e) { var ar = StrArr; a = cv(ar[0]); b = cv(ar[1]); c = cv(ar[2]); d = cv(ar[3]); e = cv(ar[4]); } public void Multi(out T a, out U b, out V c, out W d, out X e, out Y f) { var ar = StrArr; a = cv(ar[0]); b = cv(ar[1]); c = cv(ar[2]); d = cv(ar[3]); e = cv(ar[4]); f = cv(ar[5]); } } class LazySegtree { int n; T[] data; U[] lazy; Func calc; Func apply; Func merge; T ex_data; U ex_lazy; public LazySegtree(int m, Func calc, Func apply, Func merge, T ex_data, U ex_lazy) { this.calc = calc; this.apply = apply; this.merge = merge; this.ex_data = ex_data; this.ex_lazy = ex_lazy; n = 1; while (n < m) n <<= 1; data = new T[n * 2 - 1]; lazy = new U[n * 2 - 1]; for (int i = 0; i < data.Length; i++) { data[i] = ex_data; lazy[i] = ex_lazy; } } public LazySegtree(int m, Func calc, Func apply, Func merge, T ex_data, U ex_lazy, T ini) : this(m, calc, apply, merge, ex_data, ex_lazy) { for (int i = 0; i < m; i++) data[i + n - 1] = ini; for (int i = n - 2; i >= 0; i--) data[i] = calc(data[i * 2 + 1], data[i * 2 + 2]); } public LazySegtree(int m, Func calc, Func apply, Func merge, T ex_data, U ex_lazy, IList ini) : this(m, calc, apply, merge, ex_data, ex_lazy) { for (int i = 0; i < m; i++) data[i + n - 1] = ini[i]; for (int i = n - 2; i >= 0; i--) data[i] = calc(data[i * 2 + 1], data[i * 2 + 2]); } T eval(int k, int len){ if (lazy[k].Equals(ex_lazy)) return data[k]; if (k * 2 + 2 < lazy.Length){ lazy[k * 2 + 1] = merge(lazy[k * 2 + 1], lazy[k]); lazy[k * 2 + 2] = merge(lazy[k * 2 + 2], lazy[k]); } data[k] = apply(data[k], lazy[k], len); lazy[k] = ex_lazy; return data[k]; } T update(int s, int t, U x, int k, int l, int r) { eval(k, r - l); if (r <= s || t <= l) return data[k]; if (s <= l && r <= t) { lazy[k] = merge(lazy[k], x); return eval(k, r - l); } return data[k] = calc(update(s, t, x, k * 2 + 1, l, (l + r) / 2), update(s, t, x, k * 2 + 2, (l + r) / 2, r)); } T run(int s, int t, int k, int l, int r) { eval(k, r - l); if (r <= s || t <= l) return ex_data; if (s <= l && r <= t) return data[k]; return calc(run(s, t, k * 2 + 1, l, (l + r) / 2), run(s, t, k * 2 + 2, (l + r) / 2, r)); } // [s, t) public void update(int s, int t, U x) => update(s, t, x, 0, 0, n); // [s, t) public T run(int s, int t) => run(s, t, 0, 0, n); }