On a number line there are n balls. At time moment 0 for each ball the following data is known: its coordinate xi, speed vi (possibly, negative) and weight mi. The radius of the balls can be ignored.

The balls collide elastically, i.e. if two balls weighing m1 and m2 and with speeds v1 and v2 collide, their new speeds will be: 

<image>.

Your task is to find out, where each ball will be t seconds after.

Input

The first line contains two integers n and t (1 ≤ n ≤ 10, 0 ≤ t ≤ 100) — amount of balls and duration of the process. Then follow n lines, each containing three integers: xi, vi, mi (1 ≤ |vi|, mi ≤ 100, |xi| ≤ 100) — coordinate, speed and weight of the ball with index i at time moment 0.

It is guaranteed that no two balls have the same coordinate initially. Also each collision will be a collision of not more than two balls (that is, three or more balls never collide at the same point in all times from segment [0;t]).

Output

Output n numbers — coordinates of the balls t seconds after. Output the numbers accurate to at least 4 digits after the decimal point.

Examples

Input

2 9
3 4 5
0 7 8


Output

68.538461538
44.538461538


Input

3 10
1 2 3
4 -5 6
7 -8 9


Output

-93.666666667
-74.666666667
-15.666666667

Source: codeforces | Difficulty: HARD
Tags: Mathematics

Implementation

Complete search


Solutions:
class Ball:

	def __init__(self, x, v, m):
		self.v = v
		self.x = x
		self.m = m

	def move(self, time):
		self.x += self.v * time

	def collisionTime(self, other):
		if self.v == other.v:
			return float('inf')
		t = -(self.x - other.x) / (self.v - other.v)
		if t < 1e-09:
			return float('inf')
		return t

	def __str__(self):
		return 'Ball(x={:.2f} v={:.2f} m={:.2f})'.format(self.x, self.v, self.m)

def findFirst():
	global nBalls, balls
	minTime = float('inf')
	minPairs = []
	for i in range(nBalls):
		for j in range(i + 1, nBalls):
			time = balls[i].collisionTime(balls[j])
			if time < minTime:
				minTime = time
				minPairs = [(i, j)]
			elif abs(time - minTime) < 1e-09:
				minPairs.append((i, j))
	return (minTime, minPairs)

def collidePair(i, j):
	global balls
	v1 = balls[i].v
	v2 = balls[j].v
	m1 = balls[i].m
	m2 = balls[j].m
	balls[i].v = ((m1 - m2) * v1 + 2 * m2 * v2) / (m1 + m2)
	balls[j].v = ((m2 - m1) * v2 + 2 * m1 * v1) / (m1 + m2)
(nBalls, maxTime) = map(int, input().split())
balls = []
for i in range(nBalls):
	(x, v, m) = map(int, input().split())
	balls.append(Ball(x, v, m))
while True:
	(time, pairs) = findFirst()
	if time > maxTime:
		break
	for i in range(nBalls):
		balls[i].move(time)
	for (i, j) in pairs:
		collidePair(i, j)
	maxTime -= time
for ball in balls:
	ball.move(maxTime)
	print('{:.6f}'.format(ball.x))


(n, t) = map(int, input().split())
ar = []
for _ in range(n):
	ar.append(list(map(int, input().split())))
cur = 0
while True:
	T = float('inf')
	nums = []
	for i in range(n):
		for j in range(i):
			vd = ar[i][1] - ar[j][1]
			xd = ar[i][0] - ar[j][0]
			xd = -xd
			if vd == 0:
				continue
			if xd / vd <= 1e-06:
				continue
			if cur + xd / vd >= t:
				continue
			if xd / vd < T and abs(xd / vd - T) >= 1e-06:
				T = xd / vd
				nums = [[i, j]]
			elif abs(xd / vd - T) < 1e-06:
				nums.append([i, j])
	if T != float('inf'):
		cur += T
		for i in range(n):
			ar[i][0] += ar[i][1] * T
		for el in nums:
			(a, b) = (el[0], el[1])
			(m1, m2) = (ar[a][2], ar[b][2])
			(v1, v2) = (ar[a][1], ar[b][1])
			nv1 = ((m1 - m2) * v1 + 2 * m2 * v2) / (m1 + m2)
			nv2 = ((m2 - m1) * v2 + 2 * m1 * v1) / (m1 + m2)
			ar[a][1] = nv1
			ar[b][1] = nv2
	else:
		break
for i in range(n):
	ar[i][0] += ar[i][1] * (t - cur)
for i in range(n):
	print(ar[i][0])


import sys
from array import array

def input():
	return sys.stdin.buffer.readline().decode('utf-8')
(n, t) = map(int, input().split())
t = float(t)
balls = sorted((list(map(float, input().split())) + [i] for i in range(n)))
eps = 1e-09

def calc(i, j):
	(ok, ng) = (0.0, t + 1.0)
	for _ in range(50):
		mid = (ok + ng) / 2
		if balls[i][0] + balls[i][1] * mid - eps > balls[j][0] + balls[j][1] * mid:
			ng = mid
		else:
			ok = mid
	return mid

def adv(i, delta):
	balls[i][0] += balls[i][1] * delta

def collide(i, j):
	(balls[i][1], balls[j][1]) = (((balls[i][2] - balls[j][2]) * balls[i][1] + 2 * balls[j][2] * balls[j][1]) / (balls[i][2] + balls[j][2]), ((balls[j][2] - balls[i][2]) * balls[j][1] + 2 * balls[i][2] * balls[i][1]) / (balls[i][2] + balls[j][2]))
while t > 0:
	(x, y, d) = (0, 0, t + 1.0)
	for i in range(n - 1):
		res = calc(i, i + 1)
		if d > res:
			d = res
			(x, y) = (i, i + 1)
	if d >= t:
		for i in range(n):
			adv(i, t)
		break
	for i in range(n):
		adv(i, d)
	collide(x, y)
	t -= d
ans = [0.0] * n
for i in range(n):
	ans[balls[i][-1]] = balls[i][0]
print(*ans, sep='\n')