#include <stdio.h>
#include <math.h>

// number of variables
#define N 2
double A[N][N];
double x[N];
double b[N];

/*
 An simple implementation of Gauss elimination.
 It solves the equation Ax = b (A, b are given, A:N*N matrix, x:N-vector, b:N-vector).
 It transformes A into upper triangle matrix U
  a b c    a b c    a b c
  d e f -> 0 j k -> 0 j k
  g h i    0 l m    0 0 n
 An equation Ux = b' is easily can be solved.
 If it encounts A[i][i]==0, it doesn't work.
 */
void gauss_elimination_simple(){
    int i, j, k;
    double tmp;
    // elimination
    for(i=0; i<N; i++){
        for(j=i+1; j<N; j++){
            tmp = A[j][i]/A[i][i];
            for(k=i; k<N; k++){
                A[j][k] -= A[i][k]*tmp;
            }
            b[j] -= b[i]*tmp;
        }
    }
    
    // solving Ux = b (back substitution)
    x[N-1] = b[N-1]/A[N-1][N-1];
    for(i=N-2; i>=0; i--){
        x[i] = b[i];
        for(j=i+1; j<N; j++) x[i] -= A[i][j]*x[j];
        x[i] /= A[i][i];
    }
}

void dswap(double *a, double *b){
    double tmp = *a;
    *a = *b;
    *b = tmp;
}

/*
 Gauss elimination with partial pivoting.
 If can judge wheather the equations have an solution or not.
 */
void gauss_elimination(){
    int i, j, k;
    double tmp;
    for(i=0; i<N; i++){
        // find a max value from {A[i][i], A[i+1][i], ... , A[N-1][i]}
        double mx = fabs(A[i][i]);
        int mi = i;
        for(j=i+1; j<N; j++){
            tmp = fabs(A[j][i]);
            if(mx < tmp){
                mx = tmp;
                mi = j;
            }
        }
        // exchange the row i and row k which A[k][i] is the max value.
        for(j=0; j<N; j++){
            dswap(&A[i][j], &A[mi][j]);
        }
        dswap(&b[i], &b[mi]);
        
        // if A[i][i]==0 there is no solution
        if(fabs(A[i][i]) < 1.0e-8){
            printf("no solution!\n");
            return;
        }
        
        for(j=i+1; j<N; j++){
            tmp = A[j][i]/A[i][i];
            for(k=i; k<N; k++){
                A[j][k] -= A[i][k]*tmp;
            }
            b[j] -= b[i]*tmp;
        }
    }
    
    x[N-1] = b[N-1]/A[N-1][N-1];
    for(i=N-2; i>=0; i--){
        x[i] = b[i];
        for(j=i+1; j<N; j++) x[i] -= A[i][j]*x[j];
        x[i] /= A[i][i];
    }
}


int main(){
    int i, j;
    for(i=0; i<N; i++){
        for(j=0; j<N; j++){
            scanf("%lf", &A[i][j]);
        }
    }
    for(i=0; i<N; i++) scanf("%lf", &b[i]);
    
//    gauss_elimination_simple();
    gauss_elimination();
    
    for(i=0; i<N; i++){
        printf("%lf\n", x[i]);
    }
    
    return 0;
}