Problem:
Score : 800 points

Problem Statement

Takahashi and Aoki will take N exams numbered 1 to N.
They have decided to compete in these exams.
The winner will be determined as follows:

For each exam i, Takahashi decides its importance c_i, which must be an integer between l_i and u_i (inclusive).

Let A be \sum_{i=1}^{N} c_i \times (Takahashi's score on Exam i), and B be \sum_{i=1}^{N} c_i \times (Aoki's score on Exam i). Takahashi wins if A \geq B, and Aoki wins if A < B.

Takahashi knows that Aoki will score b_i on Exam i, with his supernatural power.

Takahashi himself, on the other hand, will score 0 on all the exams without studying more. For each hour of study, he can increase his score on some exam by 1. (He can only study for an integer number of hours.)
However, he cannot score more than X on an exam, since the perfect score for all the exams is X.

Print the minimum number of study hours required for Takahashi to win.

Constraints

1 \leq N \leq 10^5

1 \leq X \leq 10^5

0 \leq b_i \leq X (1 \leq i \leq N)

1 \leq l_i \leq u_i \leq 10^5 (1 \leq i \leq N)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N X
b_1 l_1 u_1
b_2 l_2 u_2
:
b_N l_N u_N

Output

Print the minimum number of study hours required for Takahashi to win.

Sample Input 1

2 100
85 2 3
60 1 1

Sample Output 1

115

One optimal strategy is as follows:

Choose c_1 = 3, c_2 = 1.

Study to score 100 on Exam 1 and 15 on Exam 2.

Then, A = 3 \times 100 + 1 \times 15 = 315, B = 3 \times 85 + 1 \times 60 = 315 and Takahashi will win.

Sample Input 2

2 100
85 2 3
60 10 10

Sample Output 2

77

Sample Input 3

1 100000
31415 2718 2818

Sample Output 3

31415

Sample Input 4

10 1000
451 4593 6263
324 310 6991
378 1431 7068
71 1757 9218
204 3676 4328
840 6221 9080
684 1545 8511
709 5467 8674
862 6504 9835
283 4965 9980

Sample Output 4

2540

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Competitive
{
    internal class Solution
    {
        public long N, X;
        public long[] B, L, U;
        public long MOD = 1000000007;
        private Data[] ary;
        private List<Data> lst;
        public void Run()
        {
            {
                var line = Input.ReadIntArray();
                N = line[0];
                X = line[1];
            }

            B = new long[N];
            L = new long[N];
            U = new long[N];

            lst = new List<Data>();

            for (int i = 0; i < N; i++)
            {
                var line = Input.ReadIntArray();
                B[i] = line[0];
                L[i] = line[1];
                U[i] = line[2];

                Data d1 = new Data(B[i], L[i], U[i], i * 2, i * 2 + 1, true, U[i]);
                Data d2 = new Data(B[i], L[i], U[i], i * 2 + 1, i * 2, false, L[i]);

                lst.Add(d1);
                lst.Add(d2);
            }

            ary = lst.ToArray();
            Array.Sort(ary, (d1, d2) => d1.v.CompareTo(d2.v) * (-1)); // vの大きい順

            long ret = Search();

            Console.WriteLine(ret);
        }

        public bool CanWin(long target)
        {
            long opponent = 0;
            long x = target;

            for (int i = 0; i < ary.Length; i++)
            {
                // 相手
                if (ary[i].isu) opponent += ary[i].b * ary[i].l;
            }

            for (int i = 0; i < ary.Length; i++)
            {
                ary[i].used = false;
            }

            List<Data> cand = new List<Data>();
            for (int i = 0; i < ary.Length; i++)
            {
                Data d = ary[i];
                if (!lst[d.no_pair].used)
                {
                    if (x >= X)
                    {
                        x -= X;
                        ary[i].used = true;
                        cand.Add(d);
                    }
                    else
                    {
                        if ((d.isu && d.b <= x) || !d.isu)
                        {
                            cand.Add(d);
                            break;
                        }
                    }
                }
            }

            long player = 0;
            long over = cand.Count * X - target;

            long deduction = Int64.MaxValue;
            for (int i = 0; i < cand.Count; i++)
            {
                Data d = cand[i];
                long scoreX = d.b * d.l + (X - d.b) * d.u;
                long red = X - over;
                long scorex = Math.Min(d.b, red) * d.l + Math.Max(red - d.b, 0) * d.u;
                deduction = Math.Min(scoreX - scorex, deduction);
                player += scoreX;
            }
            
            if (over > 0)
            {
                player -= deduction;
            }

            return player >= opponent ? true : false;
        }

        public long Search()
        {
            long left = 0;
            long right = N * X;

            if (CanWin(0)) return 0;
            if (!CanWin(N * X)) return N * X;

            while (left + 1 < right)
            {
                long mid = (left + right) / 2;
                if (!CanWin(mid))
                {
                    left = mid;
                }
                else
                {
                    right = mid;
                }
            }
            return right;
        }

    }

    // libs ----------
    // 比較のみ
    class Data
    {
        public long b;
        public long l;
        public long u;
        public int no;
        public int no_pair;
        public bool isu;
        public long v;
        public bool used = false;

        public Data(long b, long l, long u, int no, int no_pair, bool isU, long v)
        {
            this.b = b;
            this.l = l;
            this.u = u;
            this.no = no;
            this.no_pair = no_pair;
            this.isu = isU;
            this.v = v;
        }

    }

    public class PriorityQueue<T>
    {
        private Comparison<T> _comparison;
        private int _type = 0;

        private T[] _heap;
        private int _sz = 0;

        private int _count = 0;

        /// <summary>
        /// Priority Queue with custom comparer
        /// </summary>
        public PriorityQueue(Comparison<T> comparison)
        {
            _heap = new T[128];
            _comparison = comparison;
        }

        private int Compare(T x, T y)
        {
            return _comparison(x, y);
        }

        public void Push(T x)
        {
            _count++;
            if (_count > _heap.Length)
            {
                var newheap = new T[_heap.Length * 2];
                for (int n = 0; n < _heap.Length; n++) newheap[n] = _heap[n];
                _heap = newheap;
            }

            //node number
            var i = _sz++;

            while (i > 0)
            {
                //parent node number
                var p = (i - 1) / 2;

                if (Compare(_heap[p], x) <= 0) break;

                _heap[i] = _heap[p];
                i = p;
            }

            _heap[i] = x;
        }

        public T Pop()
        {
            _count--;

            T ret = _heap[0];
            T x = _heap[--_sz];

            int i = 0;
            while (i * 2 + 1 < _sz)
            {
                //children
                int a = i * 2 + 1;
                int b = i * 2 + 2;

                if (b < _sz && Compare(_heap[b], _heap[a]) < 0) a = b;

                if (Compare(_heap[a], x) >= 0) break;

                _heap[i] = _heap[a];
                i = a;
            }

            _heap[i] = x;

            return ret;
        }

        public int Count()
        {
            return _count;
        }

        public T Peek()
        {
            return _heap[0];
        }

        public bool Contains(T x)
        {
            for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true;
            return false;
        }

        public void Clear()
        {
            while (this.Count() > 0) this.Pop();
        }

        public IEnumerator<T> GetEnumerator()
        {
            var ret = new List<T>();

            while (this.Count() > 0)
            {
                ret.Add(this.Pop());
            }

            foreach (var r in ret)
            {
                this.Push(r);
                yield return r;
            }
        }

        public T[] ToArray()
        {
            T[] array = new T[_sz];
            int i = 0;

            foreach (var r in this)
            {
                array[i++] = r;
            }

            return array;
        }
    }

    // common ----------

    internal static class Input
    {
        public static string ReadString()
        {
            string line = Console.ReadLine();
            return line;
        }

        public static int ReadInt()
        {
            string line = Console.ReadLine();
            return int.Parse(line);
        }

        public static int[] ReadIntArray()
        {
            string line = Console.ReadLine();
            return line.Split(' ').Select(int.Parse).ToArray();            
        }

        public static long ReadLong()
        {
            string line = Console.ReadLine();
            return long.Parse(line);
        }

        public static long[] ReadLongArray()
        {
            string line = Console.ReadLine();
            return line.Split(' ').Select(long.Parse).ToArray();
        }

        public static double[] ReadDoubleArray()
        {
            string line = Console.ReadLine();
            return line.Split(' ').Select(double.Parse).ToArray();
        }
    }
    
    internal class Program
    {
        public static void Main(string[] args)
        {
            var s = new Solution();
            s.Run();
        }
    }
}