#
# Makefile for the cnioss library.
#

ifndef PRODDIR
PRODDIR		= $(ORIGIN)..		# product directory
endif
ifndef RM
RM		= rm -f
endif

SRC		= ..\			# source directory

AS		= $(PRODDIR)\bin\asnios
CC		= $(PRODDIR)\bin\cnios
AR		= $(PRODDIR)\bin\arnios

all		: cnioss.lib 

clean		:
		$(RM) *.obj
		$(RM) cnioss.lib 


OBJECTS		+= cstart.obj
cstart.obj   	: $(SRC)cstart.asm
		$(AS)  --use-hardware=MDX $(SRC)cstart.asm 

OBJECTS		+= _dcti.obj
_dcti.obj   	: $(SRC)_dcti.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dcti.c
		$(AS)  --use-hardware=MDX _dcti.src 
		$(RM) _dcti.src

OBJECTS		+= clock.obj
clock.obj   	: $(SRC)clock.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc --optimize=-inline  $(SRC)clock.c
		$(AS)  --use-hardware=MDX clock.src 
		$(RM) clock.src

OBJECTS		+= clockspersec.obj
clockspersec.obj   	: $(SRC)clockspersec.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)clockspersec.c
		$(AS)  --use-hardware=MDX clockspersec.src 
		$(RM) clockspersec.src

OBJECTS		+= longjmp.obj
longjmp.obj   	: $(SRC)longjmp.asm
		$(AS)  --use-hardware=MDX $(SRC)longjmp.asm 

OBJECTS		+= setjmp.obj
setjmp.obj   	: $(SRC)setjmp.asm
		$(AS)  --use-hardware=MDX $(SRC)setjmp.asm 

OBJECTS		+= strcmp.obj
strcmp.obj   	: $(SRC)strcmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc -D__TRADEOFF__=0  $(SRC)strcmp.c
		$(AS)  --use-hardware=MDX strcmp.src 
		$(RM) strcmp.src

OBJECTS		+= strcpy.obj
strcpy.obj   	: $(SRC)strcpy.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc -D__TRADEOFF__=0  $(SRC)strcpy.c
		$(AS)  --use-hardware=MDX strcpy.src 
		$(RM) strcpy.src

OBJECTS		+= locale.obj
locale.obj   	: $(SRC)locale.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)locale.c
		$(AS)  --use-hardware=MDX locale.src 
		$(RM) locale.src

OBJECTS		+= signal.obj
signal.obj   	: $(SRC)signal.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)signal.c
		$(AS)  --use-hardware=MDX signal.src 
		$(RM) signal.src

OBJECTS		+= raise.obj
raise.obj   	: $(SRC)raise.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)raise.c
		$(AS)  --use-hardware=MDX raise.src 
		$(RM) raise.src

OBJECTS		+= bounds-malloc.obj
bounds-malloc.obj   	: $(SRC)bounds-malloc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)bounds-malloc.c
		$(AS)  --use-hardware=MDX bounds-malloc.src 
		$(RM) bounds-malloc.src

OBJECTS		+= bounds.obj
bounds.obj   	: $(SRC)bounds.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)bounds.c
		$(AS)  --use-hardware=MDX bounds.src 
		$(RM) bounds.src

OBJECTS		+= tmpfile.obj
tmpfile.obj   	: $(SRC)tmpfile.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tmpfile.c
		$(AS)  --use-hardware=MDX tmpfile.src 
		$(RM) tmpfile.src

OBJECTS		+= setvbuf.obj
setvbuf.obj   	: $(SRC)setvbuf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)setvbuf.c
		$(AS)  --use-hardware=MDX setvbuf.src 
		$(RM) setvbuf.src

OBJECTS		+= fopen.obj
fopen.obj   	: $(SRC)fopen.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fopen.c
		$(AS)  --use-hardware=MDX fopen.src 
		$(RM) fopen.src

OBJECTS		+= freopen.obj
freopen.obj   	: $(SRC)freopen.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)freopen.c
		$(AS)  --use-hardware=MDX freopen.src 
		$(RM) freopen.src

OBJECTS		+= _fopen.obj
_fopen.obj   	: $(SRC)_fopen.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_fopen.c
		$(AS)  --use-hardware=MDX _fopen.src 
		$(RM) _fopen.src

OBJECTS		+= realloc.obj
realloc.obj   	: $(SRC)realloc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)realloc.c
		$(AS)  --use-hardware=MDX realloc.src 
		$(RM) realloc.src

OBJECTS		+= calloc.obj
calloc.obj   	: $(SRC)calloc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)calloc.c
		$(AS)  --use-hardware=MDX calloc.src 
		$(RM) calloc.src

OBJECTS		+= malloc.obj
malloc.obj   	: $(SRC)malloc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)malloc.c
		$(AS)  --use-hardware=MDX malloc.src 
		$(RM) malloc.src

OBJECTS		+= _sbrk.obj
_sbrk.obj   	: $(SRC)_sbrk.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_sbrk.c
		$(AS)  --use-hardware=MDX _sbrk.src 
		$(RM) _sbrk.src

OBJECTS		+= runtime-malloc.obj
runtime-malloc.obj   	: $(SRC)runtime-malloc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)runtime-malloc.c
		$(AS)  --use-hardware=MDX runtime-malloc.src 
		$(RM) runtime-malloc.src

OBJECTS		+= runtime-case.obj
runtime-case.obj   	: $(SRC)runtime-case.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)runtime-case.c
		$(AS)  --use-hardware=MDX runtime-case.src 
		$(RM) runtime-case.src

OBJECTS		+= runtime-stack.obj
runtime-stack.obj   	: $(SRC)runtime-stack.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)runtime-stack.c
		$(AS)  --use-hardware=MDX runtime-stack.src 
		$(RM) runtime-stack.src

OBJECTS		+= runtime-divide.obj
runtime-divide.obj   	: $(SRC)runtime-divide.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)runtime-divide.c
		$(AS)  --use-hardware=MDX runtime-divide.src 
		$(RM) runtime-divide.src

OBJECTS		+= malloc-error.obj
malloc-error.obj   	: $(SRC)malloc-error.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)malloc-error.c
		$(AS)  --use-hardware=MDX malloc-error.src 
		$(RM) malloc-error.src

OBJECTS		+= bounds-error.obj
bounds-error.obj   	: $(SRC)bounds-error.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)bounds-error.c
		$(AS)  --use-hardware=MDX bounds-error.src 
		$(RM) bounds-error.src

OBJECTS		+= runtime-error.obj
runtime-error.obj   	: $(SRC)runtime-error.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)runtime-error.c
		$(AS)  --use-hardware=MDX runtime-error.src 
		$(RM) runtime-error.src

OBJECTS		+= printf_llong.obj
printf_llong.obj   	: $(SRC)printf_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)printf_llong.c
		$(AS)  --use-hardware=MDX printf_llong.src 
		$(RM) printf_llong.src

OBJECTS		+= printf_long.obj
printf_long.obj   	: $(SRC)printf_long.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)printf_long.c
		$(AS)  --use-hardware=MDX printf_long.src 
		$(RM) printf_long.src

OBJECTS		+= printf_int.obj
printf_int.obj   	: $(SRC)printf_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)printf_int.c
		$(AS)  --use-hardware=MDX printf_int.src 
		$(RM) printf_int.src

OBJECTS		+= printf_simple.obj
printf_simple.obj   	: $(SRC)printf_simple.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)printf_simple.c
		$(AS)  --use-hardware=MDX printf_simple.src 
		$(RM) printf_simple.src

OBJECTS		+= printf_noarg.obj
printf_noarg.obj   	: $(SRC)printf_noarg.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)printf_noarg.c
		$(AS)  --use-hardware=MDX printf_noarg.src 
		$(RM) printf_noarg.src

OBJECTS		+= _doprint_llong.obj
_doprint_llong.obj   	: $(SRC)_doprint_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doprint_llong.c
		$(AS)  --use-hardware=MDX _doprint_llong.src 
		$(RM) _doprint_llong.src

OBJECTS		+= _doprint.obj
_doprint.obj   	: $(SRC)_doprint.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doprint.c
		$(AS)  --use-hardware=MDX _doprint.src 
		$(RM) _doprint.src

OBJECTS		+= _doprint_int.obj
_doprint_int.obj   	: $(SRC)_doprint_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doprint_int.c
		$(AS)  --use-hardware=MDX _doprint_int.src 
		$(RM) _doprint_int.src

OBJECTS		+= _doprint_simple.obj
_doprint_simple.obj   	: $(SRC)_doprint_simple.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doprint_simple.c
		$(AS)  --use-hardware=MDX _doprint_simple.src 
		$(RM) _doprint_simple.src

OBJECTS		+= _doprint_noarg.obj
_doprint_noarg.obj   	: $(SRC)_doprint_noarg.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doprint_noarg.c
		$(AS)  --use-hardware=MDX _doprint_noarg.src 
		$(RM) _doprint_noarg.src

OBJECTS		+= scanf_llong.obj
scanf_llong.obj   	: $(SRC)scanf_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scanf_llong.c
		$(AS)  --use-hardware=MDX scanf_llong.src 
		$(RM) scanf_llong.src

OBJECTS		+= scanf_long.obj
scanf_long.obj   	: $(SRC)scanf_long.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scanf_long.c
		$(AS)  --use-hardware=MDX scanf_long.src 
		$(RM) scanf_long.src

OBJECTS		+= scanf_int.obj
scanf_int.obj   	: $(SRC)scanf_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scanf_int.c
		$(AS)  --use-hardware=MDX scanf_int.src 
		$(RM) scanf_int.src

OBJECTS		+= _doscan_llong.obj
_doscan_llong.obj   	: $(SRC)_doscan_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doscan_llong.c
		$(AS)  --use-hardware=MDX _doscan_llong.src 
		$(RM) _doscan_llong.src

OBJECTS		+= _doscan.obj
_doscan.obj   	: $(SRC)_doscan.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doscan.c
		$(AS)  --use-hardware=MDX _doscan.src 
		$(RM) _doscan.src

OBJECTS		+= _doscan_int.obj
_doscan_int.obj   	: $(SRC)_doscan_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doscan_int.c
		$(AS)  --use-hardware=MDX _doscan_int.src 
		$(RM) _doscan_int.src

OBJECTS		+= snprintf.obj
snprintf.obj   	: $(SRC)snprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)snprintf.c
		$(AS)  --use-hardware=MDX snprintf.src 
		$(RM) snprintf.src

OBJECTS		+= vsnprintf.obj
vsnprintf.obj   	: $(SRC)vsnprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vsnprintf.c
		$(AS)  --use-hardware=MDX vsnprintf.src 
		$(RM) vsnprintf.src

OBJECTS		+= vfscanf.obj
vfscanf.obj   	: $(SRC)vfscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vfscanf.c
		$(AS)  --use-hardware=MDX vfscanf.src 
		$(RM) vfscanf.src

OBJECTS		+= vscanf.obj
vscanf.obj   	: $(SRC)vscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vscanf.c
		$(AS)  --use-hardware=MDX vscanf.src 
		$(RM) vscanf.src

OBJECTS		+= vsscanf.obj
vsscanf.obj   	: $(SRC)vsscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vsscanf.c
		$(AS)  --use-hardware=MDX vsscanf.src 
		$(RM) vsscanf.src

OBJECTS		+= wprintf_llong.obj
wprintf_llong.obj   	: $(SRC)wprintf_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wprintf_llong.c
		$(AS)  --use-hardware=MDX wprintf_llong.src 
		$(RM) wprintf_llong.src

OBJECTS		+= wprintf_long.obj
wprintf_long.obj   	: $(SRC)wprintf_long.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wprintf_long.c
		$(AS)  --use-hardware=MDX wprintf_long.src 
		$(RM) wprintf_long.src

OBJECTS		+= wprintf_int.obj
wprintf_int.obj   	: $(SRC)wprintf_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wprintf_int.c
		$(AS)  --use-hardware=MDX wprintf_int.src 
		$(RM) wprintf_int.src

OBJECTS		+= wprintf_simple.obj
wprintf_simple.obj   	: $(SRC)wprintf_simple.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wprintf_simple.c
		$(AS)  --use-hardware=MDX wprintf_simple.src 
		$(RM) wprintf_simple.src

OBJECTS		+= wprintf_noarg.obj
wprintf_noarg.obj   	: $(SRC)wprintf_noarg.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wprintf_noarg.c
		$(AS)  --use-hardware=MDX wprintf_noarg.src 
		$(RM) wprintf_noarg.src

OBJECTS		+= _dowprin_llong.obj
_dowprin_llong.obj   	: $(SRC)_dowprin_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowprin_llong.c
		$(AS)  --use-hardware=MDX _dowprin_llong.src 
		$(RM) _dowprin_llong.src

OBJECTS		+= _dowprin.obj
_dowprin.obj   	: $(SRC)_dowprin.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowprin.c
		$(AS)  --use-hardware=MDX _dowprin.src 
		$(RM) _dowprin.src

OBJECTS		+= _dowprin_int.obj
_dowprin_int.obj   	: $(SRC)_dowprin_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowprin_int.c
		$(AS)  --use-hardware=MDX _dowprin_int.src 
		$(RM) _dowprin_int.src

OBJECTS		+= _dowprin_simple.obj
_dowprin_simple.obj   	: $(SRC)_dowprin_simple.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowprin_simple.c
		$(AS)  --use-hardware=MDX _dowprin_simple.src 
		$(RM) _dowprin_simple.src

OBJECTS		+= _dowprin_noarg.obj
_dowprin_noarg.obj   	: $(SRC)_dowprin_noarg.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowprin_noarg.c
		$(AS)  --use-hardware=MDX _dowprin_noarg.src 
		$(RM) _dowprin_noarg.src

OBJECTS		+= wscanf_llong.obj
wscanf_llong.obj   	: $(SRC)wscanf_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wscanf_llong.c
		$(AS)  --use-hardware=MDX wscanf_llong.src 
		$(RM) wscanf_llong.src

OBJECTS		+= wscanf_long.obj
wscanf_long.obj   	: $(SRC)wscanf_long.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wscanf_long.c
		$(AS)  --use-hardware=MDX wscanf_long.src 
		$(RM) wscanf_long.src

OBJECTS		+= wscanf_int.obj
wscanf_int.obj   	: $(SRC)wscanf_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wscanf_int.c
		$(AS)  --use-hardware=MDX wscanf_int.src 
		$(RM) wscanf_int.src

OBJECTS		+= _dowscan_llong.obj
_dowscan_llong.obj   	: $(SRC)_dowscan_llong.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowscan_llong.c
		$(AS)  --use-hardware=MDX _dowscan_llong.src 
		$(RM) _dowscan_llong.src

OBJECTS		+= _dowscan.obj
_dowscan.obj   	: $(SRC)_dowscan.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowscan.c
		$(AS)  --use-hardware=MDX _dowscan.src 
		$(RM) _dowscan.src

OBJECTS		+= _dowscan_int.obj
_dowscan_int.obj   	: $(SRC)_dowscan_int.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowscan_int.c
		$(AS)  --use-hardware=MDX _dowscan_int.src 
		$(RM) _dowscan_int.src

OBJECTS		+= tmpnam.obj
tmpnam.obj   	: $(SRC)tmpnam.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tmpnam.c
		$(AS)  --use-hardware=MDX tmpnam.src 
		$(RM) tmpnam.src

OBJECTS		+= setbuf.obj
setbuf.obj   	: $(SRC)setbuf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)setbuf.c
		$(AS)  --use-hardware=MDX setbuf.src 
		$(RM) setbuf.src

OBJECTS		+= fprintf.obj
fprintf.obj   	: $(SRC)fprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fprintf.c
		$(AS)  --use-hardware=MDX fprintf.src 
		$(RM) fprintf.src

OBJECTS		+= vfprintf.obj
vfprintf.obj   	: $(SRC)vfprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vfprintf.c
		$(AS)  --use-hardware=MDX vfprintf.src 
		$(RM) vfprintf.src

OBJECTS		+= printf.obj
printf.obj   	: $(SRC)printf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)printf.c
		$(AS)  --use-hardware=MDX printf.src 
		$(RM) printf.src

OBJECTS		+= vprintf.obj
vprintf.obj   	: $(SRC)vprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vprintf.c
		$(AS)  --use-hardware=MDX vprintf.src 
		$(RM) vprintf.src

OBJECTS		+= sprintf.obj
sprintf.obj   	: $(SRC)sprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sprintf.c
		$(AS)  --use-hardware=MDX sprintf.src 
		$(RM) sprintf.src

OBJECTS		+= vsprintf.obj
vsprintf.obj   	: $(SRC)vsprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vsprintf.c
		$(AS)  --use-hardware=MDX vsprintf.src 
		$(RM) vsprintf.src

OBJECTS		+= fscanf.obj
fscanf.obj   	: $(SRC)fscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fscanf.c
		$(AS)  --use-hardware=MDX fscanf.src 
		$(RM) fscanf.src

OBJECTS		+= scanf.obj
scanf.obj   	: $(SRC)scanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scanf.c
		$(AS)  --use-hardware=MDX scanf.src 
		$(RM) scanf.src

OBJECTS		+= sscanf.obj
sscanf.obj   	: $(SRC)sscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sscanf.c
		$(AS)  --use-hardware=MDX sscanf.src 
		$(RM) sscanf.src

OBJECTS		+= _iob.obj
_iob.obj   	: $(SRC)_iob.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_iob.c
		$(AS)  --use-hardware=MDX _iob.src 
		$(RM) _iob.src

OBJECTS		+= gets.obj
gets.obj   	: $(SRC)gets.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)gets.c
		$(AS)  --use-hardware=MDX gets.src 
		$(RM) gets.src

OBJECTS		+= getc.obj
getc.obj   	: $(SRC)getc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)getc.c
		$(AS)  --use-hardware=MDX getc.src 
		$(RM) getc.src

OBJECTS		+= getchar.obj
getchar.obj   	: $(SRC)getchar.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)getchar.c
		$(AS)  --use-hardware=MDX getchar.src 
		$(RM) getchar.src

OBJECTS		+= fgets.obj
fgets.obj   	: $(SRC)fgets.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fgets.c
		$(AS)  --use-hardware=MDX fgets.src 
		$(RM) fgets.src

OBJECTS		+= fgetc.obj
fgetc.obj   	: $(SRC)fgetc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fgetc.c
		$(AS)  --use-hardware=MDX fgetc.src 
		$(RM) fgetc.src

OBJECTS		+= perror.obj
perror.obj   	: $(SRC)perror.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)perror.c
		$(AS)  --use-hardware=MDX perror.src 
		$(RM) perror.src

OBJECTS		+= puts.obj
puts.obj   	: $(SRC)puts.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)puts.c
		$(AS)  --use-hardware=MDX puts.src 
		$(RM) puts.src

OBJECTS		+= putc.obj
putc.obj   	: $(SRC)putc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)putc.c
		$(AS)  --use-hardware=MDX putc.src 
		$(RM) putc.src

OBJECTS		+= putchar.obj
putchar.obj   	: $(SRC)putchar.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)putchar.c
		$(AS)  --use-hardware=MDX putchar.src 
		$(RM) putchar.src

OBJECTS		+= fputs.obj
fputs.obj   	: $(SRC)fputs.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fputs.c
		$(AS)  --use-hardware=MDX fputs.src 
		$(RM) fputs.src

OBJECTS		+= fputc.obj
fputc.obj   	: $(SRC)fputc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fputc.c
		$(AS)  --use-hardware=MDX fputc.src 
		$(RM) fputc.src

OBJECTS		+= ungetc.obj
ungetc.obj   	: $(SRC)ungetc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ungetc.c
		$(AS)  --use-hardware=MDX ungetc.src 
		$(RM) ungetc.src

OBJECTS		+= fread.obj
fread.obj   	: $(SRC)fread.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fread.c
		$(AS)  --use-hardware=MDX fread.src 
		$(RM) fread.src

OBJECTS		+= fwrite.obj
fwrite.obj   	: $(SRC)fwrite.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fwrite.c
		$(AS)  --use-hardware=MDX fwrite.src 
		$(RM) fwrite.src

OBJECTS		+= fgetpos.obj
fgetpos.obj   	: $(SRC)fgetpos.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fgetpos.c
		$(AS)  --use-hardware=MDX fgetpos.src 
		$(RM) fgetpos.src

OBJECTS		+= fsetpos.obj
fsetpos.obj   	: $(SRC)fsetpos.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fsetpos.c
		$(AS)  --use-hardware=MDX fsetpos.src 
		$(RM) fsetpos.src

OBJECTS		+= rewind.obj
rewind.obj   	: $(SRC)rewind.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)rewind.c
		$(AS)  --use-hardware=MDX rewind.src 
		$(RM) rewind.src

OBJECTS		+= fseek.obj
fseek.obj   	: $(SRC)fseek.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fseek.c
		$(AS)  --use-hardware=MDX fseek.src 
		$(RM) fseek.src

OBJECTS		+= ftell.obj
ftell.obj   	: $(SRC)ftell.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ftell.c
		$(AS)  --use-hardware=MDX ftell.src 
		$(RM) ftell.src

OBJECTS		+= clearerr.obj
clearerr.obj   	: $(SRC)clearerr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)clearerr.c
		$(AS)  --use-hardware=MDX clearerr.src 
		$(RM) clearerr.src

OBJECTS		+= feof.obj
feof.obj   	: $(SRC)feof.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)feof.c
		$(AS)  --use-hardware=MDX feof.src 
		$(RM) feof.src

OBJECTS		+= ferror.obj
ferror.obj   	: $(SRC)ferror.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ferror.c
		$(AS)  --use-hardware=MDX ferror.src 
		$(RM) ferror.src

OBJECTS		+= fileno.obj
fileno.obj   	: $(SRC)fileno.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fileno.c
		$(AS)  --use-hardware=MDX fileno.src 
		$(RM) fileno.src

OBJECTS		+= _doflt.obj
_doflt.obj   	: $(SRC)_doflt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_doflt.c
		$(AS)  --use-hardware=MDX _doflt.src 
		$(RM) _doflt.src

OBJECTS		+= _getflt.obj
_getflt.obj   	: $(SRC)_getflt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_getflt.c
		$(AS)  --use-hardware=MDX _getflt.src 
		$(RM) _getflt.src

OBJECTS		+= _filbuf.obj
_filbuf.obj   	: $(SRC)_filbuf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_filbuf.c
		$(AS)  --use-hardware=MDX _filbuf.src 
		$(RM) _filbuf.src

OBJECTS		+= _flsbuf.obj
_flsbuf.obj   	: $(SRC)_flsbuf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_flsbuf.c
		$(AS)  --use-hardware=MDX _flsbuf.src 
		$(RM) _flsbuf.src

OBJECTS		+= fclose.obj
fclose.obj   	: $(SRC)fclose.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fclose.c
		$(AS)  --use-hardware=MDX fclose.src 
		$(RM) fclose.src

OBJECTS		+= fflush.obj
fflush.obj   	: $(SRC)fflush.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fflush.c
		$(AS)  --use-hardware=MDX fflush.src 
		$(RM) fflush.src

OBJECTS		+= _io_getc.obj
_io_getc.obj   	: $(SRC)_io_getc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_getc.c
		$(AS)  --use-hardware=MDX _io_getc.src 
		$(RM) _io_getc.src

OBJECTS		+= _io_puts.obj
_io_puts.obj   	: $(SRC)_io_puts.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_puts.c
		$(AS)  --use-hardware=MDX _io_puts.src 
		$(RM) _io_puts.src

OBJECTS		+= _io_putc.obj
_io_putc.obj   	: $(SRC)_io_putc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_putc.c
		$(AS)  --use-hardware=MDX _io_putc.src 
		$(RM) _io_putc.src

OBJECTS		+= _io_ungetc.obj
_io_ungetc.obj   	: $(SRC)_io_ungetc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_ungetc.c
		$(AS)  --use-hardware=MDX _io_ungetc.src 
		$(RM) _io_ungetc.src

OBJECTS		+= _io_getwc.obj
_io_getwc.obj   	: $(SRC)_io_getwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_getwc.c
		$(AS)  --use-hardware=MDX _io_getwc.src 
		$(RM) _io_getwc.src

OBJECTS		+= _io_putwc.obj
_io_putwc.obj   	: $(SRC)_io_putwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_putwc.c
		$(AS)  --use-hardware=MDX _io_putwc.src 
		$(RM) _io_putwc.src

OBJECTS		+= _io_putws.obj
_io_putws.obj   	: $(SRC)_io_putws.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_putws.c
		$(AS)  --use-hardware=MDX _io_putws.src 
		$(RM) _io_putws.src

OBJECTS		+= _io_ungetwc.obj
_io_ungetwc.obj   	: $(SRC)_io_ungetwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_io_ungetwc.c
		$(AS)  --use-hardware=MDX _io_ungetwc.src 
		$(RM) _io_ungetwc.src

OBJECTS		+= imaxabs.obj
imaxabs.obj   	: $(SRC)imaxabs.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)imaxabs.c
		$(AS)  --use-hardware=MDX imaxabs.src 
		$(RM) imaxabs.src

OBJECTS		+= imaxdiv.obj
imaxdiv.obj   	: $(SRC)imaxdiv.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)imaxdiv.c
		$(AS)  --use-hardware=MDX imaxdiv.src 
		$(RM) imaxdiv.src

OBJECTS		+= strtoimax.obj
strtoimax.obj   	: $(SRC)strtoimax.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtoimax.c
		$(AS)  --use-hardware=MDX strtoimax.src 
		$(RM) strtoimax.src

OBJECTS		+= strtoumax.obj
strtoumax.obj   	: $(SRC)strtoumax.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtoumax.c
		$(AS)  --use-hardware=MDX strtoumax.src 
		$(RM) strtoumax.src

OBJECTS		+= wcstoimax.obj
wcstoimax.obj   	: $(SRC)wcstoimax.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstoimax.c
		$(AS)  --use-hardware=MDX wcstoimax.src 
		$(RM) wcstoimax.src

OBJECTS		+= wcstoumax.obj
wcstoumax.obj   	: $(SRC)wcstoumax.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstoumax.c
		$(AS)  --use-hardware=MDX wcstoumax.src 
		$(RM) wcstoumax.src

OBJECTS		+= fwprintf.obj
fwprintf.obj   	: $(SRC)fwprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fwprintf.c
		$(AS)  --use-hardware=MDX fwprintf.src 
		$(RM) fwprintf.src

OBJECTS		+= vfwprint.obj
vfwprint.obj   	: $(SRC)vfwprint.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vfwprint.c
		$(AS)  --use-hardware=MDX vfwprint.src 
		$(RM) vfwprint.src

OBJECTS		+= wprintf.obj
wprintf.obj   	: $(SRC)wprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wprintf.c
		$(AS)  --use-hardware=MDX wprintf.src 
		$(RM) wprintf.src

OBJECTS		+= vwprintf.obj
vwprintf.obj   	: $(SRC)vwprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vwprintf.c
		$(AS)  --use-hardware=MDX vwprintf.src 
		$(RM) vwprintf.src

OBJECTS		+= swprintf.obj
swprintf.obj   	: $(SRC)swprintf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)swprintf.c
		$(AS)  --use-hardware=MDX swprintf.src 
		$(RM) swprintf.src

OBJECTS		+= vswprint.obj
vswprint.obj   	: $(SRC)vswprint.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vswprint.c
		$(AS)  --use-hardware=MDX vswprint.src 
		$(RM) vswprint.src

OBJECTS		+= fwscanf.obj
fwscanf.obj   	: $(SRC)fwscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fwscanf.c
		$(AS)  --use-hardware=MDX fwscanf.src 
		$(RM) fwscanf.src

OBJECTS		+= wscanf.obj
wscanf.obj   	: $(SRC)wscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wscanf.c
		$(AS)  --use-hardware=MDX wscanf.src 
		$(RM) wscanf.src

OBJECTS		+= swscanf.obj
swscanf.obj   	: $(SRC)swscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)swscanf.c
		$(AS)  --use-hardware=MDX swscanf.src 
		$(RM) swscanf.src

OBJECTS		+= fgetwc.obj
fgetwc.obj   	: $(SRC)fgetwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fgetwc.c
		$(AS)  --use-hardware=MDX fgetwc.src 
		$(RM) fgetwc.src

OBJECTS		+= fgetws.obj
fgetws.obj   	: $(SRC)fgetws.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fgetws.c
		$(AS)  --use-hardware=MDX fgetws.src 
		$(RM) fgetws.src

OBJECTS		+= fputwc.obj
fputwc.obj   	: $(SRC)fputwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fputwc.c
		$(AS)  --use-hardware=MDX fputwc.src 
		$(RM) fputwc.src

OBJECTS		+= fputws.obj
fputws.obj   	: $(SRC)fputws.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fputws.c
		$(AS)  --use-hardware=MDX fputws.src 
		$(RM) fputws.src

OBJECTS		+= getwc.obj
getwc.obj   	: $(SRC)getwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)getwc.c
		$(AS)  --use-hardware=MDX getwc.src 
		$(RM) getwc.src

OBJECTS		+= getwchar.obj
getwchar.obj   	: $(SRC)getwchar.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)getwchar.c
		$(AS)  --use-hardware=MDX getwchar.src 
		$(RM) getwchar.src

OBJECTS		+= putwc.obj
putwc.obj   	: $(SRC)putwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)putwc.c
		$(AS)  --use-hardware=MDX putwc.src 
		$(RM) putwc.src

OBJECTS		+= putwchar.obj
putwchar.obj   	: $(SRC)putwchar.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)putwchar.c
		$(AS)  --use-hardware=MDX putwchar.src 
		$(RM) putwchar.src

OBJECTS		+= ungetwc.obj
ungetwc.obj   	: $(SRC)ungetwc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ungetwc.c
		$(AS)  --use-hardware=MDX ungetwc.src 
		$(RM) ungetwc.src

OBJECTS		+= wcstol.obj
wcstol.obj   	: $(SRC)wcstol.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstol.c
		$(AS)  --use-hardware=MDX wcstol.src 
		$(RM) wcstol.src

OBJECTS		+= wcstoul.obj
wcstoul.obj   	: $(SRC)wcstoul.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstoul.c
		$(AS)  --use-hardware=MDX wcstoul.src 
		$(RM) wcstoul.src

OBJECTS		+= wcscat.obj
wcscat.obj   	: $(SRC)wcscat.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcscat.c
		$(AS)  --use-hardware=MDX wcscat.src 
		$(RM) wcscat.src

OBJECTS		+= wcsncat.obj
wcsncat.obj   	: $(SRC)wcsncat.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsncat.c
		$(AS)  --use-hardware=MDX wcsncat.src 
		$(RM) wcsncat.src

OBJECTS		+= wcscoll.obj
wcscoll.obj   	: $(SRC)wcscoll.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcscoll.c
		$(AS)  --use-hardware=MDX wcscoll.src 
		$(RM) wcscoll.src

OBJECTS		+= wcsxrfm.obj
wcsxrfm.obj   	: $(SRC)wcsxrfm.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsxrfm.c
		$(AS)  --use-hardware=MDX wcsxrfm.src 
		$(RM) wcsxrfm.src

OBJECTS		+= wcscpy.obj
wcscpy.obj   	: $(SRC)wcscpy.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcscpy.c
		$(AS)  --use-hardware=MDX wcscpy.src 
		$(RM) wcscpy.src

OBJECTS		+= wcsncpy.obj
wcsncpy.obj   	: $(SRC)wcsncpy.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsncpy.c
		$(AS)  --use-hardware=MDX wcsncpy.src 
		$(RM) wcsncpy.src

OBJECTS		+= wcscspn.obj
wcscspn.obj   	: $(SRC)wcscspn.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcscspn.c
		$(AS)  --use-hardware=MDX wcscspn.src 
		$(RM) wcscspn.src

OBJECTS		+= wcspbrk.obj
wcspbrk.obj   	: $(SRC)wcspbrk.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcspbrk.c
		$(AS)  --use-hardware=MDX wcspbrk.src 
		$(RM) wcspbrk.src

OBJECTS		+= wcsspn.obj
wcsspn.obj   	: $(SRC)wcsspn.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsspn.c
		$(AS)  --use-hardware=MDX wcsspn.src 
		$(RM) wcsspn.src

OBJECTS		+= wcsstr.obj
wcsstr.obj   	: $(SRC)wcsstr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsstr.c
		$(AS)  --use-hardware=MDX wcsstr.src 
		$(RM) wcsstr.src

OBJECTS		+= wcstok.obj
wcstok.obj   	: $(SRC)wcstok.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstok.c
		$(AS)  --use-hardware=MDX wcstok.src 
		$(RM) wcstok.src

OBJECTS		+= wcschr.obj
wcschr.obj   	: $(SRC)wcschr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcschr.c
		$(AS)  --use-hardware=MDX wcschr.src 
		$(RM) wcschr.src

OBJECTS		+= wcsrchr.obj
wcsrchr.obj   	: $(SRC)wcsrchr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsrchr.c
		$(AS)  --use-hardware=MDX wcsrchr.src 
		$(RM) wcsrchr.src

OBJECTS		+= wcscmp.obj
wcscmp.obj   	: $(SRC)wcscmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcscmp.c
		$(AS)  --use-hardware=MDX wcscmp.src 
		$(RM) wcscmp.src

OBJECTS		+= wcsncmp.obj
wcsncmp.obj   	: $(SRC)wcsncmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsncmp.c
		$(AS)  --use-hardware=MDX wcsncmp.src 
		$(RM) wcsncmp.src

OBJECTS		+= wcsftime.obj
wcsftime.obj   	: $(SRC)wcsftime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsftime.c
		$(AS)  --use-hardware=MDX wcsftime.src 
		$(RM) wcsftime.src

OBJECTS		+= wcslen.obj
wcslen.obj   	: $(SRC)wcslen.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcslen.c
		$(AS)  --use-hardware=MDX wcslen.src 
		$(RM) wcslen.src

OBJECTS		+= wmemchr.obj
wmemchr.obj   	: $(SRC)wmemchr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wmemchr.c
		$(AS)  --use-hardware=MDX wmemchr.src 
		$(RM) wmemchr.src

OBJECTS		+= wmemcmp.obj
wmemcmp.obj   	: $(SRC)wmemcmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wmemcmp.c
		$(AS)  --use-hardware=MDX wmemcmp.src 
		$(RM) wmemcmp.src

OBJECTS		+= wmemcpy.obj
wmemcpy.obj   	: $(SRC)wmemcpy.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wmemcpy.c
		$(AS)  --use-hardware=MDX wmemcpy.src 
		$(RM) wmemcpy.src

OBJECTS		+= wmemmov.obj
wmemmov.obj   	: $(SRC)wmemmov.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wmemmov.c
		$(AS)  --use-hardware=MDX wmemmov.src 
		$(RM) wmemmov.src

OBJECTS		+= wmemset.obj
wmemset.obj   	: $(SRC)wmemset.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wmemset.c
		$(AS)  --use-hardware=MDX wmemset.src 
		$(RM) wmemset.src

OBJECTS		+= btowc.obj
btowc.obj   	: $(SRC)btowc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)btowc.c
		$(AS)  --use-hardware=MDX btowc.src 
		$(RM) btowc.src

OBJECTS		+= wctob.obj
wctob.obj   	: $(SRC)wctob.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wctob.c
		$(AS)  --use-hardware=MDX wctob.src 
		$(RM) wctob.src

OBJECTS		+= mbrlen.obj
mbrlen.obj   	: $(SRC)mbrlen.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)mbrlen.c
		$(AS)  --use-hardware=MDX mbrlen.src 
		$(RM) mbrlen.src

OBJECTS		+= mbsrtowc.obj
mbsrtowc.obj   	: $(SRC)mbsrtowc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)mbsrtowc.c
		$(AS)  --use-hardware=MDX mbsrtowc.src 
		$(RM) mbsrtowc.src

OBJECTS		+= wcsrtomb.obj
wcsrtomb.obj   	: $(SRC)wcsrtomb.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcsrtomb.c
		$(AS)  --use-hardware=MDX wcsrtomb.src 
		$(RM) wcsrtomb.src

OBJECTS		+= mbrtowc.obj
mbrtowc.obj   	: $(SRC)mbrtowc.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)mbrtowc.c
		$(AS)  --use-hardware=MDX mbrtowc.src 
		$(RM) mbrtowc.src

OBJECTS		+= wcrtomb.obj
wcrtomb.obj   	: $(SRC)wcrtomb.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcrtomb.c
		$(AS)  --use-hardware=MDX wcrtomb.src 
		$(RM) wcrtomb.src

OBJECTS		+= mbsinit.obj
mbsinit.obj   	: $(SRC)mbsinit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)mbsinit.c
		$(AS)  --use-hardware=MDX mbsinit.src 
		$(RM) mbsinit.src

OBJECTS		+= fwide.obj
fwide.obj   	: $(SRC)fwide.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fwide.c
		$(AS)  --use-hardware=MDX fwide.src 
		$(RM) fwide.src

OBJECTS		+= _dowflt.obj
_dowflt.obj   	: $(SRC)_dowflt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_dowflt.c
		$(AS)  --use-hardware=MDX _dowflt.src 
		$(RM) _dowflt.src

OBJECTS		+= _getwflt.obj
_getwflt.obj   	: $(SRC)_getwflt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_getwflt.c
		$(AS)  --use-hardware=MDX _getwflt.src 
		$(RM) _getwflt.src

OBJECTS		+= _wflsbuf.obj
_wflsbuf.obj   	: $(SRC)_wflsbuf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_wflsbuf.c
		$(AS)  --use-hardware=MDX _wflsbuf.src 
		$(RM) _wflsbuf.src

OBJECTS		+= _wfilbuf.obj
_wfilbuf.obj   	: $(SRC)_wfilbuf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_wfilbuf.c
		$(AS)  --use-hardware=MDX _wfilbuf.src 
		$(RM) _wfilbuf.src

OBJECTS		+= vfwscanf.obj
vfwscanf.obj   	: $(SRC)vfwscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vfwscanf.c
		$(AS)  --use-hardware=MDX vfwscanf.src 
		$(RM) vfwscanf.src

OBJECTS		+= vwscanf.obj
vwscanf.obj   	: $(SRC)vwscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vwscanf.c
		$(AS)  --use-hardware=MDX vwscanf.src 
		$(RM) vwscanf.src

OBJECTS		+= vswscanf.obj
vswscanf.obj   	: $(SRC)vswscanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)vswscanf.c
		$(AS)  --use-hardware=MDX vswscanf.src 
		$(RM) vswscanf.src

OBJECTS		+= wcstof.obj
wcstof.obj   	: $(SRC)wcstof.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstof.c
		$(AS)  --use-hardware=MDX wcstof.src 
		$(RM) wcstof.src

OBJECTS		+= wcstold.obj
wcstold.obj   	: $(SRC)wcstold.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstold.c
		$(AS)  --use-hardware=MDX wcstold.src 
		$(RM) wcstold.src

OBJECTS		+= wcstoll.obj
wcstoll.obj   	: $(SRC)wcstoll.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstoll.c
		$(AS)  --use-hardware=MDX wcstoll.src 
		$(RM) wcstoll.src

OBJECTS		+= wcstoull.obj
wcstoull.obj   	: $(SRC)wcstoull.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstoull.c
		$(AS)  --use-hardware=MDX wcstoull.src 
		$(RM) wcstoull.src

OBJECTS		+= wcstod.obj
wcstod.obj   	: $(SRC)wcstod.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wcstod.c
		$(AS)  --use-hardware=MDX wcstod.src 
		$(RM) wcstod.src

OBJECTS		+= _wcstod.obj
_wcstod.obj   	: $(SRC)_wcstod.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_wcstod.c
		$(AS)  --use-hardware=MDX _wcstod.src 
		$(RM) _wcstod.src

OBJECTS		+= _wcsccmp.obj
_wcsccmp.obj   	: $(SRC)_wcsccmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_wcsccmp.c
		$(AS)  --use-hardware=MDX _wcsccmp.src 
		$(RM) _wcsccmp.src

OBJECTS		+= _wcsnccmp.obj
_wcsnccmp.obj   	: $(SRC)_wcsnccmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_wcsnccmp.c
		$(AS)  --use-hardware=MDX _wcsnccmp.src 
		$(RM) _wcsnccmp.src

OBJECTS		+= iswalpha.obj
iswalpha.obj   	: $(SRC)iswalpha.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswalpha.c
		$(AS)  --use-hardware=MDX iswalpha.src 
		$(RM) iswalpha.src

OBJECTS		+= iswalnum.obj
iswalnum.obj   	: $(SRC)iswalnum.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswalnum.c
		$(AS)  --use-hardware=MDX iswalnum.src 
		$(RM) iswalnum.src

OBJECTS		+= iswupper.obj
iswupper.obj   	: $(SRC)iswupper.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswupper.c
		$(AS)  --use-hardware=MDX iswupper.src 
		$(RM) iswupper.src

OBJECTS		+= iswlower.obj
iswlower.obj   	: $(SRC)iswlower.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswlower.c
		$(AS)  --use-hardware=MDX iswlower.src 
		$(RM) iswlower.src

OBJECTS		+= iswdigit.obj
iswdigit.obj   	: $(SRC)iswdigit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswdigit.c
		$(AS)  --use-hardware=MDX iswdigit.src 
		$(RM) iswdigit.src

OBJECTS		+= iswxdigi.obj
iswxdigi.obj   	: $(SRC)iswxdigi.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswxdigi.c
		$(AS)  --use-hardware=MDX iswxdigi.src 
		$(RM) iswxdigi.src

OBJECTS		+= iswspace.obj
iswspace.obj   	: $(SRC)iswspace.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswspace.c
		$(AS)  --use-hardware=MDX iswspace.src 
		$(RM) iswspace.src

OBJECTS		+= iswpunct.obj
iswpunct.obj   	: $(SRC)iswpunct.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswpunct.c
		$(AS)  --use-hardware=MDX iswpunct.src 
		$(RM) iswpunct.src

OBJECTS		+= iswcntrl.obj
iswcntrl.obj   	: $(SRC)iswcntrl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswcntrl.c
		$(AS)  --use-hardware=MDX iswcntrl.src 
		$(RM) iswcntrl.src

OBJECTS		+= iswprint.obj
iswprint.obj   	: $(SRC)iswprint.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswprint.c
		$(AS)  --use-hardware=MDX iswprint.src 
		$(RM) iswprint.src

OBJECTS		+= iswgraph.obj
iswgraph.obj   	: $(SRC)iswgraph.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswgraph.c
		$(AS)  --use-hardware=MDX iswgraph.src 
		$(RM) iswgraph.src

OBJECTS		+= towupper.obj
towupper.obj   	: $(SRC)towupper.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)towupper.c
		$(AS)  --use-hardware=MDX towupper.src 
		$(RM) towupper.src

OBJECTS		+= towlower.obj
towlower.obj   	: $(SRC)towlower.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)towlower.c
		$(AS)  --use-hardware=MDX towlower.src 
		$(RM) towlower.src

OBJECTS		+= towctran.obj
towctran.obj   	: $(SRC)towctran.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)towctran.c
		$(AS)  --use-hardware=MDX towctran.src 
		$(RM) towctran.src

OBJECTS		+= wctype.obj
wctype.obj   	: $(SRC)wctype.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wctype.c
		$(AS)  --use-hardware=MDX wctype.src 
		$(RM) wctype.src

OBJECTS		+= wctrans.obj
wctrans.obj   	: $(SRC)wctrans.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)wctrans.c
		$(AS)  --use-hardware=MDX wctrans.src 
		$(RM) wctrans.src

OBJECTS		+= iswblank.obj
iswblank.obj   	: $(SRC)iswblank.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswblank.c
		$(AS)  --use-hardware=MDX iswblank.src 
		$(RM) iswblank.src

OBJECTS		+= iswctype.obj
iswctype.obj   	: $(SRC)iswctype.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iswctype.c
		$(AS)  --use-hardware=MDX iswctype.src 
		$(RM) iswctype.src

OBJECTS		+= ctime.obj
ctime.obj   	: $(SRC)ctime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ctime.c
		$(AS)  --use-hardware=MDX ctime.src 
		$(RM) ctime.src

OBJECTS		+= asctime.obj
asctime.obj   	: $(SRC)asctime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asctime.c
		$(AS)  --use-hardware=MDX asctime.src 
		$(RM) asctime.src

OBJECTS		+= strftime.obj
strftime.obj   	: $(SRC)strftime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strftime.c
		$(AS)  --use-hardware=MDX strftime.src 
		$(RM) strftime.src

OBJECTS		+= time.obj
time.obj   	: $(SRC)time.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)time.c
		$(AS)  --use-hardware=MDX time.src 
		$(RM) time.src

OBJECTS		+= mktime.obj
mktime.obj   	: $(SRC)mktime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)mktime.c
		$(AS)  --use-hardware=MDX mktime.src 
		$(RM) mktime.src

OBJECTS		+= difftime.obj
difftime.obj   	: $(SRC)difftime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)difftime.c
		$(AS)  --use-hardware=MDX difftime.src 
		$(RM) difftime.src

OBJECTS		+= localtm.obj
localtm.obj   	: $(SRC)localtm.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)localtm.c
		$(AS)  --use-hardware=MDX localtm.src 
		$(RM) localtm.src

OBJECTS		+= gmtime.obj
gmtime.obj   	: $(SRC)gmtime.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)gmtime.c
		$(AS)  --use-hardware=MDX gmtime.src 
		$(RM) gmtime.src

OBJECTS		+= _tzone.obj
_tzone.obj   	: $(SRC)_tzone.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_tzone.c
		$(AS)  --use-hardware=MDX _tzone.src 
		$(RM) _tzone.src

OBJECTS		+= atol.obj
atol.obj   	: $(SRC)atol.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atol.c
		$(AS)  --use-hardware=MDX atol.src 
		$(RM) atol.src

OBJECTS		+= atoi.obj
atoi.obj   	: $(SRC)atoi.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atoi.c
		$(AS)  --use-hardware=MDX atoi.src 
		$(RM) atoi.src

OBJECTS		+= atof.obj
atof.obj   	: $(SRC)atof.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atof.c
		$(AS)  --use-hardware=MDX atof.src 
		$(RM) atof.src

OBJECTS		+= strtol.obj
strtol.obj   	: $(SRC)strtol.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtol.c
		$(AS)  --use-hardware=MDX strtol.src 
		$(RM) strtol.src

OBJECTS		+= strtoul.obj
strtoul.obj   	: $(SRC)strtoul.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtoul.c
		$(AS)  --use-hardware=MDX strtoul.src 
		$(RM) strtoul.src

OBJECTS		+= rand.obj
rand.obj   	: $(SRC)rand.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)rand.c
		$(AS)  --use-hardware=MDX rand.src 
		$(RM) rand.src

OBJECTS		+= atexit.obj
atexit.obj   	: $(SRC)atexit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atexit.c
		$(AS)  --use-hardware=MDX atexit.src 
		$(RM) atexit.src

OBJECTS		+= exit.obj
exit.obj   	: $(SRC)exit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)exit.c
		$(AS)  --use-hardware=MDX exit.src 
		$(RM) exit.src

OBJECTS		+= abort.obj
abort.obj   	: $(SRC)abort.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)abort.c
		$(AS)  --use-hardware=MDX abort.src 
		$(RM) abort.src

OBJECTS		+= getenv.obj
getenv.obj   	: $(SRC)getenv.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)getenv.c
		$(AS)  --use-hardware=MDX getenv.src 
		$(RM) getenv.src

OBJECTS		+= system.obj
system.obj   	: $(SRC)system.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)system.c
		$(AS)  --use-hardware=MDX system.src 
		$(RM) system.src

OBJECTS		+= qsort.obj
qsort.obj   	: $(SRC)qsort.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)qsort.c
		$(AS)  --use-hardware=MDX qsort.src 
		$(RM) qsort.src

OBJECTS		+= bsearch.obj
bsearch.obj   	: $(SRC)bsearch.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)bsearch.c
		$(AS)  --use-hardware=MDX bsearch.src 
		$(RM) bsearch.src

OBJECTS		+= abs.obj
abs.obj   	: $(SRC)abs.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)abs.c
		$(AS)  --use-hardware=MDX abs.src 
		$(RM) abs.src

OBJECTS		+= labs.obj
labs.obj   	: $(SRC)labs.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)labs.c
		$(AS)  --use-hardware=MDX labs.src 
		$(RM) labs.src

OBJECTS		+= div.obj
div.obj   	: $(SRC)div.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)div.c
		$(AS)  --use-hardware=MDX div.src 
		$(RM) div.src

OBJECTS		+= ldiv.obj
ldiv.obj   	: $(SRC)ldiv.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ldiv.c
		$(AS)  --use-hardware=MDX ldiv.src 
		$(RM) ldiv.src

OBJECTS		+= _mbchar.obj
_mbchar.obj   	: $(SRC)_mbchar.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_mbchar.c
		$(AS)  --use-hardware=MDX _mbchar.src 
		$(RM) _mbchar.src

OBJECTS		+= atoll.obj
atoll.obj   	: $(SRC)atoll.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atoll.c
		$(AS)  --use-hardware=MDX atoll.src 
		$(RM) atoll.src

OBJECTS		+= strtof.obj
strtof.obj   	: $(SRC)strtof.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtof.c
		$(AS)  --use-hardware=MDX strtof.src 
		$(RM) strtof.src

OBJECTS		+= strtold.obj
strtold.obj   	: $(SRC)strtold.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtold.c
		$(AS)  --use-hardware=MDX strtold.src 
		$(RM) strtold.src

OBJECTS		+= strtoll.obj
strtoll.obj   	: $(SRC)strtoll.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtoll.c
		$(AS)  --use-hardware=MDX strtoll.src 
		$(RM) strtoll.src

OBJECTS		+= strtoull.obj
strtoull.obj   	: $(SRC)strtoull.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtoull.c
		$(AS)  --use-hardware=MDX strtoull.src 
		$(RM) strtoull.src

OBJECTS		+= llabs.obj
llabs.obj   	: $(SRC)llabs.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)llabs.c
		$(AS)  --use-hardware=MDX llabs.src 
		$(RM) llabs.src

OBJECTS		+= lldiv.obj
lldiv.obj   	: $(SRC)lldiv.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)lldiv.c
		$(AS)  --use-hardware=MDX lldiv.src 
		$(RM) lldiv.src

OBJECTS		+= strtod.obj
strtod.obj   	: $(SRC)strtod.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtod.c
		$(AS)  --use-hardware=MDX strtod.src 
		$(RM) strtod.src

OBJECTS		+= _strtod.obj
_strtod.obj   	: $(SRC)_strtod.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_strtod.c
		$(AS)  --use-hardware=MDX _strtod.src 
		$(RM) _strtod.src

OBJECTS		+= errno.obj
errno.obj   	: $(SRC)errno.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)errno.c
		$(AS)  --use-hardware=MDX errno.src 
		$(RM) errno.src

OBJECTS		+= dbg.obj
dbg.obj   	: $(SRC)dbg.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc -g $(SRC)dbg.c
		$(AS)  --use-hardware=MDX dbg.src 
		$(RM) dbg.src

OBJECTS		+= dbg_posix.obj
dbg_posix.obj   	: $(SRC)dbg_posix.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)dbg_posix.c
		$(AS)  --use-hardware=MDX dbg_posix.src 
		$(RM) dbg_posix.src

OBJECTS		+= dbg_clock.obj
dbg_clock.obj   	: $(SRC)dbg_clock.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)dbg_clock.c
		$(AS)  --use-hardware=MDX dbg_clock.src 
		$(RM) dbg_clock.src

OBJECTS		+= dbg__exit.obj
dbg__exit.obj   	: $(SRC)dbg__exit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)dbg__exit.c
		$(AS)  --use-hardware=MDX dbg__exit.src 
		$(RM) dbg__exit.src

OBJECTS		+= dbg_trap.obj
dbg_trap.obj   	: $(SRC)dbg_trap.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)dbg_trap.c
		$(AS)  --use-hardware=MDX dbg_trap.src 
		$(RM) dbg_trap.src

OBJECTS		+= memchr.obj
memchr.obj   	: $(SRC)memchr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)memchr.c
		$(AS)  --use-hardware=MDX memchr.src 
		$(RM) memchr.src

OBJECTS		+= memcmp.obj
memcmp.obj   	: $(SRC)memcmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)memcmp.c
		$(AS)  --use-hardware=MDX memcmp.src 
		$(RM) memcmp.src

OBJECTS		+= memcpy.obj
memcpy.obj   	: $(SRC)memcpy.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)memcpy.c
		$(AS)  --use-hardware=MDX memcpy.src 
		$(RM) memcpy.src

OBJECTS		+= memmove.obj
memmove.obj   	: $(SRC)memmove.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)memmove.c
		$(AS)  --use-hardware=MDX memmove.src 
		$(RM) memmove.src

OBJECTS		+= memset.obj
memset.obj   	: $(SRC)memset.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)memset.c
		$(AS)  --use-hardware=MDX memset.src 
		$(RM) memset.src

OBJECTS		+= strcat.obj
strcat.obj   	: $(SRC)strcat.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strcat.c
		$(AS)  --use-hardware=MDX strcat.src 
		$(RM) strcat.src

OBJECTS		+= strncat.obj
strncat.obj   	: $(SRC)strncat.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strncat.c
		$(AS)  --use-hardware=MDX strncat.src 
		$(RM) strncat.src

OBJECTS		+= strchr.obj
strchr.obj   	: $(SRC)strchr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strchr.c
		$(AS)  --use-hardware=MDX strchr.src 
		$(RM) strchr.src

OBJECTS		+= strrchr.obj
strrchr.obj   	: $(SRC)strrchr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strrchr.c
		$(AS)  --use-hardware=MDX strrchr.src 
		$(RM) strrchr.src

OBJECTS		+= strcspn.obj
strcspn.obj   	: $(SRC)strcspn.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strcspn.c
		$(AS)  --use-hardware=MDX strcspn.src 
		$(RM) strcspn.src

OBJECTS		+= strerror.obj
strerror.obj   	: $(SRC)strerror.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strerror.c
		$(AS)  --use-hardware=MDX strerror.src 
		$(RM) strerror.src

OBJECTS		+= strtok.obj
strtok.obj   	: $(SRC)strtok.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strtok.c
		$(AS)  --use-hardware=MDX strtok.src 
		$(RM) strtok.src

OBJECTS		+= strpbrk.obj
strpbrk.obj   	: $(SRC)strpbrk.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strpbrk.c
		$(AS)  --use-hardware=MDX strpbrk.src 
		$(RM) strpbrk.src

OBJECTS		+= strspn.obj
strspn.obj   	: $(SRC)strspn.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strspn.c
		$(AS)  --use-hardware=MDX strspn.src 
		$(RM) strspn.src

OBJECTS		+= strstr.obj
strstr.obj   	: $(SRC)strstr.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strstr.c
		$(AS)  --use-hardware=MDX strstr.src 
		$(RM) strstr.src

OBJECTS		+= _strccmp.obj
_strccmp.obj   	: $(SRC)_strccmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_strccmp.c
		$(AS)  --use-hardware=MDX _strccmp.src 
		$(RM) _strccmp.src

OBJECTS		+= _strnccmp.obj
_strnccmp.obj   	: $(SRC)_strnccmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_strnccmp.c
		$(AS)  --use-hardware=MDX _strnccmp.src 
		$(RM) _strnccmp.src

OBJECTS		+= strcoll.obj
strcoll.obj   	: $(SRC)strcoll.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strcoll.c
		$(AS)  --use-hardware=MDX strcoll.src 
		$(RM) strcoll.src

OBJECTS		+= strxfrm.obj
strxfrm.obj   	: $(SRC)strxfrm.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strxfrm.c
		$(AS)  --use-hardware=MDX strxfrm.src 
		$(RM) strxfrm.src

OBJECTS		+= strncmp.obj
strncmp.obj   	: $(SRC)strncmp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strncmp.c
		$(AS)  --use-hardware=MDX strncmp.src 
		$(RM) strncmp.src

OBJECTS		+= strncpy.obj
strncpy.obj   	: $(SRC)strncpy.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strncpy.c
		$(AS)  --use-hardware=MDX strncpy.src 
		$(RM) strncpy.src

OBJECTS		+= strlen.obj
strlen.obj   	: $(SRC)strlen.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)strlen.c
		$(AS)  --use-hardware=MDX strlen.src 
		$(RM) strlen.src

OBJECTS		+= toupper.obj
toupper.obj   	: $(SRC)toupper.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)toupper.c
		$(AS)  --use-hardware=MDX toupper.src 
		$(RM) toupper.src

OBJECTS		+= tolower.obj
tolower.obj   	: $(SRC)tolower.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tolower.c
		$(AS)  --use-hardware=MDX tolower.src 
		$(RM) tolower.src

OBJECTS		+= toascii.obj
toascii.obj   	: $(SRC)toascii.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)toascii.c
		$(AS)  --use-hardware=MDX toascii.src 
		$(RM) toascii.src

OBJECTS		+= isalpha.obj
isalpha.obj   	: $(SRC)isalpha.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isalpha.c
		$(AS)  --use-hardware=MDX isalpha.src 
		$(RM) isalpha.src

OBJECTS		+= isalnum.obj
isalnum.obj   	: $(SRC)isalnum.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isalnum.c
		$(AS)  --use-hardware=MDX isalnum.src 
		$(RM) isalnum.src

OBJECTS		+= isascii.obj
isascii.obj   	: $(SRC)isascii.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isascii.c
		$(AS)  --use-hardware=MDX isascii.src 
		$(RM) isascii.src

OBJECTS		+= isupper.obj
isupper.obj   	: $(SRC)isupper.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isupper.c
		$(AS)  --use-hardware=MDX isupper.src 
		$(RM) isupper.src

OBJECTS		+= islower.obj
islower.obj   	: $(SRC)islower.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)islower.c
		$(AS)  --use-hardware=MDX islower.src 
		$(RM) islower.src

OBJECTS		+= isdigit.obj
isdigit.obj   	: $(SRC)isdigit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isdigit.c
		$(AS)  --use-hardware=MDX isdigit.src 
		$(RM) isdigit.src

OBJECTS		+= isxdigit.obj
isxdigit.obj   	: $(SRC)isxdigit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isxdigit.c
		$(AS)  --use-hardware=MDX isxdigit.src 
		$(RM) isxdigit.src

OBJECTS		+= isspace.obj
isspace.obj   	: $(SRC)isspace.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isspace.c
		$(AS)  --use-hardware=MDX isspace.src 
		$(RM) isspace.src

OBJECTS		+= ispunct.obj
ispunct.obj   	: $(SRC)ispunct.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ispunct.c
		$(AS)  --use-hardware=MDX ispunct.src 
		$(RM) ispunct.src

OBJECTS		+= iscntrl.obj
iscntrl.obj   	: $(SRC)iscntrl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)iscntrl.c
		$(AS)  --use-hardware=MDX iscntrl.src 
		$(RM) iscntrl.src

OBJECTS		+= isprint.obj
isprint.obj   	: $(SRC)isprint.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isprint.c
		$(AS)  --use-hardware=MDX isprint.src 
		$(RM) isprint.src

OBJECTS		+= isgraph.obj
isgraph.obj   	: $(SRC)isgraph.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isgraph.c
		$(AS)  --use-hardware=MDX isgraph.src 
		$(RM) isgraph.src

OBJECTS		+= isblank.obj
isblank.obj   	: $(SRC)isblank.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isblank.c
		$(AS)  --use-hardware=MDX isblank.src 
		$(RM) isblank.src

OBJECTS		+= _ctype.obj
_ctype.obj   	: $(SRC)_ctype.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_ctype.c
		$(AS)  --use-hardware=MDX _ctype.src 
		$(RM) _ctype.src

OBJECTS		+= weakstub.obj
weakstub.obj   	: $(SRC)weakstub.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)weakstub.c
		$(AS)  --use-hardware=MDX weakstub.src 
		$(RM) weakstub.src

OBJECTS		+= _Exit.obj
_Exit.obj   	: $(SRC)_Exit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_Exit.c
		$(AS)  --use-hardware=MDX _Exit.src 
		$(RM) _Exit.src

OBJECTS		+= sqrt.obj
sqrt.obj   	: $(SRC)sqrt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sqrt.c
		$(AS)  --use-hardware=MDX sqrt.src 
		$(RM) sqrt.src

OBJECTS		+= ldexp.obj
ldexp.obj   	: $(SRC)ldexp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ldexp.c
		$(AS)  --use-hardware=MDX ldexp.src 
		$(RM) ldexp.src

OBJECTS		+= frexp.obj
frexp.obj   	: $(SRC)frexp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)frexp.c
		$(AS)  --use-hardware=MDX frexp.src 
		$(RM) frexp.src

OBJECTS		+= modf.obj
modf.obj   	: $(SRC)modf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)modf.c
		$(AS)  --use-hardware=MDX modf.src 
		$(RM) modf.src

OBJECTS		+= sqrtf.obj
sqrtf.obj   	: $(SRC)sqrtf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sqrtf.c
		$(AS)  --use-hardware=MDX sqrtf.src 
		$(RM) sqrtf.src

OBJECTS		+= ldexpf.obj
ldexpf.obj   	: $(SRC)ldexpf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ldexpf.c
		$(AS)  --use-hardware=MDX ldexpf.src 
		$(RM) ldexpf.src

OBJECTS		+= frexpf.obj
frexpf.obj   	: $(SRC)frexpf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)frexpf.c
		$(AS)  --use-hardware=MDX frexpf.src 
		$(RM) frexpf.src

OBJECTS		+= modff.obj
modff.obj   	: $(SRC)modff.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)modff.c
		$(AS)  --use-hardware=MDX modff.src 
		$(RM) modff.src

OBJECTS		+= _issubnormal.obj
_issubnormal.obj   	: $(SRC)_issubnormal.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_issubnormal.c
		$(AS)  --use-hardware=MDX _issubnormal.src 
		$(RM) _issubnormal.src

OBJECTS		+= _issubnormalf.obj
_issubnormalf.obj   	: $(SRC)_issubnormalf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_issubnormalf.c
		$(AS)  --use-hardware=MDX _issubnormalf.src 
		$(RM) _issubnormalf.src

OBJECTS		+= _signbit.obj
_signbit.obj   	: $(SRC)_signbit.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_signbit.c
		$(AS)  --use-hardware=MDX _signbit.src 
		$(RM) _signbit.src

OBJECTS		+= _signbitf.obj
_signbitf.obj   	: $(SRC)_signbitf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_signbitf.c
		$(AS)  --use-hardware=MDX _signbitf.src 
		$(RM) _signbitf.src

OBJECTS		+= scalbln.obj
scalbln.obj   	: $(SRC)scalbln.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scalbln.c
		$(AS)  --use-hardware=MDX scalbln.src 
		$(RM) scalbln.src

OBJECTS		+= scalblnf.obj
scalblnf.obj   	: $(SRC)scalblnf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scalblnf.c
		$(AS)  --use-hardware=MDX scalblnf.src 
		$(RM) scalblnf.src

OBJECTS		+= isnan.obj
isnan.obj   	: $(SRC)isnan.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isnan.c
		$(AS)  --use-hardware=MDX isnan.src 
		$(RM) isnan.src

OBJECTS		+= isinf.obj
isinf.obj   	: $(SRC)isinf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isinf.c
		$(AS)  --use-hardware=MDX isinf.src 
		$(RM) isinf.src

OBJECTS		+= isfin.obj
isfin.obj   	: $(SRC)isfin.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isfin.c
		$(AS)  --use-hardware=MDX isfin.src 
		$(RM) isfin.src

OBJECTS		+= copysign.obj
copysign.obj   	: $(SRC)copysign.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)copysign.c
		$(AS)  --use-hardware=MDX copysign.src 
		$(RM) copysign.src

OBJECTS		+= scalb.obj
scalb.obj   	: $(SRC)scalb.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scalb.c
		$(AS)  --use-hardware=MDX scalb.src 
		$(RM) scalb.src

OBJECTS		+= isnanf.obj
isnanf.obj   	: $(SRC)isnanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isnanf.c
		$(AS)  --use-hardware=MDX isnanf.src 
		$(RM) isnanf.src

OBJECTS		+= isinff.obj
isinff.obj   	: $(SRC)isinff.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isinff.c
		$(AS)  --use-hardware=MDX isinff.src 
		$(RM) isinff.src

OBJECTS		+= isfinf.obj
isfinf.obj   	: $(SRC)isfinf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)isfinf.c
		$(AS)  --use-hardware=MDX isfinf.src 
		$(RM) isfinf.src

OBJECTS		+= cpsignf.obj
cpsignf.obj   	: $(SRC)cpsignf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)cpsignf.c
		$(AS)  --use-hardware=MDX cpsignf.src 
		$(RM) cpsignf.src

OBJECTS		+= scalbf.obj
scalbf.obj   	: $(SRC)scalbf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)scalbf.c
		$(AS)  --use-hardware=MDX scalbf.src 
		$(RM) scalbf.src

OBJECTS		+= _isgtf.obj
_isgtf.obj   	: $(SRC)_isgtf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isgtf.c
		$(AS)  --use-hardware=MDX _isgtf.src 
		$(RM) _isgtf.src

OBJECTS		+= _isgef.obj
_isgef.obj   	: $(SRC)_isgef.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isgef.c
		$(AS)  --use-hardware=MDX _isgef.src 
		$(RM) _isgef.src

OBJECTS		+= _isltf.obj
_isltf.obj   	: $(SRC)_isltf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isltf.c
		$(AS)  --use-hardware=MDX _isltf.src 
		$(RM) _isltf.src

OBJECTS		+= _islef.obj
_islef.obj   	: $(SRC)_islef.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_islef.c
		$(AS)  --use-hardware=MDX _islef.src 
		$(RM) _islef.src

OBJECTS		+= _islgf.obj
_islgf.obj   	: $(SRC)_islgf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_islgf.c
		$(AS)  --use-hardware=MDX _islgf.src 
		$(RM) _islgf.src

OBJECTS		+= _isunorderedf.obj
_isunorderedf.obj   	: $(SRC)_isunorderedf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isunorderedf.c
		$(AS)  --use-hardware=MDX _isunorderedf.src 
		$(RM) _isunorderedf.src

OBJECTS		+= _isnormalf.obj
_isnormalf.obj   	: $(SRC)_isnormalf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isnormalf.c
		$(AS)  --use-hardware=MDX _isnormalf.src 
		$(RM) _isnormalf.src

OBJECTS		+= _fpclassifyf.obj
_fpclassifyf.obj   	: $(SRC)_fpclassifyf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_fpclassifyf.c
		$(AS)  --use-hardware=MDX _fpclassifyf.src 
		$(RM) _fpclassifyf.src

OBJECTS		+= sinf.obj
sinf.obj   	: $(SRC)sinf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sinf.c
		$(AS)  --use-hardware=MDX sinf.src 
		$(RM) sinf.src

OBJECTS		+= asinf.obj
asinf.obj   	: $(SRC)asinf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asinf.c
		$(AS)  --use-hardware=MDX asinf.src 
		$(RM) asinf.src

OBJECTS		+= sinhf.obj
sinhf.obj   	: $(SRC)sinhf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sinhf.c
		$(AS)  --use-hardware=MDX sinhf.src 
		$(RM) sinhf.src

OBJECTS		+= asinhf.obj
asinhf.obj   	: $(SRC)asinhf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asinhf.c
		$(AS)  --use-hardware=MDX asinhf.src 
		$(RM) asinhf.src

OBJECTS		+= cosf.obj
cosf.obj   	: $(SRC)cosf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)cosf.c
		$(AS)  --use-hardware=MDX cosf.src 
		$(RM) cosf.src

OBJECTS		+= acosf.obj
acosf.obj   	: $(SRC)acosf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)acosf.c
		$(AS)  --use-hardware=MDX acosf.src 
		$(RM) acosf.src

OBJECTS		+= coshf.obj
coshf.obj   	: $(SRC)coshf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)coshf.c
		$(AS)  --use-hardware=MDX coshf.src 
		$(RM) coshf.src

OBJECTS		+= acoshf.obj
acoshf.obj   	: $(SRC)acoshf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)acoshf.c
		$(AS)  --use-hardware=MDX acoshf.src 
		$(RM) acoshf.src

OBJECTS		+= tanf.obj
tanf.obj   	: $(SRC)tanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tanf.c
		$(AS)  --use-hardware=MDX tanf.src 
		$(RM) tanf.src

OBJECTS		+= atanf.obj
atanf.obj   	: $(SRC)atanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atanf.c
		$(AS)  --use-hardware=MDX atanf.src 
		$(RM) atanf.src

OBJECTS		+= atan2f.obj
atan2f.obj   	: $(SRC)atan2f.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atan2f.c
		$(AS)  --use-hardware=MDX atan2f.src 
		$(RM) atan2f.src

OBJECTS		+= tanhf.obj
tanhf.obj   	: $(SRC)tanhf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tanhf.c
		$(AS)  --use-hardware=MDX tanhf.src 
		$(RM) tanhf.src

OBJECTS		+= atanhf.obj
atanhf.obj   	: $(SRC)atanhf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atanhf.c
		$(AS)  --use-hardware=MDX atanhf.src 
		$(RM) atanhf.src

OBJECTS		+= expf.obj
expf.obj   	: $(SRC)expf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)expf.c
		$(AS)  --use-hardware=MDX expf.src 
		$(RM) expf.src

OBJECTS		+= logf.obj
logf.obj   	: $(SRC)logf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)logf.c
		$(AS)  --use-hardware=MDX logf.src 
		$(RM) logf.src

OBJECTS		+= log10f.obj
log10f.obj   	: $(SRC)log10f.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)log10f.c
		$(AS)  --use-hardware=MDX log10f.src 
		$(RM) log10f.src

OBJECTS		+= powf.obj
powf.obj   	: $(SRC)powf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)powf.c
		$(AS)  --use-hardware=MDX powf.src 
		$(RM) powf.src

OBJECTS		+= ceilf.obj
ceilf.obj   	: $(SRC)ceilf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ceilf.c
		$(AS)  --use-hardware=MDX ceilf.src 
		$(RM) ceilf.src

OBJECTS		+= floorf.obj
floorf.obj   	: $(SRC)floorf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)floorf.c
		$(AS)  --use-hardware=MDX floorf.src 
		$(RM) floorf.src

OBJECTS		+= fabsf.obj
fabsf.obj   	: $(SRC)fabsf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fabsf.c
		$(AS)  --use-hardware=MDX fabsf.src 
		$(RM) fabsf.src

OBJECTS		+= fmodf.obj
fmodf.obj   	: $(SRC)fmodf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fmodf.c
		$(AS)  --use-hardware=MDX fmodf.src 
		$(RM) fmodf.src

OBJECTS		+= hypotf.obj
hypotf.obj   	: $(SRC)hypotf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)hypotf.c
		$(AS)  --use-hardware=MDX hypotf.src 
		$(RM) hypotf.src

OBJECTS		+= _sinusf.obj
_sinusf.obj   	: $(SRC)_sinusf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_sinusf.c
		$(AS)  --use-hardware=MDX _sinusf.src 
		$(RM) _sinusf.src

OBJECTS		+= _atanf.obj
_atanf.obj   	: $(SRC)_atanf.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_atanf.c
		$(AS)  --use-hardware=MDX _atanf.src 
		$(RM) _atanf.src

OBJECTS		+= _isgt.obj
_isgt.obj   	: $(SRC)_isgt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isgt.c
		$(AS)  --use-hardware=MDX _isgt.src 
		$(RM) _isgt.src

OBJECTS		+= _isge.obj
_isge.obj   	: $(SRC)_isge.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isge.c
		$(AS)  --use-hardware=MDX _isge.src 
		$(RM) _isge.src

OBJECTS		+= _islt.obj
_islt.obj   	: $(SRC)_islt.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_islt.c
		$(AS)  --use-hardware=MDX _islt.src 
		$(RM) _islt.src

OBJECTS		+= _isle.obj
_isle.obj   	: $(SRC)_isle.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isle.c
		$(AS)  --use-hardware=MDX _isle.src 
		$(RM) _isle.src

OBJECTS		+= _islg.obj
_islg.obj   	: $(SRC)_islg.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_islg.c
		$(AS)  --use-hardware=MDX _islg.src 
		$(RM) _islg.src

OBJECTS		+= _isunordered.obj
_isunordered.obj   	: $(SRC)_isunordered.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isunordered.c
		$(AS)  --use-hardware=MDX _isunordered.src 
		$(RM) _isunordered.src

OBJECTS		+= _isnormal.obj
_isnormal.obj   	: $(SRC)_isnormal.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isnormal.c
		$(AS)  --use-hardware=MDX _isnormal.src 
		$(RM) _isnormal.src

OBJECTS		+= _fpclassify.obj
_fpclassify.obj   	: $(SRC)_fpclassify.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_fpclassify.c
		$(AS)  --use-hardware=MDX _fpclassify.src 
		$(RM) _fpclassify.src

OBJECTS		+= sin.obj
sin.obj   	: $(SRC)sin.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sin.c
		$(AS)  --use-hardware=MDX sin.src 
		$(RM) sin.src

OBJECTS		+= asin.obj
asin.obj   	: $(SRC)asin.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asin.c
		$(AS)  --use-hardware=MDX asin.src 
		$(RM) asin.src

OBJECTS		+= sinh.obj
sinh.obj   	: $(SRC)sinh.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sinh.c
		$(AS)  --use-hardware=MDX sinh.src 
		$(RM) sinh.src

OBJECTS		+= asinh.obj
asinh.obj   	: $(SRC)asinh.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asinh.c
		$(AS)  --use-hardware=MDX asinh.src 
		$(RM) asinh.src

OBJECTS		+= cos.obj
cos.obj   	: $(SRC)cos.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)cos.c
		$(AS)  --use-hardware=MDX cos.src 
		$(RM) cos.src

OBJECTS		+= acos.obj
acos.obj   	: $(SRC)acos.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)acos.c
		$(AS)  --use-hardware=MDX acos.src 
		$(RM) acos.src

OBJECTS		+= cosh.obj
cosh.obj   	: $(SRC)cosh.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)cosh.c
		$(AS)  --use-hardware=MDX cosh.src 
		$(RM) cosh.src

OBJECTS		+= acosh.obj
acosh.obj   	: $(SRC)acosh.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)acosh.c
		$(AS)  --use-hardware=MDX acosh.src 
		$(RM) acosh.src

OBJECTS		+= tan.obj
tan.obj   	: $(SRC)tan.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tan.c
		$(AS)  --use-hardware=MDX tan.src 
		$(RM) tan.src

OBJECTS		+= atan.obj
atan.obj   	: $(SRC)atan.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atan.c
		$(AS)  --use-hardware=MDX atan.src 
		$(RM) atan.src

OBJECTS		+= atan2.obj
atan2.obj   	: $(SRC)atan2.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atan2.c
		$(AS)  --use-hardware=MDX atan2.src 
		$(RM) atan2.src

OBJECTS		+= tanh.obj
tanh.obj   	: $(SRC)tanh.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tanh.c
		$(AS)  --use-hardware=MDX tanh.src 
		$(RM) tanh.src

OBJECTS		+= atanh.obj
atanh.obj   	: $(SRC)atanh.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atanh.c
		$(AS)  --use-hardware=MDX atanh.src 
		$(RM) atanh.src

OBJECTS		+= exp.obj
exp.obj   	: $(SRC)exp.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)exp.c
		$(AS)  --use-hardware=MDX exp.src 
		$(RM) exp.src

OBJECTS		+= log.obj
log.obj   	: $(SRC)log.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)log.c
		$(AS)  --use-hardware=MDX log.src 
		$(RM) log.src

OBJECTS		+= log10.obj
log10.obj   	: $(SRC)log10.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)log10.c
		$(AS)  --use-hardware=MDX log10.src 
		$(RM) log10.src

OBJECTS		+= pow.obj
pow.obj   	: $(SRC)pow.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)pow.c
		$(AS)  --use-hardware=MDX pow.src 
		$(RM) pow.src

OBJECTS		+= ceil.obj
ceil.obj   	: $(SRC)ceil.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ceil.c
		$(AS)  --use-hardware=MDX ceil.src 
		$(RM) ceil.src

OBJECTS		+= floor.obj
floor.obj   	: $(SRC)floor.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)floor.c
		$(AS)  --use-hardware=MDX floor.src 
		$(RM) floor.src

OBJECTS		+= fabs.obj
fabs.obj   	: $(SRC)fabs.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fabs.c
		$(AS)  --use-hardware=MDX fabs.src 
		$(RM) fabs.src

OBJECTS		+= fmod.obj
fmod.obj   	: $(SRC)fmod.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fmod.c
		$(AS)  --use-hardware=MDX fmod.src 
		$(RM) fmod.src

OBJECTS		+= hypot.obj
hypot.obj   	: $(SRC)hypot.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)hypot.c
		$(AS)  --use-hardware=MDX hypot.src 
		$(RM) hypot.src

OBJECTS		+= _sinus.obj
_sinus.obj   	: $(SRC)_sinus.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_sinus.c
		$(AS)  --use-hardware=MDX _sinus.src 
		$(RM) _sinus.src

OBJECTS		+= _atan.obj
_atan.obj   	: $(SRC)_atan.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_atan.c
		$(AS)  --use-hardware=MDX _atan.src 
		$(RM) _atan.src

OBJECTS		+= _isgtl.obj
_isgtl.obj   	: $(SRC)_isgtl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isgtl.c
		$(AS)  --use-hardware=MDX _isgtl.src 
		$(RM) _isgtl.src

OBJECTS		+= _isgel.obj
_isgel.obj   	: $(SRC)_isgel.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isgel.c
		$(AS)  --use-hardware=MDX _isgel.src 
		$(RM) _isgel.src

OBJECTS		+= _isltl.obj
_isltl.obj   	: $(SRC)_isltl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isltl.c
		$(AS)  --use-hardware=MDX _isltl.src 
		$(RM) _isltl.src

OBJECTS		+= _islel.obj
_islel.obj   	: $(SRC)_islel.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_islel.c
		$(AS)  --use-hardware=MDX _islel.src 
		$(RM) _islel.src

OBJECTS		+= _islgl.obj
_islgl.obj   	: $(SRC)_islgl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_islgl.c
		$(AS)  --use-hardware=MDX _islgl.src 
		$(RM) _islgl.src

OBJECTS		+= _isunorderedl.obj
_isunorderedl.obj   	: $(SRC)_isunorderedl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isunorderedl.c
		$(AS)  --use-hardware=MDX _isunorderedl.src 
		$(RM) _isunorderedl.src

OBJECTS		+= _isnormall.obj
_isnormall.obj   	: $(SRC)_isnormall.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_isnormall.c
		$(AS)  --use-hardware=MDX _isnormall.src 
		$(RM) _isnormall.src

OBJECTS		+= _fpclassifyl.obj
_fpclassifyl.obj   	: $(SRC)_fpclassifyl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_fpclassifyl.c
		$(AS)  --use-hardware=MDX _fpclassifyl.src 
		$(RM) _fpclassifyl.src

OBJECTS		+= sinl.obj
sinl.obj   	: $(SRC)sinl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sinl.c
		$(AS)  --use-hardware=MDX sinl.src 
		$(RM) sinl.src

OBJECTS		+= asinl.obj
asinl.obj   	: $(SRC)asinl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asinl.c
		$(AS)  --use-hardware=MDX asinl.src 
		$(RM) asinl.src

OBJECTS		+= sinhl.obj
sinhl.obj   	: $(SRC)sinhl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)sinhl.c
		$(AS)  --use-hardware=MDX sinhl.src 
		$(RM) sinhl.src

OBJECTS		+= asinhl.obj
asinhl.obj   	: $(SRC)asinhl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)asinhl.c
		$(AS)  --use-hardware=MDX asinhl.src 
		$(RM) asinhl.src

OBJECTS		+= cosl.obj
cosl.obj   	: $(SRC)cosl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)cosl.c
		$(AS)  --use-hardware=MDX cosl.src 
		$(RM) cosl.src

OBJECTS		+= acosl.obj
acosl.obj   	: $(SRC)acosl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)acosl.c
		$(AS)  --use-hardware=MDX acosl.src 
		$(RM) acosl.src

OBJECTS		+= coshl.obj
coshl.obj   	: $(SRC)coshl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)coshl.c
		$(AS)  --use-hardware=MDX coshl.src 
		$(RM) coshl.src

OBJECTS		+= acoshl.obj
acoshl.obj   	: $(SRC)acoshl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)acoshl.c
		$(AS)  --use-hardware=MDX acoshl.src 
		$(RM) acoshl.src

OBJECTS		+= tanl.obj
tanl.obj   	: $(SRC)tanl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tanl.c
		$(AS)  --use-hardware=MDX tanl.src 
		$(RM) tanl.src

OBJECTS		+= atanl.obj
atanl.obj   	: $(SRC)atanl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atanl.c
		$(AS)  --use-hardware=MDX atanl.src 
		$(RM) atanl.src

OBJECTS		+= atan2l.obj
atan2l.obj   	: $(SRC)atan2l.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atan2l.c
		$(AS)  --use-hardware=MDX atan2l.src 
		$(RM) atan2l.src

OBJECTS		+= tanhl.obj
tanhl.obj   	: $(SRC)tanhl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)tanhl.c
		$(AS)  --use-hardware=MDX tanhl.src 
		$(RM) tanhl.src

OBJECTS		+= atanhl.obj
atanhl.obj   	: $(SRC)atanhl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)atanhl.c
		$(AS)  --use-hardware=MDX atanhl.src 
		$(RM) atanhl.src

OBJECTS		+= expl.obj
expl.obj   	: $(SRC)expl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)expl.c
		$(AS)  --use-hardware=MDX expl.src 
		$(RM) expl.src

OBJECTS		+= logl.obj
logl.obj   	: $(SRC)logl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)logl.c
		$(AS)  --use-hardware=MDX logl.src 
		$(RM) logl.src

OBJECTS		+= log10l.obj
log10l.obj   	: $(SRC)log10l.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)log10l.c
		$(AS)  --use-hardware=MDX log10l.src 
		$(RM) log10l.src

OBJECTS		+= powl.obj
powl.obj   	: $(SRC)powl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)powl.c
		$(AS)  --use-hardware=MDX powl.src 
		$(RM) powl.src

OBJECTS		+= ceill.obj
ceill.obj   	: $(SRC)ceill.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)ceill.c
		$(AS)  --use-hardware=MDX ceill.src 
		$(RM) ceill.src

OBJECTS		+= floorl.obj
floorl.obj   	: $(SRC)floorl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)floorl.c
		$(AS)  --use-hardware=MDX floorl.src 
		$(RM) floorl.src

OBJECTS		+= fabsl.obj
fabsl.obj   	: $(SRC)fabsl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fabsl.c
		$(AS)  --use-hardware=MDX fabsl.src 
		$(RM) fabsl.src

OBJECTS		+= fmodl.obj
fmodl.obj   	: $(SRC)fmodl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)fmodl.c
		$(AS)  --use-hardware=MDX fmodl.src 
		$(RM) fmodl.src

OBJECTS		+= hypotl.obj
hypotl.obj   	: $(SRC)hypotl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)hypotl.c
		$(AS)  --use-hardware=MDX hypotl.src 
		$(RM) hypotl.src

OBJECTS		+= _sinusl.obj
_sinusl.obj   	: $(SRC)_sinusl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_sinusl.c
		$(AS)  --use-hardware=MDX _sinusl.src 
		$(RM) _sinusl.src

OBJECTS		+= _atanl.obj
_atanl.obj   	: $(SRC)_atanl.c
		$(CC)  --use-hardware=MDX --no-double -gc --sdata=0 --no-jmpi --global-type-checking -Rlibc  $(SRC)_atanl.c
		$(AS)  --use-hardware=MDX _atanl.src 
		$(RM) _atanl.src

cnioss.lib   	: $(OBJECTS)
		argfile cnioss.lib.opt $(OBJECTS)
		$(AR) -r $@ -f cnioss.lib.opt
		$(RM) cnioss.lib.opt
