Go: package main

import (
  "fmt"
)

func main() {
  var a,b,c,d,e,f float64
  var x,y float64
  for _, err := fmt.Scan(&a, &b, &c, &d, &e, &f); err == nil;
   _, err = fmt.Scan(&a, &b, &c, &d, &e, &f) {
    y = (a*f-c*d)/(a*e-b*d)
    x = (c-b*y)/a
    fmt.Printf("%.3f %.3f\n", x,y)
  }
}

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

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

Python: while True:
    try:
        a,b,c,d,e,f=map(int,input().split())
    except:
        break
    
    ba=(a*e)-(d*b)
    x1=(c*e)-(f*b)
    y1=(a*f)-(d*c)

    x=round(x1/ba,4)
    if x==0:
        x=0.000
    y=round(y1/ba,4)
    if y==0:
        y=0.000
    print("{:.3f}".format(x),"{:.3f}".format(y))

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

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

Python: import sys
import math
def simeq(a,b,c,d,e,f):
    return ((c*e-b*f)/(a*e-b*d),((a*f-c*d)/(a*e-b*d)))

if __name__ == '__main__':
    for line in sys.stdin:
        (a,b,c,d,e,f) = map(int,line.split())
        (x,y) = simeq(a,b,c,d,e,f)
        print("{:.3f} {:.3f}".format(round(x,3),round(y,3)))

Python: while 1:
    i = input().split()
    if i == None:
        break
    else:
        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: def function(a,b,c,d,e,f):
    y = (c - a*f/d)/(b - a*e/d)
    x = (c - b*y)/a
    print('{:.3f}'.format(float(x)), '{:.3f}'.format(float(y)))

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

Python: # coding: utf-8

while True:
	data = map(int, raw_input().split())
	a = data[0]
	b = data[1]
	c = data[2]
	d = data[3]
	e = data[4]
	f = data[5]

	x = (c*e-b*f)*1.0 / (a*e-b*d)
	if x == -0.000:
		x = 0.000
	if b != 0:
		y = (c-a*x)/b
	else:
		y = (f-d*x)/e
	if y == -0.000:
		y = 0.000

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

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

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

Python: import sys

while True:
	line = sys.stdin.readline()
	if line is '':
		break
	
	(a, b, e, c, d, f) = map(float, line.split())
	
	D = a * d - b * c
	x = (d * e - b * f) / D
	y = (a * f - c * e) / D
	
	print("{0:.3f} {1:.3f}".format(x, y))

Python: for i in range(2):
    a,b,c,d,e,f = map(float,input().split())
    n = a*e-b*d
    print(n)
    x = round((e*c-b*f)/n,4)
    y = round((a*f-d*c)/n,4)
    if x == -0:
        x = 0
    if y == -0:
        y = 0
    print("{0:.3f}".format(x),"{0:.3f}".format(y))

Python: #! /usr/bin/python3

while True:
    try:
        l=list(map(int, input().split()))
        x=float((l[1]*l[5]-l[2]*l[4])/(l[1]*l[3]-l[0]*l[4]))
        y=float((l[2]-l[0]*x)/l[1])
        print( "{0:.3f} {1:.3f}".format(x,y))
    except:
        break

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

Python: import sys
from decimal import Decimal

def main():

    #input_strings = sys.stdin.readlines()
    for coef_and_cons in input_strings:
        a, b, c, d ,e, f = map(Decimal, coef_and_cons.split())
        print([a,b,c,d,e,f])
        x = (f/e - c/b) / (d/e - a/b)
        y = (f/d - c/a) / (e/d - b/a)
        print('%.3f %.3f' %  (x.quantize(Decimal('0.001'), rounding='ROUND_HALF_DOWN'),
                              y.quantize(Decimal('0.001'), rounding='ROUND_HALF_DOWN') )
             )


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)
 print("%.3f %.3f"%((c-b*y)/a,y))

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

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
    return x, y


sets = []

while True:
    try:
        line = list(map(int, input().split()))
        if(line[0] == " "):
            break;
        else:
            sets.append(line)
    except IndexError:
        break

for i in sets:
    x, y = ans(i[0],i[1],i[2],i[3],i[4],i[5])
    print(x, y)

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()