human
Write me a Python program to find the earliest time at which the earth collides with one of the asteroids given the following:
I found an interesting problem on https://www.codechef.com/problems/COLLIDE:
Did you hear about the Nibiru collision ? It is a supposed disastrous encounter between the earth and a large planetary object. Astronomers reject this idea. But why listen to other people's beliefs and opinions. We are coders above all, so what better way than to verify it by a small code. The earth and N asteroids are in the 2D plane. Each of them is initially located at some integer coordinates at time = 0 and is moving parallel to one of the X or Y axis with constant velocity of 1 unit per second. 

Direction of movement is given as 'U' ( Up = towards positive Y ), 'D' ( Down = towards negative Y ), 'R' ( Right = towards positive X ), 'L' ( Left = towards negative X ). Given the initial position and the direction of movement of the earth and each of the N asteroids, find the earliest time at which the earth collides with one of the asteroids. If there can not be any collisions with the earth, print "SAFE" ( without quotes ). You can ignore the collisions between asteroids ( i.e., they continue to move in same direction even after collisions between them ).

-----Input-----

First line contains T, number of test cases. T cases follow. In each test case, first line contains XE YE DIRE, where (XE,YE) is the initial position of the Earth, DIRE is the direction in which it moves. Second line contains N, the number of
asteroids. N lines follow, each containing XA YA DIRA, the initial position and the direction of movement of each asteroid. No asteroid is initially located at (XE,YE)

-----Output-----

For each test case, output the earliest time at which the earth can collide with an asteroid (rounded to 1 position after decimal). If there can not be any collisions with the earth, print "SAFE" (without quotes).

-----Constraints-----

1 ≤ T ≤ 10

1 ≤ N ≤ 2012

-100 ≤ XE, YE, XA, YA ≤ 100

(XE,YE) != any of (XA,YA)

DIRE, DIRA is one of 'U', 'R', 'D', 'L'

-----Example-----
Input:
3
0 0 R
2
1 -2 U
2 2 D
1 1 U
1
1 0 U
0 0 R
1
3 0 L

Output:
2.0
SAFE
1.5

Explanation:

Case 1 : 

Time 0 - Earth (0,0) Asteroids {...

I tried it in Python, but could not do it. Can you solve it?
assistant
#Here is Python program to find the earliest time at which the earth collides with one of the asteroids.

#-*- coding:utf-8 -*-

import sys

# class Point:
#     def __init__(self, x, y):
#         self.x = x
#         self.y = y

#     def mul(self, k):
#         return Point(k * self.x, k * self.y)

#     def __add__(self, other):
#         return Point(self.x + other.x, self.y + other.y)

#     def __sub__(self, other):
#         return self + (-other)

#     def __neg__(self):
#         return Point(-self.x, -self.y)

#     def __eq__(self, other):
#         return self.x == other.x and self.y == other.y

#     def __getitem__(self, index):
#         return (self.x, self.y)[index]

#     def __str__(self):
#         return "(%d;%d)" % (self.x, self.y)

DIRS = dict(
 U=(0, 1),
 D=(0, -1),
 R=(1, 0),
 L=(-1, 0)
)
KOEF = 0.2

def div(a, b):
 return round(float(a) / b, 1)

# class Moving:
#     def __init__(self, x, y, dir):
#         self.p = Point(x, y)
#         self.dir = Point(*DIRS[dir.upper()])

#     def collide(self, other):
#         times = []
#         for coord in range(2):
#             d = abs(self.p[coord] - other.p[coord])
#             d2 = abs((self.p + self.dir.mul(KOEF) - other.p)[coord])
#             d3 = abs((other.p + other.dir.mul(KOEF) - self.p)[coord])
#             d_next = abs((self.p + self.dir.mul(KOEF) - (other.p + other.dir    .mul(KOEF)))[coord])
#             if d2 > d or d3 > d:
#                 return None

#             speed = abs(d_next - d)
#             if speed == 0:
#                 if self.p[coord] != other.p[coord]:
#                     return None
#                 continue
#             times.append( div(d, speed / KOEF) )

#         if len(times) == 2 and times[0] != times[1]:
#             return
#         return times[0]

def collide_coord(ex, edx, x, dx):
 d = abs(ex - x)
 d2 = abs(ex + edx - x)
 d3 = abs(ex - x - dx)
 if d2 > d or d3 > d:
  return False

 d_next = abs(ex + edx * KOEF - x - dx * KOEF)
 speed = abs(d_next - d)
 if speed == 0:
  if ex != x:
   return
  return "all" # all
 else:
  return div(d, speed / KOEF)

def main():
 t =...