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: 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]

while 1:
    try:
        inpu = str(input())
    except:
        break

nums = inpu.split("\n")
for l in range(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: 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: import sys
for line in sys.stdin:
    a, b, c, d, e, f = map(float, line.split())
    print('{0:.3f} {1:.3f}'.format(
        (e * c - f * b) / (e * a - d * b) + 0, (d * c - f * a) / (d * b - e * a) + 0))

Python: import sys

while True:
    line = sys.stdin.readline()
    if not line:
        break
    a,b,c,d,e,f = map(int, line.rstrip().split(' '))
    x = (f - c*e/b)/(d - a*e/b)
    y = (f - d*c/a)/(e - b*d/a)
    print("{:.3f} {:.3f}".format(round(x,3),round(y,3)))

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
     
    if abs(x) < 1e-4:
        x = 0.0
    if abs(y) < 1e-4:
        y = 0.0
     
    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
        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: def main():
    p = [float(x) for x in input().split()]
    x = (p[4]*p[2]-p[1]*p[5])/(p[0]*p[4]-p[1]*p[3])
    y = (p[2]-p[0]*x)/p[1]
    if abs(x)<1e-4:
        x=0.0
    if abs(y)<1e-4:
        y=0.0
    print("%.3f %.3f"%(x,y))

main()

Python: ar = []
while True:
  try:
    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)
    ar.append([x, y])
  except:
    break

for i in ar:
  print("{:.3f} {:.3f}".format(i[0] + 0, i[1] + 0))

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

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

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

    except:
        break

Python: import sys

inputNum = sys.stdin.readlines()[:-1]

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: x,y = [0]*2,[0]*2
for i in range(2):
    k = list(map(float,input().split()))
    n = k[0]*k[4] -k[1]*k[3]

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

Python: import math

def my_round(x,d=0):
    p = 10 ** d
    return float(math.floor((x * p) + math.copysign(0.5, x))) / p

class Equation():
    def __init__(self, a, b, c, d, e, f):
        self.a = a
        self.b = b
        self.c = c
        self.d = d
        self.e = e
        self.f = f

    def calc(self):
        temp = (self.a * self.e - self.b * self.d)
        temp_a = (self.c * self.e - self.b * self.f)
        temp_b = (self.a * self.f - self.c * self.d)
        try:
            x = my_round(temp_a / temp, 4)
            if x < 0.0:
                x *= -1
        except ZeroDivisionError:
            x = my_round(temp_a / 1.0, 4)

        try:
            y = my_round(temp_b / temp, 4)
            if x < 0.0:
                x *= -1
        except:
            y = my_round(temp_b / 1.0, 4)


        return x, y


    def print(self):
        ans = self.calc()
        print("{0:.3f} {1:.3f}".format(ans[0], ans[1]))


def main():
    data = []

    while 1:
        try:
            n = input().split()

            a = float(n[0])
            b = float(n[1])
            c = float(n[2])
            d = float(n[3])
            e = float(n[4])
            f = float(n[5])

            data.append(Equation(a, b, c, d, e, f))

        except EOFError:
            break

    for num in data:
        num.print()

if __name__ == "__main__":
    main()

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

Python: # Vol0004.
import sys

def main():
    data = []
    lines = sys.stdin.readlines()
    for line in lines:
        data.append(line.split())  # スペース区切りで放り込む
    # ax + by = c, dx + ey = fの解は、
    # x = (ce - bf) / (ae - bd), y = (af - cd) / (ae - bd).
    # これをround(float, 3)すれば答えが出る。
    N = len(data)
    for i in range(N):
        det = data[i][0] * data[i][4] - data[i][1] * data[i][3]
        gx = data[i][2] * data[i][4] - data[i][1] * data[i][5]
        gy = data[i][0] * data[i][5] - data[i][2] * data[i][3]
        print(str(round(gx / det, 3)) + " " + str(round(gy / det, 3)))

if __name__ == "__main__":
    main()