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.Printf("%d.000 ", x)
		fmt.Printf("%d.000\n", y)
	}
}

C++: #include <iostream>
#include <iomanip>

int main(void) {
	double a, b, c, d, e, f, x, y;
	while (std::cin >> a >> b >> c >> d >> e >> f) {
		x = (f*b - e*c) / (d*b - e*a);
		y = (f*a - d*c) / (e*a - d*b);

		std::cout << std::fixed << std::setprecision(3) << x << ' ' << y << std::endl;
	}

	return 0;
}

C++: #include<stdio.h>
#include<math.h>


static const double EPS = 1e-9;

int main(void){
  double a,b,c,d,e,f;
  double x,y;
  char line[256];



  fgets(line,sizeof(line),stdin);
  sscanf(line,"%lf %lf %lf %lf %lf %lf",&a,&b,&c,&d,&e,&f);
  
  x=(d*f-b*e)/(a*d-b*c);
  y=(a*f-c*e)/(a*d-b*c);

  if(x>0){
    if((int)(x*10000) % 10>=5){
      x=x+0.001;
    }
  }
  else if(x<0){
    if((int)(x*10000)%10<5)
    x=x-0.001;
  }
  else x=0.000;

  if(y>0){
    if((int)(y*10000) % 10>=5){
      y=y+0.001;
    }
  }
  else if(y<0){
    if((int)(y*10000)%10<5)
    y=y-0.001;
  }
  else y=0.000;

  printf("%.3lf %.3lf\n",x+EPS,y+EPS);

  return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<iomanip>
#include<vector>
#include<math.h>
using namespace std;
class SimultaneousEquation{ 
    public:
        void solve(int a,int b,int c,int d,int e,int f){ 
            double x,y;
            x=double(c*e-b*f)/(a*e-b*d);
            y=double(c*d-a*f)/(b*d-a*e);
	    if(x==0)x=0;
	    if(y==0)y=0;
            printf("%.3lf %.3lf\n",x,y);
            }
};
int main(){ 
    int a,b,c,d,e,f;
    SimultaneousEquation inst;
    while(cin>>a>>b>>c>>d>>e>>f){
        inst.solve(a,b,c,d,e,f);
    }
}

C++: #include<iostream>
#include<algorithm>
#include<iomanip>
using namespace std;

const double EPS = 1e-8;
typedef vector<double> vec;
typedef vector<vec> mat;

vec gauss_jordan(const mat& A, const vec& b){
    int n = A.size();
    mat B(n, vec(n + 1));
    for(int i = 0 ; i < n ; ++i){
        for(int j = 0 ; j < n ; ++j){
            B[i][j] = A[i][j];
        }
    }
    for(int i = 0 ; i < n ; ++i){
        B[i][n] = b[i];
    }

    for(int i = 0 ; i < n ; ++i){
        int pivot = i;
        for(int j = i ; j < n ; ++j){
            if(abs(B[j][i]) > abs(B[pivot][i])){
                pivot = j;
            }
        }
        swap(B[i], B[pivot]);

        if(abs(B[i][i]) < EPS){
            return vec();
        }

        for(int j = i + 1 ; j <= n ; ++j){
            B[i][j] /= B[i][i];
        }

        for(int j = 0 ; j < n ; ++j){
            if(i != j){
                for(int k = i + 1 ; k <= n ; ++k){
                    B[j][k] -= B[j][i] * B[i][k];
                }
            }
        }
    }

    vec x(n);
    for(int i = 0 ; i < n ; ++i){
        x[i] = B[i][n];
    }

    return x;
}

int main(){
    mat A(2, vec(2));
    vec b(2);
    while(cin >> A[0][0] >> A[0][1] >> b[0] >> A[1][0] >> A[1][1] >> b[1]){
        vec ans = gauss_jordan(A, b);
        for(int i = 0 ; i < 2 ; ++i){
            if(i){
                cout << " ";
            }
            cout << fixed << setprecision(3) << ans[i];
        }
        cout << endl;
    }

    return 0;
}

C++: #include<cstdio>
using namespace std;

int main() {
        int a, b, c, d, e, f;
        double x, y;
        char line[200];

        while(fgets(line, 200, stdin) != NULL) {
                sscanf(line, "%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f);
                x = ((double)e*c - b*f) / (a*e - d*b);
                y = ((double)a*f - d*c) / (a*e - d*b);
                printf("%.3f %.3f\n", x, y);
        }
}

C++: #include<iostream>
#include<stdio.h>
using namespace std;

int main(){
	int a,b,c,d,e,f;
	while(cin>>a>>b>>c>>d>>e>>f){
		double anx=0,any=0;
		if((c*e-f*b)!=0 && (a*e-d*b)!=0){
			anx=(c*e-f*b)/(a*e-d*b);
		}
		if((c*d-f*a)!=0 && (b*d-e*a)!=0){
			any=(c*d-f*a)/(b*d-e*a);
		}
		printf("%.3f ",anx);
		printf("%.3f\n",any);
	}
	return 0;
}

C++: #include <iostream>
#include <cstdio>
using namespace std;

int main()
{
	int a, b, c, d, e, f;
	while (cin >> a >> b >> c >> d >> e >> f){
		double x = ((double)(b*f - c*e)) / (double)(b*d - a*e);
		double y = ((double)(c*d - a*f)) / (double)(b*d - a*e);
		//cout << x << ' ' << y << "\n";
		//cout << ((double)(b*f - c*e)) / (double)(b*d - a*e) << ' ' << ((double)(c*d - a*f)) / (double)(b*d - a*e) << "\n";
		printf("%.3f %.3f\n", x, y);
	}
	cout.flush();
}

C++: #include <algorithm>
#include <cstdio>
#include <iostream>


using namespace std;

int main(){
    int t;
    double a, b, c, d, e, f, x, y;
    cin >> t;
    while(t--){
        cin >> a >> b >> c >> d >> e >> f;
        y = (c/a - f/d)/(b/a - e/d);
        x = (c-b*y)/a;
        printf("%f %f\n",x,y);
    }
    return 0;
}

C++: #include<stdio.h>
#include<iostream>
#include<cmath>

using namespace std;
 
main(){
  int a, b, c, d, e, f;
  double x, y;
  while ( cin >> a >> b >> c >> d >> e >> f ){
    x = 1.0 * ( c*e - b*f ) / ( a*e - b*d ) ;
    y = 1.0 * ( c*d - a*f ) / ( b*d - a*e ) ;
    printf("%.3lf %.3lf\n", x, y);
  }
}

C++: #include <stdio.h>

void Renritsu(double a,double b,double c,double d,double e,double f){
	double ta = a * d;
	double tb = b * d;
	double tc = c * d;
	double td = d * a;
	double te = e * a;
	double tf = f * a;
	td -= ta;
	te -= tb;
	tf -= tc;
	double y = tf / te;
	ta = a * e;
	tb = b * e;
	tc = c * e;
	td = d * b;
	te = e * b;
	tf = f * b;
	td -= ta;
	te -= tb;
	tf -= tc;
	double x = tf / td;
	printf("%.3lf %.3lf \n",x,y);
}


int main(void)
{
	Renritsu(1,2,3,4,5,6);
	Renritsu(2,-1,-2,-1,-1,-5);
return 0;
}

C++: #include <iostream>
#include <iomanip>
using namespace std;

int main()
{
      double a,b,c,d,e,f;

      while(cin >> a >> b >> c >> d >> e >> f)
      {
            a = a * d / a;
            b = b * d / a;
            c = c * d / a;

            d = d - a;           // d = 0
            e = e - b;
            f = f - c;

            e = e * b / e;
            f = f * b / e;

            b = b - e;            // b = 0
            c = c - f;

            a = a / a;
            c = c / a;            // x = c

            e = e / e;
            f = f / e;            // y = f

            cout << setprecision(4) << c << " " << setprecision(4) << f << endl;
      }

      return 0;
}

C++: //
//  main.cpp
//  Sample
//
//  Created by h3037183 on 2017/07/31.
//  Copyright ?? 2017??´ ?°????. All rights reserved.
//

#include <iostream>
#include<algorithm>
using namespace std;
int main(){
    double a,b,c,d,e,f,x,y;
    cin>>a>>b>>c>>d>>e>>f;
    x=(c*e-b*f)/(a*e-b*d);
    y=(c*d-a*f)/(b*d-a*e);
    cout<<x<<" "<<y<<endl;
    return 0;
}

C++: #include <iostream>
#include <iomanip>
using namespace std;

int gcd(int g,int h){
	if(h == 0)
		return g;
	return gcd(h, g % h);
}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	int a, b, c, d, e, f;
	while(cin){
		cin >> a >> b >> c >> d >> e >> f;
		
		int g = f * b - c * e;
		int h = b * d - a * e;
		double x = (g / gcd(g, h)) / (h / gcd(g, h));
		int i = f * a - d * c;
		int j = -d * b + e * a;
		double y = (i / gcd(i, j)) / (j / gcd(i, j));
		cout << fixed << setprecision(3) << x << " " << y << endl;
	}
	return 0;
}