# This makefile is for the command line version
# of the Microsoft Visual Studio Compiler on Windows 10.
# The option '-O3' is unknown and replaced by '-O2'.

# location for the code for multiple double precision
MPD=../Norms
# location for the code for monomial evaluation and differentiation
CNV=../Convolutions
# location for the Polynomials folder for the wingettimeofday.h
POL=../Polynomials
# location for the Matrices folder for the solving of linear systems
MAT=../Matrices
# location for the Newton folder for Newton's method
NEW=../Newton

# architecture flag
smflag=sm_75

# location of the command line Microsoft Visual Studio Compiler
CL="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.25.28610\bin\Hostx64\x64"
# CL="C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\bin\Hostx64\x64"

# include path for the Microsoft Visual Studio Compiler
includepath="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.25.28610\include"
# includepath="C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include"

# include path for the Windows Kit
winkitucrt="C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt"
# include path for the Windows.h file
winkitum="C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um"
# include path for the winapifamily.h
winkitshared="C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared"

# libaries of the Microsoft Visual Studio compiler
libdirvs="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.25.28610\lib\x64"
# libdirvs="C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\lib\x64"

# libraries of the Windows Kits
libdirkitum="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\um\x64"
libdirkitucrt="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\ucrt\x64"

# include files of the CUDA SDK
CUDASDK="C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.2"
# library folder of the CUDA SDK
CUDALIB="C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.2\lib\x64"

double_double_functions.obj:
	@-echo ">>> compiling double double functions ..."
	$(CL)\cl /c -I$(MPD) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(MPD)/double_double_functions.cpp \
                 /Fo: double_double_functions.obj /EHsc

quad_double_functions.obj:
	@-echo ">>> compiling quad double functions ..."
	$(CL)\cl /c -I$(MPD) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(MPD)/quad_double_functions.cpp \
                 /Fo: quad_double_functions.obj /EHsc

octo_double_functions.obj:
	@-echo ">>> compiling octo double functions ..."
	$(CL)\cl /c -I$(MPD) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(MPD)/octo_double_functions.cpp \
                 /Fo: octo_double_functions.obj /EHsc

random_numbers.obj:
	@-echo ">>> compiling random_numbers ..."
	$(CL)\cl /c -I$(MPD) $(MPD)/random_numbers.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: random_numbers.obj /EHsc

random_series.obj:
	@-echo ">>> compiling random_series ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/random_series.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: random_series.obj /EHsc

random2_series.obj:
	@-echo ">>> compiling double double random_series ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/random2_series.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: random2_series.obj /EHsc

random4_series.obj:
	@-echo ">>> compiling quad double random_series ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/random4_series.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: random4_series.obj /EHsc

random8_series.obj:
	@-echo ">>> compiling octo double random_series ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/random8_series.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: random8_series.obj /EHsc

random_monomials.obj:
	@-echo ">>> compiling random_monomials ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/random_monomials.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: random_monomials.obj /EHsc

random2_vectors.obj:
	@-echo ">>> compiling double double random vector generators ..."
	$(CL)\cl /c -I$(MPD) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(MPD)/random2_vectors.cpp \
                 /Fo: random2_vectors.obj /EHsc

random4_vectors.obj:
	@-echo ">>> compiling quad double random vector generators ..."
	$(CL)\cl /c -I$(MPD) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(MPD)/random4_vectors.cpp \
                 /Fo: random4_vectors.obj /EHsc

random8_vectors.obj:
	@-echo ">>> compiling octo double random vector generators ..."
	$(CL)\cl /c -I$(MPD) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(MPD)/random8_vectors.cpp \
                 /Fo: random8_vectors.obj /EHsc

dbl_convolutions_host.obj:
	@-echo ">>> compiling dbl_convolutions_host ..."
	$(CL)\cl /c -I$(CNV) $(CNV)/dbl_convolutions_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl_convolutions_host.obj /EHsc

dbl2_convolutions_host.obj:
	@-echo ">>> compiling dbl2_convolutions_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/dbl2_convolutions_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl2_convolutions_host.obj /EHsc

dbl4_convolutions_host.obj:
	@-echo ">>> compiling dbl4_convolutions_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/dbl4_convolutions_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl4_convolutions_host.obj /EHsc

dbl8_convolutions_host.obj:
	@-echo ">>> compiling dbl8_convolutions_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/dbl8_convolutions_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl8_convolutions_host.obj /EHsc

dbl_monomials_host.obj:
	@-echo ">>> compiling dbl_monomials_host ..."
	$(CL)\cl /c -I$(CNV) $(CNV)/dbl_monomials_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl_monomials_host.obj /EHsc

dbl2_monomials_host.obj:
	@-echo ">>> compiling dbl2_monomials_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/dbl2_monomials_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl2_monomials_host.obj /EHsc

dbl4_monomials_host.obj:
	@-echo ">>> compiling dbl4_monomials_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/dbl4_monomials_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl4_monomials_host.obj /EHsc

dbl8_monomials_host.obj:
	@-echo ">>> compiling dbl8_monomials_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) $(CNV)/dbl8_monomials_host.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl8_monomials_host.obj /EHsc

dbl_factorizations.obj:
	@-echo ">>> compiling dbl_factorizations ..."
	$(CL)\cl /c -I$(MAT) $(MAT)/dbl_factorizations.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl_factorizations.obj /EHsc

dbl2_factorizations.obj:
	@-echo ">>> compiling dbl2_factorizations ..."
	$(CL)\cl /c -I$(MPD) -I$(MAT) $(MAT)/dbl2_factorizations.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl2_factorizations.obj /EHsc

dbl4_factorizations.obj:
	@-echo ">>> compiling dbl4_factorizations ..."
	$(CL)\cl /c -I$(MPD) -I$(MAT) $(MAT)/dbl4_factorizations.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl4_factorizations.obj /EHsc

dbl8_factorizations.obj:
	@-echo ">>> compiling dbl8_factorizations ..."
	$(CL)\cl /c -I$(MPD) -I$(MAT) $(MAT)/dbl8_factorizations.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /Fo: dbl8_factorizations.obj /EHsc

unimodular_matrices.obj:
	@-echo ">>> compiling unimodular matrices ..."
	$(CL)\cl /c -I$(CNV) -I$(NEW) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/unimodular_matrices.cpp \
                 /Fo: unimodular_matrices.obj /EHsc

dbl_onenorms_host.obj:
	@-echo ">>> compiling dbl_onenorms_host ..."
	$(CL)\cl /c -I$(NEW) -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl_onenorms_host.cpp \
                 /Fo: dbl_onenorms_host.obj /EHsc

dbl_bals_host.obj:
	@-echo ">>> compiling dbl_bals_host ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl_bals_host.cpp \
                 /Fo: dbl_bals_host.obj /EHsc

dbl2_bals_host.obj:
	@-echo ">>> compiling dbl2_bals_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl2_bals_host.cpp \
                 /Fo: dbl2_bals_host.obj /EHsc

dbl4_bals_host.obj:
	@-echo ">>> compiling dbl4_bals_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl4_bals_host.cpp \
                 /Fo: dbl4_bals_host.obj /EHsc

dbl8_bals_host.obj:
	@-echo ">>> compiling dbl8_bals_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl8_bals_host.cpp \
                 /Fo: dbl8_bals_host.obj /EHsc

dbl_baqr_flopcounts.obj:
	@-echo ">>> compiling dbl_baqr_flopcounts ..."
	$(CL)\cl /c $(MAT)/dbl_baqr_flopcounts.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /I$(CUDASDK)/include \
                 /Fo: dbl_baqr_flopcounts.obj /EHsc

dbl_tabs_flopcounts.obj:
	@-echo ">>> compiling dbl_tabs_flopcounts ..."
	$(CL)\cl /c $(MAT)/dbl_tabs_flopcounts.cpp \
                 -I$(winkitucrt) -I$(includepath) -O2 \
                 /I$(CUDASDK)/include \
                 /Fo: dbl_tabs_flopcounts.obj /EHsc

gettimeofday4win.obj:
	@-echo ">>> compiling gettimeofday4win ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
                $(MAT)/gettimeofday4win.cpp \
             -o gettimeofday4win.obj

dbl_baqr_kernels.obj:
	@-echo ">>> compiling dbl_baqr_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) \
             --define-macro winwalltime=1 \
                $(MAT)/dbl_baqr_kernels.cu \
             -o dbl_baqr_kernels.obj

dbl2_baqr_kernels.obj:
	@-echo ">>> compiling dbl2_baqr_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(MAT)/dbl2_baqr_kernels.cu \
             -o dbl2_baqr_kernels.obj

dbl4_baqr_kernels.obj:
	@-echo ">>> compiling dbl4_baqr_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(MAT)/dbl4_baqr_kernels.cu \
             -o dbl4_baqr_kernels.obj

dbl8_baqr_kernels.obj:
	@-echo ">>> compiling dbl8_baqr_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(MAT)/dbl8_baqr_kernels.cu \
             -o dbl8_baqr_kernels.obj

dbl_tabs_kernels.obj:
	@-echo ">>> compiling dbl_tabs_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) \
             --define-macro winwalltime=1 \
                $(MAT)/dbl_tabs_kernels.cu \
             -o dbl_tabs_kernels.obj

dbl2_tabs_kernels.obj:
	@-echo ">>> compiling dbl2_tabs_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(MAT)/dbl2_tabs_kernels.cu \
             -o dbl2_tabs_kernels.obj

dbl4_tabs_kernels.obj:
	@-echo ">>> compiling dbl4_tabs_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(MAT)/dbl4_tabs_kernels.cu \
             -o dbl4_tabs_kernels.obj

dbl8_tabs_kernels.obj:
	@-echo ">>> compiling dbl8_tabs_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(POL) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(MAT)/dbl8_tabs_kernels.cu \
             -o dbl8_tabs_kernels.obj

dbl_polynomials_kernels.obj:
	@-echo ">>> compiling dbl_polynomials_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(CNV) -I$(MAT) \
             --define-macro winwalltime=1 \
                $(POL)/dbl_polynomials_kernels.cu \
             -o dbl_polynomials_kernels.obj

dbl2_polynomials_kernels.obj:
	@-echo ">>> compiling dbl2_polynomials_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(CNV) -I$(MAT) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(POL)/dbl2_polynomials_kernels.cu \
             -o dbl2_polynomials_kernels.obj

dbl4_polynomials_kernels.obj:
	@-echo ">>> compiling dbl4_polynomials_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(CNV) -I$(MAT) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(POL)/dbl4_polynomials_kernels.cu \
             -o dbl4_polynomials_kernels.obj

dbl8_polynomials_kernels.obj:
	@-echo ">>> compiling dbl8_polynomials_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 -I$(CNV) -I$(MAT) -I$(MPD) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(POL)/dbl8_polynomials_kernels.cu \
             -o dbl8_polynomials_kernels.obj

dbl_tail_kernels.obj:
	@-echo ">>> compiling dbl_tail_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(NEW) \
             --define-macro winwalltime=1 \
                $(NEW)/dbl_tail_kernels.cu \
             -o dbl_tail_kernels.obj

dbl2_tail_kernels.obj:
	@-echo ">>> compiling dbl2_tail_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(MPD) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl2_tail_kernels.cu \
             -o dbl2_tail_kernels.obj

dbl4_tail_kernels.obj:
	@-echo ">>> compiling dbl4_tail_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(MPD) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl4_tail_kernels.cu \
             -o dbl4_tail_kernels.obj

dbl8_tail_kernels.obj:
	@-echo ">>> compiling dbl8_tail_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(MPD) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl8_tail_kernels.cu \
             -o dbl8_tail_kernels.obj

dbl_bals_kernels.obj:
	@-echo ">>> compiling dbl_bals_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(NEW) \
             --define-macro winwalltime=1 \
                $(NEW)/dbl_bals_kernels.cu \
             -o dbl_bals_kernels.obj

dbl2_bals_kernels.obj:
	@-echo ">>> compiling dbl2_bals_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(MPD) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl2_bals_kernels.cu \
             -o dbl2_bals_kernels.obj

dbl4_bals_kernels.obj:
	@-echo ">>> compiling dbl4_bals_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(MPD) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl4_bals_kernels.cu \
             -o dbl4_bals_kernels.obj

dbl8_bals_kernels.obj:
	@-echo ">>> compiling dbl8_bals_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(POL) -I$(MAT) -I$(MPD) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl8_bals_kernels.cu \
             -o dbl8_bals_kernels.obj

dbl_systems_host.obj:
	@-echo ">>> compiling dbl_systems_host ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl_systems_host.cpp \
                 /Fo: dbl_systems_host.obj /EHsc

dbl2_systems_host.obj:
	@-echo ">>> compiling dbl2_systems_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl2_systems_host.cpp \
                 /Fo: dbl2_systems_host.obj /EHsc

dbl4_systems_host.obj:
	@-echo ">>> compiling dbl4_systems_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl4_systems_host.cpp \
                 /Fo: dbl4_systems_host.obj /EHsc

dbl8_systems_host.obj:
	@-echo ">>> compiling dbl8_systems_host ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl8_systems_host.cpp \
                 /Fo: dbl8_systems_host.obj /EHsc

dbl_systems_kernels.obj:
	@-echo ">>> compiling dbl_systems_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
             --define-macro winwalltime=1 \
                $(NEW)/dbl_systems_kernels.cu \
             -o dbl_systems_kernels.obj

dbl2_systems_kernels.obj:
	@-echo ">>> compiling dbl2_systems_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl2_systems_kernels.cu \
             -o dbl2_systems_kernels.obj

dbl4_systems_kernels.obj:
	@-echo ">>> compiling dbl4_systems_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl4_systems_kernels.cu \
             -o dbl4_systems_kernels.obj

dbl8_systems_kernels.obj:
	@-echo ">>> compiling dbl8_systems_kernels ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O3 \
             -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
             --define-macro winwalltime=1 \
             --define-macro gpufun=1 \
                $(NEW)/dbl8_systems_kernels.cu \
             -o dbl8_systems_kernels.obj

dbl_newton_method.obj:
	@-echo ">>> compiling dbl_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/dbl_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl_newton_method.obj /EHsc

dbl2_newton_method.obj:
	@-echo ">>> compiling dbl2_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/dbl2_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl2_newton_method.obj /EHsc

dbl4_newton_method.obj:
	@-echo ">>> compiling dbl4_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/dbl4_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl4_newton_method.obj /EHsc

dbl8_newton_method.obj:
	@-echo ">>> compiling dbl8_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/dbl8_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl8_newton_method.obj /EHsc

cmplx_newton_method.obj:
	@-echo ">>> compiling cmplx_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/cmplx_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx_newton_method.obj /EHsc

cmplx2_newton_method.obj:
	@-echo ">>> compiling cmplx2_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/cmplx2_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx2_newton_method.obj /EHsc

cmplx4_newton_method.obj:
	@-echo ">>> compiling cmplx4_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/cmplx4_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx4_newton_method.obj /EHsc

cmplx8_newton_method.obj:
	@-echo ">>> compiling cmplx8_newton_method ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      $(NEW)/cmplx8_newton_method.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx8_newton_method.obj /EHsc

dbl_newton_testers.obj:
	@-echo ">>> compiling dbl_newton_testers ..."
	$(CL)\cl /c -I$(winkitucrt) -I$(includepath) -O2 \
                    -I$(NEW) $(NEW)/dbl_newton_testers.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl_newton_testers.obj /EHsc

dbl2_newton_testers.obj:
	@-echo ">>> compiling dbl2_newton_testers ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl2_newton_testers.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl2_newton_testers.obj /EHsc

dbl4_newton_testers.obj:
	@-echo ">>> compiling dbl4_newton_testers ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl4_newton_testers.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl4_newton_testers.obj /EHsc

dbl8_newton_testers.obj:
	@-echo ">>> compiling dbl8_newton_testers ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl8_newton_testers.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl8_newton_testers.obj /EHsc

test_unimodular.obj:
	@-echo ">>> compiling test_unimodular ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/test_unimodular.cpp \
                 /Fo: test_unimodular.obj /EHsc

cyclic_columns.obj:
	@-echo ">>> compiling cyclic_columns ..."
	$(CL)\cl /c -I$(winkitucrt) -I$(includepath) -O2 \
                    -I$(NEW) $(NEW)/cyclic_columns.cpp \
                 /Fo: cyclic_columns.obj /EHsc

test_columns.obj:
	@-echo ">>> compiling test_columns ..."
	$(CL)\cl /c -I$(winkitucrt) -I$(includepath) -O2 \
                    -I$(NEW) $(NEW)/test_columns.cpp \
                 /Fo: test_columns.obj /EHsc

dbl_monomial_systems.obj:
	@-echo ">>> compiling dbl_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl_monomial_systems.cpp \
                 /Fo: dbl_monomial_systems.obj /EHsc

dbl2_monomial_systems.obj:
	@-echo ">>> compiling dbl2_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl2_monomial_systems.cpp \
                 /Fo: dbl2_monomial_systems.obj /EHsc

dbl4_monomial_systems.obj:
	@-echo ">>> compiling dbl4_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl4_monomial_systems.cpp \
                 /Fo: dbl4_monomial_systems.obj /EHsc

dbl8_monomial_systems.obj:
	@-echo ">>> compiling dbl8_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/dbl8_monomial_systems.cpp \
                 /Fo: dbl8_monomial_systems.obj /EHsc

test_monomial_systems.obj:
	@-echo ">>> compiling test_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      $(NEW)/test_monomial_systems.cpp \
                 /Fo: test_monomial_systems.obj /EHsc

test2_monomial_systems.obj:
	@-echo ">>> compiling test2_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(winkitucrt) -I$(includepath) -O2 \
                      test2_monomial_systems.cpp \
                 /Fo: test2_monomial_systems.obj /EHsc

test4_monomial_systems.obj:
	@-echo ">>> compiling test4_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(winkitucrt) -I$(includepath) -O2 \
                      test4_monomial_systems.cpp \
                 /Fo: test4_monomial_systems.obj /EHsc

test8_monomial_systems.obj:
	@-echo ">>> compiling test8_monomial_systems ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(winkitucrt) -I$(includepath) -O2 \
                      test8_monomial_systems.cpp \
                 /Fo: test8_monomial_systems.obj /EHsc

convolution_job.obj:
	@-echo ">>> compiling convolution_job ..."
	$(CL)\cl /c $(POL)/convolution_job.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: convolution_job.obj /EHsc

convolution_jobs.obj:
	@-echo ">>> compiling convolution_jobs ..."
	$(CL)\cl /c $(POL)/convolution_jobs.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: convolution_jobs.obj /EHsc

addition_job.obj:
	@-echo ">>> compiling addition_job ..."
	$(CL)\cl /c $(POL)/addition_job.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: addition_job.obj /EHsc

addition_jobs.obj:
	@-echo ">>> compiling addition_jobs ..."
	$(CL)\cl /c $(POL)/addition_jobs.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: addition_jobs.obj /EHsc

job_coordinates.obj:
	@-echo ">>> compiling job_coordinates ..."
	$(CL)\cl /c $(POL)/job_coordinates.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: job_coordinates.obj /EHsc

write_job_counts.obj:
	@-echo ">>> compiling write_job_counts ..."
	$(CL)\cl /c $(POL)/write_job_counts.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_job_counts.obj /EHsc

test_monomial_jobs.obj:
	@-echo ">>> compiling test_monomial_jobs ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(POL) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_monomial_jobs.cpp \
                 /Fo: test_monomial_jobs.obj /EHsc

write_gpu_timings.obj:
	@-echo ">>> compiling write_gpu_timings ..."
	$(CL)\cl /c $(POL)/write_gpu_timings.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_gpu_timings.obj /EHsc

dbl_bals_flopcounts.obj:
	@-echo ">>> compiling dbl_bals_flopcounts ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O2 \
                      -I$(NEW) $(NEW)/dbl_bals_flopcounts.cpp \
                   -o dbl_bals_flopcounts.obj

write_dbl_bstimeflops.obj:
	@-echo ">>> compiling write_dbl_bstimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl_bstimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl_bstimeflops.obj /EHsc

write_dbl_qrtimeflops.obj:
	@-echo ">>> compiling write_dbl_qrtimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl_qrtimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl_qrtimeflops.obj /EHsc

write_dbl2_bstimeflops.obj:
	@-echo ">>> compiling write_dbl2_bstimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl2_bstimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl2_bstimeflops.obj /EHsc

write_dbl2_qrtimeflops.obj:
	@-echo ">>> compiling write_dbl2_qrtimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl2_qrtimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl2_qrtimeflops.obj /EHsc

write_dbl4_bstimeflops.obj:
	@-echo ">>> compiling write_dbl4_bstimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl4_bstimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl4_bstimeflops.obj /EHsc

write_dbl4_qrtimeflops.obj:
	@-echo ">>> compiling write_dbl4_qrtimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl4_qrtimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl4_qrtimeflops.obj /EHsc

write_dbl8_bstimeflops.obj:
	@-echo ">>> compiling write_dbl8_bstimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl8_bstimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl8_bstimeflops.obj /EHsc

write_dbl8_qrtimeflops.obj:
	@-echo ">>> compiling write_dbl8_qrtimeflops ..."
	$(CL)\cl /c $(MAT)/write_dbl8_qrtimeflops.cpp \
                 -I$(winkitucrt) -I$(includepath) -I$(MPD) -I$(CNV) -O2 \
                 /Fo: write_dbl8_qrtimeflops.obj /EHsc

test_dbl_flopbals.obj:
	@-echo ">>> compiling test_dbl_flopbals ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O2 -I$(MPD) -I$(MAT) \
             --define-macro winwalltime=1 \
                      test_dbl_flopbals.cpp \
                   -o test_dbl_flopbals.obj

test_dbl2_flopbals.obj:
	@-echo ">>> compiling test_dbl2_flopbals ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O2 -I$(MPD) -I$(MAT) \
             --define-macro winwalltime=1 \
                      test_dbl2_flopbals.cpp \
                   -o test_dbl2_flopbals.obj

test_dbl4_flopbals.obj:
	@-echo ">>> compiling test_dbl4_flopbals ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O2 -I$(MPD) -I$(MAT) \
             --define-macro winwalltime=1 \
                      test_dbl4_flopbals.cpp \
                   -o test_dbl4_flopbals.obj

test_dbl8_flopbals.obj:
	@-echo ">>> compiling test_dbl8_flopbals ..."
	nvcc -ccbin=$(CL) -arch=$(smflag) -c -O2 -I$(MPD) -I$(MAT) \
             --define-macro winwalltime=1 \
                      test_dbl8_flopbals.cpp \
                   -o test_dbl8_flopbals.obj

test_dbl_newton.obj:
	@-echo ">>> compiling test_dbl_newton ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl_newton.cpp \
                 /Fo: test_dbl_newton.obj /EHsc

test_dbl2_newton.obj:
	@-echo ">>> compiling test_dbl2_newton ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl2_newton.cpp \
                 /Fo: test_dbl2_newton.obj /EHsc

test_dbl4_newton.obj:
	@-echo ">>> compiling test_dbl4_newton ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl4_newton.cpp \
                 /Fo: test_dbl4_newton.obj /EHsc

test_dbl8_newton.obj:
	@-echo ">>> compiling test_dbl8_newton ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl8_newton.cpp \
                 /Fo: test_dbl8_newton.obj /EHsc

test_unimodular: unimodular_matrices.obj test_unimodular.obj \
                 random_numbers.obj random_series.obj random_monomials.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_unimodular.exe test_unimodular.obj \
             unimodular_matrices.obj \
             random_numbers.obj random_series.obj random_monomials.obj

test_columns: cyclic_columns.obj test_columns.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_columns.exe \
             cyclic_columns.obj test_columns.obj

test_monomial_systems: cyclic_columns.obj \
	         test_monomial_systems.obj unimodular_matrices.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 dbl_monomial_systems.obj dbl_convolutions_host.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_monomial_systems.exe cyclic_columns.obj \
             test_monomial_systems.obj dbl_monomial_systems.obj \
             unimodular_matrices.obj dbl_convolutions_host.obj \
             random_numbers.obj random_series.obj random_monomials.obj

test2_monomial_systems: test2_monomial_systems.obj unimodular_matrices.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 double_double_functions.obj cyclic_columns.obj \
		 random2_vectors.obj random2_series.obj \
                 dbl2_monomial_systems.obj dbl2_convolutions_host.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test2_monomial_systems.exe \
             test2_monomial_systems.obj dbl2_monomial_systems.obj \
             unimodular_matrices.obj dbl2_convolutions_host.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
             double_double_functions.obj \
	     random2_vectors.obj random2_series.obj cyclic_columns.obj

test4_monomial_systems: test4_monomial_systems.obj unimodular_matrices.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 double_double_functions.obj quad_double_functions.obj \
		 random4_vectors.obj random4_series.obj cyclic_columns.obj \
                 dbl4_monomial_systems.obj dbl4_convolutions_host.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test4_monomial_systems.exe \
             test4_monomial_systems.obj dbl4_monomial_systems.obj \
             unimodular_matrices.obj dbl4_convolutions_host.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
             double_double_functions.obj quad_double_functions.obj \
	     random4_vectors.obj random4_series.obj cyclic_columns.obj

test8_monomial_systems: test8_monomial_systems.obj unimodular_matrices.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 double_double_functions.obj quad_double_functions.obj \
		 octo_double_functions.obj cyclic_columns.obj \
		 random8_vectors.obj random8_series.obj \
                 dbl8_monomial_systems.obj dbl8_convolutions_host.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test8_monomial_systems.exe \
             test8_monomial_systems.obj dbl8_monomial_systems.obj \
             unimodular_matrices.obj dbl8_convolutions_host.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
             double_double_functions.obj quad_double_functions.obj \
	     octo_double_functions.obj random8_vectors.obj random8_series.obj \
	     cyclic_columns.obj

test_monomial_jobs: unimodular_matrices.obj test_monomial_jobs.obj \
                    convolution_job.obj convolution_jobs.obj \
                    random_numbers.obj random_series.obj random_monomials.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_monomial_jobs.exe \
                             test_monomial_jobs.obj \
             unimodular_matrices.obj convolution_job.obj convolution_jobs.obj \
             random_numbers.obj random_series.obj random_monomials.obj

prompt_newton_setup.obj:
	@-echo ">>> compiling prompt_newton_setup ..."
	$(CL)\cl /c -I$(winkitucrt) -I$(includepath) -O2 \
                    -I$(NEW) $(NEW)/prompt_newton_setup.cpp \
                 /Fo: prompt_newton_setup.obj /EHsc

test_dbl_flopbals: random_numbers.obj test_dbl_flopbals.obj \
                   dbl_tail_kernels.obj dbl_bals_flopcounts.obj \
                   gettimeofday4win.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl_flopbals.exe test_dbl_flopbals.obj \
	     random_numbers.obj dbl_tail_kernels.obj dbl_bals_flopcounts.obj \
             gettimeofday4win.obj

test_dbl2_flopbals: random_numbers.obj random2_vectors.obj \
                    double_double_functions.obj test_dbl2_flopbals.obj \
                    dbl2_tail_kernels.obj dbl_bals_flopcounts.obj \
                    gettimeofday4win.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl2_flopbals.exe test_dbl2_flopbals.obj \
	     random_numbers.obj random2_vectors.obj dbl_bals_flopcounts.obj \
	     double_double_functions.obj dbl2_tail_kernels.obj \
	     gettimeofday4win.obj

test_dbl4_flopbals: random_numbers.obj random4_vectors.obj \
                    double_double_functions.obj quad_double_functions.obj \
		    test_dbl4_flopbals.obj dbl_bals_flopcounts.obj \
                    dbl4_tail_kernels.obj gettimeofday4win.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl4_flopbals.exe test_dbl4_flopbals.obj \
	     random_numbers.obj random4_vectors.obj \
	     double_double_functions.obj quad_double_functions.obj \
	     dbl4_tail_kernels.obj dbl_bals_flopcounts.obj \
             gettimeofday4win.obj

test_dbl8_flopbals: random_numbers.obj random8_vectors.obj \
                    double_double_functions.obj quad_double_functions.obj \
                    octo_double_functions.obj dbl_bals_flopcounts.obj \
		    test_dbl8_flopbals.obj dbl8_tail_kernels.obj \
		    gettimeofday4win.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl8_flopbals.exe test_dbl8_flopbals.obj \
	     random_numbers.obj random8_vectors.obj \
	     double_double_functions.obj quad_double_functions.obj \
	     octo_double_functions.obj dbl_bals_flopcounts.obj \
	     dbl8_tail_kernels.obj gettimeofday4win.obj

dbl_fabry_host.obj:
	@-echo ">>> compiling dbl_fabry_host ..."
	$(CL)\cl /c -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      dbl_fabry_host.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl_fabry_host.obj /EHsc

dbl_path_tracker.obj:
	@-echo ">>> compiling dbl_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      dbl_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl_path_tracker.obj /EHsc

dbl2_path_tracker.obj:
	@-echo ">>> compiling dbl2_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      dbl2_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl2_path_tracker.obj /EHsc

dbl4_path_tracker.obj:
	@-echo ">>> compiling dbl4_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      dbl4_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl4_path_tracker.obj /EHsc

dbl8_path_tracker.obj:
	@-echo ">>> compiling dbl8_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      dbl8_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: dbl8_path_tracker.obj /EHsc

cmplx_path_tracker.obj:
	@-echo ">>> compiling cmplx_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      cmplx_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx_path_tracker.obj /EHsc

cmplx2_path_tracker.obj:
	@-echo ">>> compiling cmplx2_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      cmplx2_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx2_path_tracker.obj /EHsc

cmplx4_path_tracker.obj:
	@-echo ">>> compiling cmplx4_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      cmplx4_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx4_path_tracker.obj /EHsc

cmplx8_path_tracker.obj:
	@-echo ">>> compiling cmplx8_path_tracker ..."
	$(CL)\cl /c -I$(MPD) -I$(CNV) -I$(MAT) -I$(POL) -I$(NEW) \
                    -I$(winkitucrt) -I$(winkitum) -I$(winkitshared) \
                    -I$(includepath) -O2 \
                    -D winwalltime=1 \
                      cmplx8_path_tracker.cpp \
                 /I$(CUDASDK)/include \
                 /Fo: cmplx8_path_tracker.obj /EHsc

test_dbl_track.obj:
	@-echo ">>> compiling test_dbl_track ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl_track.cpp \
                 /Fo: test_dbl_track.obj /EHsc

test_dbl2_track.obj:
	@-echo ">>> compiling test_dbl2_track ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl2_track.cpp \
                 /Fo: test_dbl2_track.obj /EHsc

test_dbl4_track.obj:
	@-echo ">>> compiling test_dbl4_track ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl4_track.cpp \
                 /Fo: test_dbl4_track.obj /EHsc

test_dbl8_track.obj:
	@-echo ">>> compiling test_dbl8_track ..."
	$(CL)\cl /c -I$(CNV) -I$(MAT) -I$(NEW) \
                    -I$(winkitucrt) -I$(includepath) -O2 \
                      test_dbl8_track.cpp \
                 /Fo: test_dbl8_track.obj /EHsc

test_dbl_track: unimodular_matrices.obj \
                test_dbl_track.obj dbl_path_tracker.obj \
		cmplx_path_tracker.obj dbl_fabry_host.obj \
                dbl_newton_testers.obj prompt_newton_setup.obj \
                dbl_monomial_systems.obj cyclic_columns.obj \
                dbl_newton_method.obj cmplx_newton_method.obj \
                dbl_bals_kernels.obj dbl_tail_kernels.obj \
                random_numbers.obj random_series.obj random_monomials.obj \
                dbl_convolutions_host.obj dbl_monomials_host.obj \
                convolution_job.obj convolution_jobs.obj \
                addition_job.obj addition_jobs.obj job_coordinates.obj \
                gettimeofday4win.obj write_gpu_timings.obj \
                dbl_systems_host.obj write_dbl_bstimeflops.obj \
                write_dbl_qrtimeflops.obj write_job_counts.obj \
                dbl_systems_kernels.obj dbl_polynomials_kernels.obj \
                dbl_factorizations.obj dbl_onenorms_host.obj \
                dbl_bals_host.obj dbl_bals_flopcounts.obj \
                dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
                dbl_baqr_kernels.obj dbl_tabs_kernels.obj 
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl_track.exe \
                             test_dbl_track.obj dbl_path_tracker.obj \
             cmplx_path_tracker.obj dbl_fabry_host.obj \
             unimodular_matrices.obj prompt_newton_setup.obj \
	     dbl_newton_testers.obj dbl_monomial_systems.obj \
             dbl_newton_method.obj cmplx_newton_method.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
	     dbl_convolutions_host.obj dbl_monomials_host.obj \
             cyclic_columns.obj convolution_job.obj convolution_jobs.obj \
             addition_job.obj addition_jobs.obj job_coordinates.obj \
             dbl_systems_host.obj write_gpu_timings.obj write_job_counts.obj \
             gettimeofday4win.obj write_dbl_qrtimeflops.obj \
             dbl_systems_kernels.obj dbl_polynomials_kernels.obj \
             dbl_factorizations.obj dbl_onenorms_host.obj \
             dbl_bals_host.obj dbl_tail_kernels.obj dbl_bals_kernels.obj \
             dbl_bals_flopcounts.obj write_dbl_bstimeflops.obj \
	     dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
	     dbl_baqr_kernels.obj dbl_tabs_kernels.obj

test_dbl2_track: unimodular_matrices.obj \
                 test_dbl2_track.obj dbl2_path_tracker.obj dbl_fabry_host.obj \
                 cmplx2_path_tracker.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 random2_vectors.obj random2_series.obj cyclic_columns.obj \
                 dbl2_monomial_systems.obj prompt_newton_setup.obj \
                 double_double_functions.obj dbl2_newton_testers.obj \
                 dbl2_newton_method.obj cmplx2_newton_method.obj \
                 dbl2_convolutions_host.obj dbl2_monomials_host.obj \
                 convolution_job.obj convolution_jobs.obj \
                 addition_job.obj addition_jobs.obj job_coordinates.obj \
                 gettimeofday4win.obj write_gpu_timings.obj \
                 dbl2_systems_host.obj write_dbl2_bstimeflops.obj \
                 write_dbl2_qrtimeflops.obj write_job_counts.obj \
                 dbl2_systems_kernels.obj dbl2_polynomials_kernels.obj \
                 dbl2_factorizations.obj dbl_onenorms_host.obj \
                 dbl2_bals_host.obj dbl_bals_flopcounts.obj \
                 dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
                 dbl2_baqr_kernels.obj dbl2_tabs_kernels.obj \
                 dbl2_tail_kernels.obj dbl2_bals_kernels.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl2_track.exe \
		             test_dbl2_track.obj dbl2_path_tracker.obj \
             cmplx2_path_tracker.obj dbl_fabry_host.obj \
             unimodular_matrices.obj prompt_newton_setup.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
             random2_vectors.obj random2_series.obj cyclic_columns.obj \
             double_double_functions.obj dbl2_newton_testers.obj \
	     dbl2_newton_method.obj cmplx2_newton_method.obj \
	     dbl2_convolutions_host.obj dbl2_monomials_host.obj \
             convolution_job.obj convolution_jobs.obj write_job_counts.obj \
             addition_job.obj addition_jobs.obj job_coordinates.obj \
             gettimeofday4win.obj write_gpu_timings.obj \
             dbl2_systems_host.obj dbl2_monomial_systems.obj \
             dbl2_systems_kernels.obj dbl2_polynomials_kernels.obj \
             dbl2_factorizations.obj dbl_onenorms_host.obj \
             dbl2_bals_host.obj dbl_bals_flopcounts.obj \
             write_dbl2_bstimeflops.obj write_dbl2_qrtimeflops.obj \
             dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
             dbl2_baqr_kernels.obj dbl2_tabs_kernels.obj \
             dbl2_tail_kernels.obj dbl2_bals_kernels.obj

test_dbl4_track: unimodular_matrices.obj \
                 test_dbl4_track.obj dbl4_path_tracker.obj dbl_fabry_host.obj \
		 cmplx4_path_tracker.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 random4_vectors.obj random4_series.obj cyclic_columns.obj \
                 dbl4_monomial_systems.obj prompt_newton_setup.obj \
                 double_double_functions.obj quad_double_functions.obj \
		 dbl4_newton_testers.obj \
                 dbl4_newton_method.obj cmplx4_newton_method.obj \
                 dbl4_convolutions_host.obj dbl4_monomials_host.obj \
                 convolution_job.obj convolution_jobs.obj \
                 addition_job.obj addition_jobs.obj job_coordinates.obj \
                 gettimeofday4win.obj write_gpu_timings.obj \
                 dbl4_systems_host.obj write_dbl4_bstimeflops.obj \
                 write_dbl4_qrtimeflops.obj write_job_counts.obj \
                 dbl4_systems_kernels.obj dbl4_polynomials_kernels.obj \
                 dbl4_factorizations.obj dbl_onenorms_host.obj \
                 dbl4_bals_host.obj dbl_bals_flopcounts.obj \
                 dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
                 dbl4_baqr_kernels.obj dbl4_tabs_kernels.obj \
                 dbl4_tail_kernels.obj dbl4_bals_kernels.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl4_track.exe \
		             test_dbl4_track.obj dbl4_path_tracker.obj \
             unimodular_matrices.obj prompt_newton_setup.obj \
             dbl_fabry_host.obj cmplx4_path_tracker.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
             random4_vectors.obj random4_series.obj cyclic_columns.obj \
             double_double_functions.obj quad_double_functions.obj\
	     dbl4_newton_testers.obj \
	     dbl4_newton_method.obj cmplx4_newton_method.obj \
	     dbl4_convolutions_host.obj dbl4_monomials_host.obj \
             convolution_job.obj convolution_jobs.obj write_job_counts.obj \
             addition_job.obj addition_jobs.obj job_coordinates.obj \
             gettimeofday4win.obj write_gpu_timings.obj \
             dbl4_systems_host.obj dbl4_monomial_systems.obj \
             dbl4_systems_kernels.obj dbl4_polynomials_kernels.obj \
             dbl4_factorizations.obj dbl_onenorms_host.obj \
             dbl4_bals_host.obj dbl_bals_flopcounts.obj \
             write_dbl4_bstimeflops.obj write_dbl4_qrtimeflops.obj \
             dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
             dbl4_baqr_kernels.obj dbl4_tabs_kernels.obj \
             dbl4_tail_kernels.obj dbl4_bals_kernels.obj

test_dbl8_track: unimodular_matrices.obj \
                 test_dbl8_track.obj dbl8_path_tracker.obj dbl_fabry_host.obj \
		 cmplx8_path_tracker.obj \
                 random_numbers.obj random_series.obj random_monomials.obj \
                 random8_vectors.obj random8_series.obj cyclic_columns.obj \
                 dbl8_monomial_systems.obj prompt_newton_setup.obj \
                 double_double_functions.obj quad_double_functions.obj \
		 octo_double_functions.obj dbl8_newton_testers.obj \
                 dbl8_newton_method.obj cmplx8_newton_method.obj \
                 dbl8_convolutions_host.obj dbl8_monomials_host.obj \
                 convolution_job.obj convolution_jobs.obj \
                 addition_job.obj addition_jobs.obj job_coordinates.obj \
                 gettimeofday4win.obj write_gpu_timings.obj \
                 dbl8_systems_host.obj write_dbl8_bstimeflops.obj \
                 write_dbl8_qrtimeflops.obj write_job_counts.obj \
                 dbl8_systems_kernels.obj dbl8_polynomials_kernels.obj \
                 dbl8_factorizations.obj dbl_onenorms_host.obj \
                 dbl8_bals_host.obj dbl_bals_flopcounts.obj \
                 dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
                 dbl8_baqr_kernels.obj dbl8_tabs_kernels.obj \
                 dbl8_tail_kernels.obj dbl8_bals_kernels.obj
	@-echo ">>> linking ..."
	nvcc -ccbin=$(CL) -o test_dbl8_track.exe \
		             test_dbl8_track.obj dbl8_path_tracker.obj \
             dbl_fabry_host.obj cmplx8_path_tracker.obj \
             unimodular_matrices.obj prompt_newton_setup.obj \
             random_numbers.obj random_series.obj random_monomials.obj \
             random8_vectors.obj random8_series.obj cyclic_columns.obj \
             double_double_functions.obj quad_double_functions.obj\
	     octo_double_functions.obj dbl8_newton_testers.obj \
	     dbl8_newton_method.obj cmplx8_newton_method.obj \
	     dbl8_convolutions_host.obj dbl8_monomials_host.obj \
             convolution_job.obj convolution_jobs.obj write_job_counts.obj \
             addition_job.obj addition_jobs.obj job_coordinates.obj \
             gettimeofday4win.obj write_gpu_timings.obj \
             dbl8_systems_host.obj dbl8_monomial_systems.obj \
             dbl8_systems_kernels.obj dbl8_polynomials_kernels.obj \
             dbl8_factorizations.obj dbl_onenorms_host.obj \
             dbl8_bals_host.obj dbl_bals_flopcounts.obj \
             write_dbl8_bstimeflops.obj write_dbl8_qrtimeflops.obj \
             dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj \
             dbl8_baqr_kernels.obj dbl8_tabs_kernels.obj \
             dbl8_tail_kernels.obj dbl8_bals_kernels.obj

clean:
	del *~
	del dbl_fabry_host.obj
	del dbl_path_tracker.obj cmplx_path_tracker.obj
	del dbl2_path_tracker.obj cmplx2_path_tracker.obj
	del dbl4_path_tracker.obj cmplx4_path_tracker.obj
	del dbl8_path_tracker.obj cmplx8_path_tracker.obj
	del test_dbl_track.obj test_dbl_track.exp
	del test_dbl_track.lib test_dbl_track.exe
	del test_dbl2_track.obj test_dbl2_track.exp
	del test_dbl2_track.lib test_dbl2_track.exe
	del test_dbl4_track.obj test_dbl4_track.exp
	del test_dbl4_track.lib test_dbl4_track.exe
	del test_dbl8_track.obj test_dbl8_track.exp
	del test_dbl8_track.lib test_dbl8_track.exe

cleanall: clean
	del random_numbers.obj random_series.obj random_monomials.obj
	del double_double_functions.obj quad_double_functions.obj
	del octo_double_functions.obj
	del random2_series.obj random4_series.obj random8_series.obj
	del random2_vectors.obj random4_vectors.obj random8_vectors.obj
	del dbl_convolutions_host.obj dbl_monomials_host.obj
	del dbl2_convolutions_host.obj dbl2_monomials_host.obj
	del dbl4_convolutions_host.obj dbl4_monomials_host.obj
	del dbl8_convolutions_host.obj dbl8_monomials_host.obj
	del dbl_factorizations.obj dbl2_factorizations.obj
	del dbl4_factorizations.obj dbl8_factorizations.obj
	del dbl_baqr_kernels.obj dbl_tabs_kernels.obj
	del dbl2_baqr_kernels.obj dbl2_tabs_kernels.obj
	del dbl4_baqr_kernels.obj dbl4_tabs_kernels.obj
	del dbl8_baqr_kernels.obj dbl8_tabs_kernels.obj
	del convolution_job.obj convolution_jobs.obj write_job_counts.obj
	del write_gpu_timings.obj
	del addition_job.obj addition_jobs.obj job_coordinates.obj
	del dbl_polynomials_kernels.obj dbl2_polynomials_kernels.obj
	del dbl4_polynomials_kernels.obj dbl8_polynomials_kernels.obj
	del gettimeofday4win.obj
	del dbl_baqr_flopcounts.obj dbl_tabs_flopcounts.obj
	del write_dbl_bstimeflops.obj write_dbl2_bstimeflops.obj
	del write_dbl4_bstimeflops.obj write_dbl8_bstimeflops.obj
	del write_dbl_qrtimeflops.obj write_dbl2_qrtimeflops.obj
	del write_dbl4_qrtimeflops.obj write_dbl8_qrtimeflops.obj
	del dbl_onenorms_host.obj dbl_bals_host.obj dbl2_bals_host.obj
	del dbl4_bals_host.obj dbl8_bals_host.obj
	del dbl_tail_kernels.obj dbl_bals_kernels.obj
	del dbl2_tail_kernels.obj dbl2_bals_kernels.obj
	del dbl4_tail_kernels.obj dbl4_bals_kernels.obj
	del dbl8_tail_kernels.obj dbl8_bals_kernels.obj
	del unimodular_matrices.obj 
	del test_unimodular.exe test_unimodular.exp
	del test_unimodular.obj test_unimodular.lib
	del test_columns.exe test_columns.exp
	del test_columns.obj test_columns.lib cyclic_columns.obj
	del dbl_monomial_systems.obj test_monomial_systems.obj
	del dbl2_monomial_systems.obj test2_monomial_systems.obj
	del dbl4_monomial_systems.obj test4_monomial_systems.obj
	del dbl8_monomial_systems.obj test8_monomial_systems.obj
	del test_monomial_systems.exe test_monomial_systems.exp
	del test_monomial_systems.obj test_monomial_systems.lib
	del test2_monomial_systems.exe test2_monomial_systems.exp
	del test2_monomial_systems.obj test2_monomial_systems.lib
	del test4_monomial_systems.exe test4_monomial_systems.exp
	del test4_monomial_systems.obj test4_monomial_systems.lib
	del test8_monomial_systems.exe test8_monomial_systems.exp
	del test8_monomial_systems.obj test8_monomial_systems.lib
	del prompt_newton_setup.obj 
	del dbl_systems_host.obj dbl_systems_kernels.obj
	del dbl2_systems_host.obj dbl2_systems_kernels.obj
	del dbl4_systems_host.obj dbl4_systems_kernels.obj
	del dbl8_systems_host.obj dbl8_systems_kernels.obj
	del dbl_newton_method.obj cmplx_newton_method.obj
	del dbl2_newton_method.obj cmplx2_newton_method.obj
	del dbl4_newton_method.obj cmplx4_newton_method.obj
	del dbl8_newton_method.obj cmplx8_newton_method.obj
	del dbl_newton_testers.obj dbl2_newton_testers.obj
	del dbl4_newton_testers.obj dbl8_newton_testers.obj
	del convolution_job.obj convolution_jobs.obj
	del addition_job.obj addition_jobs.obj job_coordinates.obj
	del test_monomial_jobs.exe test_monomial_jobs.exp
	del test_monomial_jobs.obj test_monomial_jobs.lib
	del dbl_bals_flopcounts.obj
	del test_dbl_flopbals.exe test_dbl_flopbals.exp
	del test_dbl_flopbals.obj test_dbl_flopbals_lib
	del test_dbl2_flopbals.exe test_dbl2_flopbals.exp
	del test_dbl2_flopbals.obj test_dbl2_flopbals_lib
	del test_dbl4_flopbals.exe test_dbl4_flopbals.exp
	del test_dbl4_flopbals.obj test_dbl4_flopbals_lib
	del test_dbl8_flopbals.exe test_dbl8_flopbals.exp
	del test_dbl8_flopbals.obj test_dbl8_flopbals_lib
	del test_dbl_newton.exe test_dbl_newton.exp
	del test_dbl_newton.obj test_dbl_newton_lib
	del test_dbl2_newton.exe test_dbl2_newton.exp
	del test_dbl2_newton.obj test_dbl2_newton_lib
	del test_dbl4_newton.exe test_dbl4_newton.exp
	del test_dbl4_newton.obj test_dbl4_newton_lib
	del test_dbl8_newton.exe test_dbl8_newton.exp
	del test_dbl8_newton.obj test_dbl8_newton_lib
