Find Inverse Matrix in C and checking output

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

void getmat(int m, float a[][m]);
void copyArr(int m, int n, float a[][n], float b[][n]);
void printmat(int m, float a[][m]);
void invmat(int m, float a[][m]);
void mulMat(int r1, int c1, float a[][c1], int r2, int c2, float b[][c2], float c[][c2]);

// Main Function
void main()
{
    FILE *fp = NULL;
    int i, j, m;
    char ch, name[100];

printf("Enter matrix order:");
    scanf("%d", &m);
    float a[m][m], b[m][m], c[m][m];
    printf("\n1. Take User input");
    printf("\n2. Take File input");
    printf("\n>>>");
    scanf("%c", &ch); // emptying input buffer
    scanf("%c", &ch);
    switch (ch)
    {
    case '1':
        getmat(m, a);
        break;

case '2':
        scanf("%c", &ch);
        printf("Enter file name>>> ");

fgets(name, 100, stdin);
        name[strlen(name) - 1] = '\0';

fp = fopen(name, "r");
        printf("\n");

if (fp == NULL)
        {
            printf("unable to read file...\n");
            exit(1);
        }
        else
        {
            for (i = 0; i < m; ++i)
            {
                for (j = 0; j < m; ++j)
                {
                    fscanf(fp, "%f", &a[i][j]);
                }
            }
        }
        break;
    }

copyArr(m, m, a, b);
    printf("A[%d][%d]:\n", m, m);
    printmat(m, a);
    invmat(m, a);

printf("=============================================================================================\n");

printf("INV-A[%d][%d]:\n", m, m);
    printmat(m, a);

printf("=============================================================================================\n");

mulMat(m, m, b, m, m, a, c);
    printmat(m, c);

/* writitng in output file "output.txt" */
    FILE *fout;
    fout = fopen("output.txt", "w");
    for (i = 0; i < m; ++i)
    {
        for (j = 0; j < m; ++j)
        {
            fprintf(fout, "%f ", a[i][j]);
        }
        fprintf(fout, "\n");
    }

// closing the file reader
    fclose(fp);
    fclose(fout);
}

// Get Data from user
void getmat(int m, float a[][m])
{
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            printf("Enter a[%d][%d]:", i, j);
            scanf("%f", &a[i][j]);
        }
    }
}

// Print Square Matrix
void printmat(int m, float a[][m])
{
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            printf("%f\t", a[i][j]);
        }
        printf("\n");
    }
}
// Get Inv of Matrix(With identify Singular or NonSingular Matrix)
void invmat(int m, float a[][m])
{
    int i, j, k;
    float pivot, em2;
    for (k = 0; k < m; ++k)
    {
        pivot = a[k][0];
        em2 *= pivot;
        if (em2 == 0)
        {
            printf("Singular Matrix Inverse not possible\n");
            printf("Iteration close in I(%d)\n", k - 1);
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    a[i][j] = 0;
                }
            }

break;
        }
        for (j = 0; j < m; ++j)
        {
            if (j == m - 1)
            {
                a[k][m - 1] = 1 / pivot;
            }
            else
            {
                a[k][j] = a[k][j + 1] / pivot;
            }
        }
        for (i = 0; i < m; ++i)
        {
            pivot = a[i][0];
            for (j = 0; j < m; ++j)
            {
                if (i == k)
                {
                    break;
                }
                else if (j == m - 1)
                {
                    a[i][m - 1] = -pivot * a[k][m - 1];
                }
                else
                {
                    a[i][j] = a[i][j + 1] - pivot * a[k][j];
                }
            }
        }
    }
    if (em2 != 0)
    {
        printf("NonSingular Matrix\n");
    }
}
// Matrix multiplication
void mulMat(int r1, int c1, float a[][c1], int r2, int c2, float b[][c2], float c[][c2])
{

for (int i = 0; i < r1; ++i)
    {
        for (int j = 0; j < c2; ++j)
        {
            c[i][j] = 0;
            for (int k = 0; k < r2; ++k)
            {
                c[i][j] += (a[i][k] * b[k][j]);
            }
        }
    }
}
// Copy matrix
void copyArr(int m, int n, float a[][n], float b[][n])
{
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            b[i][j] = a[i][j];
        }
    }
}

Output1:

Enter matrix order:3

1. Take User input

2. Take File input

>>>1

Enter a[0][0]:4

Enter a[0][1]:5

Enter a[0][2]:6

Enter a[1][0]:8

Enter a[1][1]:9

Enter a[1][2]:2

Enter a[2][0]:6

Enter a[2][1]:4

Enter a[2][2]:7

A[3][3]:

4.000000 5.000000 6.000000

8.000000 9.000000 2.000000

6.000000 4.000000 7.000000

NonSingular Matrix

=============================================================================================

INV-A[3][3]:

-0.416667 0.083333 0.333333

0.333333 0.060606 -0.303030

0.166667 -0.106061 0.030303

=============================================================================================

1.000000 -0.000000 0.000000

-0.000000 1.000000 0.000000

0.000000 -0.000000 1.000000

Output2:

Enter matrix order:5

1. Take User input

2. Take File input

>>>2

Enter file name>>> matrix.txt

A[5][5]:

2.000000 15.000000 13.000000 13.000000 8.000000

6.000000 0.000000 4.000000 5.000000 19.000000

9.000000 3.000000 4.000000 0.000000 8.000000

1.000000 11.000000 3.000000 16.000000 8.000000

10.000000 19.000000 5.000000 9.000000 20.000000

NonSingular Matrix

=============================================================================================

INV-A[5][5]:

-0.044762 -0.052732 0.189492 0.073850 -0.037336

0.008855 -0.045723 -0.048856 -0.033986 0.073031

0.094667 0.022941 0.017931 -0.059990 -0.042837

-0.020892 -0.002071 0.057795 0.112669 -0.057861

-0.000297 0.064999 -0.078824 -0.040341 0.036035

=============================================================================================

1.000000 -0.000000 -0.000000 0.000000 -0.000000

-0.000000 1.000000 0.000000 0.000000 -0.000000

-0.000000 -0.000000 1.000000 0.000000 0.000000

0.000000 -0.000000 -0.000000 1.000000 -0.000000

-0.000000 -0.000001 0.000000 0.000001 1.000000

Find Inverse Matrix in C and checking output..