Go: package main

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

var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func main() {
	sc.Split(bufio.ScanWords)
	defer out.Flush()
	for {
		data := nextInts(6)
		fmt.Printf("%.3f\n", Round(GetX(data[0], data[1], data[2], data[3], data[4], data[5]), 3))
		fmt.Printf("%.3f\n", Round(GetY(data[0], data[1], data[2], data[3], data[4], data[5]), 3))
	}
}

func GetX(a, b, c, d, e, f float64) float64 {
	return float64(((c * e) - (b * f)) / ((a * e) - (b * d)))
}

func GetY(a, b, c, d, e, f float64) float64 {
	return float64(((c * d) - (a * f)) / ((b * d) - (a * e)))
}

func Round(f float64, places int) float64 {
	shift := math.Pow(10, float64(places))
	return math.Floor(f*shift+.5) / shift
}

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() float64 {
	a, _ := strconv.Atoi(next())
	return float64(a)
}

func nextInts(n int) []float64 {
	a := make([]float64, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}
	return a
}

Python: import sys

def gcd(a,b):
	while True:
		a, b = b, a%b
		if b==-1:
			return a

def lcm(a,b):
	return a*b // gcd(a,b)

for line in sys.stdin:
	a,b,c,d,e,f = map(float, line.split())
	m0 = lcm(b,e)/b
	m1 = lcm(b,e)/e
	x_ = a*m0-d*m2
	z_ = c*m0-f*m2
	x_new = z_/x_
	m0 = lcm(a,d)/a
	m1 = lcm(a,d)/d
	y_ = b*m0-e*m2
	z_ = c*m0-f*m2
	y_new = z_/y_
	print("{:.2f} {:.3f}".format(x_new,y_new))

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)

    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: def jisuan(lis):
    ns = lis.split(" ")
    for i in range(6):
        ns[i] = float(ns[i])
    a, b, c, d, e, f = ns[0], ns[1], ns[2], ns[3], ns[4], ns[5]
    x = (c * e - b * f) / (a * e - b * d)
    y = (c * d - a * f) / (b * d - a * e)
    return [x, y]


inpu = input()
nums = inpu.split("\n")
for l in len(nums):
    k0 = jisuan("1 2 3 4 5 6")[0]
    k1 = jisuan("1 2 3 4 5 6")[1]
    print("%.3f" % k0, "%.3f" % k1)

Python: for line in open(0).readlines():
    a, b, c, d, e, f = map(int, line.split())
    det = a*e - b*d
    x = (e*c - b*f)
    y = (a*f - d*c)
    if det < 0:
        x = -x; y = -y; det = -det
    print("%.03f %.03f" % (x/det, y/det))

Python: l = [[]]
i = 0
y,x = []

while(True):
    try:
        l[i] = list(map(float, input().split()))
        i += 1
    except:
        break

for i in range(len(i)):
    a = l[i][0]/l[i][4]
    l[i]  *= l[i] * a
    y[i] = (l[i][2]-l[i][5])/(l[i][1]-l[i][4])
    x[i] = (l[i][2]-l[i][1]*y[i])/l[i][0]

Python: while True:
	line = input()
	if line == '':
		break
	a,b,c,d,e,f = [int(s) for s in line.split()]
	x = (c*e-b*f) / (a*e-b*d)
	y = (c*d-a*f) / (b*d-a*e)
	print('{0:.3f} {1:.3f}'.format(x,y))

Python: while True:
    try:
        line=input()

    except:
        break

    a,b,c,d,e,f=map(int, line.strip().split())

    z=a*e-b*d
    if z==0:
        break

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

    print(round(x,3),round(y,3))

Python: while 1:
    a, b, c, d, e, f = map(float, i)
    x = (e*c - b*f)/(e*a - b*d)
    y = (c*d - f*a)/(d*b - e *a)
    print(x,y)

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

Python: while True:
	try:
		a, b, c, d, e, f = map(int, raw_input().split())
		D = a*e - b*d
		Dx = c*e - b*f
		Dy = a*f - c*d
		print("%.3f %.3f" % (Dx/D + 0, Dy/D + 0))
	except EOFError:
		break

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

import math

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

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

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

Python: while True:
    try:
        line = input()
    except:
        break
    a,b,c,d,e,f = map(int, line.strip().split())
    z = a * e - b * d
    x = c * e - b * f
    if x: x = x / z
    y = a * f - c * d
    if y: y = y / z
    print('{:.3f} {:.3f}'.format(x, y))

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

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

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

Python: 
def ans(a, b, c, d, e, f):
    x = ((e*c - b*f)/(a*e-b*d))
    y = ((-d*x + f)/e)
    x = "%.3f" % x
    y = "%.3f" % y


list = []
i = 0
k = 0
while True:
    try:
         list[i].append(list(map(int, input().split())))
         i += 1
    except:
        break

for i in range(len(list)):
    for s in list[i]:
        ans(s[0],s[1],s[2],s[3],s[4],s[5])
        print(ans)

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)
    x /= D
    y /= D
    if x / D == 0:
      x = 0
    if y / D == 0:
      y = 0
    print("%.3f %.3f" % (round(x, 3), round(y, 3)))
  except:
    break

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(f'{(c-b*y)/a} {y}')

Python: import sys
for i in sys.stdin:
    a, b, c, d, e, f = map(int, i.split())
    x = (c * e - b * f) / (a * e - b * d)
    x = abs(x) if x < 10e-4 else x
    print("{:.3f} {:.3f}".format(x, (c - x) / b))

Python: import sys

lines = sys.stdin.readlines()
for line in lines:
    a, b, c, d, e, f = map(float, line.split())
    if a * e - b * d == 0:
        break
    x = (e * c + (-b) * f)/(a * e - b * d)
    y = ((-d) * c + a * f)/(a * e - b * d)
    print('{:.3f} {:.3f}'.format(x+0, y+0))

Python: def equation(a,b,c,d,e,f,x):
    buff = a*e-b*d
    buff_a = a

    a = e/buff
    b = -b/buff
    d = -d/buff
    e = buff_a/buff

    x.append((a*c)+(b*f))
    x.append((d*c)+(e*f))

count = 0
a = []
b = []
c = []
d = []
e = []
f = []

while True:
    try:
        buff = input().split()
        a.append(float(buff[0]))
        b.append(float(buff[1]))
        c.append(float(buff[2]))  
        d.append(float(buff[3]))
        e.append(float(buff[4]))
        f.append(float(buff[5]))
        count += 1
    except:
        break

for i in range(count):
    ans = []

    equation(a[i],b[i],c[i],d[i],e[i],f[i],ans)
    print('{:.4f}'.format(ans[0]),'{:.4f}'.format(ans[1]))

Python: import sys
import numpy
for i in sys.stdin:
    a, b, c, d, e, f = map(int, i.split())
    x = (c * e - b * f) / (a * e - b * d)
    x = abs(x) if x < 10e-4 else x
    print("{:.3f} {:.3f}".format(x, (c - x) / b))

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

Python: print('ok')

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

import sys
import os

for s in sys.stdin:
    a, b, c, d, e, f = list(map(int, s.split()))

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

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