Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

blockquote {
font-family: Menlo, Monaco, "Courier New", monospace;
color: #333333;
display: block;
padding: 8.5px;
margin: 0 0 9px;
font-size: 12px;
line-height: 18px;
background-color: #f5f5f5;
border: 1px solid #ccc;
border: 1px solid rgba(0, 0, 0, 0.15);
-webkit-border-radius: 4px;
-moz-border-radius: 4px;
border-radius: 4px;
white-space: pre;
white-space: pre-wrap;
word-break: break-all;
word-wrap: break-word;
}

Problem Statement

We have planted $N$ flower seeds, all of which come into different flowers.
We want to make all the flowers come out together.

Each plant has a value called vitality, which is initially zero.
Watering and spreading fertilizers cause changes on it, and the $i$-th plant will come into flower if its vitality is equal to or greater than $\mathit{th}_i$.
Note that $\mathit{th}_i$ may be negative because some flowers require no additional nutrition.

Watering effects on all the plants.
Watering the plants with $W$ liters of water changes the vitality of the $i$-th plant by $W \times \mathit{vw}_i$ for all $i$ ($1 \le i \le n$), and costs $W \times \mathit{pw}$ yen, where $W$ need not be an integer.
$\mathit{vw}_i$ may be negative because some flowers hate water.

We have $N$ kinds of fertilizers, and the $i$-th fertilizer effects only on the $i$-th plant.
Spreading $F_i$ kilograms of the $i$-th fertilizer changes the vitality of the $i$-th plant by $F_i \times \mathit{vf}_i$, and costs $F_i \times \mathit{pf}_i$ yen, where $F_i$ need not be an integer as well.
Each fertilizer is specially made for the corresponding plant, therefore $\mathit{vf}_i$ is guaranteed to be positive.

Of course, we also want to minimize the cost.
Formally, our purpose is described as "to minimize $W \times \mathit{pw} + \sum_{i=1}^{N}(F_i \times \mathit{pf}_i)$ under $W \times \mathit{vw}_i + F_i \times \mathit{vf}_i \ge \mathit{th}_i$, $W \ge 0$, and $F_i \ge 0$ for all $i$ ($1 \le i \le N$)".
Your task is to calculate the minimum cost.

Input

The input consists of multiple datasets.
The number of datasets does not exceed $100$, and the data size of the input does not exceed $20\mathrm{MB}$.
Each dataset is formatted as follows.

$N$
$\mathit{pw}$
$\mathit{vw}_1$ $\mathit{pf}_1$ $\mathit{vf}_1$ $\mathit{th}_1$
:
:
$\mathit{vw}_N$ $\mathit{pf}_N$ $\mathit{vf}_N$ $\mathit{th}_N$

The first line of a dataset contains a single integer $N$, number of flower seeds.
The second line of a dataset contains a single integer $\mathit{pw}$, cost of watering one liter.
Each of the following $N$ lines describes a flower. The $i$-th line contains four integers, $\mathit{vw}_i$, $\mathit{pf}_i$, $\mathit{vf}_i$, and $\mathit{th}_i$, separated by a space.

You can assume that $1 \le N \le 10^5$, $1 \le \mathit{pw} \le 100$, $-100 \le \mathit{vw}_i \le 100$, $1 \le \mathit{pf}_i \le 100$, $1 \le \mathit{vf}_i \le 100$, and $-100 \le \mathit{th}_i \le 100$.

The end of the input is indicated by a line containing a zero.

Output

For each dataset, output a line containing the minimum cost to make all the flowers come out.
The output must have an absolute or relative error at most $10^{-4}$.

Sample Input

3
10
4 3 4 10
5 4 5 20
6 5 6 30
3
7
-4 3 4 -10
5 4 5 20
6 5 6 30
3
1
-4 3 4 -10
-5 4 5 -20
6 5 6 30
3
10
-4 3 4 -10
-5 4 5 -20
-6 5 6 -30
0

Output for the Sample Input

43.5
36
13.5
0

Solution in JAVA (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		IO io = new IO();
		while (true) {
			int n = io.nextInt();
			if (n == 0) {
				break;
			}
			int pw = io.nextInt();
			Tuple[] t = new Tuple[n]; // a + bx
			double a = 0;
			double b = pw;
			for (int i = 0; i < n; i++) {
				double vw = io.nextInt();
				double pf = io.nextInt();
				double vf = io.nextInt();
				double th = io.nextInt();
				t[i] = new Tuple(th / vw, pf * th / vf, -pf * vw / vf);
				if (t[i].a > 0) {
					a += t[i].a;
					b += t[i].b;
					t[i].a *= -1;
					t[i].b *= -1;
				}
			}
			Arrays.sort(t);
			double ans = a;
			for (int i = 0; i < n; i++) {
				if (t[i].x >= 0) {
					ans = Math.min(ans, a + b * t[i].x);
				}
				a += t[i].a;
				b += t[i].b;
			}
			io.println(ans);
		}
		io.flush();

	}

}

class Tuple implements Comparable<Tuple> {
	double x, a, b;

	public Tuple(double x, double a, double b) {
		this.x = x;
		this.a = a;
		this.b = b;
	}

	public int compareTo(Tuple o) {
		return Double.compare(this.x, o.x);
	}

	public String toString() {
		return "(" + x + "," + a + "," + b + ")";
	}
}

class IO {
	BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
	StringBuilder out = new StringBuilder();
	int index = 0;
	String bfl = null;
	String[] bf = new String[0];

	private boolean read() {
		try {
			bfl = bi.readLine();
			if (bfl == null) {
				return false;
			}
			bf = bfl.split("\\s");
			index = 0;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return true;
	}

	public boolean hasNext() {
		return index < bf.length ? true : read();
	}

	public boolean hasNextLine() {
		return read();
	}

	public String next() {
		return hasNext() ? bf[index++] : null;
	}

	public String nextLine() {
		return hasNextLine() ? bfl : null;
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	};

	public void println(long x) {
		out.append(x);
		out.append("\n");
	}

	public void println(double x) {
		out.append(x);
		out.append("\n");
	}

	public void println(String s) {
		out.append(s);
		out.append("\n");
	}

	public void print(long x) {
		out.append(x);
	}

	public void print(double x) {
		out.append(x);
	}

	public void print(String s) {
		out.append(s);
	}

	public void flush() {
		System.out.print(out);
		out = new StringBuilder();
	}

	public int[] arrayInt(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public long[] arrayLong(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextLong();
		}
		return a;
	}

	public double[] arrayDouble(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextDouble();
		}
		return a;
	}
}