class InputError():
    def errorSizes(self, n, m):
        n_num = 0
        m_num = 0
        for i in range(len(n)):
            if (n[i] not in '0123456789'):
                print('Matrix sizes are incorrect!')
                exit()
            n_num = n_num * 10 + int(n[i])

        for i in range(len(m)):
            if (m[i] not in '0123456789'):
                print('Matrix sizes are incorrect!')
                exit()
            m_num = m_num * 10 + int(m[i])


        if (n_num != m_num):
            print('Matrix sizes are not equal!')
            exit()

        return (n_num, m_num)

    def errorMatrix(self, A, B, n):
        ans_A = A
        ans_B = B

        if (len(A) != n or len(B) != n):
            print('Matrix is incorrect!')
            exit()

        for i in range(n):
            if (len(A[i]) != n):
                print('Matrix is incorrect!')
                exit()

            for j in range(n):
                current = A[i][j]
                ans = 0
                for k in range(len(current)):
                    if (current[k] not in '0123456789'):
                        if (k == 0 and current[k] == '-'):
                            continue
                        print('Matrix is incorrect!')
                        exit()
                    ans = ans * 10 + int(current[k])
                if (current[0] == '-'):
                    ans *= -1
                ans_A[i][j] = ans
        for i in range(n):
            current = B[i]
            ans = 0
            for j in range(len(current)):
                if (current[j] not in '0123456789'):
                    if (j == 0 and current[j] == '-'):
                        continue
                    print('Matrix is incorrect!')
                    exit()
                ans = ans * 10 + int(current[j])
            if (current[0] == '-'):
                ans *= -1
            ans_B[i] = ans
        return(ans_A, ans_B)

class SlaeError():
    def checkDet(self, A):
        for i in range(len(A)):
            if (A[i][i] == 0):
                print('There is not only one solution!')
                exit()




class Slae(InputError, SlaeError):
    stringLength = 0
    numStrings = 0
    A = []
    B = []

    def read(self):
        self.stringLength = input()
        self.numStrings = input()

        data = self.errorSizes(self.stringLength, self.numStrings)
        self.stringLength = data[0]
        self.numStrings = data[1]

        for i in range(self.numStrings):
            self.A.append(list(input().split()))
        self.B = list(input().split())

        data = self.errorMatrix(self.A, self.B, self.numStrings)
        self.A = data[0]
        self.B = data[1]

    def writeSolution(self):
        for i in range(self.numStrings):
            print('X[', i + 1, '] = ', float(self.B[i]) / float(self.A[i][i]))
    def swapStr(self, firstIndex, secondIndex):
        for i in range(self.stringLength):
            self.A[firstIndex][i], self.A[secondIndex][i] = self.A[secondIndex][i], self.A[firstIndex][i]
        self.B[firstIndex], self.B[secondIndex] = self.B[secondIndex], self.B[firstIndex]
    def rationing(self, index):
        value = self.A[index][index]
        if (value == 0):
            return
        for i in range(index, self.stringLength):
            self.A[index][i] /= value
        self.B[index] /= value
    def partialPivoting(self, index):
        maxElem = self.A[index][index]
        indexMaxElem = index
        for i in range(index, self.numStrings):
            if (abs(self.A[i][index]) > maxElem):
                maxElem = abs(self.A[i][index])
                indexMaxElem = i
        self.swapStr(index, indexMaxElem)
    def gauss(self):
        for i in range(self.numStrings):
            self.partialPivoting(i)
            self.rationing(i)
            for j in range(self.numStrings):
                if (i == j):
                    continue
                value = self.A[j][i]
                for k in range(i, self.stringLength):
                    self.A[j][k] -= value * self.A[i][k]
                self.B[j] -= value * self.B[i]
        self.checkDet(self.A)

task = Slae()
task.read()
task.gauss()
task.writeSolution()