--- BLAS/TESTING/Makefile	2021-03-26 03:25:15.000000000 +0900
+++ BLAS/TESTING/Makefile	2021-04-09 15:14:58.539778998 +0900
@@ -37,18 +37,18 @@
 
 .PHONY: run
 run: all
-	./xblat1s > sblat1.out
-	./xblat1d > dblat1.out
-	./xblat1c > cblat1.out
-	./xblat1z > zblat1.out
-	./xblat2s < sblat2.in
-	./xblat2d < dblat2.in
-	./xblat2c < cblat2.in
-	./xblat2z < zblat2.in
-	./xblat3s < sblat3.in
-	./xblat3d < dblat3.in
-	./xblat3c < cblat3.in
-	./xblat3z < zblat3.in
+	wine64 ./xblat1s.exe > sblat1.out
+	wine64 ./xblat1d.exe > dblat1.out
+	wine64 ./xblat1c.exe > cblat1.out
+	wine64 ./xblat1z.exe > zblat1.out
+	wine64 ./xblat2s.exe < sblat2.in
+	wine64 ./xblat2d.exe < dblat2.in
+	wine64 ./xblat2c.exe < cblat2.in
+	wine64 ./xblat2z.exe < zblat2.in
+	wine64 ./xblat3s.exe < sblat3.in
+	wine64 ./xblat3d.exe < dblat3.in
+	wine64 ./xblat3c.exe < cblat3.in
+	wine64 ./xblat3z.exe < zblat3.in
 
 .PHONY: clean cleanobj cleanexe cleantest
 clean: cleanobj cleanexe cleantest

--- INSTALL/Makefile	2021-03-26 03:25:15.000000000 +0900
+++ INSTALL/Makefile	2021-04-09 15:14:58.537778998 +0900
@@ -29,13 +29,13 @@
 
 .PHONY: run
 run: all
-	./testlsame
-	./testslamch
-	./testdlamch
-	./testsecond
-	./testdsecnd
-	./testieee
-	./testversion
+	wine64 ./testlsame.exe
+	wine64 ./testslamch.exe
+	wine64 ./testdlamch.exe
+	wine64 ./testsecond.exe
+	wine64 ./testdsecnd.exe
+	wine64 ./testieee.exe
+	wine64 ./testversion.exe
 
 .PHONY: clean cleanobj cleanexe cleantest
 clean: cleanobj cleanexe cleantest

--- TESTING/Makefile	2021-03-26 03:25:15.000000000 +0900
+++ TESTING/Makefile	2021-04-09 15:18:19.366034766 +0900
@@ -158,61 +158,61 @@
 
 stest.out: stest.in LIN/xlintsts
 	@echo Testing REAL LAPACK linear equation routines
-	./LIN/xlintsts < stest.in > $@ 2>&1
+	wine64 ./LIN/xlintsts.exe < stest.in > $@ 2>&1
 #
 # ======== COMPLEX LIN TESTS ==========================
 
 ctest.out: ctest.in LIN/xlintstc
 	@echo Testing COMPLEX LAPACK linear equation routines
-	./LIN/xlintstc < ctest.in > $@ 2>&1
+	wine64 ./LIN/xlintstc.exe < ctest.in > $@ 2>&1
 #
 # ======== DOUBLE LIN TESTS ===========================
 
 dtest.out: dtest.in LIN/xlintstd
 	@echo Testing DOUBLE PRECISION LAPACK linear equation routines
-	./LIN/xlintstd < dtest.in > $@ 2>&1
+	wine64 ./LIN/xlintstd.exe < dtest.in > $@ 2>&1
 #
 # ======== COMPLEX16 LIN TESTS ========================
 
 ztest.out: ztest.in LIN/xlintstz
 	@echo Testing COMPLEX16 LAPACK linear equation routines
-	./LIN/xlintstz < ztest.in > $@ 2>&1
+	wine64 ./LIN/xlintstz.exe < ztest.in > $@ 2>&1
 #
 # ======== SINGLE-DOUBLE PROTO LIN TESTS ==============
 
 dstest.out: dstest.in LIN/xlintstds
 	@echo Testing SINGLE-DOUBLE PRECISION LAPACK prototype linear equation routines
-	./LIN/xlintstds < dstest.in > $@ 2>&1
+	wine64 ./LIN/xlintstds.exe < dstest.in > $@ 2>&1
 #
 # ======== COMPLEX-COMPLEX16 LIN TESTS ========================
 
 zctest.out: zctest.in LIN/xlintstzc
 	@echo Testing COMPLEX-COMPLEX16 LAPACK prototype linear equation routines
-	./LIN/xlintstzc < zctest.in > $@ 2>&1
+	wine64 ./LIN/xlintstzc.exe < zctest.in > $@ 2>&1
 #
 # ======== SINGLE RFP LIN TESTS ========================
 
 stest_rfp.out: stest_rfp.in LIN/xlintstrfs
 	@echo Testing REAL LAPACK RFP prototype linear equation routines
-	./LIN/xlintstrfs < stest_rfp.in > $@ 2>&1
+	wine64 ./LIN/xlintstrfs.exe < stest_rfp.in > $@ 2>&1
 #
 # ======== COMPLEX16 RFP LIN TESTS ========================
 
 dtest_rfp.out: dtest_rfp.in LIN/xlintstrfd
 	@echo Testing DOUBLE PRECISION LAPACK RFP prototype linear equation routines
-	./LIN/xlintstrfd < dtest_rfp.in > $@ 2>&1
+	wine64 ./LIN/xlintstrfd.exe < dtest_rfp.in > $@ 2>&1
 #
 # ======== COMPLEX16 RFP LIN TESTS ========================
 
 ctest_rfp.out: ctest_rfp.in LIN/xlintstrfc
 	@echo Testing COMPLEX LAPACK RFP prototype linear equation routines
-	./LIN/xlintstrfc < ctest_rfp.in > $@ 2>&1
+	wine64 ./LIN/xlintstrfc.exe < ctest_rfp.in > $@ 2>&1
 #
 # ======== COMPLEX16 RFP LIN TESTS ========================
 
 ztest_rfp.out: ztest_rfp.in LIN/xlintstrfz
 	@echo Testing COMPLEX16 LAPACK RFP prototype linear equation routines
-	./LIN/xlintstrfz < ztest_rfp.in > $@ 2>&1
+	wine64 ./LIN/xlintstrfz.exe < ztest_rfp.in > $@ 2>&1
 #
 #
 # ======== SINGLE EIG TESTS ===========================
@@ -220,329 +220,329 @@
 
 snep.out: nep.in EIG/xeigtsts
 	@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
-	./EIG/xeigtsts < nep.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < nep.in > $@ 2>&1
 
 ssep.out: sep.in EIG/xeigtsts
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtsts < sep.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sep.in > $@ 2>&1
 
 sse2.out: se2.in EIG/xeigtsts
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtsts < se2.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < se2.in > $@ 2>&1
 
 ssvd.out: svd.in EIG/xeigtsts
 	@echo SVD: Testing Singular Value Decomposition routines
-	./EIG/xeigtsts < svd.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < svd.in > $@ 2>&1
 
 sec.out: sec.in EIG/xeigtsts
 	@echo SEC: Testing REAL Eigen Condition Routines
-	./EIG/xeigtsts < sec.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sec.in > $@ 2>&1
 
 sed.out: sed.in EIG/xeigtsts
 	@echo SEV: Testing REAL Nonsymmetric Eigenvalue Driver
-	./EIG/xeigtsts < sed.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sed.in > $@ 2>&1
 
 sgg.out: sgg.in EIG/xeigtsts
 	@echo SGG: Testing REAL Nonsymmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtsts < sgg.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sgg.in > $@ 2>&1
 
 sgd.out: sgd.in EIG/xeigtsts
 	@echo SGD: Testing REAL Nonsymmetric Generalized Eigenvalue Problem driver routines
-	./EIG/xeigtsts < sgd.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sgd.in > $@ 2>&1
 
 ssb.out: ssb.in EIG/xeigtsts
 	@echo SSB: Testing REAL Symmetric Eigenvalue Problem routines
-	./EIG/xeigtsts < ssb.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < ssb.in > $@ 2>&1
 
 ssg.out: ssg.in EIG/xeigtsts
 	@echo SSG: Testing REAL Symmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtsts < ssg.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < ssg.in > $@ 2>&1
 
 sbal.out: sbal.in EIG/xeigtsts
 	@echo SGEBAL: Testing the balancing of a REAL general matrix
-	./EIG/xeigtsts < sbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sbal.in > $@ 2>&1
 
 sbak.out: sbak.in EIG/xeigtsts
 	@echo SGEBAK: Testing the back transformation of a REAL balanced matrix
-	./EIG/xeigtsts < sbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sbak.in > $@ 2>&1
 
 sgbal.out: sgbal.in EIG/xeigtsts
 	@echo SGGBAL: Testing the balancing of a pair of REAL general matrices
-	./EIG/xeigtsts < sgbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sgbal.in > $@ 2>&1
 
 sgbak.out: sgbak.in EIG/xeigtsts
 	@echo SGGBAK: Testing the back transformation of a pair of REAL balanced matrices
-	./EIG/xeigtsts < sgbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sgbak.in > $@ 2>&1
 
 sbb.out: sbb.in EIG/xeigtsts
 	@echo SBB: Testing banded Singular Value Decomposition routines
-	./EIG/xeigtsts < sbb.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < sbb.in > $@ 2>&1
 
 sglm.out: glm.in EIG/xeigtsts
 	@echo GLM: Testing Generalized Linear Regression Model routines
-	./EIG/xeigtsts < glm.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < glm.in > $@ 2>&1
 
 sgqr.out: gqr.in EIG/xeigtsts
 	@echo GQR: Testing Generalized QR and RQ factorization routines
-	./EIG/xeigtsts < gqr.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < gqr.in > $@ 2>&1
 
 sgsv.out: gsv.in EIG/xeigtsts
 	@echo GSV: Testing Generalized Singular Value Decomposition routines
-	./EIG/xeigtsts < gsv.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < gsv.in > $@ 2>&1
 
 scsd.out: csd.in EIG/xeigtsts
 	@echo CSD: Testing CS Decomposition routines
-	./EIG/xeigtsts < csd.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < csd.in > $@ 2>&1
 
 slse.out: lse.in EIG/xeigtsts
 	@echo LSE: Testing Constrained Linear Least Squares routines
-	./EIG/xeigtsts < lse.in > $@ 2>&1
+	wine64 ./EIG/xeigtsts.exe < lse.in > $@ 2>&1
 #
 # ======== COMPLEX EIG TESTS ===========================
 
 cnep.out: nep.in EIG/xeigtstc
 	@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
-	./EIG/xeigtstc < nep.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < nep.in > $@ 2>&1
 
 csep.out: sep.in EIG/xeigtstc
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstc < sep.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < sep.in > $@ 2>&1
 
 cse2.out: se2.in EIG/xeigtstc
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstc < se2.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < se2.in > $@ 2>&1
 
 csvd.out: svd.in EIG/xeigtstc
 	@echo SVD: Testing Singular Value Decomposition routines
-	./EIG/xeigtstc < svd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < svd.in > $@ 2>&1
 
 cec.out: cec.in EIG/xeigtstc
 	@echo CEC: Testing COMPLEX Eigen Condition Routines
-	./EIG/xeigtstc < cec.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cec.in > $@ 2>&1
 
 ced.out: ced.in EIG/xeigtstc
 	@echo CES: Testing COMPLEX Nonsymmetric Schur Form Driver
-	./EIG/xeigtstc < ced.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < ced.in > $@ 2>&1
 
 cgg.out: cgg.in EIG/xeigtstc
 	@echo CGG: Testing COMPLEX Nonsymmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtstc < cgg.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cgg.in > $@ 2>&1
 
 cgd.out: cgd.in EIG/xeigtstc
 	@echo CGD: Testing COMPLEX Nonsymmetric Generalized Eigenvalue Problem driver routines
-	./EIG/xeigtstc < cgd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cgd.in > $@ 2>&1
 
 csb.out: csb.in EIG/xeigtstc
 	@echo CHB: Testing Hermitian Eigenvalue Problem routines
-	./EIG/xeigtstc < csb.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < csb.in > $@ 2>&1
 
 csg.out: csg.in EIG/xeigtstc
 	@echo CSG: Testing Symmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtstc < csg.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < csg.in > $@ 2>&1
 
 cbal.out: cbal.in EIG/xeigtstc
 	@echo CGEBAL: Testing the balancing of a COMPLEX general matrix
-	./EIG/xeigtstc < cbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cbal.in > $@ 2>&1
 
 cbak.out: cbak.in EIG/xeigtstc
 	@echo CGEBAK: Testing the back transformation of a COMPLEX balanced matrix
-	./EIG/xeigtstc < cbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cbak.in > $@ 2>&1
 
 cgbal.out: cgbal.in EIG/xeigtstc
 	@echo CGGBAL: Testing the balancing of a pair of COMPLEX general matrices
-	./EIG/xeigtstc < cgbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cgbal.in > $@ 2>&1
 
 cgbak.out: cgbak.in EIG/xeigtstc
 	@echo CGGBAK: Testing the back transformation of a pair of COMPLEX balanced matrices
-	./EIG/xeigtstc < cgbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cgbak.in > $@ 2>&1
 
 cbb.out: cbb.in EIG/xeigtstc
 	@echo CBB: Testing banded Singular Value Decomposition routines
-	./EIG/xeigtstc < cbb.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < cbb.in > $@ 2>&1
 
 cglm.out: glm.in EIG/xeigtstc
 	@echo GLM: Testing Generalized Linear Regression Model routines
-	./EIG/xeigtstc < glm.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < glm.in > $@ 2>&1
 
 cgqr.out: gqr.in EIG/xeigtstc
 	@echo GQR: Testing Generalized QR and RQ factorization routines
-	./EIG/xeigtstc < gqr.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < gqr.in > $@ 2>&1
 
 cgsv.out: gsv.in EIG/xeigtstc
 	@echo GSV: Testing Generalized Singular Value Decomposition routines
-	./EIG/xeigtstc < gsv.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < gsv.in > $@ 2>&1
 
 ccsd.out: csd.in EIG/xeigtstc
 	@echo CSD: Testing CS Decomposition routines
-	./EIG/xeigtstc < csd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < csd.in > $@ 2>&1
 
 clse.out: lse.in EIG/xeigtstc
 	@echo LSE: Testing Constrained Linear Least Squares routines
-	./EIG/xeigtstc < lse.in > $@ 2>&1
+	wine64 ./EIG/xeigtstc.exe < lse.in > $@ 2>&1
 #
 # ======== DOUBLE EIG TESTS ===========================
 
 dnep.out: nep.in EIG/xeigtstd
 	@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
-	./EIG/xeigtstd < nep.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < nep.in > $@ 2>&1
 
 dsep.out: sep.in EIG/xeigtstd
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstd < sep.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < sep.in > $@ 2>&1
 
 dse2.out: se2.in EIG/xeigtstd
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstd < se2.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < se2.in > $@ 2>&1
 
 dsvd.out: svd.in EIG/xeigtstd
 	@echo SVD: Testing Singular Value Decomposition routines
-	./EIG/xeigtstd < svd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < svd.in > $@ 2>&1
 
 dec.out: dec.in EIG/xeigtstd
 	@echo DEC: Testing DOUBLE PRECISION Eigen Condition Routines
-	./EIG/xeigtstd < dec.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dec.in > $@ 2>&1
 
 ded.out: ded.in EIG/xeigtstd
 	@echo DEV: Testing DOUBLE PRECISION Nonsymmetric Eigenvalue Driver
-	./EIG/xeigtstd < ded.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < ded.in > $@ 2>&1
 
 dgg.out: dgg.in EIG/xeigtstd
 	@echo DGG: Testing DOUBLE PRECISION Nonsymmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtstd < dgg.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dgg.in > $@ 2>&1
 
 dgd.out: dgd.in EIG/xeigtstd
 	@echo DGD: Testing DOUBLE PRECISION Nonsymmetric Generalized Eigenvalue Problem driver routines
-	./EIG/xeigtstd < dgd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dgd.in > $@ 2>&1
 
 dsb.out: dsb.in EIG/xeigtstd
 	@echo DSB: Testing DOUBLE PRECISION Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstd < dsb.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dsb.in > $@ 2>&1
 
 dsg.out: dsg.in EIG/xeigtstd
 	@echo DSG: Testing DOUBLE PRECISION Symmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtstd < dsg.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dsg.in > $@ 2>&1
 
 dbal.out: dbal.in EIG/xeigtstd
 	@echo DGEBAL: Testing the balancing of a DOUBLE PRECISION general matrix
-	./EIG/xeigtstd < dbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dbal.in > $@ 2>&1
 
 dbak.out: dbak.in EIG/xeigtstd
 	@echo DGEBAK: Testing the back transformation of a DOUBLE PRECISION balanced matrix
-	./EIG/xeigtstd < dbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dbak.in > $@ 2>&1
 
 dgbal.out: dgbal.in EIG/xeigtstd
 	@echo DGGBAL: Testing the balancing of a pair of DOUBLE PRECISION general matrices
-	./EIG/xeigtstd < dgbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dgbal.in > $@ 2>&1
 
 dgbak.out: dgbak.in EIG/xeigtstd
 	@echo DGGBAK: Testing the back transformation of a pair of DOUBLE PRECISION balanced matrices
-	./EIG/xeigtstd < dgbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dgbak.in > $@ 2>&1
 
 dbb.out: dbb.in EIG/xeigtstd
 	@echo DBB: Testing banded Singular Value Decomposition routines
-	./EIG/xeigtstd < dbb.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < dbb.in > $@ 2>&1
 
 dglm.out: glm.in EIG/xeigtstd
 	@echo GLM: Testing Generalized Linear Regression Model routines
-	./EIG/xeigtstd < glm.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < glm.in > $@ 2>&1
 
 dgqr.out: gqr.in EIG/xeigtstd
 	@echo GQR: Testing Generalized QR and RQ factorization routines
-	./EIG/xeigtstd < gqr.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < gqr.in > $@ 2>&1
 
 dgsv.out: gsv.in EIG/xeigtstd
 	@echo GSV: Testing Generalized Singular Value Decomposition routines
-	./EIG/xeigtstd < gsv.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < gsv.in > $@ 2>&1
 
 dcsd.out: csd.in EIG/xeigtstd
 	@echo CSD: Testing CS Decomposition routines
-	./EIG/xeigtstd < csd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < csd.in > $@ 2>&1
 
 dlse.out: lse.in EIG/xeigtstd
 	@echo LSE: Testing Constrained Linear Least Squares routines
-	./EIG/xeigtstd < lse.in > $@ 2>&1
+	wine64 ./EIG/xeigtstd.exe < lse.in > $@ 2>&1
 #
 # ======== COMPLEX16 EIG TESTS ===========================
 
 znep.out: nep.in EIG/xeigtstz
 	@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
-	./EIG/xeigtstz < nep.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < nep.in > $@ 2>&1
 
 zsep.out: sep.in EIG/xeigtstz
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstz < sep.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < sep.in > $@ 2>&1
 
 zse2.out: se2.in EIG/xeigtstz
 	@echo SEP: Testing Symmetric Eigenvalue Problem routines
-	./EIG/xeigtstz < se2.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < se2.in > $@ 2>&1
 
 zsvd.out: svd.in EIG/xeigtstz
 	@echo SVD: Testing Singular Value Decomposition routines
-	./EIG/xeigtstz < svd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < svd.in > $@ 2>&1
 
 zec.out: zec.in EIG/xeigtstz
 	@echo ZEC: Testing COMPLEX16 Eigen Condition Routines
-	./EIG/xeigtstz < zec.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zec.in > $@ 2>&1
 
 zed.out: zed.in EIG/xeigtstz
 	@echo ZES: Testing COMPLEX16 Nonsymmetric Schur Form Driver
-	./EIG/xeigtstz < zed.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zed.in > $@ 2>&1
 
 zgg.out: zgg.in EIG/xeigtstz
 	@echo ZGG: Testing COMPLEX16 Nonsymmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtstz < zgg.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zgg.in > $@ 2>&1
 
 zgd.out: zgd.in EIG/xeigtstz
 	@echo ZGD: Testing COMPLEX16 Nonsymmetric Generalized Eigenvalue Problem driver routines
-	./EIG/xeigtstz < zgd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zgd.in > $@ 2>&1
 
 zsb.out: zsb.in EIG/xeigtstz
 	@echo ZHB: Testing Hermitian Eigenvalue Problem routines
-	./EIG/xeigtstz < zsb.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zsb.in > $@ 2>&1
 
 zsg.out: zsg.in EIG/xeigtstz
 	@echo ZSG: Testing Symmetric Generalized Eigenvalue Problem routines
-	./EIG/xeigtstz < zsg.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zsg.in > $@ 2>&1
 
 zbal.out: zbal.in EIG/xeigtstz
 	@echo ZGEBAL: Testing the balancing of a COMPLEX16 general matrix
-	./EIG/xeigtstz < zbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zbal.in > $@ 2>&1
 
 zbak.out: zbak.in EIG/xeigtstz
 	@echo ZGEBAK: Testing the back transformation of a COMPLEX16 balanced matrix
-	./EIG/xeigtstz < zbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zbak.in > $@ 2>&1
 
 zgbal.out: zgbal.in EIG/xeigtstz
 	@echo ZGGBAL: Testing the balancing of a pair of COMPLEX general matrices
-	./EIG/xeigtstz < zgbal.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zgbal.in > $@ 2>&1
 
 zgbak.out: zgbak.in EIG/xeigtstz
 	@echo ZGGBAK: Testing the back transformation of a pair of COMPLEX16 balanced matrices
-	./EIG/xeigtstz < zgbak.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zgbak.in > $@ 2>&1
 
 zbb.out: zbb.in EIG/xeigtstz
 	@echo ZBB: Testing banded Singular Value Decomposition routines
-	./EIG/xeigtstz < zbb.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < zbb.in > $@ 2>&1
 
 zglm.out: glm.in EIG/xeigtstz
 	@echo GLM: Testing Generalized Linear Regression Model routines
-	./EIG/xeigtstz < glm.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < glm.in > $@ 2>&1
 
 zgqr.out: gqr.in EIG/xeigtstz
 	@echo GQR: Testing Generalized QR and RQ factorization routines
-	./EIG/xeigtstz < gqr.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < gqr.in > $@ 2>&1
 
 zgsv.out: gsv.in EIG/xeigtstz
 	@echo GSV: Testing Generalized Singular Value Decomposition routines
-	./EIG/xeigtstz < gsv.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < gsv.in > $@ 2>&1
 
 zcsd.out: csd.in EIG/xeigtstz
 	@echo CSD: Testing CS Decomposition routines
-	./EIG/xeigtstz < csd.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < csd.in > $@ 2>&1
 
 zlse.out: lse.in EIG/xeigtstz
 	@echo LSE: Testing Constrained Linear Least Squares routines
-	./EIG/xeigtstz < lse.in > $@ 2>&1
+	wine64 ./EIG/xeigtstz.exe < lse.in > $@ 2>&1
 # ==============================================================================
 
 LIN/xlintsts: $(FRCLIN) $(FRC)
