#
# Makefile for the c51as library.
#
SRC		= ..\			# source directory

AS		= $(PRODDIR)\c51\bin\as51
CC		= $(PRODDIR)\c51\bin\c51
AR		= $(PRODDIR)\bin\tlb

all		: c51as.lib 

clean		:
		$(RM) *.obj
		$(RM) *.src
		$(RM) c51as.lib 


OBJECTS		+= cstart.obj
cstart.obj   	: $(SRC)cstart.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)cstart.c
		$(AS)  -DMODEL=a  --require-end cstart.src 
		$(RM) cstart.src

OBJECTS		+= init.obj
init.obj   	: $(SRC)init.src
		$(AS)  -DMODEL=a  --require-end $(SRC)init.src 

OBJECTS		+= longjmp.obj
longjmp.obj   	: $(SRC)longjmp.src
		$(AS)  -DMODEL=a  --require-end $(SRC)longjmp.src 

OBJECTS		+= setjmp.obj
setjmp.obj   	: $(SRC)setjmp.src
		$(AS)  -DMODEL=a  --require-end $(SRC)setjmp.src 

OBJECTS		+= clock.obj
clock.obj   	: $(SRC)clock.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)clock.c
		$(AS)  -DMODEL=a  --require-end clock.src 
		$(RM) clock.src

OBJECTS		+= _modf.obj
_modf.obj   	: $(SRC)_modf.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_modf.src 

OBJECTS		+= _frexp.obj
_frexp.obj   	: $(SRC)_frexp.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_frexp.src 

OBJECTS		+= _ldexp.obj
_ldexp.obj   	: $(SRC)_ldexp.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_ldexp.src 

OBJECTS		+= _fabs.obj
_fabs.obj   	: $(SRC)_fabs.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_fabs.src 

OBJECTS		+= _copysign.obj
_copysign.obj   	: $(SRC)_copysign.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_copysign.src 

OBJECTS		+= _isinf.obj
_isinf.obj   	: $(SRC)_isinf.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_isinf.src 

OBJECTS		+= _isnan.obj
_isnan.obj   	: $(SRC)_isnan.src
		$(AS)  -DMODEL=a  --require-end $(SRC)_isnan.src 

OBJECTS		+= locale.obj
locale.obj   	: $(SRC)locale.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)locale.c
		$(AS)  -DMODEL=a  --require-end locale.src 
		$(RM) locale.src

OBJECTS		+= signal.obj
signal.obj   	: $(SRC)signal.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)signal.c
		$(AS)  -DMODEL=a  --require-end signal.src 
		$(RM) signal.src

OBJECTS		+= raise.obj
raise.obj   	: $(SRC)raise.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)raise.c
		$(AS)  -DMODEL=a  --require-end raise.src 
		$(RM) raise.src

OBJECTS		+= toupper.obj
toupper.obj   	: $(SRC)toupper.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)toupper.c
		$(AS)  -DMODEL=a  --require-end toupper.src 
		$(RM) toupper.src

OBJECTS		+= tolower.obj
tolower.obj   	: $(SRC)tolower.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tolower.c
		$(AS)  -DMODEL=a  --require-end tolower.src 
		$(RM) tolower.src

OBJECTS		+= toascii.obj
toascii.obj   	: $(SRC)toascii.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)toascii.c
		$(AS)  -DMODEL=a  --require-end toascii.src 
		$(RM) toascii.src

OBJECTS		+= isalpha.obj
isalpha.obj   	: $(SRC)isalpha.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isalpha.c
		$(AS)  -DMODEL=a  --require-end isalpha.src 
		$(RM) isalpha.src

OBJECTS		+= isalnum.obj
isalnum.obj   	: $(SRC)isalnum.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isalnum.c
		$(AS)  -DMODEL=a  --require-end isalnum.src 
		$(RM) isalnum.src

OBJECTS		+= isascii.obj
isascii.obj   	: $(SRC)isascii.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isascii.c
		$(AS)  -DMODEL=a  --require-end isascii.src 
		$(RM) isascii.src

OBJECTS		+= isupper.obj
isupper.obj   	: $(SRC)isupper.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isupper.c
		$(AS)  -DMODEL=a  --require-end isupper.src 
		$(RM) isupper.src

OBJECTS		+= islower.obj
islower.obj   	: $(SRC)islower.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)islower.c
		$(AS)  -DMODEL=a  --require-end islower.src 
		$(RM) islower.src

OBJECTS		+= isdigit.obj
isdigit.obj   	: $(SRC)isdigit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isdigit.c
		$(AS)  -DMODEL=a  --require-end isdigit.src 
		$(RM) isdigit.src

OBJECTS		+= isxdigit.obj
isxdigit.obj   	: $(SRC)isxdigit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isxdigit.c
		$(AS)  -DMODEL=a  --require-end isxdigit.src 
		$(RM) isxdigit.src

OBJECTS		+= isspace.obj
isspace.obj   	: $(SRC)isspace.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isspace.c
		$(AS)  -DMODEL=a  --require-end isspace.src 
		$(RM) isspace.src

OBJECTS		+= ispunct.obj
ispunct.obj   	: $(SRC)ispunct.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ispunct.c
		$(AS)  -DMODEL=a  --require-end ispunct.src 
		$(RM) ispunct.src

OBJECTS		+= iscntrl.obj
iscntrl.obj   	: $(SRC)iscntrl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iscntrl.c
		$(AS)  -DMODEL=a  --require-end iscntrl.src 
		$(RM) iscntrl.src

OBJECTS		+= isprint.obj
isprint.obj   	: $(SRC)isprint.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isprint.c
		$(AS)  -DMODEL=a  --require-end isprint.src 
		$(RM) isprint.src

OBJECTS		+= isgraph.obj
isgraph.obj   	: $(SRC)isgraph.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isgraph.c
		$(AS)  -DMODEL=a  --require-end isgraph.src 
		$(RM) isgraph.src

OBJECTS		+= _ctype.obj
_ctype.obj   	: $(SRC)_ctype.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_ctype.c
		$(AS)  -DMODEL=a  --require-end _ctype.src 
		$(RM) _ctype.src

OBJECTS		+= isblank.obj
isblank.obj   	: $(SRC)isblank.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isblank.c
		$(AS)  -DMODEL=a  --require-end isblank.src 
		$(RM) isblank.src

OBJECTS		+= memchr.obj
memchr.obj   	: $(SRC)memchr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)memchr.c
		$(AS)  -DMODEL=a  --require-end memchr.src 
		$(RM) memchr.src

OBJECTS		+= memcmp.obj
memcmp.obj   	: $(SRC)memcmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)memcmp.c
		$(AS)  -DMODEL=a  --require-end memcmp.src 
		$(RM) memcmp.src

OBJECTS		+= memcpy.obj
memcpy.obj   	: $(SRC)memcpy.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)memcpy.c
		$(AS)  -DMODEL=a  --require-end memcpy.src 
		$(RM) memcpy.src

OBJECTS		+= memmove.obj
memmove.obj   	: $(SRC)memmove.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)memmove.c
		$(AS)  -DMODEL=a  --require-end memmove.src 
		$(RM) memmove.src

OBJECTS		+= memset.obj
memset.obj   	: $(SRC)memset.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)memset.c
		$(AS)  -DMODEL=a  --require-end memset.src 
		$(RM) memset.src

OBJECTS		+= strcat.obj
strcat.obj   	: $(SRC)strcat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strcat.c
		$(AS)  -DMODEL=a  --require-end strcat.src 
		$(RM) strcat.src

OBJECTS		+= strncat.obj
strncat.obj   	: $(SRC)strncat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strncat.c
		$(AS)  -DMODEL=a  --require-end strncat.src 
		$(RM) strncat.src

OBJECTS		+= strchr.obj
strchr.obj   	: $(SRC)strchr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strchr.c
		$(AS)  -DMODEL=a  --require-end strchr.src 
		$(RM) strchr.src

OBJECTS		+= strrchr.obj
strrchr.obj   	: $(SRC)strrchr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strrchr.c
		$(AS)  -DMODEL=a  --require-end strrchr.src 
		$(RM) strrchr.src

OBJECTS		+= strcmp.obj
strcmp.obj   	: $(SRC)strcmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strcmp.c
		$(AS)  -DMODEL=a  --require-end strcmp.src 
		$(RM) strcmp.src

OBJECTS		+= strncmp.obj
strncmp.obj   	: $(SRC)strncmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strncmp.c
		$(AS)  -DMODEL=a  --require-end strncmp.src 
		$(RM) strncmp.src

OBJECTS		+= strcpy.obj
strcpy.obj   	: $(SRC)strcpy.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strcpy.c
		$(AS)  -DMODEL=a  --require-end strcpy.src 
		$(RM) strcpy.src

OBJECTS		+= strncpy.obj
strncpy.obj   	: $(SRC)strncpy.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strncpy.c
		$(AS)  -DMODEL=a  --require-end strncpy.src 
		$(RM) strncpy.src

OBJECTS		+= strcspn.obj
strcspn.obj   	: $(SRC)strcspn.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strcspn.c
		$(AS)  -DMODEL=a  --require-end strcspn.src 
		$(RM) strcspn.src

OBJECTS		+= strerror.obj
strerror.obj   	: $(SRC)strerror.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strerror.c
		$(AS)  -DMODEL=a  --require-end strerror.src 
		$(RM) strerror.src

OBJECTS		+= strlen.obj
strlen.obj   	: $(SRC)strlen.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strlen.c
		$(AS)  -DMODEL=a  --require-end strlen.src 
		$(RM) strlen.src

OBJECTS		+= strpbrk.obj
strpbrk.obj   	: $(SRC)strpbrk.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strpbrk.c
		$(AS)  -DMODEL=a  --require-end strpbrk.src 
		$(RM) strpbrk.src

OBJECTS		+= strspn.obj
strspn.obj   	: $(SRC)strspn.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strspn.c
		$(AS)  -DMODEL=a  --require-end strspn.src 
		$(RM) strspn.src

OBJECTS		+= strstr.obj
strstr.obj   	: $(SRC)strstr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strstr.c
		$(AS)  -DMODEL=a  --require-end strstr.src 
		$(RM) strstr.src

OBJECTS		+= strtok.obj
strtok.obj   	: $(SRC)strtok.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtok.c
		$(AS)  -DMODEL=a  --require-end strtok.src 
		$(RM) strtok.src

OBJECTS		+= _strccmp.obj
_strccmp.obj   	: $(SRC)_strccmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_strccmp.c
		$(AS)  -DMODEL=a  --require-end _strccmp.src 
		$(RM) _strccmp.src

OBJECTS		+= _strnccmp.obj
_strnccmp.obj   	: $(SRC)_strnccmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_strnccmp.c
		$(AS)  -DMODEL=a  --require-end _strnccmp.src 
		$(RM) _strnccmp.src

OBJECTS		+= strcoll.obj
strcoll.obj   	: $(SRC)strcoll.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strcoll.c
		$(AS)  -DMODEL=a  --require-end strcoll.src 
		$(RM) strcoll.src

OBJECTS		+= strxfrm.obj
strxfrm.obj   	: $(SRC)strxfrm.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strxfrm.c
		$(AS)  -DMODEL=a  --require-end strxfrm.src 
		$(RM) strxfrm.src

OBJECTS		+= malloc.obj
malloc.obj   	: $(SRC)malloc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)malloc.c
		$(AS)  -DMODEL=a  --require-end malloc.src 
		$(RM) malloc.src

OBJECTS		+= realloc.obj
realloc.obj   	: $(SRC)realloc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)realloc.c
		$(AS)  -DMODEL=a  --require-end realloc.src 
		$(RM) realloc.src

OBJECTS		+= calloc.obj
calloc.obj   	: $(SRC)calloc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)calloc.c
		$(AS)  -DMODEL=a  --require-end calloc.src 
		$(RM) calloc.src

OBJECTS		+= _sbrk.obj
_sbrk.obj   	: $(SRC)_sbrk.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_sbrk.c
		$(AS)  -DMODEL=a  --require-end _sbrk.src 
		$(RM) _sbrk.src

OBJECTS		+= asctime.obj
asctime.obj   	: $(SRC)asctime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asctime.c
		$(AS)  -DMODEL=a  --require-end asctime.src 
		$(RM) asctime.src

OBJECTS		+= ctime.obj
ctime.obj   	: $(SRC)ctime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ctime.c
		$(AS)  -DMODEL=a  --require-end ctime.src 
		$(RM) ctime.src

OBJECTS		+= strftime.obj
strftime.obj   	: $(SRC)strftime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strftime.c
		$(AS)  -DMODEL=a  --require-end strftime.src 
		$(RM) strftime.src

OBJECTS		+= time.obj
time.obj   	: $(SRC)time.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)time.c
		$(AS)  -DMODEL=a  --require-end time.src 
		$(RM) time.src

OBJECTS		+= mktime.obj
mktime.obj   	: $(SRC)mktime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)mktime.c
		$(AS)  -DMODEL=a  --require-end mktime.src 
		$(RM) mktime.src

OBJECTS		+= difftime.obj
difftime.obj   	: $(SRC)difftime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)difftime.c
		$(AS)  -DMODEL=a  --require-end difftime.src 
		$(RM) difftime.src

OBJECTS		+= gmtime.obj
gmtime.obj   	: $(SRC)gmtime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)gmtime.c
		$(AS)  -DMODEL=a  --require-end gmtime.src 
		$(RM) gmtime.src

OBJECTS		+= localtm.obj
localtm.obj   	: $(SRC)localtm.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)localtm.c
		$(AS)  -DMODEL=a  --require-end localtm.src 
		$(RM) localtm.src

OBJECTS		+= _tzone.obj
_tzone.obj   	: $(SRC)_tzone.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_tzone.c
		$(AS)  -DMODEL=a  --require-end _tzone.src 
		$(RM) _tzone.src

OBJECTS		+= errno.obj
errno.obj   	: $(SRC)errno.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)errno.c
		$(AS)  -DMODEL=a  --require-end errno.src 
		$(RM) errno.src

OBJECTS		+= printf_llong.obj
printf_llong.obj   	: $(SRC)printf_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)printf_llong.c
		$(AS)  -DMODEL=a  --require-end printf_llong.src 
		$(RM) printf_llong.src

OBJECTS		+= printf_long.obj
printf_long.obj   	: $(SRC)printf_long.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)printf_long.c
		$(AS)  -DMODEL=a  --require-end printf_long.src 
		$(RM) printf_long.src

OBJECTS		+= printf_int.obj
printf_int.obj   	: $(SRC)printf_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)printf_int.c
		$(AS)  -DMODEL=a  --require-end printf_int.src 
		$(RM) printf_int.src

OBJECTS		+= _doprint_int.obj
_doprint_int.obj   	: $(SRC)_doprint_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doprint_int.c
		$(AS)  -DMODEL=a  --require-end _doprint_int.src 
		$(RM) _doprint_int.src

OBJECTS		+= _doprint_llong.obj
_doprint_llong.obj   	: $(SRC)_doprint_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doprint_llong.c
		$(AS)  -DMODEL=a  --require-end _doprint_llong.src 
		$(RM) _doprint_llong.src

OBJECTS		+= scanf_llong.obj
scanf_llong.obj   	: $(SRC)scanf_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scanf_llong.c
		$(AS)  -DMODEL=a  --require-end scanf_llong.src 
		$(RM) scanf_llong.src

OBJECTS		+= scanf_long.obj
scanf_long.obj   	: $(SRC)scanf_long.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scanf_long.c
		$(AS)  -DMODEL=a  --require-end scanf_long.src 
		$(RM) scanf_long.src

OBJECTS		+= scanf_int.obj
scanf_int.obj   	: $(SRC)scanf_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scanf_int.c
		$(AS)  -DMODEL=a  --require-end scanf_int.src 
		$(RM) scanf_int.src

OBJECTS		+= _doscan_int.obj
_doscan_int.obj   	: $(SRC)_doscan_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doscan_int.c
		$(AS)  -DMODEL=a  --require-end _doscan_int.src 
		$(RM) _doscan_int.src

OBJECTS		+= _doscan_llong.obj
_doscan_llong.obj   	: $(SRC)_doscan_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doscan_llong.c
		$(AS)  -DMODEL=a  --require-end _doscan_llong.src 
		$(RM) _doscan_llong.src

OBJECTS		+= snprintf.obj
snprintf.obj   	: $(SRC)snprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)snprintf.c
		$(AS)  -DMODEL=a  --require-end snprintf.src 
		$(RM) snprintf.src

OBJECTS		+= vsnprintf.obj
vsnprintf.obj   	: $(SRC)vsnprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vsnprintf.c
		$(AS)  -DMODEL=a  --require-end vsnprintf.src 
		$(RM) vsnprintf.src

OBJECTS		+= vfscanf.obj
vfscanf.obj   	: $(SRC)vfscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vfscanf.c
		$(AS)  -DMODEL=a  --require-end vfscanf.src 
		$(RM) vfscanf.src

OBJECTS		+= vscanf.obj
vscanf.obj   	: $(SRC)vscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vscanf.c
		$(AS)  -DMODEL=a  --require-end vscanf.src 
		$(RM) vscanf.src

OBJECTS		+= vsscanf.obj
vsscanf.obj   	: $(SRC)vsscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vsscanf.c
		$(AS)  -DMODEL=a  --require-end vsscanf.src 
		$(RM) vsscanf.src

OBJECTS		+= wprintf_llong.obj
wprintf_llong.obj   	: $(SRC)wprintf_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wprintf_llong.c
		$(AS)  -DMODEL=a  --require-end wprintf_llong.src 
		$(RM) wprintf_llong.src

OBJECTS		+= wprintf_long.obj
wprintf_long.obj   	: $(SRC)wprintf_long.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wprintf_long.c
		$(AS)  -DMODEL=a  --require-end wprintf_long.src 
		$(RM) wprintf_long.src

OBJECTS		+= wprintf_int.obj
wprintf_int.obj   	: $(SRC)wprintf_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wprintf_int.c
		$(AS)  -DMODEL=a  --require-end wprintf_int.src 
		$(RM) wprintf_int.src

OBJECTS		+= _dowprin_int.obj
_dowprin_int.obj   	: $(SRC)_dowprin_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowprin_int.c
		$(AS)  -DMODEL=a  --require-end _dowprin_int.src 
		$(RM) _dowprin_int.src

OBJECTS		+= _dowprin_llong.obj
_dowprin_llong.obj   	: $(SRC)_dowprin_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowprin_llong.c
		$(AS)  -DMODEL=a  --require-end _dowprin_llong.src 
		$(RM) _dowprin_llong.src

OBJECTS		+= wscanf_llong.obj
wscanf_llong.obj   	: $(SRC)wscanf_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wscanf_llong.c
		$(AS)  -DMODEL=a  --require-end wscanf_llong.src 
		$(RM) wscanf_llong.src

OBJECTS		+= wscanf_long.obj
wscanf_long.obj   	: $(SRC)wscanf_long.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wscanf_long.c
		$(AS)  -DMODEL=a  --require-end wscanf_long.src 
		$(RM) wscanf_long.src

OBJECTS		+= wscanf_int.obj
wscanf_int.obj   	: $(SRC)wscanf_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wscanf_int.c
		$(AS)  -DMODEL=a  --require-end wscanf_int.src 
		$(RM) wscanf_int.src

OBJECTS		+= _dowscan_int.obj
_dowscan_int.obj   	: $(SRC)_dowscan_int.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowscan_int.c
		$(AS)  -DMODEL=a  --require-end _dowscan_int.src 
		$(RM) _dowscan_int.src

OBJECTS		+= _dowscan_llong.obj
_dowscan_llong.obj   	: $(SRC)_dowscan_llong.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowscan_llong.c
		$(AS)  -DMODEL=a  --require-end _dowscan_llong.src 
		$(RM) _dowscan_llong.src

OBJECTS		+= remove.obj
remove.obj   	: $(SRC)remove.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)remove.c
		$(AS)  -DMODEL=a  --require-end remove.src 
		$(RM) remove.src

OBJECTS		+= tmpfile.obj
tmpfile.obj   	: $(SRC)tmpfile.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tmpfile.c
		$(AS)  -DMODEL=a  --require-end tmpfile.src 
		$(RM) tmpfile.src

OBJECTS		+= tmpnam.obj
tmpnam.obj   	: $(SRC)tmpnam.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tmpnam.c
		$(AS)  -DMODEL=a  --require-end tmpnam.src 
		$(RM) tmpnam.src

OBJECTS		+= fclose.obj
fclose.obj   	: $(SRC)fclose.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fclose.c
		$(AS)  -DMODEL=a  --require-end fclose.src 
		$(RM) fclose.src

OBJECTS		+= fflush.obj
fflush.obj   	: $(SRC)fflush.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fflush.c
		$(AS)  -DMODEL=a  --require-end fflush.src 
		$(RM) fflush.src

OBJECTS		+= fopen.obj
fopen.obj   	: $(SRC)fopen.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fopen.c
		$(AS)  -DMODEL=a  --require-end fopen.src 
		$(RM) fopen.src

OBJECTS		+= freopen.obj
freopen.obj   	: $(SRC)freopen.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)freopen.c
		$(AS)  -DMODEL=a  --require-end freopen.src 
		$(RM) freopen.src

OBJECTS		+= setbuf.obj
setbuf.obj   	: $(SRC)setbuf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)setbuf.c
		$(AS)  -DMODEL=a  --require-end setbuf.src 
		$(RM) setbuf.src

OBJECTS		+= setvbuf.obj
setvbuf.obj   	: $(SRC)setvbuf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)setvbuf.c
		$(AS)  -DMODEL=a  --require-end setvbuf.src 
		$(RM) setvbuf.src

OBJECTS		+= fprintf.obj
fprintf.obj   	: $(SRC)fprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fprintf.c
		$(AS)  -DMODEL=a  --require-end fprintf.src 
		$(RM) fprintf.src

OBJECTS		+= vfprintf.obj
vfprintf.obj   	: $(SRC)vfprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vfprintf.c
		$(AS)  -DMODEL=a  --require-end vfprintf.src 
		$(RM) vfprintf.src

OBJECTS		+= printf.obj
printf.obj   	: $(SRC)printf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)printf.c
		$(AS)  -DMODEL=a  --require-end printf.src 
		$(RM) printf.src

OBJECTS		+= vprintf.obj
vprintf.obj   	: $(SRC)vprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vprintf.c
		$(AS)  -DMODEL=a  --require-end vprintf.src 
		$(RM) vprintf.src

OBJECTS		+= sprintf.obj
sprintf.obj   	: $(SRC)sprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sprintf.c
		$(AS)  -DMODEL=a  --require-end sprintf.src 
		$(RM) sprintf.src

OBJECTS		+= vsprintf.obj
vsprintf.obj   	: $(SRC)vsprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vsprintf.c
		$(AS)  -DMODEL=a  --require-end vsprintf.src 
		$(RM) vsprintf.src

OBJECTS		+= fscanf.obj
fscanf.obj   	: $(SRC)fscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fscanf.c
		$(AS)  -DMODEL=a  --require-end fscanf.src 
		$(RM) fscanf.src

OBJECTS		+= scanf.obj
scanf.obj   	: $(SRC)scanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scanf.c
		$(AS)  -DMODEL=a  --require-end scanf.src 
		$(RM) scanf.src

OBJECTS		+= sscanf.obj
sscanf.obj   	: $(SRC)sscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sscanf.c
		$(AS)  -DMODEL=a  --require-end sscanf.src 
		$(RM) sscanf.src

OBJECTS		+= fgetc.obj
fgetc.obj   	: $(SRC)fgetc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fgetc.c
		$(AS)  -DMODEL=a  --require-end fgetc.src 
		$(RM) fgetc.src

OBJECTS		+= fgets.obj
fgets.obj   	: $(SRC)fgets.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fgets.c
		$(AS)  -DMODEL=a  --require-end fgets.src 
		$(RM) fgets.src

OBJECTS		+= fputc.obj
fputc.obj   	: $(SRC)fputc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fputc.c
		$(AS)  -DMODEL=a  --require-end fputc.src 
		$(RM) fputc.src

OBJECTS		+= fputs.obj
fputs.obj   	: $(SRC)fputs.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fputs.c
		$(AS)  -DMODEL=a  --require-end fputs.src 
		$(RM) fputs.src

OBJECTS		+= getc.obj
getc.obj   	: $(SRC)getc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)getc.c
		$(AS)  -DMODEL=a  --require-end getc.src 
		$(RM) getc.src

OBJECTS		+= gets.obj
gets.obj   	: $(SRC)gets.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)gets.c
		$(AS)  -DMODEL=a  --require-end gets.src 
		$(RM) gets.src

OBJECTS		+= getchar.obj
getchar.obj   	: $(SRC)getchar.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)getchar.c
		$(AS)  -DMODEL=a  --require-end getchar.src 
		$(RM) getchar.src

OBJECTS		+= putc.obj
putc.obj   	: $(SRC)putc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)putc.c
		$(AS)  -DMODEL=a  --require-end putc.src 
		$(RM) putc.src

OBJECTS		+= puts.obj
puts.obj   	: $(SRC)puts.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)puts.c
		$(AS)  -DMODEL=a  --require-end puts.src 
		$(RM) puts.src

OBJECTS		+= putchar.obj
putchar.obj   	: $(SRC)putchar.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)putchar.c
		$(AS)  -DMODEL=a  --require-end putchar.src 
		$(RM) putchar.src

OBJECTS		+= ungetc.obj
ungetc.obj   	: $(SRC)ungetc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ungetc.c
		$(AS)  -DMODEL=a  --require-end ungetc.src 
		$(RM) ungetc.src

OBJECTS		+= fread.obj
fread.obj   	: $(SRC)fread.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fread.c
		$(AS)  -DMODEL=a  --require-end fread.src 
		$(RM) fread.src

OBJECTS		+= fwrite.obj
fwrite.obj   	: $(SRC)fwrite.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fwrite.c
		$(AS)  -DMODEL=a  --require-end fwrite.src 
		$(RM) fwrite.src

OBJECTS		+= fgetpos.obj
fgetpos.obj   	: $(SRC)fgetpos.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fgetpos.c
		$(AS)  -DMODEL=a  --require-end fgetpos.src 
		$(RM) fgetpos.src

OBJECTS		+= fsetpos.obj
fsetpos.obj   	: $(SRC)fsetpos.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fsetpos.c
		$(AS)  -DMODEL=a  --require-end fsetpos.src 
		$(RM) fsetpos.src

OBJECTS		+= fseek.obj
fseek.obj   	: $(SRC)fseek.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fseek.c
		$(AS)  -DMODEL=a  --require-end fseek.src 
		$(RM) fseek.src

OBJECTS		+= ftell.obj
ftell.obj   	: $(SRC)ftell.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ftell.c
		$(AS)  -DMODEL=a  --require-end ftell.src 
		$(RM) ftell.src

OBJECTS		+= rewind.obj
rewind.obj   	: $(SRC)rewind.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)rewind.c
		$(AS)  -DMODEL=a  --require-end rewind.src 
		$(RM) rewind.src

OBJECTS		+= clearerr.obj
clearerr.obj   	: $(SRC)clearerr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)clearerr.c
		$(AS)  -DMODEL=a  --require-end clearerr.src 
		$(RM) clearerr.src

OBJECTS		+= feof.obj
feof.obj   	: $(SRC)feof.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)feof.c
		$(AS)  -DMODEL=a  --require-end feof.src 
		$(RM) feof.src

OBJECTS		+= ferror.obj
ferror.obj   	: $(SRC)ferror.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ferror.c
		$(AS)  -DMODEL=a  --require-end ferror.src 
		$(RM) ferror.src

OBJECTS		+= perror.obj
perror.obj   	: $(SRC)perror.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)perror.c
		$(AS)  -DMODEL=a  --require-end perror.src 
		$(RM) perror.src

OBJECTS		+= _doprint.obj
_doprint.obj   	: $(SRC)_doprint.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doprint.c
		$(AS)  -DMODEL=a  --require-end _doprint.src 
		$(RM) _doprint.src

OBJECTS		+= _doflt.obj
_doflt.obj   	: $(SRC)_doflt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doflt.c
		$(AS)  -DMODEL=a  --require-end _doflt.src 
		$(RM) _doflt.src

OBJECTS		+= _doscan.obj
_doscan.obj   	: $(SRC)_doscan.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_doscan.c
		$(AS)  -DMODEL=a  --require-end _doscan.src 
		$(RM) _doscan.src

OBJECTS		+= _getflt.obj
_getflt.obj   	: $(SRC)_getflt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_getflt.c
		$(AS)  -DMODEL=a  --require-end _getflt.src 
		$(RM) _getflt.src

OBJECTS		+= _filbuf.obj
_filbuf.obj   	: $(SRC)_filbuf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_filbuf.c
		$(AS)  -DMODEL=a  --require-end _filbuf.src 
		$(RM) _filbuf.src

OBJECTS		+= _flsbuf.obj
_flsbuf.obj   	: $(SRC)_flsbuf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_flsbuf.c
		$(AS)  -DMODEL=a  --require-end _flsbuf.src 
		$(RM) _flsbuf.src

OBJECTS		+= _iob.obj
_iob.obj   	: $(SRC)_iob.c
		$(CC) -e -DSTDIN_BUF=0 -DSTDOUT_BUF=0 -Ma -x0 -DFSS_MINIMAL   $(SRC)_iob.c
		$(AS)  -DMODEL=a  --require-end _iob.src 
		$(RM) _iob.src

OBJECTS		+= _fopen.obj
_fopen.obj   	: $(SRC)_fopen.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_fopen.c
		$(AS)  -DMODEL=a  --require-end _fopen.src 
		$(RM) _fopen.src

OBJECTS		+= _io_getc.obj
_io_getc.obj   	: $(SRC)_io_getc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_getc.c
		$(AS)  -DMODEL=a  --require-end _io_getc.src 
		$(RM) _io_getc.src

OBJECTS		+= _io_putc.obj
_io_putc.obj   	: $(SRC)_io_putc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_putc.c
		$(AS)  -DMODEL=a  --require-end _io_putc.src 
		$(RM) _io_putc.src

OBJECTS		+= _io_puts.obj
_io_puts.obj   	: $(SRC)_io_puts.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_puts.c
		$(AS)  -DMODEL=a  --require-end _io_puts.src 
		$(RM) _io_puts.src

OBJECTS		+= _io_ungetc.obj
_io_ungetc.obj   	: $(SRC)_io_ungetc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_ungetc.c
		$(AS)  -DMODEL=a  --require-end _io_ungetc.src 
		$(RM) _io_ungetc.src

OBJECTS		+= _io_getwc.obj
_io_getwc.obj   	: $(SRC)_io_getwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_getwc.c
		$(AS)  -DMODEL=a  --require-end _io_getwc.src 
		$(RM) _io_getwc.src

OBJECTS		+= _io_putwc.obj
_io_putwc.obj   	: $(SRC)_io_putwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_putwc.c
		$(AS)  -DMODEL=a  --require-end _io_putwc.src 
		$(RM) _io_putwc.src

OBJECTS		+= _io_putws.obj
_io_putws.obj   	: $(SRC)_io_putws.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_putws.c
		$(AS)  -DMODEL=a  --require-end _io_putws.src 
		$(RM) _io_putws.src

OBJECTS		+= _io_ungetwc.obj
_io_ungetwc.obj   	: $(SRC)_io_ungetwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_io_ungetwc.c
		$(AS)  -DMODEL=a  --require-end _io_ungetwc.src 
		$(RM) _io_ungetwc.src

OBJECTS		+= atoi.obj
atoi.obj   	: $(SRC)atoi.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atoi.c
		$(AS)  -DMODEL=a  --require-end atoi.src 
		$(RM) atoi.src

OBJECTS		+= atol.obj
atol.obj   	: $(SRC)atol.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atol.c
		$(AS)  -DMODEL=a  --require-end atol.src 
		$(RM) atol.src

OBJECTS		+= atof.obj
atof.obj   	: $(SRC)atof.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atof.c
		$(AS)  -DMODEL=a  --require-end atof.src 
		$(RM) atof.src

OBJECTS		+= strtol.obj
strtol.obj   	: $(SRC)strtol.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtol.c
		$(AS)  -DMODEL=a  --require-end strtol.src 
		$(RM) strtol.src

OBJECTS		+= strtoul.obj
strtoul.obj   	: $(SRC)strtoul.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtoul.c
		$(AS)  -DMODEL=a  --require-end strtoul.src 
		$(RM) strtoul.src

OBJECTS		+= strtod.obj
strtod.obj   	: $(SRC)strtod.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtod.c
		$(AS)  -DMODEL=a  --require-end strtod.src 
		$(RM) strtod.src

OBJECTS		+= rand.obj
rand.obj   	: $(SRC)rand.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)rand.c
		$(AS)  -DMODEL=a  --require-end rand.src 
		$(RM) rand.src

OBJECTS		+= atexit.obj
atexit.obj   	: $(SRC)atexit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atexit.c
		$(AS)  -DMODEL=a  --require-end atexit.src 
		$(RM) atexit.src

OBJECTS		+= exit.obj
exit.obj   	: $(SRC)exit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)exit.c
		$(AS)  -DMODEL=a  --require-end exit.src 
		$(RM) exit.src

OBJECTS		+= abort.obj
abort.obj   	: $(SRC)abort.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)abort.c
		$(AS)  -DMODEL=a  --require-end abort.src 
		$(RM) abort.src

OBJECTS		+= getenv.obj
getenv.obj   	: $(SRC)getenv.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)getenv.c
		$(AS)  -DMODEL=a  --require-end getenv.src 
		$(RM) getenv.src

OBJECTS		+= system.obj
system.obj   	: $(SRC)system.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)system.c
		$(AS)  -DMODEL=a  --require-end system.src 
		$(RM) system.src

OBJECTS		+= qsort.obj
qsort.obj   	: $(SRC)qsort.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)qsort.c
		$(AS)  -DMODEL=a  --require-end qsort.src 
		$(RM) qsort.src

OBJECTS		+= bsearch.obj
bsearch.obj   	: $(SRC)bsearch.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)bsearch.c
		$(AS)  -DMODEL=a  --require-end bsearch.src 
		$(RM) bsearch.src

OBJECTS		+= abs.obj
abs.obj   	: $(SRC)abs.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)abs.c
		$(AS)  -DMODEL=a  --require-end abs.src 
		$(RM) abs.src

OBJECTS		+= labs.obj
labs.obj   	: $(SRC)labs.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)labs.c
		$(AS)  -DMODEL=a  --require-end labs.src 
		$(RM) labs.src

OBJECTS		+= div.obj
div.obj   	: $(SRC)div.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)div.c
		$(AS)  -DMODEL=a  --require-end div.src 
		$(RM) div.src

OBJECTS		+= ldiv.obj
ldiv.obj   	: $(SRC)ldiv.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ldiv.c
		$(AS)  -DMODEL=a  --require-end ldiv.src 
		$(RM) ldiv.src

OBJECTS		+= _mbchar.obj
_mbchar.obj   	: $(SRC)_mbchar.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_mbchar.c
		$(AS)  -DMODEL=a  --require-end _mbchar.src 
		$(RM) _mbchar.src

OBJECTS		+= _strtod.obj
_strtod.obj   	: $(SRC)_strtod.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_strtod.c
		$(AS)  -DMODEL=a  --require-end _strtod.src 
		$(RM) _strtod.src

OBJECTS		+= atoll.obj
atoll.obj   	: $(SRC)atoll.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atoll.c
		$(AS)  -DMODEL=a  --require-end atoll.src 
		$(RM) atoll.src

OBJECTS		+= strtof.obj
strtof.obj   	: $(SRC)strtof.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtof.c
		$(AS)  -DMODEL=a  --require-end strtof.src 
		$(RM) strtof.src

OBJECTS		+= strtold.obj
strtold.obj   	: $(SRC)strtold.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtold.c
		$(AS)  -DMODEL=a  --require-end strtold.src 
		$(RM) strtold.src

OBJECTS		+= strtoll.obj
strtoll.obj   	: $(SRC)strtoll.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtoll.c
		$(AS)  -DMODEL=a  --require-end strtoll.src 
		$(RM) strtoll.src

OBJECTS		+= strtoull.obj
strtoull.obj   	: $(SRC)strtoull.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtoull.c
		$(AS)  -DMODEL=a  --require-end strtoull.src 
		$(RM) strtoull.src

OBJECTS		+= llabs.obj
llabs.obj   	: $(SRC)llabs.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)llabs.c
		$(AS)  -DMODEL=a  --require-end llabs.src 
		$(RM) llabs.src

OBJECTS		+= lldiv.obj
lldiv.obj   	: $(SRC)lldiv.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)lldiv.c
		$(AS)  -DMODEL=a  --require-end lldiv.src 
		$(RM) lldiv.src

OBJECTS		+= iswalpha.obj
iswalpha.obj   	: $(SRC)iswalpha.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswalpha.c
		$(AS)  -DMODEL=a  --require-end iswalpha.src 
		$(RM) iswalpha.src

OBJECTS		+= iswalnum.obj
iswalnum.obj   	: $(SRC)iswalnum.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswalnum.c
		$(AS)  -DMODEL=a  --require-end iswalnum.src 
		$(RM) iswalnum.src

OBJECTS		+= iswctype.obj
iswctype.obj   	: $(SRC)iswctype.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswctype.c
		$(AS)  -DMODEL=a  --require-end iswctype.src 
		$(RM) iswctype.src

OBJECTS		+= iswupper.obj
iswupper.obj   	: $(SRC)iswupper.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswupper.c
		$(AS)  -DMODEL=a  --require-end iswupper.src 
		$(RM) iswupper.src

OBJECTS		+= iswlower.obj
iswlower.obj   	: $(SRC)iswlower.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswlower.c
		$(AS)  -DMODEL=a  --require-end iswlower.src 
		$(RM) iswlower.src

OBJECTS		+= iswdigit.obj
iswdigit.obj   	: $(SRC)iswdigit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswdigit.c
		$(AS)  -DMODEL=a  --require-end iswdigit.src 
		$(RM) iswdigit.src

OBJECTS		+= iswxdigi.obj
iswxdigi.obj   	: $(SRC)iswxdigi.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswxdigi.c
		$(AS)  -DMODEL=a  --require-end iswxdigi.src 
		$(RM) iswxdigi.src

OBJECTS		+= iswspace.obj
iswspace.obj   	: $(SRC)iswspace.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswspace.c
		$(AS)  -DMODEL=a  --require-end iswspace.src 
		$(RM) iswspace.src

OBJECTS		+= iswpunct.obj
iswpunct.obj   	: $(SRC)iswpunct.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswpunct.c
		$(AS)  -DMODEL=a  --require-end iswpunct.src 
		$(RM) iswpunct.src

OBJECTS		+= iswcntrl.obj
iswcntrl.obj   	: $(SRC)iswcntrl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswcntrl.c
		$(AS)  -DMODEL=a  --require-end iswcntrl.src 
		$(RM) iswcntrl.src

OBJECTS		+= iswprint.obj
iswprint.obj   	: $(SRC)iswprint.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswprint.c
		$(AS)  -DMODEL=a  --require-end iswprint.src 
		$(RM) iswprint.src

OBJECTS		+= iswgraph.obj
iswgraph.obj   	: $(SRC)iswgraph.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswgraph.c
		$(AS)  -DMODEL=a  --require-end iswgraph.src 
		$(RM) iswgraph.src

OBJECTS		+= towupper.obj
towupper.obj   	: $(SRC)towupper.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)towupper.c
		$(AS)  -DMODEL=a  --require-end towupper.src 
		$(RM) towupper.src

OBJECTS		+= towlower.obj
towlower.obj   	: $(SRC)towlower.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)towlower.c
		$(AS)  -DMODEL=a  --require-end towlower.src 
		$(RM) towlower.src

OBJECTS		+= towctran.obj
towctran.obj   	: $(SRC)towctran.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)towctran.c
		$(AS)  -DMODEL=a  --require-end towctran.src 
		$(RM) towctran.src

OBJECTS		+= wctype.obj
wctype.obj   	: $(SRC)wctype.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wctype.c
		$(AS)  -DMODEL=a  --require-end wctype.src 
		$(RM) wctype.src

OBJECTS		+= wctrans.obj
wctrans.obj   	: $(SRC)wctrans.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wctrans.c
		$(AS)  -DMODEL=a  --require-end wctrans.src 
		$(RM) wctrans.src

OBJECTS		+= iswblank.obj
iswblank.obj   	: $(SRC)iswblank.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)iswblank.c
		$(AS)  -DMODEL=a  --require-end iswblank.src 
		$(RM) iswblank.src

OBJECTS		+= fwprintf.obj
fwprintf.obj   	: $(SRC)fwprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fwprintf.c
		$(AS)  -DMODEL=a  --require-end fwprintf.src 
		$(RM) fwprintf.src

OBJECTS		+= vfwprint.obj
vfwprint.obj   	: $(SRC)vfwprint.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vfwprint.c
		$(AS)  -DMODEL=a  --require-end vfwprint.src 
		$(RM) vfwprint.src

OBJECTS		+= wprintf.obj
wprintf.obj   	: $(SRC)wprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wprintf.c
		$(AS)  -DMODEL=a  --require-end wprintf.src 
		$(RM) wprintf.src

OBJECTS		+= vwprintf.obj
vwprintf.obj   	: $(SRC)vwprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vwprintf.c
		$(AS)  -DMODEL=a  --require-end vwprintf.src 
		$(RM) vwprintf.src

OBJECTS		+= swprintf.obj
swprintf.obj   	: $(SRC)swprintf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)swprintf.c
		$(AS)  -DMODEL=a  --require-end swprintf.src 
		$(RM) swprintf.src

OBJECTS		+= vswprint.obj
vswprint.obj   	: $(SRC)vswprint.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vswprint.c
		$(AS)  -DMODEL=a  --require-end vswprint.src 
		$(RM) vswprint.src

OBJECTS		+= fwscanf.obj
fwscanf.obj   	: $(SRC)fwscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fwscanf.c
		$(AS)  -DMODEL=a  --require-end fwscanf.src 
		$(RM) fwscanf.src

OBJECTS		+= wscanf.obj
wscanf.obj   	: $(SRC)wscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wscanf.c
		$(AS)  -DMODEL=a  --require-end wscanf.src 
		$(RM) wscanf.src

OBJECTS		+= swscanf.obj
swscanf.obj   	: $(SRC)swscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)swscanf.c
		$(AS)  -DMODEL=a  --require-end swscanf.src 
		$(RM) swscanf.src

OBJECTS		+= fgetwc.obj
fgetwc.obj   	: $(SRC)fgetwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fgetwc.c
		$(AS)  -DMODEL=a  --require-end fgetwc.src 
		$(RM) fgetwc.src

OBJECTS		+= fgetws.obj
fgetws.obj   	: $(SRC)fgetws.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fgetws.c
		$(AS)  -DMODEL=a  --require-end fgetws.src 
		$(RM) fgetws.src

OBJECTS		+= fputwc.obj
fputwc.obj   	: $(SRC)fputwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fputwc.c
		$(AS)  -DMODEL=a  --require-end fputwc.src 
		$(RM) fputwc.src

OBJECTS		+= fputws.obj
fputws.obj   	: $(SRC)fputws.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fputws.c
		$(AS)  -DMODEL=a  --require-end fputws.src 
		$(RM) fputws.src

OBJECTS		+= getwc.obj
getwc.obj   	: $(SRC)getwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)getwc.c
		$(AS)  -DMODEL=a  --require-end getwc.src 
		$(RM) getwc.src

OBJECTS		+= getwchar.obj
getwchar.obj   	: $(SRC)getwchar.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)getwchar.c
		$(AS)  -DMODEL=a  --require-end getwchar.src 
		$(RM) getwchar.src

OBJECTS		+= putwc.obj
putwc.obj   	: $(SRC)putwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)putwc.c
		$(AS)  -DMODEL=a  --require-end putwc.src 
		$(RM) putwc.src

OBJECTS		+= putwchar.obj
putwchar.obj   	: $(SRC)putwchar.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)putwchar.c
		$(AS)  -DMODEL=a  --require-end putwchar.src 
		$(RM) putwchar.src

OBJECTS		+= ungetwc.obj
ungetwc.obj   	: $(SRC)ungetwc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ungetwc.c
		$(AS)  -DMODEL=a  --require-end ungetwc.src 
		$(RM) ungetwc.src

OBJECTS		+= wcstod.obj
wcstod.obj   	: $(SRC)wcstod.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstod.c
		$(AS)  -DMODEL=a  --require-end wcstod.src 
		$(RM) wcstod.src

OBJECTS		+= wcstol.obj
wcstol.obj   	: $(SRC)wcstol.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstol.c
		$(AS)  -DMODEL=a  --require-end wcstol.src 
		$(RM) wcstol.src

OBJECTS		+= wcstoul.obj
wcstoul.obj   	: $(SRC)wcstoul.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstoul.c
		$(AS)  -DMODEL=a  --require-end wcstoul.src 
		$(RM) wcstoul.src

OBJECTS		+= wcscpy.obj
wcscpy.obj   	: $(SRC)wcscpy.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcscpy.c
		$(AS)  -DMODEL=a  --require-end wcscpy.src 
		$(RM) wcscpy.src

OBJECTS		+= wcsncpy.obj
wcsncpy.obj   	: $(SRC)wcsncpy.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsncpy.c
		$(AS)  -DMODEL=a  --require-end wcsncpy.src 
		$(RM) wcsncpy.src

OBJECTS		+= wcscat.obj
wcscat.obj   	: $(SRC)wcscat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcscat.c
		$(AS)  -DMODEL=a  --require-end wcscat.src 
		$(RM) wcscat.src

OBJECTS		+= wcsncat.obj
wcsncat.obj   	: $(SRC)wcsncat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsncat.c
		$(AS)  -DMODEL=a  --require-end wcsncat.src 
		$(RM) wcsncat.src

OBJECTS		+= wcscmp.obj
wcscmp.obj   	: $(SRC)wcscmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcscmp.c
		$(AS)  -DMODEL=a  --require-end wcscmp.src 
		$(RM) wcscmp.src

OBJECTS		+= wcsncmp.obj
wcsncmp.obj   	: $(SRC)wcsncmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsncmp.c
		$(AS)  -DMODEL=a  --require-end wcsncmp.src 
		$(RM) wcsncmp.src

OBJECTS		+= wcscoll.obj
wcscoll.obj   	: $(SRC)wcscoll.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcscoll.c
		$(AS)  -DMODEL=a  --require-end wcscoll.src 
		$(RM) wcscoll.src

OBJECTS		+= wcsxrfm.obj
wcsxrfm.obj   	: $(SRC)wcsxrfm.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsxrfm.c
		$(AS)  -DMODEL=a  --require-end wcsxrfm.src 
		$(RM) wcsxrfm.src

OBJECTS		+= wcschr.obj
wcschr.obj   	: $(SRC)wcschr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcschr.c
		$(AS)  -DMODEL=a  --require-end wcschr.src 
		$(RM) wcschr.src

OBJECTS		+= wcsrchr.obj
wcsrchr.obj   	: $(SRC)wcsrchr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsrchr.c
		$(AS)  -DMODEL=a  --require-end wcsrchr.src 
		$(RM) wcsrchr.src

OBJECTS		+= wcscspn.obj
wcscspn.obj   	: $(SRC)wcscspn.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcscspn.c
		$(AS)  -DMODEL=a  --require-end wcscspn.src 
		$(RM) wcscspn.src

OBJECTS		+= wcspbrk.obj
wcspbrk.obj   	: $(SRC)wcspbrk.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcspbrk.c
		$(AS)  -DMODEL=a  --require-end wcspbrk.src 
		$(RM) wcspbrk.src

OBJECTS		+= wcsspn.obj
wcsspn.obj   	: $(SRC)wcsspn.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsspn.c
		$(AS)  -DMODEL=a  --require-end wcsspn.src 
		$(RM) wcsspn.src

OBJECTS		+= wcsstr.obj
wcsstr.obj   	: $(SRC)wcsstr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsstr.c
		$(AS)  -DMODEL=a  --require-end wcsstr.src 
		$(RM) wcsstr.src

OBJECTS		+= wcstok.obj
wcstok.obj   	: $(SRC)wcstok.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstok.c
		$(AS)  -DMODEL=a  --require-end wcstok.src 
		$(RM) wcstok.src

OBJECTS		+= wcslen.obj
wcslen.obj   	: $(SRC)wcslen.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcslen.c
		$(AS)  -DMODEL=a  --require-end wcslen.src 
		$(RM) wcslen.src

OBJECTS		+= wmemchr.obj
wmemchr.obj   	: $(SRC)wmemchr.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wmemchr.c
		$(AS)  -DMODEL=a  --require-end wmemchr.src 
		$(RM) wmemchr.src

OBJECTS		+= wmemcmp.obj
wmemcmp.obj   	: $(SRC)wmemcmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wmemcmp.c
		$(AS)  -DMODEL=a  --require-end wmemcmp.src 
		$(RM) wmemcmp.src

OBJECTS		+= wmemcpy.obj
wmemcpy.obj   	: $(SRC)wmemcpy.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wmemcpy.c
		$(AS)  -DMODEL=a  --require-end wmemcpy.src 
		$(RM) wmemcpy.src

OBJECTS		+= wmemmov.obj
wmemmov.obj   	: $(SRC)wmemmov.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wmemmov.c
		$(AS)  -DMODEL=a  --require-end wmemmov.src 
		$(RM) wmemmov.src

OBJECTS		+= wmemset.obj
wmemset.obj   	: $(SRC)wmemset.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wmemset.c
		$(AS)  -DMODEL=a  --require-end wmemset.src 
		$(RM) wmemset.src

OBJECTS		+= wcsftime.obj
wcsftime.obj   	: $(SRC)wcsftime.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsftime.c
		$(AS)  -DMODEL=a  --require-end wcsftime.src 
		$(RM) wcsftime.src

OBJECTS		+= btowc.obj
btowc.obj   	: $(SRC)btowc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)btowc.c
		$(AS)  -DMODEL=a  --require-end btowc.src 
		$(RM) btowc.src

OBJECTS		+= wctob.obj
wctob.obj   	: $(SRC)wctob.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wctob.c
		$(AS)  -DMODEL=a  --require-end wctob.src 
		$(RM) wctob.src

OBJECTS		+= mbsinit.obj
mbsinit.obj   	: $(SRC)mbsinit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)mbsinit.c
		$(AS)  -DMODEL=a  --require-end mbsinit.src 
		$(RM) mbsinit.src

OBJECTS		+= mbrlen.obj
mbrlen.obj   	: $(SRC)mbrlen.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)mbrlen.c
		$(AS)  -DMODEL=a  --require-end mbrlen.src 
		$(RM) mbrlen.src

OBJECTS		+= mbrtowc.obj
mbrtowc.obj   	: $(SRC)mbrtowc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)mbrtowc.c
		$(AS)  -DMODEL=a  --require-end mbrtowc.src 
		$(RM) mbrtowc.src

OBJECTS		+= wcrtomb.obj
wcrtomb.obj   	: $(SRC)wcrtomb.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcrtomb.c
		$(AS)  -DMODEL=a  --require-end wcrtomb.src 
		$(RM) wcrtomb.src

OBJECTS		+= mbsrtowc.obj
mbsrtowc.obj   	: $(SRC)mbsrtowc.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)mbsrtowc.c
		$(AS)  -DMODEL=a  --require-end mbsrtowc.src 
		$(RM) mbsrtowc.src

OBJECTS		+= wcsrtomb.obj
wcsrtomb.obj   	: $(SRC)wcsrtomb.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcsrtomb.c
		$(AS)  -DMODEL=a  --require-end wcsrtomb.src 
		$(RM) wcsrtomb.src

OBJECTS		+= fwide.obj
fwide.obj   	: $(SRC)fwide.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fwide.c
		$(AS)  -DMODEL=a  --require-end fwide.src 
		$(RM) fwide.src

OBJECTS		+= _dowprin.obj
_dowprin.obj   	: $(SRC)_dowprin.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowprin.c
		$(AS)  -DMODEL=a  --require-end _dowprin.src 
		$(RM) _dowprin.src

OBJECTS		+= _dowflt.obj
_dowflt.obj   	: $(SRC)_dowflt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowflt.c
		$(AS)  -DMODEL=a  --require-end _dowflt.src 
		$(RM) _dowflt.src

OBJECTS		+= _dowscan.obj
_dowscan.obj   	: $(SRC)_dowscan.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_dowscan.c
		$(AS)  -DMODEL=a  --require-end _dowscan.src 
		$(RM) _dowscan.src

OBJECTS		+= _getwflt.obj
_getwflt.obj   	: $(SRC)_getwflt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_getwflt.c
		$(AS)  -DMODEL=a  --require-end _getwflt.src 
		$(RM) _getwflt.src

OBJECTS		+= _wflsbuf.obj
_wflsbuf.obj   	: $(SRC)_wflsbuf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_wflsbuf.c
		$(AS)  -DMODEL=a  --require-end _wflsbuf.src 
		$(RM) _wflsbuf.src

OBJECTS		+= _wfilbuf.obj
_wfilbuf.obj   	: $(SRC)_wfilbuf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_wfilbuf.c
		$(AS)  -DMODEL=a  --require-end _wfilbuf.src 
		$(RM) _wfilbuf.src

OBJECTS		+= _wcstod.obj
_wcstod.obj   	: $(SRC)_wcstod.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_wcstod.c
		$(AS)  -DMODEL=a  --require-end _wcstod.src 
		$(RM) _wcstod.src

OBJECTS		+= _wcsccmp.obj
_wcsccmp.obj   	: $(SRC)_wcsccmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_wcsccmp.c
		$(AS)  -DMODEL=a  --require-end _wcsccmp.src 
		$(RM) _wcsccmp.src

OBJECTS		+= _wcsnccmp.obj
_wcsnccmp.obj   	: $(SRC)_wcsnccmp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_wcsnccmp.c
		$(AS)  -DMODEL=a  --require-end _wcsnccmp.src 
		$(RM) _wcsnccmp.src

OBJECTS		+= vfwscanf.obj
vfwscanf.obj   	: $(SRC)vfwscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vfwscanf.c
		$(AS)  -DMODEL=a  --require-end vfwscanf.src 
		$(RM) vfwscanf.src

OBJECTS		+= vwscanf.obj
vwscanf.obj   	: $(SRC)vwscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vwscanf.c
		$(AS)  -DMODEL=a  --require-end vwscanf.src 
		$(RM) vwscanf.src

OBJECTS		+= vswscanf.obj
vswscanf.obj   	: $(SRC)vswscanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)vswscanf.c
		$(AS)  -DMODEL=a  --require-end vswscanf.src 
		$(RM) vswscanf.src

OBJECTS		+= wcstof.obj
wcstof.obj   	: $(SRC)wcstof.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstof.c
		$(AS)  -DMODEL=a  --require-end wcstof.src 
		$(RM) wcstof.src

OBJECTS		+= wcstold.obj
wcstold.obj   	: $(SRC)wcstold.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstold.c
		$(AS)  -DMODEL=a  --require-end wcstold.src 
		$(RM) wcstold.src

OBJECTS		+= wcstoll.obj
wcstoll.obj   	: $(SRC)wcstoll.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstoll.c
		$(AS)  -DMODEL=a  --require-end wcstoll.src 
		$(RM) wcstoll.src

OBJECTS		+= wcstoull.obj
wcstoull.obj   	: $(SRC)wcstoull.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstoull.c
		$(AS)  -DMODEL=a  --require-end wcstoull.src 
		$(RM) wcstoull.src

OBJECTS		+= imaxabs.obj
imaxabs.obj   	: $(SRC)imaxabs.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)imaxabs.c
		$(AS)  -DMODEL=a  --require-end imaxabs.src 
		$(RM) imaxabs.src

OBJECTS		+= imaxdiv.obj
imaxdiv.obj   	: $(SRC)imaxdiv.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)imaxdiv.c
		$(AS)  -DMODEL=a  --require-end imaxdiv.src 
		$(RM) imaxdiv.src

OBJECTS		+= strtoimax.obj
strtoimax.obj   	: $(SRC)strtoimax.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtoimax.c
		$(AS)  -DMODEL=a  --require-end strtoimax.src 
		$(RM) strtoimax.src

OBJECTS		+= strtoumax.obj
strtoumax.obj   	: $(SRC)strtoumax.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)strtoumax.c
		$(AS)  -DMODEL=a  --require-end strtoumax.src 
		$(RM) strtoumax.src

OBJECTS		+= wcstoimax.obj
wcstoimax.obj   	: $(SRC)wcstoimax.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstoimax.c
		$(AS)  -DMODEL=a  --require-end wcstoimax.src 
		$(RM) wcstoimax.src

OBJECTS		+= wcstoumax.obj
wcstoumax.obj   	: $(SRC)wcstoumax.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)wcstoumax.c
		$(AS)  -DMODEL=a  --require-end wcstoumax.src 
		$(RM) wcstoumax.src

OBJECTS		+= fss.obj
fss.obj   	: $(SRC)fss.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL -R=-f -g  $(SRC)fss.c
		$(AS)  -DMODEL=a  --require-end fss.src 
		$(RM) fss.src

OBJECTS		+= fss_init.obj
fss_init.obj   	: $(SRC)fss_init.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_init.c
		$(AS)  -DMODEL=a  --require-end fss_init.src 
		$(RM) fss_init.src

OBJECTS		+= fss_open.obj
fss_open.obj   	: $(SRC)fss_open.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_open.c
		$(AS)  -DMODEL=a  --require-end fss_open.src 
		$(RM) fss_open.src

OBJECTS		+= fss__open.obj
fss__open.obj   	: $(SRC)fss__open.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss__open.c
		$(AS)  -DMODEL=a  --require-end fss__open.src 
		$(RM) fss__open.src

OBJECTS		+= fss_read.obj
fss_read.obj   	: $(SRC)fss_read.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_read.c
		$(AS)  -DMODEL=a  --require-end fss_read.src 
		$(RM) fss_read.src

OBJECTS		+= fss__read.obj
fss__read.obj   	: $(SRC)fss__read.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss__read.c
		$(AS)  -DMODEL=a  --require-end fss__read.src 
		$(RM) fss__read.src

OBJECTS		+= fss_write.obj
fss_write.obj   	: $(SRC)fss_write.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_write.c
		$(AS)  -DMODEL=a  --require-end fss_write.src 
		$(RM) fss_write.src

OBJECTS		+= fss__write.obj
fss__write.obj   	: $(SRC)fss__write.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss__write.c
		$(AS)  -DMODEL=a  --require-end fss__write.src 
		$(RM) fss__write.src

OBJECTS		+= fss_close.obj
fss_close.obj   	: $(SRC)fss_close.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_close.c
		$(AS)  -DMODEL=a  --require-end fss_close.src 
		$(RM) fss_close.src

OBJECTS		+= fss__close.obj
fss__close.obj   	: $(SRC)fss__close.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss__close.c
		$(AS)  -DMODEL=a  --require-end fss__close.src 
		$(RM) fss__close.src

OBJECTS		+= fss_lseek.obj
fss_lseek.obj   	: $(SRC)fss_lseek.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_lseek.c
		$(AS)  -DMODEL=a  --require-end fss_lseek.src 
		$(RM) fss_lseek.src

OBJECTS		+= fss__lseek.obj
fss__lseek.obj   	: $(SRC)fss__lseek.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss__lseek.c
		$(AS)  -DMODEL=a  --require-end fss__lseek.src 
		$(RM) fss__lseek.src

OBJECTS		+= fss_unlink.obj
fss_unlink.obj   	: $(SRC)fss_unlink.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_unlink.c
		$(AS)  -DMODEL=a  --require-end fss_unlink.src 
		$(RM) fss_unlink.src

OBJECTS		+= fss__unlink.obj
fss__unlink.obj   	: $(SRC)fss__unlink.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss__unlink.c
		$(AS)  -DMODEL=a  --require-end fss__unlink.src 
		$(RM) fss__unlink.src

OBJECTS		+= fss_stat.obj
fss_stat.obj   	: $(SRC)fss_stat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_stat.c
		$(AS)  -DMODEL=a  --require-end fss_stat.src 
		$(RM) fss_stat.src

OBJECTS		+= fss_getcwd.obj
fss_getcwd.obj   	: $(SRC)fss_getcwd.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_getcwd.c
		$(AS)  -DMODEL=a  --require-end fss_getcwd.src 
		$(RM) fss_getcwd.src

OBJECTS		+= fss_chdir.obj
fss_chdir.obj   	: $(SRC)fss_chdir.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_chdir.c
		$(AS)  -DMODEL=a  --require-end fss_chdir.src 
		$(RM) fss_chdir.src

OBJECTS		+= fss_access.obj
fss_access.obj   	: $(SRC)fss_access.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_access.c
		$(AS)  -DMODEL=a  --require-end fss_access.src 
		$(RM) fss_access.src

OBJECTS		+= fss_rename.obj
fss_rename.obj   	: $(SRC)fss_rename.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fss_rename.c
		$(AS)  -DMODEL=a  --require-end fss_rename.src 
		$(RM) fss_rename.src

OBJECTS		+= fstat.obj
fstat.obj   	: $(SRC)fstat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fstat.c
		$(AS)  -DMODEL=a  --require-end fstat.src 
		$(RM) fstat.src

OBJECTS		+= lstat.obj
lstat.obj   	: $(SRC)lstat.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)lstat.c
		$(AS)  -DMODEL=a  --require-end lstat.src 
		$(RM) lstat.src

OBJECTS		+= weakstub.obj
weakstub.obj   	: $(SRC)weakstub.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)weakstub.c
		$(AS)  -DMODEL=a  --require-end weakstub.src 
		$(RM) weakstub.src

OBJECTS		+= _Exit.obj
_Exit.obj   	: $(SRC)_Exit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL -R=-f   $(SRC)_Exit.c
		$(AS)  -DMODEL=a  --require-end _Exit.src 
		$(RM) _Exit.src

OBJECTS		+= sqrt.obj
sqrt.obj   	: $(SRC)sqrt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sqrt.c
		$(AS)  -DMODEL=a  --require-end sqrt.src 
		$(RM) sqrt.src

OBJECTS		+= sqrtf.obj
sqrtf.obj   	: $(SRC)sqrtf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sqrtf.c
		$(AS)  -DMODEL=a  --require-end sqrtf.src 
		$(RM) sqrtf.src

OBJECTS		+= _issubnormal.obj
_issubnormal.obj   	: $(SRC)_issubnormal.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_issubnormal.c
		$(AS)  -DMODEL=a  --require-end _issubnormal.src 
		$(RM) _issubnormal.src

OBJECTS		+= _issubnormalf.obj
_issubnormalf.obj   	: $(SRC)_issubnormalf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_issubnormalf.c
		$(AS)  -DMODEL=a  --require-end _issubnormalf.src 
		$(RM) _issubnormalf.src

OBJECTS		+= _signbit.obj
_signbit.obj   	: $(SRC)_signbit.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_signbit.c
		$(AS)  -DMODEL=a  --require-end _signbit.src 
		$(RM) _signbit.src

OBJECTS		+= _signbitf.obj
_signbitf.obj   	: $(SRC)_signbitf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_signbitf.c
		$(AS)  -DMODEL=a  --require-end _signbitf.src 
		$(RM) _signbitf.src

OBJECTS		+= scalbln.obj
scalbln.obj   	: $(SRC)scalbln.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scalbln.c
		$(AS)  -DMODEL=a  --require-end scalbln.src 
		$(RM) scalbln.src

OBJECTS		+= scalblnf.obj
scalblnf.obj   	: $(SRC)scalblnf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scalblnf.c
		$(AS)  -DMODEL=a  --require-end scalblnf.src 
		$(RM) scalblnf.src

OBJECTS		+= isfin.obj
isfin.obj   	: $(SRC)isfin.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isfin.c
		$(AS)  -DMODEL=a  --require-end isfin.src 
		$(RM) isfin.src

OBJECTS		+= scalb.obj
scalb.obj   	: $(SRC)scalb.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scalb.c
		$(AS)  -DMODEL=a  --require-end scalb.src 
		$(RM) scalb.src

OBJECTS		+= isfinf.obj
isfinf.obj   	: $(SRC)isfinf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)isfinf.c
		$(AS)  -DMODEL=a  --require-end isfinf.src 
		$(RM) isfinf.src

OBJECTS		+= scalbf.obj
scalbf.obj   	: $(SRC)scalbf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)scalbf.c
		$(AS)  -DMODEL=a  --require-end scalbf.src 
		$(RM) scalbf.src

OBJECTS		+= _isgtf.obj
_isgtf.obj   	: $(SRC)_isgtf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isgtf.c
		$(AS)  -DMODEL=a  --require-end _isgtf.src 
		$(RM) _isgtf.src

OBJECTS		+= _isgef.obj
_isgef.obj   	: $(SRC)_isgef.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isgef.c
		$(AS)  -DMODEL=a  --require-end _isgef.src 
		$(RM) _isgef.src

OBJECTS		+= _isltf.obj
_isltf.obj   	: $(SRC)_isltf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isltf.c
		$(AS)  -DMODEL=a  --require-end _isltf.src 
		$(RM) _isltf.src

OBJECTS		+= _islef.obj
_islef.obj   	: $(SRC)_islef.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_islef.c
		$(AS)  -DMODEL=a  --require-end _islef.src 
		$(RM) _islef.src

OBJECTS		+= _islgf.obj
_islgf.obj   	: $(SRC)_islgf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_islgf.c
		$(AS)  -DMODEL=a  --require-end _islgf.src 
		$(RM) _islgf.src

OBJECTS		+= _isunorderedf.obj
_isunorderedf.obj   	: $(SRC)_isunorderedf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isunorderedf.c
		$(AS)  -DMODEL=a  --require-end _isunorderedf.src 
		$(RM) _isunorderedf.src

OBJECTS		+= _isnormalf.obj
_isnormalf.obj   	: $(SRC)_isnormalf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isnormalf.c
		$(AS)  -DMODEL=a  --require-end _isnormalf.src 
		$(RM) _isnormalf.src

OBJECTS		+= _fpclassifyf.obj
_fpclassifyf.obj   	: $(SRC)_fpclassifyf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_fpclassifyf.c
		$(AS)  -DMODEL=a  --require-end _fpclassifyf.src 
		$(RM) _fpclassifyf.src

OBJECTS		+= sinf.obj
sinf.obj   	: $(SRC)sinf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sinf.c
		$(AS)  -DMODEL=a  --require-end sinf.src 
		$(RM) sinf.src

OBJECTS		+= asinf.obj
asinf.obj   	: $(SRC)asinf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asinf.c
		$(AS)  -DMODEL=a  --require-end asinf.src 
		$(RM) asinf.src

OBJECTS		+= sinhf.obj
sinhf.obj   	: $(SRC)sinhf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sinhf.c
		$(AS)  -DMODEL=a  --require-end sinhf.src 
		$(RM) sinhf.src

OBJECTS		+= asinhf.obj
asinhf.obj   	: $(SRC)asinhf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asinhf.c
		$(AS)  -DMODEL=a  --require-end asinhf.src 
		$(RM) asinhf.src

OBJECTS		+= cosf.obj
cosf.obj   	: $(SRC)cosf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)cosf.c
		$(AS)  -DMODEL=a  --require-end cosf.src 
		$(RM) cosf.src

OBJECTS		+= acosf.obj
acosf.obj   	: $(SRC)acosf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)acosf.c
		$(AS)  -DMODEL=a  --require-end acosf.src 
		$(RM) acosf.src

OBJECTS		+= coshf.obj
coshf.obj   	: $(SRC)coshf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)coshf.c
		$(AS)  -DMODEL=a  --require-end coshf.src 
		$(RM) coshf.src

OBJECTS		+= acoshf.obj
acoshf.obj   	: $(SRC)acoshf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)acoshf.c
		$(AS)  -DMODEL=a  --require-end acoshf.src 
		$(RM) acoshf.src

OBJECTS		+= tanf.obj
tanf.obj   	: $(SRC)tanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tanf.c
		$(AS)  -DMODEL=a  --require-end tanf.src 
		$(RM) tanf.src

OBJECTS		+= atanf.obj
atanf.obj   	: $(SRC)atanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atanf.c
		$(AS)  -DMODEL=a  --require-end atanf.src 
		$(RM) atanf.src

OBJECTS		+= atan2f.obj
atan2f.obj   	: $(SRC)atan2f.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atan2f.c
		$(AS)  -DMODEL=a  --require-end atan2f.src 
		$(RM) atan2f.src

OBJECTS		+= tanhf.obj
tanhf.obj   	: $(SRC)tanhf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tanhf.c
		$(AS)  -DMODEL=a  --require-end tanhf.src 
		$(RM) tanhf.src

OBJECTS		+= atanhf.obj
atanhf.obj   	: $(SRC)atanhf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atanhf.c
		$(AS)  -DMODEL=a  --require-end atanhf.src 
		$(RM) atanhf.src

OBJECTS		+= expf.obj
expf.obj   	: $(SRC)expf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)expf.c
		$(AS)  -DMODEL=a  --require-end expf.src 
		$(RM) expf.src

OBJECTS		+= logf.obj
logf.obj   	: $(SRC)logf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)logf.c
		$(AS)  -DMODEL=a  --require-end logf.src 
		$(RM) logf.src

OBJECTS		+= log10f.obj
log10f.obj   	: $(SRC)log10f.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)log10f.c
		$(AS)  -DMODEL=a  --require-end log10f.src 
		$(RM) log10f.src

OBJECTS		+= powf.obj
powf.obj   	: $(SRC)powf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)powf.c
		$(AS)  -DMODEL=a  --require-end powf.src 
		$(RM) powf.src

OBJECTS		+= ceilf.obj
ceilf.obj   	: $(SRC)ceilf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ceilf.c
		$(AS)  -DMODEL=a  --require-end ceilf.src 
		$(RM) ceilf.src

OBJECTS		+= floorf.obj
floorf.obj   	: $(SRC)floorf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)floorf.c
		$(AS)  -DMODEL=a  --require-end floorf.src 
		$(RM) floorf.src

OBJECTS		+= fmodf.obj
fmodf.obj   	: $(SRC)fmodf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fmodf.c
		$(AS)  -DMODEL=a  --require-end fmodf.src 
		$(RM) fmodf.src

OBJECTS		+= hypotf.obj
hypotf.obj   	: $(SRC)hypotf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)hypotf.c
		$(AS)  -DMODEL=a  --require-end hypotf.src 
		$(RM) hypotf.src

OBJECTS		+= _sinusf.obj
_sinusf.obj   	: $(SRC)_sinusf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_sinusf.c
		$(AS)  -DMODEL=a  --require-end _sinusf.src 
		$(RM) _sinusf.src

OBJECTS		+= _atanf.obj
_atanf.obj   	: $(SRC)_atanf.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_atanf.c
		$(AS)  -DMODEL=a  --require-end _atanf.src 
		$(RM) _atanf.src

OBJECTS		+= _isgt.obj
_isgt.obj   	: $(SRC)_isgt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isgt.c
		$(AS)  -DMODEL=a  --require-end _isgt.src 
		$(RM) _isgt.src

OBJECTS		+= _isge.obj
_isge.obj   	: $(SRC)_isge.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isge.c
		$(AS)  -DMODEL=a  --require-end _isge.src 
		$(RM) _isge.src

OBJECTS		+= _islt.obj
_islt.obj   	: $(SRC)_islt.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_islt.c
		$(AS)  -DMODEL=a  --require-end _islt.src 
		$(RM) _islt.src

OBJECTS		+= _isle.obj
_isle.obj   	: $(SRC)_isle.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isle.c
		$(AS)  -DMODEL=a  --require-end _isle.src 
		$(RM) _isle.src

OBJECTS		+= _islg.obj
_islg.obj   	: $(SRC)_islg.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_islg.c
		$(AS)  -DMODEL=a  --require-end _islg.src 
		$(RM) _islg.src

OBJECTS		+= _isunordered.obj
_isunordered.obj   	: $(SRC)_isunordered.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isunordered.c
		$(AS)  -DMODEL=a  --require-end _isunordered.src 
		$(RM) _isunordered.src

OBJECTS		+= _isnormal.obj
_isnormal.obj   	: $(SRC)_isnormal.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isnormal.c
		$(AS)  -DMODEL=a  --require-end _isnormal.src 
		$(RM) _isnormal.src

OBJECTS		+= _fpclassify.obj
_fpclassify.obj   	: $(SRC)_fpclassify.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_fpclassify.c
		$(AS)  -DMODEL=a  --require-end _fpclassify.src 
		$(RM) _fpclassify.src

OBJECTS		+= sin.obj
sin.obj   	: $(SRC)sin.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sin.c
		$(AS)  -DMODEL=a  --require-end sin.src 
		$(RM) sin.src

OBJECTS		+= asin.obj
asin.obj   	: $(SRC)asin.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asin.c
		$(AS)  -DMODEL=a  --require-end asin.src 
		$(RM) asin.src

OBJECTS		+= sinh.obj
sinh.obj   	: $(SRC)sinh.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sinh.c
		$(AS)  -DMODEL=a  --require-end sinh.src 
		$(RM) sinh.src

OBJECTS		+= asinh.obj
asinh.obj   	: $(SRC)asinh.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asinh.c
		$(AS)  -DMODEL=a  --require-end asinh.src 
		$(RM) asinh.src

OBJECTS		+= cos.obj
cos.obj   	: $(SRC)cos.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)cos.c
		$(AS)  -DMODEL=a  --require-end cos.src 
		$(RM) cos.src

OBJECTS		+= acos.obj
acos.obj   	: $(SRC)acos.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)acos.c
		$(AS)  -DMODEL=a  --require-end acos.src 
		$(RM) acos.src

OBJECTS		+= cosh.obj
cosh.obj   	: $(SRC)cosh.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)cosh.c
		$(AS)  -DMODEL=a  --require-end cosh.src 
		$(RM) cosh.src

OBJECTS		+= acosh.obj
acosh.obj   	: $(SRC)acosh.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)acosh.c
		$(AS)  -DMODEL=a  --require-end acosh.src 
		$(RM) acosh.src

OBJECTS		+= tan.obj
tan.obj   	: $(SRC)tan.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tan.c
		$(AS)  -DMODEL=a  --require-end tan.src 
		$(RM) tan.src

OBJECTS		+= atan.obj
atan.obj   	: $(SRC)atan.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atan.c
		$(AS)  -DMODEL=a  --require-end atan.src 
		$(RM) atan.src

OBJECTS		+= atan2.obj
atan2.obj   	: $(SRC)atan2.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atan2.c
		$(AS)  -DMODEL=a  --require-end atan2.src 
		$(RM) atan2.src

OBJECTS		+= tanh.obj
tanh.obj   	: $(SRC)tanh.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tanh.c
		$(AS)  -DMODEL=a  --require-end tanh.src 
		$(RM) tanh.src

OBJECTS		+= atanh.obj
atanh.obj   	: $(SRC)atanh.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atanh.c
		$(AS)  -DMODEL=a  --require-end atanh.src 
		$(RM) atanh.src

OBJECTS		+= exp.obj
exp.obj   	: $(SRC)exp.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)exp.c
		$(AS)  -DMODEL=a  --require-end exp.src 
		$(RM) exp.src

OBJECTS		+= log.obj
log.obj   	: $(SRC)log.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)log.c
		$(AS)  -DMODEL=a  --require-end log.src 
		$(RM) log.src

OBJECTS		+= log10.obj
log10.obj   	: $(SRC)log10.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)log10.c
		$(AS)  -DMODEL=a  --require-end log10.src 
		$(RM) log10.src

OBJECTS		+= pow.obj
pow.obj   	: $(SRC)pow.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)pow.c
		$(AS)  -DMODEL=a  --require-end pow.src 
		$(RM) pow.src

OBJECTS		+= ceil.obj
ceil.obj   	: $(SRC)ceil.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ceil.c
		$(AS)  -DMODEL=a  --require-end ceil.src 
		$(RM) ceil.src

OBJECTS		+= floor.obj
floor.obj   	: $(SRC)floor.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)floor.c
		$(AS)  -DMODEL=a  --require-end floor.src 
		$(RM) floor.src

OBJECTS		+= fmod.obj
fmod.obj   	: $(SRC)fmod.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fmod.c
		$(AS)  -DMODEL=a  --require-end fmod.src 
		$(RM) fmod.src

OBJECTS		+= hypot.obj
hypot.obj   	: $(SRC)hypot.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)hypot.c
		$(AS)  -DMODEL=a  --require-end hypot.src 
		$(RM) hypot.src

OBJECTS		+= _sinus.obj
_sinus.obj   	: $(SRC)_sinus.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_sinus.c
		$(AS)  -DMODEL=a  --require-end _sinus.src 
		$(RM) _sinus.src

OBJECTS		+= _atan.obj
_atan.obj   	: $(SRC)_atan.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_atan.c
		$(AS)  -DMODEL=a  --require-end _atan.src 
		$(RM) _atan.src

OBJECTS		+= _isgtl.obj
_isgtl.obj   	: $(SRC)_isgtl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isgtl.c
		$(AS)  -DMODEL=a  --require-end _isgtl.src 
		$(RM) _isgtl.src

OBJECTS		+= _isgel.obj
_isgel.obj   	: $(SRC)_isgel.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isgel.c
		$(AS)  -DMODEL=a  --require-end _isgel.src 
		$(RM) _isgel.src

OBJECTS		+= _isltl.obj
_isltl.obj   	: $(SRC)_isltl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isltl.c
		$(AS)  -DMODEL=a  --require-end _isltl.src 
		$(RM) _isltl.src

OBJECTS		+= _islel.obj
_islel.obj   	: $(SRC)_islel.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_islel.c
		$(AS)  -DMODEL=a  --require-end _islel.src 
		$(RM) _islel.src

OBJECTS		+= _islgl.obj
_islgl.obj   	: $(SRC)_islgl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_islgl.c
		$(AS)  -DMODEL=a  --require-end _islgl.src 
		$(RM) _islgl.src

OBJECTS		+= _isunorderedl.obj
_isunorderedl.obj   	: $(SRC)_isunorderedl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isunorderedl.c
		$(AS)  -DMODEL=a  --require-end _isunorderedl.src 
		$(RM) _isunorderedl.src

OBJECTS		+= _isnormall.obj
_isnormall.obj   	: $(SRC)_isnormall.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_isnormall.c
		$(AS)  -DMODEL=a  --require-end _isnormall.src 
		$(RM) _isnormall.src

OBJECTS		+= _fpclassifyl.obj
_fpclassifyl.obj   	: $(SRC)_fpclassifyl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_fpclassifyl.c
		$(AS)  -DMODEL=a  --require-end _fpclassifyl.src 
		$(RM) _fpclassifyl.src

OBJECTS		+= sinl.obj
sinl.obj   	: $(SRC)sinl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sinl.c
		$(AS)  -DMODEL=a  --require-end sinl.src 
		$(RM) sinl.src

OBJECTS		+= asinl.obj
asinl.obj   	: $(SRC)asinl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asinl.c
		$(AS)  -DMODEL=a  --require-end asinl.src 
		$(RM) asinl.src

OBJECTS		+= sinhl.obj
sinhl.obj   	: $(SRC)sinhl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)sinhl.c
		$(AS)  -DMODEL=a  --require-end sinhl.src 
		$(RM) sinhl.src

OBJECTS		+= asinhl.obj
asinhl.obj   	: $(SRC)asinhl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)asinhl.c
		$(AS)  -DMODEL=a  --require-end asinhl.src 
		$(RM) asinhl.src

OBJECTS		+= cosl.obj
cosl.obj   	: $(SRC)cosl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)cosl.c
		$(AS)  -DMODEL=a  --require-end cosl.src 
		$(RM) cosl.src

OBJECTS		+= acosl.obj
acosl.obj   	: $(SRC)acosl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)acosl.c
		$(AS)  -DMODEL=a  --require-end acosl.src 
		$(RM) acosl.src

OBJECTS		+= coshl.obj
coshl.obj   	: $(SRC)coshl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)coshl.c
		$(AS)  -DMODEL=a  --require-end coshl.src 
		$(RM) coshl.src

OBJECTS		+= acoshl.obj
acoshl.obj   	: $(SRC)acoshl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)acoshl.c
		$(AS)  -DMODEL=a  --require-end acoshl.src 
		$(RM) acoshl.src

OBJECTS		+= tanl.obj
tanl.obj   	: $(SRC)tanl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tanl.c
		$(AS)  -DMODEL=a  --require-end tanl.src 
		$(RM) tanl.src

OBJECTS		+= atanl.obj
atanl.obj   	: $(SRC)atanl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atanl.c
		$(AS)  -DMODEL=a  --require-end atanl.src 
		$(RM) atanl.src

OBJECTS		+= atan2l.obj
atan2l.obj   	: $(SRC)atan2l.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atan2l.c
		$(AS)  -DMODEL=a  --require-end atan2l.src 
		$(RM) atan2l.src

OBJECTS		+= tanhl.obj
tanhl.obj   	: $(SRC)tanhl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)tanhl.c
		$(AS)  -DMODEL=a  --require-end tanhl.src 
		$(RM) tanhl.src

OBJECTS		+= atanhl.obj
atanhl.obj   	: $(SRC)atanhl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)atanhl.c
		$(AS)  -DMODEL=a  --require-end atanhl.src 
		$(RM) atanhl.src

OBJECTS		+= expl.obj
expl.obj   	: $(SRC)expl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)expl.c
		$(AS)  -DMODEL=a  --require-end expl.src 
		$(RM) expl.src

OBJECTS		+= logl.obj
logl.obj   	: $(SRC)logl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)logl.c
		$(AS)  -DMODEL=a  --require-end logl.src 
		$(RM) logl.src

OBJECTS		+= log10l.obj
log10l.obj   	: $(SRC)log10l.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)log10l.c
		$(AS)  -DMODEL=a  --require-end log10l.src 
		$(RM) log10l.src

OBJECTS		+= powl.obj
powl.obj   	: $(SRC)powl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)powl.c
		$(AS)  -DMODEL=a  --require-end powl.src 
		$(RM) powl.src

OBJECTS		+= ceill.obj
ceill.obj   	: $(SRC)ceill.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)ceill.c
		$(AS)  -DMODEL=a  --require-end ceill.src 
		$(RM) ceill.src

OBJECTS		+= floorl.obj
floorl.obj   	: $(SRC)floorl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)floorl.c
		$(AS)  -DMODEL=a  --require-end floorl.src 
		$(RM) floorl.src

OBJECTS		+= fabsl.obj
fabsl.obj   	: $(SRC)fabsl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fabsl.c
		$(AS)  -DMODEL=a  --require-end fabsl.src 
		$(RM) fabsl.src

OBJECTS		+= fmodl.obj
fmodl.obj   	: $(SRC)fmodl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)fmodl.c
		$(AS)  -DMODEL=a  --require-end fmodl.src 
		$(RM) fmodl.src

OBJECTS		+= hypotl.obj
hypotl.obj   	: $(SRC)hypotl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)hypotl.c
		$(AS)  -DMODEL=a  --require-end hypotl.src 
		$(RM) hypotl.src

OBJECTS		+= _sinusl.obj
_sinusl.obj   	: $(SRC)_sinusl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_sinusl.c
		$(AS)  -DMODEL=a  --require-end _sinusl.src 
		$(RM) _sinusl.src

OBJECTS		+= _atanl.obj
_atanl.obj   	: $(SRC)_atanl.c
		$(CC) -e -Ma -x0 -DFSS_MINIMAL   $(SRC)_atanl.c
		$(AS)  -DMODEL=a  --require-end _atanl.src 
		$(RM) _atanl.src

c51as.lib   	: $(OBJECTS)
		$(AR) -r $@  -f <<EOF
			$(separate "\n" $(OBJECTS))
		EOF
