Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		strNums := strings.Fields(scanner.Text())
		nums := []int{}
		for _, strNum := range strNums {
			num, _ := strconv.Atoi(strNum)
			nums = append(nums, num)
		}
		a := nums[0]
		b := nums[1]
		c := nums[2]
		d := nums[3]
		e := nums[4]
		f := nums[5]
		var mulA, mulD int
		if a < 0 {
			mulA = a * -1
		} else {
			mulA = a
		}
		if d < 0 {
			mulD = d * -1
		} else {
			mulD = d
		}
		a *= mulD
		b *= mulD
		c *= mulD
		d *= mulA
		e *= mulA
		f *= mulA

		if d < 0 {
			d *= -1
			e *= -1
			f *= -1
		}

		bE := b - e
		cF := c - f
		if bE == 0 {
			bE = 1
		}
		y := cF / bE
		x := (c - (y * b)) / a

		fmt.Print(x)
		fmt.Println(".000")
		fmt.Print(y)
		fmt.Println(".000")
	}
}

Python: import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
import numpy as np

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    sa = [s for s in sys.stdin.read().split('\n') if s]
    r = []
    for s in sa:
        a,b,c,d,e,f = [int(x) for x in s.split()]
        A = np.matrix([[a,b],[d,e]])
        B = np.array([c,f])
        AT = np.linalg.inv(A)
        x = np.dot(AT, B)
        r.append('{:01.3f} {:01.3f}'.format(x[0,0], x[0,1]))
    return '\n'.join(r)

print(main())

Python: import sys
for e in sys.stdin:
    a, b, c, d, e, f = map(int, e.split())
    y=(c*d-a*f)/(b*d-a*e)
    x = (e*y-f) / -d
    print (round(x, 3)+' '+round(y, 3))

Python: while True:
  try:
    a, b, c, d, e, f = map(int, input(). split())
    D = (a * e) - (b * d)
    x = (e * c) - (b * f)
    y = (a * f) - (d * c)
    print("%.3f %.3f" % (x / D, y / D))
  except:
    break

Python: while True:
    try:
        a, b, c, d, e, f = map(int, input().split(" "))

        det = 1 / (a * d - b * c)
        x = det * (d * e - b * f)
        y = det * ((-c) * e + a * f)

        print('{:.3f}'.format(x), '{:.3f}'.format(y))

    except:
        break

Python: # -*-coding:utf-8

import numpy as np

def main():

    line = input()
    tokens = list(map(float, line.strip().split()))

    A = np.array([[tokens[0],tokens[1]] ,[tokens[3],tokens[4]]])
    B = np.array([tokens[2],tokens[5]])

    X = np.linalg.solve(A, B)

    for i in range(2):
        if X[i] == -0.000:
            X[i] = abs(X[i])

    print( '%.3f %0.3f' % (X[0], X[1]) )

    return 0

if __name__ == '__main__':
    for i in range(2):
        main()

Python: while True:
    try:
        a,b,c,d,e,f = (map(int,input().split()))

        n = d/a
        a = n*a
        b = n*b
        c = n*c

        y = (c-f)/(b-e)
        x = (c-(b*y))/a

        print("{0:.3f} {1:.3f}".format(x, y))
    except:
        break

Python: # -*-coding:utf-8

import numpy as np

def main():

    tokens = list(map(float, input().split(' ')))

    A = np.array([[tokens[0],tokens[1]] ,[tokens[3],tokens[4]]])
    B = np.array([tokens[2],tokens[5]])

    X = np.linalg.solve(A, B)

    print( '%.3f %0.3f' % (X[0], X[1]) )
if __name__ == '__main__':
    for i in range(2):
        main()

Python: import sys

for line in sys.stdin:
    a, b, c, d, e, f = list(map(float, line.split()))
    x = (c * e - b * f) / (a * e - b * d)
    y = (a * f - c * d) / (a * e - b * d)
    print("{0:.3f} {1:.3f}".format(x, y))

Python: while True:
    try:
        a, b, c, d, e, f = map(float, input().split())
        z = a * e - b * d
        x = (c * e - b * f) / z
        y = (a * f - c * d) / z
        print("{:.3f} {:.3f}".format(x + 0, y + 0))
    except:
        break

Python: while 1:
        a, b, c, d, e, f = map(int,input().split())
        x = (c/b-f/e) / (a/b-d/e)
        y = (c/a-f/d) / (b/a-e/d)
        print("{:+.3f} {:+.3f}".format(x,y))

Python: import numpy as np
while True:
	try:
		a,b,c,d,e,f = (int(i) for i in input().split())
		x,y = [np.dot(np.linalg.inv(np.array([[a,b],[d,e]])),np.array([c,f]))[0],np.dot(np.linalg.inv(np.array([[a,b],[d,e]])),np.array([c,f]))[1]]
		print(x,y)
	except EOFError:
		break

Python: import sys
for line in sys.stdin:
    a,b,c,d,e,f = map(float, line.split())
    x = round((c*e-b*f)/(a*e-b*d), 3)
    y = round((a*f-c*d)/(a*e-b*d), 3)
    if x == -0:
        x = 0
    if y == -0:
        y = 0
    print(x, y)

Python: t = 0
while t == 0:	
	try:
		a,b,c,d,e,f = [int(i) for i in input().split()]
	except:
		break
	else:
		print(1)

Python: while True:
    try:
        a,b,c,d,e,f = map(float,input().split(' '))
        print('{0:.3f} {1:.3f}'.format(round((c*e-b*f)/(a*e-b*d),3),round((c*d-a*f)/(b*d-a*e),3)))
    except:
        break

Python: import sys
from fractions import Fraction
 
def main():
 
    input_strings = sys.stdin.readlines()
    for matrix_string in input_strings:
        matrix = list(map(Fraction, list(matrix_string.split())))
        if matrix[0] == 0:
            matrix = matrix[3:] + matrix[:3]
        matrix = list(map(lambda x: x / matrix[0], matrix[:3])) + matrix[3:]
        matrix = matrix[:3] + list(map(lambda x: x[1] - matrix[3] * x[0], zip(matrix[:3], matrix[3:])))
        matrix = matrix[:3] + list(map(lambda x: x / matrix[4], matrix[3:]))
        matrix = list(map(lambda x: x[0] - matrix[1] * x[1], zip(matrix[:3], matrix[3:]))) + matrix[3:]
        matrix = list(map(int, matrix))
        matrix = list(map(lambda x: x + 0, matrix))
        print('%.3f %.3f' % (matrix[2], matrix[5]))
 
 
main()

Python: while True:
    try:
        a,b,c,d,e,f=map(int,input().split())
        print("{0:.3f} {1:.3f}".format((c*e-b*f)/(a*e-b*d)+1e-10,(a*f-c*d)/(a*e-b*d)+1e-10))
    except:break

Python: import sys

for line in sys.stdin:
    ll = [int(x) for x in line.split()]
    #print(ll)
    a = ll[0]
    b = ll[1]
    c = ll[2]
    d = ll[3]
    e = ll[4]
    f = ll[5]

    x = format(round((c*e-b*f)/(a*e-b*d),3), '.3f')
    y = format(round((a*f-d*c)/(a*e-d*b),3), '.3f')
    
    print(x, y)

Python: import sys
for e in sys.stdin:
 a,b,c,d,e,f=map(int,e.split())
 y=(c*d-a*f)/(b*d-a*e)
 print("%.3f %.3f"%((c-b*y)/a,y))

Python: import sys
for line in sys.stdin:
    a,b,c,d,e,f = map(float, line.split())
    print(round((c*e-b*f)/(a*e-b*d), 3), round((a*f-c*d)/(a*e-b*d), 3))

Python: import sys

inputNum = sys.stdin.readlines()

for i in inputNum:
    new = []
    n = i[:-1].split(' ', 6)
    for s in n:
        new.append(float(s))
    k = new[0]
    q = 0
    for a in new[0:3]:
        new[q] = a/k
        q = q + 1
    l = new[3]
    for a in new[3:6]:
        new[q] = a - l*new[q-3]
        q = q + 1
    if new[4] == 0:
        y = new[5]
    else:
        y = new[5]/new[4]
    x = new[2]-(new[1]*y)
    print("{0:.3f}".format(x)+" "+"{0:.3f}".format(y))

Python: import sys
for line in sys.stdin:
    a,b,c,d,e,f = map(int, line.split())
    y = (c/a - f/d)/(b/a - e/d)
    x = -(e/d) * y + (f/d)
    print("{:.3f} {:.3f}".format(x, y))

Python: while(True):
    try:
        list = [ float(x) for x in raw_input().split() ]
        x = (list[2]*list[4]-list[1]*list[5])/(list[0]*list[4]-list[1]*list[3])
        y = (list[0]*list[5]-list[2]*list[3])/(list[0]*list[4]-list[1]*list[3])
        
        print("%.3f %.3f" %(x, y))
        
    except EOFError:
        break

Python: # coding: utf-8
# Your code here!
def ren(a,b,c,d,e,f):
    x=(c*e-f*b)/(a*e-b*d)
    y=(c*d-f*a)/(b*d-e*a)
    
    print(f'{x+0:.3f} {y+0:.3f}')

while True:
    try:
        a,b,c,d,e,f=map(int,input().split())
    except EOFError:
        break
    ren(a,b,c,d,e,f)