using System;
using System.IO;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using E = System.Linq.Enumerable;

partial class Solver
{
    public void Run()
    {
        var N = ni();
        var X = ni();
        var b = new int[N];
        var l = new int[N];
        var u = new int[N];
        for (int i = 0; i < N; i++)
        {
            b[i] = ni();
            l[i] = ni();
            u[i] = ni();
        }
        long ans = 0;
        long currentDiff = 0;
        for (int i = 0; i < N; i++) currentDiff += CalcBestDiff(l[i], u[i], b[i], 0); // all zero-point
        var p = E.Range(0, N)
            .Select(i => new { Value = CalcBestDiff(l[i], u[i], b[i], X) - CalcBestDiff(l[i], u[i], b[i], 0), Index = i })
            .OrderByDescending(a => a.Value)
            .ToArray();
        var rank = new int[N];
        for (int i = 0; i < p.Length; i++)
        {
            rank[p[i].Index] = i;
        }
        var sumUp = p.Select(a => a.Value).ToList();
        for (int i = 1; i < N; i++)
        {
            sumUp[i] += sumUp[i - 1];
        }

        long lower = 0, upper = 1L * X * N;
        while (lower <= upper)
        {
            var mid = (lower + upper) / 2;

            var maxUp = 0L;
            var all = (int)(mid / X);
            var remain = mid % X;

            if (remain == 0)
            {
                if (all > 0)
                {
                    maxUp = sumUp[all - 1];
                }
            }
            else
            {
                for (int i = 0; i < N; i++)
                {
                    var up = CalcBestDiff(l[i], u[i], b[i], remain) - CalcBestDiff(l[i], u[i], b[i], 0);
                    if (all > 0)
                    {
                        if (rank[i] < all)
                        {
                            up += sumUp[all] - (CalcBestDiff(l[i], u[i], b[i], X) - CalcBestDiff(l[i], u[i], b[i], 0));
                        }
                        else
                        {
                            up += sumUp[all - 1];
                        }
                    }
                    maxUp = Math.Max(maxUp, up);
                }
            }

            if (currentDiff + maxUp >= 0)
            {
                ans = mid;
                upper = mid - 1;
            }
            else
            {
                lower = mid + 1;
            }
        }

        cout.WriteLine(ans);
    }

    public long CalcBestDiff(long l, long u, long b, long x)
    {
        if (b == x) return 0;
        if (b < x) return u * (x - b);
        return l * (x - b);
    }
}

// PREWRITEN CODE BEGINS FROM HERE
partial class Solver : Scanner
{
    public static void Main(string[] args)
    {
#if LOCAL
        new Solver(Console.In, Console.Out).Run();
#else
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        new Solver(Console.In, Console.Out).Run();
        Console.Out.Flush();
#endif
    }

#pragma warning disable IDE0052
    private readonly TextReader cin;
    private readonly TextWriter cout;
#pragma warning restore IDE0052

    public Solver(TextReader reader, TextWriter writer)
        : base(reader)
    {
        this.cin = reader;
        this.cout = writer;
    }
    public Solver(string input, TextWriter writer)
        : this(new StringReader(input), writer)
    {
    }

#pragma warning disable IDE1006
#pragma warning disable IDE0051
    private int ni() { return NextInt(); }
    private int[] ni(int n) { return NextIntArray(n); }
    private long nl() { return NextLong(); }
    private long[] nl(int n) { return NextLongArray(n); }
    private double nd() { return NextDouble(); }
    private double[] nd(int n) { return NextDoubleArray(n); }
    private string ns() { return Next(); }
    private string[] ns(int n) { return NextArray(n); }
#pragma warning restore IDE1006
#pragma warning restore IDE0051
}

public class Scanner
{
    private readonly TextReader Reader;
    private readonly Queue<string> TokenQueue = new Queue<string>();
    private readonly CultureInfo ci = CultureInfo.InvariantCulture;

    public Scanner()
        : this(Console.In)
    {
    }

    public Scanner(TextReader reader)
    {
        this.Reader = reader;
    }

    public int NextInt() { return int.Parse(Next(), ci); }
    public long NextLong() { return long.Parse(Next(), ci); }
    public double NextDouble() { return double.Parse(Next(), ci); }
    public string[] NextArray(int size)
    {
        var array = new string[size];
        for (int i = 0; i < size; i++) array[i] = Next();
        return array;
    }
    public int[] NextIntArray(int size)
    {
        var array = new int[size];
        for (int i = 0; i < size; i++) array[i] = NextInt();
        return array;
    }

    public long[] NextLongArray(int size)
    {
        var array = new long[size];
        for (int i = 0; i < size; i++) array[i] = NextLong();
        return array;
    }

    public double[] NextDoubleArray(int size)
    {
        var array = new double[size];
        for (int i = 0; i < size; i++) array[i] = NextDouble();
        return array;
    }

    public string Next()
    {
        if (TokenQueue.Count == 0)
        {
            if (!StockTokens()) throw new InvalidOperationException();
        }
        return TokenQueue.Dequeue();
    }

    public bool HasNext()
    {
        if (TokenQueue.Count > 0)
            return true;
        return StockTokens();
    }
    static readonly char[] _separator = new[] { ' ' };
    private bool StockTokens()
    {
        while (true)
        {
            var line = Reader.ReadLine();
            if (line == null) return false;
            var tokens = line.Split(_separator, StringSplitOptions.RemoveEmptyEntries);
            if (tokens.Length == 0) continue;
            foreach (var token in tokens)
                TokenQueue.Enqueue(token);
            return true;
        }
    }
}


Measured memory_bytes: 31808