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: for i in range(2):
    a,b,c,d,e,f = map(int,input().split(' '))
    print('{:.3f}'.format(round((c*e-b*f)/(b*d-a*e),3)),'{:.3f}'.format(round((c*e-b*f)/(b*d-a*e),3)))

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

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

Python: # -*- coding:utf-8 -*-
 
def main():
    while True:
        try:
            IN=input()
            if IN=="":
                raise EOFError
            else:
                val=IN.split(" ")
                a=int(val[0])
                b=int(val[1])
                c=int(val[2])
                d=int(val[3])
                e=int(val[4])
                f=int(val[5])

                x=round(float((c*e-b*f)/(a*e-b*d)),3)
                y=round(float((c*d-a*f)/(b*d-a*e)),3)

            print(x,y)
                
        except EOFError:
            break
  
if __name__ == '__main__':
    main()

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

Python: while True:
    try:
        a, b, c, d, e, f = [float(x) for x in input().split()]
    except:
        exit()
    m = [[a,b,c],[d,e,f]]
    row = len(m)
    col = len(m[0])
    for k in range(row):
        for j in range(k+1,col):
            m[k][j] /=m[k][k]
        for i in range(row):
            if(i != k):
                for j in range(k+1,col):
                    m[i][j] -= m[i][k] * m[k][j]
    print ("%.3f %.3f" % (m[0][2],m[1][2]))

Python: import sys
import math

r = sys.stdin.readlines()

#r.pop(0)

n = [[int(i) for i in (j.split())] for j in r] #n is list of each lines

for l in n:
    y = (l[2]*l[3]-l[0]*l[5])/(l[1]*l[3]-l[0]*l[4])
    
    x = (l[2]-l[1]*y)/l[0]
    
    print("{:.3f} {:.3f} ".format(x,y))

Python: import sys

for line in sys.stdin:
    try:
        a,b,c,d,e,f = map(float, line.rstrip().split(' '))
        x = round((b*f-c*e)/(b*d-a*e), 3)
        y = round((a*f-d*c)/(a*e-b*d), 3)
        print("{:.3f} {:.3f}".format(x,y))
    except:
        break

Python: aaa

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

	y = (c / a - f / d) / (b / a - e / d)
	x = ( c - b * y ) / a
	print ("%.3f %.3f" % (x,y))

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

Python: import sys


def det(mat):
  t = 1 / (mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0])
  a = t * mat[1][1]
  b = t * -1 * mat[0][1]
  c = t * -1 * mat[1][0]
  d = t * mat[0][0]
  return [[a, b], [c, d]]


for line in sys.stdin:
  try:
    a, b, c, d, e, f = [int(i) for i in line.split()]
    A = [[a, b], [d, e]]
    P = [c, f]
    detA = det(A)
    print("%lf %lf" % (detA[0][0] * P[0] + detA[0][1] * P[1], detA[1][0] * P[0] + detA[1][1] * P[1]))
  except:
    break

Python: import numpy as np

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)

A = np.matrix([
[a, b],
[d, e]
])
Y = np.matrix([
[c],
[f]
])
result = np.linalg.inv(A)*Y
print('{:.3f}'.format(float(result[0])), '{:.3f}'.format(float(result[1])))

Python: import sys
for line in sys.stdin.readlines():
    a, b, c, d, e, f = [float(x) for x in line.split()]
    if a!=0 and d!=0:
        a, b, c = [x/a for x in [a, b, c]]
        d, e, f = [x/d for x in [d, e, f]]
        y = (c-f) / (b-e)
        x = c - b * y

    else:
        a, b, c = [x/b for x in [a, b, c]]
        d, e, f = [x/e for x in [d, e, f]]
        x = (c-f) / (a-d)
        y = c - a * x
    print(f'{x:.3f} {y:.3f}')

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(float, input().split())
        
        x = (c * e - b * f) / (a * e - b * d)
        y = (c * d - a * f) / (b * d - a * e)
        
        if x == -0 :
            x = 0
        if y == -0 :
            y = 0
            
        print(f"{x:.3f} {y:.3f}")
        
    except :
        break

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

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

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

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 = str(input())
nums = inpu.split("\n")
for l in range(len(nums)):
    k0 = jisuan(nums[l])[0]
    k1 = jisuan(nums[l])[1]
    print("%.3f" % k0, "%.3f" % k1)

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('{0:.3f}'.format(x) +' {0:.3f}'.format(y))
              
    except EOFError: break

Python: # AOJ 0004 Simultaneous Equation
# Python3 2018.6.9 bal4u

while True:
	try:
		a = list(map(float, input().split()))
		dd = a[0]*a[4]-a[3]*a[1]
		d1 = a[2]*a[4]-a[5]*a[1]
		d2 = a[0]*a[5]-a[3]*a[2]
		print("{0:.3f} {1:.3f}".format(d1/dd, d2/dd))
	except EOFError:
		break

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




if __name__ == '__main__':
    main()