Each year in the castle of Dwarven King there is a competition in growing mushrooms among the dwarves. The competition is one of the most prestigious ones, and the winner gets a wooden salad bowl. This year's event brought together the best mushroom growers from around the world, so we had to slightly change the rules so that the event gets more interesting to watch.

Each mushroom grower has a mushroom that he will grow on the competition. Under the new rules, the competition consists of two parts. The first part lasts t1 seconds and the second part lasts t2 seconds. The first and the second part are separated by a little break.

After the starting whistle the first part of the contest starts, and all mushroom growers start growing mushrooms at once, each at his individual speed of vi meters per second. After t1 seconds, the mushroom growers stop growing mushrooms and go to have a break. During the break, for unexplained reasons, the growth of all mushrooms is reduced by k percent. After the break the second part of the contest starts and all mushrooms growers at the same time continue to grow mushrooms, each at his individual speed of ui meters per second. After a t2 seconds after the end of the break, the competition ends. Note that the speeds before and after the break may vary.

Before the match dwarf Pasha learned from all participants, what two speeds they have chosen. However, the participants did not want to disclose to him all their strategy and therefore, did not say in what order they will be using these speeds. That is, if a participant chose speeds ai and bi, then there are two strategies: he either uses speed ai before the break and speed bi after it, or vice versa.

Dwarf Pasha really wants to win the totalizer. He knows that each participant chooses the strategy that maximizes the height of the mushroom. Help Dwarf Pasha make the final table of competition results.

The participants are sorted in the result table by the mushroom height (the participants with higher mushrooms follow earlier in the table). In case of equal mushroom heights, the participants are sorted by their numbers (the participants with a smaller number follow earlier).

Input

The first input line contains four integer numbers n, t1, t2, k (1 ≤ n, t1, t2 ≤ 1000; 1 ≤ k ≤ 100) — the number of participants, the time before the break, the time after the break and the percentage, by which the mushroom growth drops during the break, correspondingly.

Each of the following n lines contains two integers. The i-th (1 ≤ i ≤ n) line contains space-separated integers ai, bi (1 ≤ ai, bi ≤ 1000) — the speeds which the participant number i chose.

Output

Print the final results' table: n lines, each line should contain the number of the corresponding dwarf and the final maximum height of his mushroom with exactly two digits after the decimal point. The answer will be considered correct if it is absolutely accurate.

Examples

Input

2 3 3 50
2 4
4 2


Output

1 15.00
2 15.00


Input

4 1 1 1
544 397
280 101
280 101
693 970


Output

4 1656.07
1 937.03
2 379.99
3 379.99

Note

  * First example: for each contestant it is optimal to use firstly speed 2 and afterwards speed 4, because 2·3·0.5 + 4·3 > 4·3·0.5 + 2·3.

Difficulty: EASY
Tags: Sorting

Greedy algorithms
Skill types: Sorting

Greedy algorithms

Starter code:

Solutions:
(n, t1, t2, k) = map(int, input().split())
a = n * [0]
list_indexes = []
for i in range(n):
	x = list(map(int, input().split()))
	x.sort()
	a[i] = x
for j in range(n):
	a[j] = max(a[j][0] * t1 * ((100 - k) / 100) + a[j][1] * t2, a[j][1] * t1 * ((100 - k) / 100) + a[j][0] * t2)
	list_indexes.append(j + 1)
v = a.copy()
a.sort(reverse=True)
for _ in range(n):
	if v.count(a[_]) == 1:
		print(v.index(a[_]) + 1, '%.2f' % a[_])
	else:
		print(v.index(a[_]) + 1, '%.2f' % a[_])
		v[v.index(a[_])] = 0


from itertools import product
from math import ceil, gcd, sqrt
import string
from decimal import Decimal

def binary_table(string_with_all_characters, length_to_make):
	return [''.join(x) for x in product(string_with_all_characters, repeat=length_to_make)]

def all_possible_substrings(string):
	return [int(string[i:j]) for i in range(len(string)) for j in range(i + 1, len(string) + 1)]

def number_of_substrings(length):
	return int(length * (length + 1) / 2)
(num_of_players, time_before_break, time_after_break, percentage) = map(int, input().split())
percentage = 1 - float(percentage / 100)
temp = {}
for i in range(num_of_players):
	(speed_1, speed_2) = map(int, input().split())
	value_1 = speed_1 * time_before_break * percentage + speed_2 * time_after_break
	value_2 = speed_2 * time_before_break * percentage + speed_1 * time_after_break
	max_ = max(value_1, value_2)
	if temp.get(max_) is None:
		temp[max_] = [i + 1]
	else:
		temp[max_].append(i + 1)
values = list(temp.keys())
values.sort(reverse=True)
for i in values:
	for j in temp[i]:
		print(j, format(i, '.2f'))


import os
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from io import BytesIO, IOBase
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def main():
	(n, t1, t2, k) = invr()
	k /= 100
	res = []
	for i in range(1, n + 1):
		(a, b) = invr()
		res.append([i, max(t1 * a - t1 * a * k + t2 * b, t1 * b - t1 * b * k + t2 * a)])
	res = sorted(res, key=lambda d: d[1], reverse=True)
	for r in res:
		print(r[0], end=' ')
		print('%.2f' % r[1])
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


(n, t1, t2, k) = list(map(int, input().split()))
result = []
for i in range(n):
	(v, u) = list(map(int, input().split()))
	result.append([max(v * t1 * (100 - k) + u * t2 * 100, u * t1 * (100 - k) + v * t2 * 100), i])
result.sort(reverse=True, key=lambda x: x[0])
for i in result:
	print(str(i[1] + 1) + ' %.2f' % (i[0] / 100))


(n, t1, t2, k) = map(int, input().split())
dwarves = []
for i in range(n):
	(a, b) = map(int, input().split())
	dwarves += [[max([t1 * a * (100 - k) / 100 + t2 * b, t1 * b * (100 - k) / 100 + t2 * a]), i]]
dwarves.sort()
for i in range(n):
	dwarves[i] += [i + 1]
dwarves.sort(key=lambda x: (-x[0], x[1]))
for (result, index, _) in dwarves:
	print(index + 1, '%.2f' % round(result, 2))


def calc(u, v, t1, t2, k):
	length_1 = u * t1 - u * t1 * (k / 100) + v * t2
	length_2 = v * t1 - v * t1 * (k / 100) + u * t2
	return round(max(length_1, length_2), 2)

def solve():
	(n, t1, t2, k) = map(int, input().split())
	farmers = []
	for i in range(n):
		(u, v) = map(int, input().split())
		length = calc(u, v, t1, t2, k)
		farmers.append([i + 1, length])
	farmers.sort(reverse=True, key=lambda x: x[1])
	for i in farmers:
		print(i[0], format(i[1], '.2f'))
solve()


st1 = input()
t = st1.split(' ')
n = int(t[0])
t1 = int(t[1])
t2 = int(t[2])
k = int(t[3])
inp = []
out = []
rak = []
for i in range(n):
	st2 = input()
	st = st2.split(' ')
	a = int(st[0])
	b = int(st[1])
	z1 = t1 * a * (100 - k) / 100 + t2 * b
	z2 = t1 * b * (100 - k) / 100 + t2 * a
	if z1 > z2:
		out.append(z1)
	else:
		out.append(z2)
for i in range(n):
	rk = 0
	for j in range(n):
		if out[j] > out[i] or (out[j] == out[i] and j <= i):
			rk += 1
	rak.append(rk)
for i in range(n):
	for j in range(n):
		if rak[j] == i + 1:
			o = str('%.2f' % out[j])
			print(str(j + 1) + ' ' + o[:o.find('.') + 3])


def getkey(item):
	return item[1]
(n, t1, t2, k) = map(int, input().split())
board = []
for i in range(n):
	(v, u) = map(int, input().split())
	mx = max(v * t1 * (100 - k) / 100 + u * t2, u * t1 * (100 - k) / 100 + v * t2)
	board.append([i + 1, mx])
board = sorted(board, key=getkey, reverse=True)
for i in board:
	print(i[0], '{:.2f}'.format(i[1]))


(n, t1, t2, k) = [int(i) for i in input().split()]
ans = []
for i in range(n):
	(v, u) = [int(i) for i in input().split()]
	h = max(v * t1 * (100 - k) / 100 + u * t2, u * t1 * (100 - k) / 100 + v * t2)
	ans.append((i, h))
ans.sort(key=lambda x: x[1], reverse=True)
for (i, h) in ans:
	print(i + 1, '{0:.2f}'.format(h))


import math
s = input()
n = int(s.split(' ')[0])
t1 = int(s.split(' ')[1])
t2 = int(s.split(' ')[2])
k = int(s.split(' ')[3])
maxheight = []
for i in range(n):
	temp = input()
	a = int(temp.split(' ')[0])
	b = int(temp.split(' ')[1])
	maxheight.append([i + 1, max(a * t1 - a * t1 * 0.01 * k + b * t2, b * t1 - b * t1 * 0.01 * k + a * t2)])
maxheight = sorted(maxheight, key=lambda x: (-x[1], x[0]))
for a in maxheight:
	res = format('%d %0.2f')
	print('%d %0.2f' % (a[0], a[1]))


from sys import stdin, stdout
from decimal import Decimal
(n, t1, t2, k) = map(Decimal, stdin.readline().split())
challengers = []
for i in range(int(n)):
	(a, b) = map(Decimal, stdin.readline().split())
	(f, s) = (a * t1 * (1 - k / 100) + b * t2, b * t1 * (1 - k / 100) + a * t2)
	challengers.append((max(f, s), i))
challengers.sort(key=lambda x: (x[0], n - x[1]), reverse=True)
for i in range(int(n)):
	stdout.write(str(challengers[i][1] + 1) + ' ' + str('%.2f' % challengers[i][0]) + '\n')


(num, t1, t2, per) = map(int, input().split())
k = []
c = 9999999999999999
for i in range(1, num + 1):
	p = list(map(int, input().split()))
	p.sort()
	a = float('{:.2f}'.format(p[0] * t1 * (100 - per) / 100 + p[1] * t2))
	b = float('{:.2f}'.format(p[1] * t1 * (100 - per) / 100 + p[0] * t2))
	k.append([float(max(a, b)), c, i])
	c -= 1
k.sort()
k.reverse()
for i in k:
	print(i[2], '{:.2f}'.format(i[0]))


def inp():
	return map(int, input().split())
(n, t1, t2, k) = inp()
ans = []
for i in range(n):
	(a, b) = inp()
	height = max(t1 * a * ((100 - k) / 100) + t2 * b, t1 * b * ((100 - k) / 100) + t2 * a)
	ans.append([i + 1, height, 2])
ans.sort(key=lambda x: x[1], reverse=True)
for i in range(n):
	print(ans[i][0], '{:.2f}'.format(ans[i][1]))


import collections

def permutationbysum():
	for _ in range(int(input())):
		(num, l, r, achieve) = map(int, input().split())
		k = r - l + 1
		if k * (k + 1) // 2 <= achieve <= k * (num * 2 + 1 - k) // 2:
			outpos = r % num
			inpos = l - 1
			ans = [0] * num
			for i in range(num, 0, -1):
				if achieve - i > 0 or (achieve - i == 0 and inpos == r - 1):
					achieve -= i
					ans[inpos] = i
					inpos += 1
				else:
					ans[outpos] = i
					outpos += 1
					outpos %= num
			print(*ans)
		else:
			print(-1)

def peaks():
	for _ in range(int(input())):
		(num, peak) = map(int, input().split())
		pos = 1
		rpos = num
		ans = []
		now = 0
		if num == 1:
			if not peak:
				print(1)
			else:
				print(-1)
			continue
		if num == 2:
			if peak:
				print(-1)
			else:
				print(1, 2)
			continue
		added = 0
		while rpos + 1 != pos:
			if not peak:
				while pos <= rpos:
					ans.append(pos)
					pos += 1
				break
			if not now:
				ans.append(pos)
				pos += 1
			else:
				ans.append(rpos)
				rpos -= 1
				if num - added != 1:
					peak -= 1
			added += 1
			now = 1 - now
		if peak:
			print(-1)
			continue
		print(*ans)
import sys
input = sys.stdin.readline

def addone():
	for _ in range(int(input())):
		(num, changes) = input().split()
		l = collections.deque(sorted([int(i) for i in num]))
		perm = collections.deque()
		changes = int(changes)
		cd = 0
		ans = len(num)
		while True:
			nextnum = l.pop()
			while perm and perm[-1] == nextnum:
				l.append(perm.pop())
			c = 10 - nextnum - cd
			changes -= c
			cd += c
			if changes >= 0:
				if not c:
					perm.appendleft(1 - cd)
					l.appendleft(-cd)
				else:
					l.appendleft(1 - cd)
					l.appendleft(-cd)
				ans += 1
			else:
				break
		print(ans % 1000000007)
import math

def andsequences():

	def mapping(num):
		nonlocal mnum
		nonlocal c
		num = int(num)
		if num < mnum:
			mnum = num
			c = 1
		elif num == mnum:
			c += 1
		return num
	mod = 1000000007
	for _ in range(int(input())):
		mnum = float('inf')
		c = 0
		num = int(input())
		l = list(map(mapping, input().split()))
		for i in l:
			if mnum & i != mnum:
				print(0)
				break
		else:
			if c == 1:
				print(0)
			else:
				print(math.factorial(num - 2) * (c - 1) * c % mod)

def numberdigit():
	n = 10 ** 5 * 2
	l = [0] * 11
	mod = 10 ** 9 + 7
	l[0] = l[1] = l[2] = l[3] = l[4] = l[5] = l[6] = l[7] = l[8] = 2
	l[9] = 3
	l[10] = 4
	for i in range(11, n):
		l.append((l[i - 10] + l[i - 9]) % mod)
	for _ in range(int(input())):
		(num, c) = input().split()
		c = int(c)
		ans = 0
		for i in num:
			i = int(i)
			if 10 - i > c:
				ans += 1
			else:
				ans += l[c - (10 - i)]
		print(ans % mod)

def mushroom():
	(people, t1, t2, percent) = map(int, input().split())
	l = []
	percent = 1 - percent * 0.01
	for i in range(1, people + 1):
		(s, s1) = map(int, input().split())
		l.append([i, max(s * t1 * percent + s1 * t2, s1 * t1 * percent + s * t2)])
	l.sort(key=lambda x: x[1], reverse=True)
	for i in l:
		i[1] = '{:.2f}'.format(i[1])
		print(*i)
mushroom()


def main():
	(n, t1, t2, p) = map(int, input().split())
	p = 1 - p / 100
	a = [0] * n
	for i in range(n):
		(x, y) = map(int, input().split())
		z = max(x * t1 * p + y * t2, y * t1 * p + x * t2)
		a[i] = [i + 1, z]
	a.sort(key=lambda x: x[1], reverse=True)
	for i in a:
		print(i[0], '%.2f' % i[1])
main()


(n, t1, t2, k) = map(int, input().split())
k = k / 100
ans = []
for i in range(1, n + 1):
	a = list(map(int, input().split()))
	a.sort()
	b = a[1] * t1 * (1 - k) + a[0] * t2
	c = a[0] * t1 * (1 - k) + a[1] * t2
	if c > b:
		b = c
	ans.append((i, '%.2f' % b))
ans.sort(key=lambda x: float(x[1]), reverse=True)
for e in ans:
	print(*e)


from operator import itemgetter
(n, t1, t2, k) = [int(s) for s in input().split()]
a = []
b = []
for _ in range(n):
	(x, y) = [int(s) for s in input().split()]
	a.append(x)
	b.append(y)
h = []
for i in range(n):
	h1 = t1 * a[i] * (100 - k) + 100 * t2 * b[i]
	h2 = t1 * b[i] * (100 - k) + 100 * t2 * a[i]
	h.append((i, max(h1, h2)))
h.sort(key=itemgetter(0), reverse=True)
h.sort(key=itemgetter(1))
for (idx, height) in reversed(h):
	print(idx + 1, '%.2f' % (height / 100))


def read():
	return map(int, input().split())

def main():
	(n, t1, t2, k) = read()
	ans = []
	for i in range(n):
		(a, b) = read()
		growth_a = a * t1 * (1 - k / 100) + b * t2
		growth_b = b * t1 * (1 - k / 100) + a * t2
		growth = max(growth_a, growth_b)
		ans.append((-growth, i + 1))
	ans.sort()
	for (growth, idx) in ans:
		print('%d %.2f' % (idx, -growth))
main()


import operator
(n, t1, t2, k) = list(map(int, input().split()))
m = []
for i in range(n):
	(a, b) = list(map(int, input().split()))
	c1 = a * t1
	c1 -= c1 / 100 * k
	c2 = b * t2
	s = [c1 + c2]
	c1 = b * t1
	c1 -= c1 / 100 * k
	c2 = a * t2
	s.append(c1 + c2)
	m.append((i + 1, max(s)))
m.sort(key=operator.itemgetter(1), reverse=True)
for i in m:
	print('{0} {1:.2f}'.format(i[0], i[1]))


(n, t1, t2, k) = map(int, input().split())
contestants = []
for i in range(n):
	(a, b) = map(int, input().split())
	x = (100 - k) / 100 * a * t1 + b * t2
	y = (100 - k) / 100 * b * t1 + a * t2
	contestants.append((-max(x, y), i + 1))
contestants.sort()
for (value, pos) in contestants:
	print('%d %.2f' % (pos, -value))


from operator import itemgetter
(n, t1, t2, k) = [int(x) for x in input().split()]
dwarfs = []
for i in range(n):
	(a, b) = [int(x) for x in input().split()]
	r = (100 - k) / 100
	h = max(a * t1 * r + b * t2, b * t1 * r + a * t2)
	dwarfs.append((h, i + 1))
dwarfs.sort(key=itemgetter(1))
dwarfs.sort(reverse=True, key=itemgetter(0))
for d in dwarfs:
	print(f'{d[1]} {d[0]:.2f}')


from sys import stdin

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
(n, t1, t2, k) = get_ints()
arr = []
for i in range(n):
	(a, b) = get_ints()
	mi = min(a, b)
	ma = max(a, b)
	x = max(t1 * a * (1 - k / 100) + b * t2, t1 * b * (1 - k / 100) + a * t2)
	arr.append([str(i + 1), '{:.2f}'.format(x)])
for row in sorted(arr, key=lambda x: float(x[1]), reverse=True):
	print(' '.join(row))


(n, t1, t2, k) = map(int, input().split())
lst = []
for i in range(n):
	(a, b) = map(int, input().split())
	lst.append((-max(a * t1 * ((100 - k) / 100) + b * t2, b * t1 * ((100 - k) / 100) + a * t2), i + 1))
lst.sort()
for i in range(n):
	print('%d %.2f' % (lst[i][1], -lst[i][0]))


(n, t1, t2, k) = map(int, input().split())
(result, res) = ({}, {})
a = {i: list(map(int, input().split())) for i in range(1, n + 1)}
for i in range(1, n + 1):
	s = a[i][0] * t1 - a[i][0] * t1 * (k / 100) + a[i][1] * t2
	t = a[i][1] * t1 - a[i][1] * t1 * (k / 100) + a[i][0] * t2
	s = format(max(s, t), '.2f')
	res[i] = s
	result[i] = float(s)
result = sorted(result.items(), key=lambda x: x[1], reverse=True)
for (i, j) in result:
	print(i, res[i])


def sort(lst):
	for i in range(len(lst)):
		for j in range(len(lst)):
			if lst[i][0] > lst[j][0]:
				(lst[i], lst[j]) = (lst[j], lst[i])
			if lst[i][0] == lst[j][0]:
				if lst[i][1] < lst[j][1]:
					(lst[i], lst[j]) = (lst[j], lst[i])
(n, t1, t2, k) = map(int, input().split())
table = []
for i in range(n):
	(a, b) = map(int, input().split())
	table += [[max(t1 * a * (100 - k) / 100 + t2 * b, t1 * b * (100 - k) / 100 + t2 * a), i + 1]]
sort(table)
for i in table:
	print(i[1], '%.2f' % i[0])


(a, b, c, d) = map(int, input().split())
x = []
for _ in range(a):
	(e, f) = map(int, input().split())
	g = e * b - e * b * d / 100 + f * c
	h = f * b - f * b * d / 100 + e * c
	i = max(g, h)
	x.append((-i, _ + 1))
x.sort()
for (i, y) in x:
	print('%d %.2f' % (y, -i))


(n, t1, t2, k) = map(int, input().split(' '))
d1 = {}
d_r = {}
for i in range(n):
	d1[i + 1] = list(map(int, input().split(' ')))
for i in range(n):
	a = d1[i + 1][0] * t1 * (100 - k) / 100 + d1[i + 1][1] * t2
	b = d1[i + 1][1] * t1 * (100 - k) / 100 + d1[i + 1][0] * t2
	if a > b:
		d_r[i + 1] = round(a, 2)
	else:
		d_r[i + 1] = round(b, 2)
sort_orders = sorted(d_r.items(), key=lambda x: x[1], reverse=True)
for i in sort_orders:
	print(i[0], '%.2f' % i[1])


(n, t1, t2, k) = list(map(int, input().split()))
rank = []
for seed_grower in range(n):
	(speed1, speed2) = list(map(int, input().split()))
	var1 = speed1 * t1 * (1 - k / 100) + speed2 * t2
	var2 = speed2 * t1 * (1 - k / 100) + speed1 * t2
	total = max(var1, var2)
	rank.append((seed_grower + 1, total))
for (seed_grower, plant_height) in sorted(sorted(rank, key=lambda x: x[0]), key=lambda x: x[1], reverse=True):
	print(seed_grower, '{:.2f}'.format(plant_height))


(n, t1, t2, k) = map(int, input().split())
matrix = []
for i in range(n):
	(a, b) = map(int, input().split())
	choice1 = a * t1 - a * t1 * (k / 100) + b * t2
	choice2 = b * t1 - b * t1 * (k / 100) + a * t2
	a = [i + 1, max(choice1, choice2)]
	matrix.append(a)
matrix.sort(key=lambda x: x[1], reverse=True)
for i in matrix:
	print('{} {:.2f}'.format(i[0], i[1]))


from sys import stdin, stdout
from collections import Counter, deque
from queue import PriorityQueue
import math
helperConstants = True
helperUtilityFunctions = True

def input():
	return stdin.readline().strip()
if helperConstants:
	YES = 'YES'
	NO = 'NO'
	yes = 'yes'
	no = 'no'
	true = 'true'
	false = 'false'
	FALSE = 'FALSE'
	TRUE = 'TRUE'
	IMPOSSIBLE = 'IMPOSSIBLE'
	POSSIBLE = 'POSSIBLE'
	INF = float('inf')
if helperUtilityFunctions:

	def getInputArray():
		return list(map(int, input().split()))

	def getIntegerInputs():
		return map(int, input().split())

	def getInputIntegerMatrix(n):
		matrix = []
		for i in range(n):
			matrix.append(list(map(int, input().split())))
		return matrix

	def getInputStringMatrix(n):
		matrix = []
		for i in range(n):
			matrix.append(input())
		return matrix

	def outputIntegerMatrix(matrix):
		for i in range(len(matrix)):
			print(*matrix[i])

	def outputStringMatrix(matrix):
		for i in range(len(matrix)):
			print(matrix[i])

	def kickstartoutput(testcase, *outputs):
		print('Case #%d:' % testcase, *outputs)

def solve():
	(n, t1, t2, k) = getIntegerInputs()
	participants = []
	k = 1 - k * 0.01
	for i in range(n):
		(a, b) = getIntegerInputs()
		ans1 = 0
		ans2 = 0
		ans1 += a * t1
		ans1 = ans1 * k
		ans1 += b * t2
		ans2 += b * t1
		ans2 = ans2 * k
		ans2 += a * t2
		ans = max(ans1, ans2)
		participants.append({'index': i + 1, 'value': ans})
	participants.sort(reverse=True, key=lambda x: x['value'])
	for participant in participants:
		print('%d %.2f' % (participant['index'], participant['value']))
solve()


from collections import deque
(n, t1, t2, k) = map(int, input().split())
l = deque()
for i in range(n):
	(a, b) = map(int, input().split())
	r1 = a * t1 - a * t1 * k / 100 + b * t2
	r2 = b * t1 - b * t1 * k / 100 + a * t2
	l.append([i + 1, max(r1, r2)])
l = list(l)
l.sort(key=lambda x: x[1], reverse=True)
for i in range(len(l)):
	print('%d %.2f' % (l[i][0], l[i][1]))


inputs = input().split()
n = int(inputs[0])
t1 = int(inputs[1])
t2 = int(inputs[2])
k = int(inputs[3]) / 100
inputs.clear()
results = []
for i in range(n):
	inputs.append([int(x) for x in input().split()])
	if k == 1:
		results.append(max(inputs[i][0], inputs[i][1]) * t2)
	else:
		alt1 = inputs[i][0] * t1 * (1 - k) + inputs[i][1] * t2
		alt2 = inputs[i][1] * t1 * (1 - k) + inputs[i][0] * t2
		results.append(round(max(alt1, alt2), 2))
finalResult = {i: ele for (i, ele) in enumerate(results)}
finalResult = dict(sorted(finalResult.items(), key=lambda item: item[1], reverse=True))
for (key, value) in zip(finalResult.keys(), finalResult.values()):
	print('{} {:.2f}'.format(key + 1, value))


(n, t1, t2, c) = tuple([int(d) for d in input().split(' ')])
arr = list()
for i in range(0, n):
	items = [int(g) for g in input().split(' ')]
	val1 = t1 * items[0] - t1 * items[0] * (c / 100.0) + t2 / 1.0 * (items[1] / 1.0)
	val2 = t1 * items[1] - t1 * items[1] * (c / 100.0) + t2 / 1.0 * (items[0] / 1.0)
	arr.append([max([val1, val2]), i + 1])
sorted_arr = sorted(arr, key=lambda x: x[0], reverse=True)
for i in range(0, len(sorted_arr)):
	print(str(sorted_arr[i][1]) + ' ' + str('{0:.2f}'.format(sorted_arr[i][0])))


__author__ = 'Alex'
(n, t1, t2, k) = [int(i) for i in input().split()]
(u, v) = ([], [])
for i in range(n):
	(a, b) = [int(i) for i in input().split()]
	u.append(a)
	v.append(b)
a = []
for j in range(n):
	a.append((-max(t1 * u[j] * (100 - k) / 100 + t2 * v[j], t1 * v[j] * (100 - k) / 100 + t2 * u[j]), j))
a.sort()
for i in range(n):
	print('%d %2.2f' % (a[i][1] + 1, -a[i][0]))


def count(t1, t2, k, a, b):
	s = a * t1
	s -= s * k / 100
	s += b * t2
	return s

def my_format(a):
	a = str(a)
	i = 0
	while i < len(a) and a[i] != '.':
		i += 1
	a = a[:min(len(a), i + 2)]
	return a
(n, t1, t2, k) = map(int, input().split())
a = [0] * n
b = [0] * n
s = [(0, 0) for i in range(n)]
for i in range(n):
	(a[i], b[i]) = map(int, input().split())
	s[i] = (-max(count(t1, t2, k, b[i], a[i]), count(t1, t2, k, a[i], b[i])), i + 1)
s.sort()
for i in s:
	print(i[1], '%.2f' % -i[0])


(n, t1, t2, k) = map(int, input().split())
ds = []
for i in range(n):
	(v, u) = map(int, input().split())
	ds.append([i + 1, max(t1 * v * (1 - k / 100) + t2 * u, t1 * u * (1 - k / 100) + t2 * v)])
ds = sorted(ds, key=lambda x: (-x[1], x[0]))
for d in ds:
	print(str(d[0]) + ' ' + f'{d[1]:.2f}')


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
(n, a, b, k) = r()
arr = [rr() for _ in range(n)]
k = k / 100
k = 1 - k
brr = []
for (i, j) in arr:
	x = i * a * k + j * b
	y = j * a * k + b * i
	brr.append(max(x, y))
arr = brr[:]
arr = list(enumerate(arr, 1))
arr.sort(key=lambda x: x[1], reverse=True)
for (i, j) in arr:
	print(f'{i} {j:.2f}')


from operator import itemgetter
(n, t1, t2, k) = map(int, input().split())
arr = []
k = (100 - k) / 100
for i in range(1, n + 1):
	(a, b) = map(int, input().split())
	p = a * t1 * k + b * t2
	q = b * t1 * k + a * t2
	arr.append([max(p, q), i])
s = sorted(arr, key=lambda l: l[1])
s = sorted(s, key=lambda l: l[0], reverse=True)
for i in s:
	print(i[1], '{0:.2f}'.format(i[0]))


(n, t1, t2, k) = map(int, input().split(' '))
nums = [[0, 0] for t in range(n)]
for line in range(n):
	(a, b) = map(int, input().split(' '))
	nums[line][0] = max(a * t2 + b * (t1 * (1 - k / 100)), b * t2 + a * (t1 * (1 - k / 100)))
	nums[line][1] = 13379001 - line
nums.sort()
nums.reverse()
for a in range(len(nums)):
	print(13379001 - nums[a][1] + 1, '{0:.2f}'.format(nums[a][0]))


def main():
	(n, t1, t2, k) = [int(i) for i in input().split()]
	v = []
	for i in range(n):
		(a, b) = [int(i) for i in input().split()]
		v.append([a, b])
	res = []
	for i in range(n):
		(a, b) = v[i]
		h1 = a * t1 * (1 - k / 100) + b * t2
		h2 = b * t1 * (1 - k / 100) + a * t2
		h = max(h1, h2)
		res.append([i + 1, h])
	for (i, rec) in sorted(res, key=lambda x: x[1], reverse=True):
		print(f'{i} {rec:.2f}')
main()


(n, t1, t2, k) = [int(y) for y in input().split()]
res = []
for i in range(n):
	(a, b) = [int(y) for y in input().split()]
	temp = max(a * t1 * (100 - k) / 100 + b * t2, b * t1 * (100 - k) / 100 + a * t2)
	res.append([i + 1, round(temp, 2)])
res = sorted(res, key=lambda item: item[1], reverse=True)
for i in res:
	if str(i[1])[-3] != '.':
		i[1] = str(i[1]) + '0'
	print(i[0], i[1])


(n, t1, t2, k) = map(int, input().split())
arr = [0] * n
redn = (100 - k) / 100
for i in range(n):
	(a, b) = map(int, input().split())
	res = max(t1 * a * redn + t2 * b, t1 * b * redn + t2 * a)
	arr[i] = [i + 1, res]
arr.sort(key=lambda x: (-x[1], x[0]))
for ele in arr:
	print(ele[0], '%.2f' % ele[1])


(n, t1, t2, k) = map(int, input().split())
res = []
for i in range(n):
	(a, b) = map(int, input().split())
	res.append([a, b])
for i in range(n):
	res[i] = max(t1 * res[i][0] - t1 * res[i][0] * (k / 100) + t2 * res[i][1], t1 * res[i][1] - t1 * res[i][1] * (k / 100) + t2 * res[i][0])
for i in range(n):
	res[i] = [i + 1, res[i]]
res.sort(key=lambda x: x[1], reverse=True)
start = False
end = False
s = None
e = None
for i in range(n - 1):
	if res[i][1] == res[i + 1][1] and (not start):
		s = i
		start = True
	if res[i][1] != res[i + 1][1] and start:
		e = i
		end = True
	if start and end:
		res[start:end] = res[start:end][::-1]
		start = False
		end = False
		s = None
		e = None
for i in res:
	print(i[0], '%.2f' % i[1])


(n, t1, t2, k) = map(int, input().split())
lis = []
arr = []
for i in range(n):
	(h, h1, h2, h11, h22, hh) = (0, 0, 0, 0, 0, 0)
	(a, b) = map(int, input().split())
	h1 = a * t1
	h11 = b * t1
	h1 = h1 - k * h1 / 100
	h11 = h11 - k * h11 / 100
	h2 = b * t2
	h22 = a * t2
	h = h1 + h2
	hh = h11 + h22
	arr.append(max(h, hh))
	c = max(h, hh)
	c = '%.2f' % c
	lis.append(c)
dic = {}
for i in range(len(lis)):
	if lis[i] in dic:
		dic[lis[i]].append(i + 1)
	else:
		dic[lis[i]] = [i + 1]
se = set(arr)
new_arr = []
final_arr = []
for i in se:
	new_arr.append(i)
new_arr.sort(reverse=True)
for j in new_arr:
	j = '%.2f' % j
	final_arr.append(j)
for i in final_arr:
	for j in dic[i]:
		print(j, i)


from decimal import Decimal
(n, t1, t2, k) = map(int, input().strip().split())
l = []
i = 1
while n != 0:
	(x, y) = map(int, input().strip().split())
	p1 = x * t1 - x * t1 / 100 * k + y * t2
	p2 = y * t1 - y * t1 / 100 * k + x * t2
	g = max(p1, p2)
	l.append([i, g])
	i += 1
	n -= 1
l.sort(key=lambda el: el[1], reverse=True)
for i in range(0, len(l)):
	print('%d %.2f' % (l[i][0], l[i][1]))


I = lambda : map(int, input().split())
(n, t1, t2, k) = I()
res = []
for i in range(n):
	(a, b) = I()
	res.append((i, max((1 - k / 100) * a * t1 + b * t2, (1 - k / 100) * b * t1 + a * t2)))
for (i, h) in sorted(res, key=lambda x: (-x[1], x[0])):
	print(i + 1, f'{h:.2f}')


(n, t1, t2, k) = map(int, input().split())
growths = []
for i in range(n):
	(a, b) = map(int, input().split())
	growth = max(a * t1 * (1 - k / 100) + b * t2, b * t1 * (1 - k / 100) + a * t2)
	growths.append((i + 1, growth))
for l in sorted(growths, key=lambda x: (-x[1], x[0])):
	print('{:d} {:.2f}'.format(l[0], l[1]))


(n, t1, t2, k) = map(int, input().split())
t1 *= 100 - k
t2 *= 100
p = [map(int, input().split()) for i in range(n)]
if t1 < t2:
	l = [(t1 * a + t2 * b if a < b else t1 * b + t2 * a, -i) for (i, (a, b)) in enumerate(p, 1)]
else:
	l = [(t1 * a + t2 * b if a > b else t1 * b + t2 * a, -i) for (i, (a, b)) in enumerate(p, 1)]
l.sort(reverse=True)
print('\n'.join((str(-k) + ' ' + str(r // 100) + '.' + str(100 + r)[-2:] for (r, k) in l)))


(n, t1, t2, k) = map(int, input().split())
l = []
i = 1
while n != 0:
	(a, b) = map(int, input().split())
	r1 = a * t1 - a * t1 / 100 * k + b * t2
	r2 = b * t1 - b * t1 / 100 * k + a * t2
	g = max(r1, r2)
	l.append([i, g])
	i += 1
	n -= 1
l.sort(key=lambda x: x[1], reverse=True)
for i in range(len(l)):
	print('%d %.2f' % (l[i][0], l[i][1]))


def main():
	(n, t1, t2, k) = list(map(int, input().split()))
	res = []
	for i in range(1, n + 1):
		(a, b) = list(map(int, input().split()))
		ta = a * t1 * (1 - k / 100) + b * t2
		tb = b * t1 * (1 - k / 100) + a * t2
		t = max(ta, tb)
		res.append([i, t])
	res = sorted(res, key=lambda x: (x[1], -x[0]))[::-1]
	for (i, r) in res:
		print('{:d} {:.2f}'.format(i, r))
main()


(n, t1, t2, k) = map(int, input().split())
k = k / 100
c = []
for i in range(n):
	(a, b) = map(int, input().split())
	cal = max(a * t1 - a * t1 * k + b * t2, b * t1 - b * t1 * k + a * t2)
	c.append((i + 1, cal))
c.sort(key=lambda x: x[1], reverse=True)
for i in c:
	print(i[0], end=' ')
	print('%.2f' % i[1], end=' ')
	print()


class Result:

	def __init__(self, n, l):
		self.participant_number = n
		self.mushroom_length = l

	def __lt__(self, result):
		return self.mushroom_length < result.mushroom_length or (self.mushroom_length == result.mushroom_length and self.participant_number > result.participant_number)

	def __gt__(self, result):
		return not (self.mushroom_length < result.mushroom_length or (self.mushroom_length == result.mushroom_length and self.participant_number > result.participant_number))

	def __str__(self):
		return str(self.participant_number) + ' ' + '{:.2f}'.format(self.mushroom_length)

def sort_results(results):
	n = len(results)
	for i in range(n):
		max_index = i
		for j in range(i + 1, n):
			if results[j] > results[max_index]:
				max_index = j
		if max_index != i:
			(results[i], results[max_index]) = (results[max_index], results[i])
	return results

def length(t1, t2, k, u, v):
	return max(t1 * u * (100 - k) / 100 + t2 * v, t1 * v * (100 - k) / 100 + t2 * u)
(n, t1, t2, k) = list(map(lambda x: int(x), input().split()))
v = []
u = []
results = []
for i in range(n):
	(vi, ui) = list(map(lambda x: int(x), input().split()))
	v.append(vi)
	u.append(ui)
	results.append(Result(i + 1, length(t1, t2, k, u[i], v[i])))
sort_results(results)
for i in range(n):
	print(results[i])


inpu = input()
(n, t1, t2, k) = inpu.split()
n = int(n)
t1 = float(t1)
t2 = float(t2)
k = float(k)
ans = {}
for i in range(n):
	a = input()
	b = a.split()[1]
	a = a.split()[0]
	a = float(a)
	b = float(b)
	before = round(a * t1 * (1 - k / float(100)) + b * t2, 2)
	after = round(b * t1 * (1 - k / float(100)) + a * t2, 2)
	if before > after:
		if before not in ans:
			ans[before] = []
		ans[before].append(i + 1)
	else:
		if after not in ans:
			ans[after] = []
		ans[after].append(i + 1)
growths = sorted(ans.keys())
growths = growths[::-1]
for g in growths:
	for i in ans[g]:
		print(i, '%.2f' % g)


(n, t1, t2, k) = map(int, input().split())
dw = []
for i in range(n):
	(a, b) = map(int, input().split())
	first = t1 * a - t1 * a * k / 100 + t2 * b
	second = t1 * b - t1 * b * k / 100 + t2 * a
	dw.append((i + 1, max(first, second)))
dw.sort(key=lambda x: x[1], reverse=True)
for i in dw:
	print('%d %.2f' % (i[0], i[1]))


from sys import stdin, stdout

def main():
	(n, t1, t2, k) = map(int, stdin.readline().split())
	parts = []
	for i in range(1, n + 1):
		(a, b) = map(int, stdin.readline().split())
		m = max(a * t1 * (100 - k) / 100 + b * t2, b * t1 * (100 - k) / 100 + a * t2)
		parts.append((i, m))
	parts.sort(key=lambda x: x[1], reverse=True)
	for (i, val) in parts:
		print('{} {:.2f}'.format(i, val))
main()


import sys

def ints_input():
	return [int(i) for i in sys.stdin.readline().strip('\n').split(' ')]

def print_list(arr):
	sys.stdout.writelines((str(x) + ' ' for x in arr))
	sys.stdout.write('\n')

def fast_input(type=str):
	return type(sys.stdin.readline().strip('\n'))

class grower:

	def __init__(self, i, h):
		self.i = i
		self.h = h

	def __str__(self) -> str:
		return '{} {:0.2f}'.format(self.i, self.h)
(n, t1, t2, k) = ints_input()
arr = []
for i in range(n):
	(v1, v2) = ints_input()
	if v1 * t1 * (100 - k) / 100 + v2 * t2 > v2 * t1 * (100 - k) / 100 + v1 * t2:
		arr.append(grower(i + 1, v1 * t1 * (100 - k) / 100 + v2 * t2))
	else:
		arr.append(grower(i + 1, v2 * t1 * (100 - k) / 100 + v1 * t2))
arr.sort(key=lambda o: o.h, reverse=True)
for i in arr:
	print(i)


(n, t1, t2, k) = map(int, input().split())
table = []
for i in range(n):
	(a, b) = map(int, input().split())
	g1 = a * t1 * (100 - k) / 100 + b * t2
	g2 = b * t1 * (100 - k) / 100 + a * t2
	table.append([max(g1, g2), i + 1])
table.sort(key=lambda x: x[0], reverse=True)
for (i, t) in enumerate(table):
	print(t[1], end=' ')
	print('{:.2f}'.format(t[0]))


(n, t1, t2, k) = map(int, input().split())
board = []
for i in range(1, n + 1):
	(a, b) = map(int, input().split())
	c1 = a * t2 + (1 - k / 100) * t1 * b
	c2 = b * t2 + (1 - k / 100) * t1 * a
	c = c1 if c1 > c2 else c2
	board.append((i, c))
board = sorted(board, key=lambda x: x[1], reverse=True)
for p in board:
	print('%d %.2f' % (p[0], p[1]))


def comp(item1, item2):
	if item1[0] > item2[0]:
		return True
	elif item2[0] > item1[0]:
		return False
	elif item1[1] < item2[1]:
		return True
	else:
		return False

def mergeSort(nums):
	if len(nums) < 2:
		return nums
	else:
		mid = len(nums) // 2
		left = mergeSort(nums[:mid])
		right = mergeSort(nums[mid:])
	temp = []
	i = 0
	j = 0
	while i < len(left) and j < len(right):
		if comp(left[i], right[j]):
			temp.append(left[i])
			i += 1
		else:
			temp.append(right[j])
			j += 1
	if i < len(left):
		temp.extend(left[i:])
	if j < len(right):
		temp.extend(right[j:])
	return temp
(n, t1, t2, k) = map(int, input().split())
nums = []
for i in range(n):
	(a, b) = map(int, input().split())
	val = max(a * t1 * (1 - k / 100) + b * t2, b * t1 * (1 - k / 100) + a * t2)
	nums.append([val, i + 1])
nums = mergeSort(nums)
for i in nums:
	print('{} {:.2f}'.format(i[1], i[0]))


from decimal import Decimal as de
get_int = lambda : int(input())
get_mul_int = lambda : map(int, input().rstrip().split())
get_list = lambda : list(map(int, input().rstrip().split()))
TEST_CASES = False

def main():
	(n, t1, t2, k) = get_mul_int()
	table = []
	for j in range(n):
		(a, b) = get_mul_int()
		h1 = de(a * t1 * ((100 - k) / 100)) + b * t2
		h2 = de(b * t1 * ((100 - k) / 100)) + a * t2
		table.append([j + 1, round(max(h1, h2), 2)])
	new = sorted(table, key=lambda x: x[-1], reverse=True)
	for i in new:
		print(*i)
if not TEST_CASES:
	main()
else:
	[main() for _ in range(int(input()))]


(n, t1, t2, k) = map(int, input().split(' '))
factor = 1 - k / 100
listX = []
for i in range(n):
	(a, b) = map(int, input().split(' '))
	maxX = max(a * t1 * factor + b * t2, b * t1 * factor + a * t2)
	listX.append(maxX)
maxVal = max(listX)
while maxVal != -1:
	indexMax = listX.index(maxVal)
	print(indexMax + 1, '%.2f' % maxVal)
	listX[indexMax] = -1
	maxVal = max(listX)


(n, t1, t2, k) = map(int, input().split())
n = int(n)
k = k / 100
d = {}
for i in range(1, n + 1):
	(a, b) = map(float, input().split())
	mi = min(a, b)
	ma = max(a, b)
	z1 = mi * t1 - mi * t1 * k + ma * t2
	z2 = ma * t1 - ma * t1 * k + mi * t2
	z = max(z1, z2)
	z = round(z, 2)
	d[i] = z
h = sorted(d.values(), reverse=True)
for i in h:
	for (key, value) in d.items():
		if i == value:
			value = str(value)
			if value[::-1].find('.') == 1:
				value = value + '0'
			print(key, value)
			del d[key]
			break


(n, t1, t2, k) = map(int, input().split())
k = (100 - k) / 100
from collections import defaultdict
result = defaultdict()
for i in range(n):
	(a, b) = map(int, input().split())
	result[i + 1] = max(b * t1 * k + t2 * a, a * t1 * k + t2 * b)
result = {k: v for (k, v) in sorted(result.items(), reverse=True, key=lambda item: item[1])}
for each in result.keys():
	print(each, '{:.2f}'.format(result[each]))


import operator
(n, t1, t2, l) = map(int, input().split())
partData = []
finalData = []
for x in range(n):
	partData.append(list(map(int, input().split())))
counter = 1
for (j, k) in partData:
	if j * t1 - j * t1 * (l / 100) + k * t2 > k * t1 - k * t1 * (l / 100) + j * t2:
		finalData.append((counter, j * t1 - j * t1 * (l / 100) + k * t2))
	else:
		finalData.append((counter, k * t1 - k * t1 * (l / 100) + j * t2))
	counter += 1
finalData = sorted(finalData, key=operator.itemgetter(1), reverse=True)
for (x, y) in finalData:
	print('{} {:.2F}'.format(x, y))


import sys
import math
(n, t1, t2, k) = [int(x) for x in sys.stdin.readline().split()]
res = []
for i in range(n):
	(a, b) = [int(x) for x in sys.stdin.readline().split()]
	v1 = t1 * a
	v1 -= v1 * k / 100
	v2 = t2 * b
	v1_2 = t1 * b
	v1_2 -= v1_2 * k / 100
	v2_2 = t2 * a
	res.append((i + 1, max(v1 + v2, v1_2 + v2_2)))
res = sorted(res, key=lambda x: (x[1], -x[0]), reverse=True)
for i in res:
	print(i[0], '%.2f' % i[1])


from collections import defaultdict
(n, t1, t2, k) = map(int, input().split())
results = defaultdict(list)
i = 1
while n:
	(a, b) = map(int, input().split())
	first_height = a * t1 - a * t1 * k / 100 + b * t2
	second_height = b * t1 - b * t1 * k / 100 + a * t2
	height = round(max(first_height, second_height), 2)
	results[height].append(i)
	i += 1
	n -= 1
for key in sorted(results, reverse=True):
	for i in results[key]:
		s = str(key)
		s = s.split('.')
		if len(s[-1]) == 1:
			print(i, s[0] + '.' + s[-1] + '0')
		else:
			print(i, key)


from operator import itemgetter
(n, t1, t2, k) = list(map(int, input().split()))
c = []
for i in range(n):
	(a, b) = list(map(int, input().split()))
	h1 = a * t1 * (1 - k / 100) + b * t2
	h2 = b * t1 * (1 - k / 100) + a * t2
	c.append([-max(h1, h2), i + 1])
c.sort(key=itemgetter(0, 1))
for el in c:
	print('{0} {1:.2f}'.format(el[1], -el[0]))


(n, t1, t2, k) = map(int, input().split())
(a, b) = ([], [])
for _ in range(n):
	(t11, t21) = map(int, input().split())
	a.append(t11)
	b.append(t21)
res = [0] * n
for i in range(n):
	res[i] = (max(t1 * a[i] * 0.01 * (100 - k) + t2 * b[i], t1 * b[i] * 0.01 * (100 - k) + t2 * a[i]), i + 1)
res.sort(key=lambda k: (k[0], -k[1]), reverse=True)
for i in res:
	print(i[1], '%.2f' % i[0])


def I():
	return list(map(int, input().split()))
(n, t1, t2, k) = I()
lis = []
for i in range(n):
	(x, y) = I()
	a = y * t2 - x * t1 * (k / 100) + x * t1
	b = x * t2 - y * t1 * (k / 100) + y * t1
	maxi = max(a, b)
	lis.append([i + 1, maxi])
lis.sort(key=lambda x: x[1], reverse=True)
for (i, j) in lis:
	print(f'{i} {j:.2f}')


import sys

def input():
	return sys.stdin.readline().strip()
(n, t1, t2, k) = map(int, input().split())
speed = []
for i in range(n):
	speed.append([int(i) for i in input().split()])
h = []
for i in range(n):
	break1 = min(speed[i]) * t1 * (1 - k / 100) + max(speed[i]) * t2
	break2 = max(speed[i]) * t1 * (1 - k / 100) + min(speed[i]) * t2
	h.append([max(break1, break2), i + 1])
h.sort(reverse=True)
i = 0
while i < n - 1:
	j = i + 1
	ind = [h[i][1]]
	while j < n and h[i][0] == h[j][0]:
		ind.append(h[j][1])
		j += 1
	ind.sort()
	for k in range(i, j):
		h[k][1] = ind[k - i]
	i = j
for i in range(n):
	print(h[i][1], '%.2f' % h[i][0])


import sys
import math
from heapq import *
input = sys.stdin.readline
from functools import cmp_to_key

def pi():
	return int(input())

def pl():
	return int(input(), 16)

def ti():
	return list(map(int, input().split()))

def ts():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
mod = 1000000007
f = []

def fact(n, m):
	global f
	f = [1 for i in range(n + 1)]
	f[0] = 1
	for i in range(1, n + 1):
		f[i] = f[i - 1] * i % m

def fast_mod_exp(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b = b >> 1
	return res

def inverseMod(n, m):
	return fast_mod_exp(n, m - 2, m)

def ncr(n, r, m):
	if n < 0 or r < 0 or r > n:
		return 0
	if r == 0:
		return 1
	return f[n] * inverseMod(f[n - r], m) % m * inverseMod(f[r], m) % m

def main():
	B()

def cmp(a, b):
	if a[1] < b[1]:
		return 1
	if a[1] > b[1]:
		return -1
	if a[1] == b[1]:
		if a[0] < b[0]:
			return -1
		else:
			return 1

def B():
	[n, t1, t2, k] = ti()
	(a, b) = ([], [])
	for i in range(n):
		[x, y] = ti()
		a.append(x)
		b.append(y)
	pair = [0 for i in range(n)]
	for i in range(n):
		pair[i] = [i, round(max(t1 * a[i] * (100 - k) / 100 + t2 * b[i], t1 * b[i] * (100 - k) / 100 + t2 * a[i]), 2)]
	pair.sort(key=cmp_to_key(cmp))
	for i in range(n):
		print(pair[i][0] + 1, pair[i][1] if len(str(pair[i][1]).split('.')[1]) == 2 else str(pair[i][1]) + '0')
main()


(n, t1, t2, k) = map(int, input().split())
res = []
for i in range(n):
	(a, b) = map(int, input().split())
	x = (100 - k) / 100 * a * t1 + b * t2
	y = (100 - k) / 100 * b * t1 + a * t2
	res.append((-max(x, y), i + 1))
res.sort()
for (val, idx) in res:
	print('%d %.2f' % (idx, -val))


(n, t1, t2, k) = map(int, input().split())
arr = []
for i in range(1, n + 1):
	(a, b) = map(int, input().split())
	arr.append([i, round(max(a * t1 * (1 - k / 100) + b * t2, b * t1 * (1 - k / 100) + a * t2), 2)])
arr.sort(reverse=True, key=lambda x: x[1])
for i in arr:
	print(i[0], '{0:.2f}'.format(i[1]))


import sys
import math
import collections
import bisect

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
(n, t1, t2, k) = get_ints()
ans = []
for i in range(n):
	(a, b) = get_ints()
	v1 = a * t1 * (1 - k / 100) + b * t2
	v2 = b * t1 * (1 - k / 100) + a * t2
	v = max(v1, v2)
	ans.append([i + 1, v])
ans.sort(reverse=True, key=lambda x: x[1])
for i in ans:
	print(i[0], '{:0.2f}'.format(i[1]))


import sys
input = sys.stdin.readline
read_tuple = lambda _type: map(_type, input().split(' '))

def solve():
	(n, t_1, t_2, k) = read_tuple(int)
	v = [tuple(read_tuple(int)) for _ in range(n)]
	heights = [(i + 1, max(a * t_1 * (1 - k / 100) + b * t_2, b * t_1 * (1 - k / 100) + a * t_2)) for (i, (a, b)) in enumerate(v)]
	heights.sort(key=lambda x: x[1], reverse=True)
	for (i, h) in heights:
		print(f'{i} {h:.2f}')
solve()


(n, t1, t2, k) = map(int, input().split())
arr = []
for i in range(n):
	curr = list(map(int, input().split()))
	curr.sort()
	a = curr[0]
	b = curr[1]
	arr.append([a, b])
ans = []
y = 1
for i in arr:
	a = i[0]
	b = i[1]
	curr_1 = a * (t1 - t1 * (k / 100)) + b * t2
	a = i[1]
	b = i[0]
	curr_2 = a * (t1 - t1 * (k / 100)) + b * t2
	curr = max(curr_1, curr_2)
	x = '{:.2f}'.format(curr)
	ans.append([x, y])
	y += 1
ans.sort(reverse=True, key=lambda arr: float(arr[0]))
for i in ans:
	print(i[1], i[0])


(n, t1, t2, k) = map(int, input().split())
speeds = []
for i in range(n):
	(u, v) = map(int, input().split())
	speeds.append([u, v])
tally = []
for i in range(n):
	if t1 * ((100 - k) / 100) > t2:
		tally.append([i + 1, t1 * ((100 - k) / 100) * max(speeds[i][0], speeds[i][1]) + t2 * min(speeds[i][0], speeds[i][1])])
	else:
		tally.append([i + 1, t1 * ((100 - k) / 100) * min(speeds[i][0], speeds[i][1]) + t2 * max(speeds[i][0], speeds[i][1])])
tally.sort(reverse=True, key=lambda x: x[1])
for i in range(n):
	print(tally[i][0], '{:.2f}'.format(tally[i][1]))


num_testcases = 1
for _ in range(num_testcases):
	(num_participant, time_before_break, time_after_break, percentage) = map(int, input().split())
	result = []
	for i in range(num_participant):
		(a, b) = map(int, input().split())
		max_s = max(a * time_before_break - percentage * a * time_before_break / 100.0 + b * time_after_break, b * time_before_break - percentage * b * time_before_break / 100.0 + a * time_after_break)
		result.append([i + 1, max_s])
	result.sort(key=lambda c: c[1], reverse=True)
	for i in result:
		print(i[0], '%.2f' % i[1])


(n, t1, t2, k) = map(int, input().split())
l = list((list(map(int, input().split())) for i in range(n)))
s = {}
if t1 * (100 - k) / 100 >= t2:
	for i in range(n):
		s[i + 1] = max(l[i]) * t1 * (100 - k) / 100 + min(l[i]) * t2
else:
	for i in range(n):
		s[i + 1] = min(l[i]) * t1 * (100 - k) / 100 + max(l[i]) * t2
s = {k: v for (k, v) in sorted(s.items(), key=lambda item: item[1], reverse=True)}
for (i, j) in s.items():
	print(i, '{:.2f}'.format(j), sep=' ')