__attribute__((section(".data.export~")))
short __export_stubs_end = -1;
__attribute__((section(".data.export@")))
short __export_stubs_start = -1;




	asm(""
	".section .data.export_abort \n"
"___export_abort_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_abort: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _abort \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_abort;
__attribute__((section(".dlist_so_export_abort")))
char const * __name_abort = "abort";
__attribute__((section(".dlist_so_export_abort")))
void ** __ptr_to_abort = &__export_abort;


extern void *abs;
__attribute__((section(".dlist_so_export_abs")))
char const * __name_abs = "abs";
__attribute__((section(".dlist_so_export_abs")))
void ** __ptr_to_abs = (void **)&abs;



	asm(""
	".section .data.export_access \n"
"___export_access_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_access: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _access \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_access;
__attribute__((section(".dlist_so_export_access")))
char const * __name_access = "access";
__attribute__((section(".dlist_so_export_access")))
void ** __ptr_to_access = &__export_access;



	asm(""
	".section .data.export_acos \n"
"___export_acos_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_acos: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _acos \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_acos;
__attribute__((section(".dlist_so_export_acos")))
char const * __name_acos = "acos";
__attribute__((section(".dlist_so_export_acos")))
void ** __ptr_to_acos = &__export_acos;



	asm(""
	".section .data.export_acosf \n"
"___export_acosf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_acosf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _acosf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_acosf;
__attribute__((section(".dlist_so_export_acosf")))
char const * __name_acosf = "acosf";
__attribute__((section(".dlist_so_export_acosf")))
void ** __ptr_to_acosf = &__export_acosf;



	asm(""
	".section .data.export_acosh \n"
"___export_acosh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_acosh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _acosh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_acosh;
__attribute__((section(".dlist_so_export_acosh")))
char const * __name_acosh = "acosh";
__attribute__((section(".dlist_so_export_acosh")))
void ** __ptr_to_acosh = &__export_acosh;



	asm(""
	".section .data.export_acoshf \n"
"___export_acoshf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_acoshf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _acoshf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_acoshf;
__attribute__((section(".dlist_so_export_acoshf")))
char const * __name_acoshf = "acoshf";
__attribute__((section(".dlist_so_export_acoshf")))
void ** __ptr_to_acoshf = &__export_acoshf;



	asm(""
	".section .data.export___adddf3 \n"
"___export___adddf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___adddf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___adddf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___adddf3;
__attribute__((section(".dlist_so_export___adddf3")))
char const * __name___adddf3 = "__adddf3";
__attribute__((section(".dlist_so_export___adddf3")))
void ** __ptr_to___adddf3 = &__export___adddf3;



	asm(""
	".section .data.export___addsf3 \n"
"___export___addsf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___addsf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___addsf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___addsf3;
__attribute__((section(".dlist_so_export___addsf3")))
char const * __name___addsf3 = "__addsf3";
__attribute__((section(".dlist_so_export___addsf3")))
void ** __ptr_to___addsf3 = &__export___addsf3;


extern void *alarm;
__attribute__((section(".dlist_so_export_alarm")))
char const * __name_alarm = "alarm";
__attribute__((section(".dlist_so_export_alarm")))
void ** __ptr_to_alarm = (void **)&alarm;



	asm(""
	".section .data.export___allocfd \n"
"___export___allocfd_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___allocfd: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___allocfd \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___allocfd;
__attribute__((section(".dlist_so_export___allocfd")))
char const * __name___allocfd = "__allocfd";
__attribute__((section(".dlist_so_export___allocfd")))
void ** __ptr_to___allocfd = &__export___allocfd;



	asm(""
	".section .data.export_alphasort \n"
"___export_alphasort_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_alphasort: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _alphasort \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_alphasort;
__attribute__((section(".dlist_so_export_alphasort")))
char const * __name_alphasort = "alphasort";
__attribute__((section(".dlist_so_export_alphasort")))
void ** __ptr_to_alphasort = &__export_alphasort;



	asm(""
	".section .data.export_amifprintf \n"
"___export_amifprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amifprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amifprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amifprintf;
__attribute__((section(".dlist_so_export_amifprintf")))
char const * __name_amifprintf = "amifprintf";
__attribute__((section(".dlist_so_export_amifprintf")))
void ** __ptr_to_amifprintf = &__export_amifprintf;



	asm(""
	".section .data.export___amigapath \n"
"___export___amigapath_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___amigapath: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___amigapath \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___amigapath;
__attribute__((section(".dlist_so_export___amigapath")))
char const * __name___amigapath = "__amigapath";
__attribute__((section(".dlist_so_export___amigapath")))
void ** __ptr_to___amigapath = &__export___amigapath;


extern void *amigets;
__attribute__((section(".dlist_so_export_amigets")))
char const * __name_amigets = "amigets";
__attribute__((section(".dlist_so_export_amigets")))
void ** __ptr_to_amigets = (void **)&amigets;



	asm(""
	".section .data.export_amiprintf \n"
"___export_amiprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amiprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amiprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amiprintf;
__attribute__((section(".dlist_so_export_amiprintf")))
char const * __name_amiprintf = "amiprintf";
__attribute__((section(".dlist_so_export_amiprintf")))
void ** __ptr_to_amiprintf = &__export_amiprintf;


extern void *amiputchar;
__attribute__((section(".dlist_so_export_amiputchar")))
char const * __name_amiputchar = "amiputchar";
__attribute__((section(".dlist_so_export_amiputchar")))
void ** __ptr_to_amiputchar = (void **)&amiputchar;



	asm(""
	".section .data.export_amiputs \n"
"___export_amiputs_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amiputs: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amiputs \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amiputs;
__attribute__((section(".dlist_so_export_amiputs")))
char const * __name_amiputs = "amiputs";
__attribute__((section(".dlist_so_export_amiputs")))
void ** __ptr_to_amiputs = &__export_amiputs;



	asm(""
	".section .data.export___amiputs_putchar_callback \n"
"___export___amiputs_putchar_callback_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___amiputs_putchar_callback: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___amiputs_putchar_callback \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___amiputs_putchar_callback;
__attribute__((section(".dlist_so_export___amiputs_putchar_callback")))
char const * __name___amiputs_putchar_callback = "__amiputs_putchar_callback";
__attribute__((section(".dlist_so_export___amiputs_putchar_callback")))
void ** __ptr_to___amiputs_putchar_callback = &__export___amiputs_putchar_callback;



	asm(""
	".section .data.export_amisnprintf \n"
"___export_amisnprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amisnprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amisnprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amisnprintf;
__attribute__((section(".dlist_so_export_amisnprintf")))
char const * __name_amisnprintf = "amisnprintf";
__attribute__((section(".dlist_so_export_amisnprintf")))
void ** __ptr_to_amisnprintf = &__export_amisnprintf;



	asm(""
	".section .data.export_amistderr \n"
"___export_amistderr_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amistderr: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amistderr \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amistderr;
__attribute__((section(".dlist_so_export_amistderr")))
char const * __name_amistderr = "amistderr";
__attribute__((section(".dlist_so_export_amistderr")))
void ** __ptr_to_amistderr = &__export_amistderr;



	asm(""
	".section .data.export_amivfprintf \n"
"___export_amivfprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amivfprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amivfprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amivfprintf;
__attribute__((section(".dlist_so_export_amivfprintf")))
char const * __name_amivfprintf = "amivfprintf";
__attribute__((section(".dlist_so_export_amivfprintf")))
void ** __ptr_to_amivfprintf = &__export_amivfprintf;



	asm(""
	".section .data.export_amivsnprintf \n"
"___export_amivsnprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_amivsnprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _amivsnprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_amivsnprintf;
__attribute__((section(".dlist_so_export_amivsnprintf")))
char const * __name_amivsnprintf = "amivsnprintf";
__attribute__((section(".dlist_so_export_amivsnprintf")))
void ** __ptr_to_amivsnprintf = &__export_amivsnprintf;



	asm(""
	".section .data.export_asctime \n"
"___export_asctime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_asctime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _asctime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_asctime;
__attribute__((section(".dlist_so_export_asctime")))
char const * __name_asctime = "asctime";
__attribute__((section(".dlist_so_export_asctime")))
void ** __ptr_to_asctime = &__export_asctime;



	asm(""
	".section .data.export_asin \n"
"___export_asin_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_asin: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _asin \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_asin;
__attribute__((section(".dlist_so_export_asin")))
char const * __name_asin = "asin";
__attribute__((section(".dlist_so_export_asin")))
void ** __ptr_to_asin = &__export_asin;



	asm(""
	".section .data.export_asinf \n"
"___export_asinf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_asinf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _asinf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_asinf;
__attribute__((section(".dlist_so_export_asinf")))
char const * __name_asinf = "asinf";
__attribute__((section(".dlist_so_export_asinf")))
void ** __ptr_to_asinf = &__export_asinf;



	asm(""
	".section .data.export_asinh \n"
"___export_asinh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_asinh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _asinh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_asinh;
__attribute__((section(".dlist_so_export_asinh")))
char const * __name_asinh = "asinh";
__attribute__((section(".dlist_so_export_asinh")))
void ** __ptr_to_asinh = &__export_asinh;



	asm(""
	".section .data.export_asinhf \n"
"___export_asinhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_asinhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _asinhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_asinhf;
__attribute__((section(".dlist_so_export_asinhf")))
char const * __name_asinhf = "asinhf";
__attribute__((section(".dlist_so_export_asinhf")))
void ** __ptr_to_asinhf = &__export_asinhf;



	asm(""
	".section .data.export_asprintf \n"
"___export_asprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_asprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _asprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_asprintf;
__attribute__((section(".dlist_so_export_asprintf")))
char const * __name_asprintf = "asprintf";
__attribute__((section(".dlist_so_export_asprintf")))
void ** __ptr_to_asprintf = &__export_asprintf;



	asm(""
	".section .data.export___assert \n"
"___export___assert_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___assert: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___assert \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___assert;
__attribute__((section(".dlist_so_export___assert")))
char const * __name___assert = "__assert";
__attribute__((section(".dlist_so_export___assert")))
void ** __ptr_to___assert = &__export___assert;



	asm(""
	".section .data.export___assert_func \n"
"___export___assert_func_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___assert_func: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___assert_func \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___assert_func;
__attribute__((section(".dlist_so_export___assert_func")))
char const * __name___assert_func = "__assert_func";
__attribute__((section(".dlist_so_export___assert_func")))
void ** __ptr_to___assert_func = &__export___assert_func;



	asm(""
	".section .data.export_atan \n"
"___export_atan_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atan: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atan \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atan;
__attribute__((section(".dlist_so_export_atan")))
char const * __name_atan = "atan";
__attribute__((section(".dlist_so_export_atan")))
void ** __ptr_to_atan = &__export_atan;



	asm(""
	".section .data.export_atan2 \n"
"___export_atan2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atan2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atan2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atan2;
__attribute__((section(".dlist_so_export_atan2")))
char const * __name_atan2 = "atan2";
__attribute__((section(".dlist_so_export_atan2")))
void ** __ptr_to_atan2 = &__export_atan2;



	asm(""
	".section .data.export_atan2f \n"
"___export_atan2f_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atan2f: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atan2f \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atan2f;
__attribute__((section(".dlist_so_export_atan2f")))
char const * __name_atan2f = "atan2f";
__attribute__((section(".dlist_so_export_atan2f")))
void ** __ptr_to_atan2f = &__export_atan2f;



	asm(""
	".section .data.export_atanf \n"
"___export_atanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atanf;
__attribute__((section(".dlist_so_export_atanf")))
char const * __name_atanf = "atanf";
__attribute__((section(".dlist_so_export_atanf")))
void ** __ptr_to_atanf = &__export_atanf;



	asm(""
	".section .data.export_atanh \n"
"___export_atanh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atanh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atanh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atanh;
__attribute__((section(".dlist_so_export_atanh")))
char const * __name_atanh = "atanh";
__attribute__((section(".dlist_so_export_atanh")))
void ** __ptr_to_atanh = &__export_atanh;



	asm(""
	".section .data.export_atanhf \n"
"___export_atanhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atanhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atanhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atanhf;
__attribute__((section(".dlist_so_export_atanhf")))
char const * __name_atanhf = "atanhf";
__attribute__((section(".dlist_so_export_atanhf")))
void ** __ptr_to_atanhf = &__export_atanhf;



	asm(""
	".section .data.export_atexit \n"
"___export_atexit_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atexit: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atexit \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atexit;
__attribute__((section(".dlist_so_export_atexit")))
char const * __name_atexit = "atexit";
__attribute__((section(".dlist_so_export_atexit")))
void ** __ptr_to_atexit = &__export_atexit;



	asm(""
	".section .data.export_atof \n"
"___export_atof_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atof: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atof \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atof;
__attribute__((section(".dlist_so_export_atof")))
char const * __name_atof = "atof";
__attribute__((section(".dlist_so_export_atof")))
void ** __ptr_to_atof = &__export_atof;



	asm(""
	".section .data.export_atoi \n"
"___export_atoi_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atoi: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atoi \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atoi;
__attribute__((section(".dlist_so_export_atoi")))
char const * __name_atoi = "atoi";
__attribute__((section(".dlist_so_export_atoi")))
void ** __ptr_to_atoi = &__export_atoi;



	asm(""
	".section .data.export_atol \n"
"___export_atol_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atol: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atol \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atol;
__attribute__((section(".dlist_so_export_atol")))
char const * __name_atol = "atol";
__attribute__((section(".dlist_so_export_atol")))
void ** __ptr_to_atol = &__export_atol;



	asm(""
	".section .data.export_atoll \n"
"___export_atoll_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_atoll: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _atoll \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_atoll;
__attribute__((section(".dlist_so_export_atoll")))
char const * __name_atoll = "atoll";
__attribute__((section(".dlist_so_export_atoll")))
void ** __ptr_to_atoll = &__export_atoll;



	asm(""
	".section .data.export_basename \n"
"___export_basename_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_basename: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _basename \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_basename;
__attribute__((section(".dlist_so_export_basename")))
char const * __name_basename = "basename";
__attribute__((section(".dlist_so_export_basename")))
void ** __ptr_to_basename = &__export_basename;


extern void *bcmp;
__attribute__((section(".dlist_so_export_bcmp")))
char const * __name_bcmp = "bcmp";
__attribute__((section(".dlist_so_export_bcmp")))
void ** __ptr_to_bcmp = (void **)&bcmp;


extern void *bcopy;
__attribute__((section(".dlist_so_export_bcopy")))
char const * __name_bcopy = "bcopy";
__attribute__((section(".dlist_so_export_bcopy")))
void ** __ptr_to_bcopy = (void **)&bcopy;


extern void *__bcopz;
__attribute__((section(".dlist_so_export___bcopz")))
char const * __name___bcopz = "__bcopz";
__attribute__((section(".dlist_so_export___bcopz")))
void ** __ptr_to___bcopz = (void **)&__bcopz;


extern void *bindtextdomain;
__attribute__((section(".dlist_so_export_bindtextdomain")))
char const * __name_bindtextdomain = "bindtextdomain";
__attribute__((section(".dlist_so_export_bindtextdomain")))
void ** __ptr_to_bindtextdomain = (void **)&bindtextdomain;



	asm(""
	".section .data.export_bsearch \n"
"___export_bsearch_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_bsearch: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _bsearch \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_bsearch;
__attribute__((section(".dlist_so_export_bsearch")))
char const * __name_bsearch = "bsearch";
__attribute__((section(".dlist_so_export_bsearch")))
void ** __ptr_to_bsearch = &__export_bsearch;


extern void *btowc;
__attribute__((section(".dlist_so_export_btowc")))
char const * __name_btowc = "btowc";
__attribute__((section(".dlist_so_export_btowc")))
void ** __ptr_to_btowc = (void **)&btowc;


extern void *bzero;
__attribute__((section(".dlist_so_export_bzero")))
char const * __name_bzero = "bzero";
__attribute__((section(".dlist_so_export_bzero")))
void ** __ptr_to_bzero = (void **)&bzero;



	asm(""
	".section .data.export_cabs \n"
"___export_cabs_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cabs: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cabs \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cabs;
__attribute__((section(".dlist_so_export_cabs")))
char const * __name_cabs = "cabs";
__attribute__((section(".dlist_so_export_cabs")))
void ** __ptr_to_cabs = &__export_cabs;



	asm(""
	".section .data.export_cabsf \n"
"___export_cabsf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cabsf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cabsf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cabsf;
__attribute__((section(".dlist_so_export_cabsf")))
char const * __name_cabsf = "cabsf";
__attribute__((section(".dlist_so_export_cabsf")))
void ** __ptr_to_cabsf = &__export_cabsf;



	asm(""
	".section .data.export_cacos \n"
"___export_cacos_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cacos: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cacos \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cacos;
__attribute__((section(".dlist_so_export_cacos")))
char const * __name_cacos = "cacos";
__attribute__((section(".dlist_so_export_cacos")))
void ** __ptr_to_cacos = &__export_cacos;



	asm(""
	".section .data.export_cacosf \n"
"___export_cacosf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cacosf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cacosf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cacosf;
__attribute__((section(".dlist_so_export_cacosf")))
char const * __name_cacosf = "cacosf";
__attribute__((section(".dlist_so_export_cacosf")))
void ** __ptr_to_cacosf = &__export_cacosf;



	asm(""
	".section .data.export_cacosh \n"
"___export_cacosh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cacosh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cacosh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cacosh;
__attribute__((section(".dlist_so_export_cacosh")))
char const * __name_cacosh = "cacosh";
__attribute__((section(".dlist_so_export_cacosh")))
void ** __ptr_to_cacosh = &__export_cacosh;



	asm(""
	".section .data.export_cacoshf \n"
"___export_cacoshf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cacoshf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cacoshf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cacoshf;
__attribute__((section(".dlist_so_export_cacoshf")))
char const * __name_cacoshf = "cacoshf";
__attribute__((section(".dlist_so_export_cacoshf")))
void ** __ptr_to_cacoshf = &__export_cacoshf;



	asm(""
	".section .data.export_calloc \n"
"___export_calloc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_calloc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _calloc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_calloc;
__attribute__((section(".dlist_so_export_calloc")))
char const * __name_calloc = "calloc";
__attribute__((section(".dlist_so_export_calloc")))
void ** __ptr_to_calloc = &__export_calloc;



	asm(""
	".section .data.export_carg \n"
"___export_carg_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_carg: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _carg \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_carg;
__attribute__((section(".dlist_so_export_carg")))
char const * __name_carg = "carg";
__attribute__((section(".dlist_so_export_carg")))
void ** __ptr_to_carg = &__export_carg;



	asm(""
	".section .data.export_cargf \n"
"___export_cargf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cargf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cargf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cargf;
__attribute__((section(".dlist_so_export_cargf")))
char const * __name_cargf = "cargf";
__attribute__((section(".dlist_so_export_cargf")))
void ** __ptr_to_cargf = &__export_cargf;



	asm(""
	".section .data.export_casin \n"
"___export_casin_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_casin: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _casin \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_casin;
__attribute__((section(".dlist_so_export_casin")))
char const * __name_casin = "casin";
__attribute__((section(".dlist_so_export_casin")))
void ** __ptr_to_casin = &__export_casin;



	asm(""
	".section .data.export_casinf \n"
"___export_casinf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_casinf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _casinf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_casinf;
__attribute__((section(".dlist_so_export_casinf")))
char const * __name_casinf = "casinf";
__attribute__((section(".dlist_so_export_casinf")))
void ** __ptr_to_casinf = &__export_casinf;



	asm(""
	".section .data.export_casinh \n"
"___export_casinh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_casinh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _casinh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_casinh;
__attribute__((section(".dlist_so_export_casinh")))
char const * __name_casinh = "casinh";
__attribute__((section(".dlist_so_export_casinh")))
void ** __ptr_to_casinh = &__export_casinh;



	asm(""
	".section .data.export_casinhf \n"
"___export_casinhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_casinhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _casinhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_casinhf;
__attribute__((section(".dlist_so_export_casinhf")))
char const * __name_casinhf = "casinhf";
__attribute__((section(".dlist_so_export_casinhf")))
void ** __ptr_to_casinhf = &__export_casinhf;



	asm(""
	".section .data.export_catan \n"
"___export_catan_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_catan: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _catan \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_catan;
__attribute__((section(".dlist_so_export_catan")))
char const * __name_catan = "catan";
__attribute__((section(".dlist_so_export_catan")))
void ** __ptr_to_catan = &__export_catan;



	asm(""
	".section .data.export_catanf \n"
"___export_catanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_catanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _catanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_catanf;
__attribute__((section(".dlist_so_export_catanf")))
char const * __name_catanf = "catanf";
__attribute__((section(".dlist_so_export_catanf")))
void ** __ptr_to_catanf = &__export_catanf;



	asm(""
	".section .data.export_catanh \n"
"___export_catanh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_catanh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _catanh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_catanh;
__attribute__((section(".dlist_so_export_catanh")))
char const * __name_catanh = "catanh";
__attribute__((section(".dlist_so_export_catanh")))
void ** __ptr_to_catanh = &__export_catanh;



	asm(""
	".section .data.export_catanhf \n"
"___export_catanhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_catanhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _catanhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_catanhf;
__attribute__((section(".dlist_so_export_catanhf")))
char const * __name_catanhf = "catanhf";
__attribute__((section(".dlist_so_export_catanhf")))
void ** __ptr_to_catanhf = &__export_catanhf;



	asm(""
	".section .data.export_cbrt \n"
"___export_cbrt_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cbrt: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cbrt \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cbrt;
__attribute__((section(".dlist_so_export_cbrt")))
char const * __name_cbrt = "cbrt";
__attribute__((section(".dlist_so_export_cbrt")))
void ** __ptr_to_cbrt = &__export_cbrt;



	asm(""
	".section .data.export_cbrtf \n"
"___export_cbrtf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cbrtf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cbrtf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cbrtf;
__attribute__((section(".dlist_so_export_cbrtf")))
char const * __name_cbrtf = "cbrtf";
__attribute__((section(".dlist_so_export_cbrtf")))
void ** __ptr_to_cbrtf = &__export_cbrtf;



	asm(""
	".section .data.export_ccos \n"
"___export_ccos_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ccos: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ccos \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ccos;
__attribute__((section(".dlist_so_export_ccos")))
char const * __name_ccos = "ccos";
__attribute__((section(".dlist_so_export_ccos")))
void ** __ptr_to_ccos = &__export_ccos;



	asm(""
	".section .data.export_ccosf \n"
"___export_ccosf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ccosf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ccosf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ccosf;
__attribute__((section(".dlist_so_export_ccosf")))
char const * __name_ccosf = "ccosf";
__attribute__((section(".dlist_so_export_ccosf")))
void ** __ptr_to_ccosf = &__export_ccosf;



	asm(""
	".section .data.export_ccosh \n"
"___export_ccosh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ccosh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ccosh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ccosh;
__attribute__((section(".dlist_so_export_ccosh")))
char const * __name_ccosh = "ccosh";
__attribute__((section(".dlist_so_export_ccosh")))
void ** __ptr_to_ccosh = &__export_ccosh;



	asm(""
	".section .data.export_ccoshf \n"
"___export_ccoshf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ccoshf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ccoshf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ccoshf;
__attribute__((section(".dlist_so_export_ccoshf")))
char const * __name_ccoshf = "ccoshf";
__attribute__((section(".dlist_so_export_ccoshf")))
void ** __ptr_to_ccoshf = &__export_ccoshf;



	asm(""
	".section .data.export_ceil \n"
"___export_ceil_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ceil: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ceil \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ceil;
__attribute__((section(".dlist_so_export_ceil")))
char const * __name_ceil = "ceil";
__attribute__((section(".dlist_so_export_ceil")))
void ** __ptr_to_ceil = &__export_ceil;



	asm(""
	".section .data.export_ceilf \n"
"___export_ceilf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ceilf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ceilf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ceilf;
__attribute__((section(".dlist_so_export_ceilf")))
char const * __name_ceilf = "ceilf";
__attribute__((section(".dlist_so_export_ceilf")))
void ** __ptr_to_ceilf = &__export_ceilf;



	asm(""
	".section .data.export_cexp \n"
"___export_cexp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cexp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cexp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cexp;
__attribute__((section(".dlist_so_export_cexp")))
char const * __name_cexp = "cexp";
__attribute__((section(".dlist_so_export_cexp")))
void ** __ptr_to_cexp = &__export_cexp;



	asm(""
	".section .data.export_cexpf \n"
"___export_cexpf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cexpf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cexpf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cexpf;
__attribute__((section(".dlist_so_export_cexpf")))
char const * __name_cexpf = "cexpf";
__attribute__((section(".dlist_so_export_cexpf")))
void ** __ptr_to_cexpf = &__export_cexpf;



	asm(""
	".section .data.export_chdir \n"
"___export_chdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_chdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _chdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_chdir;
__attribute__((section(".dlist_so_export_chdir")))
char const * __name_chdir = "chdir";
__attribute__((section(".dlist_so_export_chdir")))
void ** __ptr_to_chdir = &__export_chdir;



	asm(""
	".section .data.export___checkstack \n"
"___export___checkstack_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___checkstack: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___checkstack \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___checkstack;
__attribute__((section(".dlist_so_export___checkstack")))
char const * __name___checkstack = "__checkstack";
__attribute__((section(".dlist_so_export___checkstack")))
void ** __ptr_to___checkstack = &__export___checkstack;



	asm(""
	".section .data.export___chkabort \n"
"___export___chkabort_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___chkabort: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___chkabort \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___chkabort;
__attribute__((section(".dlist_so_export___chkabort")))
char const * __name___chkabort = "__chkabort";
__attribute__((section(".dlist_so_export___chkabort")))
void ** __ptr_to___chkabort = &__export___chkabort;



	asm(""
	".section .data.export_chmod \n"
"___export_chmod_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_chmod: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _chmod \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_chmod;
__attribute__((section(".dlist_so_export_chmod")))
char const * __name_chmod = "chmod";
__attribute__((section(".dlist_so_export_chmod")))
void ** __ptr_to_chmod = &__export_chmod;


extern void *chown;
__attribute__((section(".dlist_so_export_chown")))
char const * __name_chown = "chown";
__attribute__((section(".dlist_so_export_chown")))
void ** __ptr_to_chown = (void **)&chown;


extern void *chroot;
__attribute__((section(".dlist_so_export_chroot")))
char const * __name_chroot = "chroot";
__attribute__((section(".dlist_so_export_chroot")))
void ** __ptr_to_chroot = (void **)&chroot;


extern void *cimag;
__attribute__((section(".dlist_so_export_cimag")))
char const * __name_cimag = "cimag";
__attribute__((section(".dlist_so_export_cimag")))
void ** __ptr_to_cimag = (void **)&cimag;


extern void *cimagf;
__attribute__((section(".dlist_so_export_cimagf")))
char const * __name_cimagf = "cimagf";
__attribute__((section(".dlist_so_export_cimagf")))
void ** __ptr_to_cimagf = (void **)&cimagf;



	asm(""
	".section .data.export_clearenv \n"
"___export_clearenv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clearenv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clearenv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clearenv;
__attribute__((section(".dlist_so_export_clearenv")))
char const * __name_clearenv = "clearenv";
__attribute__((section(".dlist_so_export_clearenv")))
void ** __ptr_to_clearenv = &__export_clearenv;


extern void *clearerr;
__attribute__((section(".dlist_so_export_clearerr")))
char const * __name_clearerr = "clearerr";
__attribute__((section(".dlist_so_export_clearerr")))
void ** __ptr_to_clearerr = (void **)&clearerr;



	asm(""
	".section .data.export_clock \n"
"___export_clock_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clock: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clock \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clock;
__attribute__((section(".dlist_so_export_clock")))
char const * __name_clock = "clock";
__attribute__((section(".dlist_so_export_clock")))
void ** __ptr_to_clock = &__export_clock;



	asm(""
	".section .data.export_clock_getres \n"
"___export_clock_getres_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clock_getres: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clock_getres \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clock_getres;
__attribute__((section(".dlist_so_export_clock_getres")))
char const * __name_clock_getres = "clock_getres";
__attribute__((section(".dlist_so_export_clock_getres")))
void ** __ptr_to_clock_getres = &__export_clock_getres;



	asm(""
	".section .data.export_clock_gettime \n"
"___export_clock_gettime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clock_gettime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clock_gettime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clock_gettime;
__attribute__((section(".dlist_so_export_clock_gettime")))
char const * __name_clock_gettime = "clock_gettime";
__attribute__((section(".dlist_so_export_clock_gettime")))
void ** __ptr_to_clock_gettime = &__export_clock_gettime;



	asm(""
	".section .data.export_clog \n"
"___export_clog_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clog: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clog \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clog;
__attribute__((section(".dlist_so_export_clog")))
char const * __name_clog = "clog";
__attribute__((section(".dlist_so_export_clog")))
void ** __ptr_to_clog = &__export_clog;



	asm(""
	".section .data.export_clog10 \n"
"___export_clog10_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clog10: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clog10 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clog10;
__attribute__((section(".dlist_so_export_clog10")))
char const * __name_clog10 = "clog10";
__attribute__((section(".dlist_so_export_clog10")))
void ** __ptr_to_clog10 = &__export_clog10;



	asm(""
	".section .data.export_clog10f \n"
"___export_clog10f_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clog10f: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clog10f \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clog10f;
__attribute__((section(".dlist_so_export_clog10f")))
char const * __name_clog10f = "clog10f";
__attribute__((section(".dlist_so_export_clog10f")))
void ** __ptr_to_clog10f = &__export_clog10f;



	asm(""
	".section .data.export_clogf \n"
"___export_clogf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_clogf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _clogf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_clogf;
__attribute__((section(".dlist_so_export_clogf")))
char const * __name_clogf = "clogf";
__attribute__((section(".dlist_so_export_clogf")))
void ** __ptr_to_clogf = &__export_clogf;



	asm(""
	".section .data.export_close \n"
"___export_close_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_close: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _close \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_close;
__attribute__((section(".dlist_so_export_close")))
char const * __name_close = "close";
__attribute__((section(".dlist_so_export_close")))
void ** __ptr_to_close = &__export_close;



	asm(""
	".section .data.export_closedir \n"
"___export_closedir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_closedir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _closedir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_closedir;
__attribute__((section(".dlist_so_export_closedir")))
char const * __name_closedir = "closedir";
__attribute__((section(".dlist_so_export_closedir")))
void ** __ptr_to_closedir = &__export_closedir;



	asm(""
	".section .data.export_closelog \n"
"___export_closelog_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_closelog: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _closelog \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_closelog;
__attribute__((section(".dlist_so_export_closelog")))
char const * __name_closelog = "closelog";
__attribute__((section(".dlist_so_export_closelog")))
void ** __ptr_to_closelog = &__export_closelog;



	asm(""
	".section .data.export___cmpdf2 \n"
"___export___cmpdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___cmpdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___cmpdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___cmpdf2;
__attribute__((section(".dlist_so_export___cmpdf2")))
char const * __name___cmpdf2 = "__cmpdf2";
__attribute__((section(".dlist_so_export___cmpdf2")))
void ** __ptr_to___cmpdf2 = &__export___cmpdf2;



	asm(""
	".section .data.export___cmpsf2 \n"
"___export___cmpsf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___cmpsf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___cmpsf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___cmpsf2;
__attribute__((section(".dlist_so_export___cmpsf2")))
char const * __name___cmpsf2 = "__cmpsf2";
__attribute__((section(".dlist_so_export___cmpsf2")))
void ** __ptr_to___cmpsf2 = &__export___cmpsf2;



	asm(""
	".section .data.export___cmpxf2 \n"
"___export___cmpxf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___cmpxf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___cmpxf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___cmpxf2;
__attribute__((section(".dlist_so_export___cmpxf2")))
char const * __name___cmpxf2 = "__cmpxf2";
__attribute__((section(".dlist_so_export___cmpxf2")))
void ** __ptr_to___cmpxf2 = &__export___cmpxf2;


extern void *__cmsg_alignbytes;
__attribute__((section(".dlist_so_export___cmsg_alignbytes")))
char const * __name___cmsg_alignbytes = "__cmsg_alignbytes";
__attribute__((section(".dlist_so_export___cmsg_alignbytes")))
void ** __ptr_to___cmsg_alignbytes = (void **)&__cmsg_alignbytes;



	asm(""
	".section .data.export_concat \n"
"___export_concat_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_concat: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _concat \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_concat;
__attribute__((section(".dlist_so_export_concat")))
char const * __name_concat = "concat";
__attribute__((section(".dlist_so_export_concat")))
void ** __ptr_to_concat = &__export_concat;


extern void *conj;
__attribute__((section(".dlist_so_export_conj")))
char const * __name_conj = "conj";
__attribute__((section(".dlist_so_export_conj")))
void ** __ptr_to_conj = (void **)&conj;


extern void *conjf;
__attribute__((section(".dlist_so_export_conjf")))
char const * __name_conjf = "conjf";
__attribute__((section(".dlist_so_export_conjf")))
void ** __ptr_to_conjf = (void **)&conjf;


extern void *copysign;
__attribute__((section(".dlist_so_export_copysign")))
char const * __name_copysign = "copysign";
__attribute__((section(".dlist_so_export_copysign")))
void ** __ptr_to_copysign = (void **)&copysign;


extern void *copysignf;
__attribute__((section(".dlist_so_export_copysignf")))
char const * __name_copysignf = "copysignf";
__attribute__((section(".dlist_so_export_copysignf")))
void ** __ptr_to_copysignf = (void **)&copysignf;



	asm(""
	".section .data.export_cos \n"
"___export_cos_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cos: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cos \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cos;
__attribute__((section(".dlist_so_export_cos")))
char const * __name_cos = "cos";
__attribute__((section(".dlist_so_export_cos")))
void ** __ptr_to_cos = &__export_cos;



	asm(""
	".section .data.export_cosf \n"
"___export_cosf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cosf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cosf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cosf;
__attribute__((section(".dlist_so_export_cosf")))
char const * __name_cosf = "cosf";
__attribute__((section(".dlist_so_export_cosf")))
void ** __ptr_to_cosf = &__export_cosf;



	asm(""
	".section .data.export_cosh \n"
"___export_cosh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cosh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cosh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cosh;
__attribute__((section(".dlist_so_export_cosh")))
char const * __name_cosh = "cosh";
__attribute__((section(".dlist_so_export_cosh")))
void ** __ptr_to_cosh = &__export_cosh;



	asm(""
	".section .data.export_coshf \n"
"___export_coshf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_coshf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _coshf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_coshf;
__attribute__((section(".dlist_so_export_coshf")))
char const * __name_coshf = "coshf";
__attribute__((section(".dlist_so_export_coshf")))
void ** __ptr_to_coshf = &__export_coshf;



	asm(""
	".section .data.export_cpow \n"
"___export_cpow_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cpow: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cpow \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cpow;
__attribute__((section(".dlist_so_export_cpow")))
char const * __name_cpow = "cpow";
__attribute__((section(".dlist_so_export_cpow")))
void ** __ptr_to_cpow = &__export_cpow;



	asm(""
	".section .data.export_cpowf \n"
"___export_cpowf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_cpowf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _cpowf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_cpowf;
__attribute__((section(".dlist_so_export_cpowf")))
char const * __name_cpowf = "cpowf";
__attribute__((section(".dlist_so_export_cpowf")))
void ** __ptr_to_cpowf = &__export_cpowf;


extern void *cproj;
__attribute__((section(".dlist_so_export_cproj")))
char const * __name_cproj = "cproj";
__attribute__((section(".dlist_so_export_cproj")))
void ** __ptr_to_cproj = (void **)&cproj;


extern void *cprojf;
__attribute__((section(".dlist_so_export_cprojf")))
char const * __name_cprojf = "cprojf";
__attribute__((section(".dlist_so_export_cprojf")))
void ** __ptr_to_cprojf = (void **)&cprojf;


extern void *__cpucheck;
__attribute__((section(".dlist_so_export___cpucheck")))
char const * __name___cpucheck = "__cpucheck";
__attribute__((section(".dlist_so_export___cpucheck")))
void ** __ptr_to___cpucheck = (void **)&__cpucheck;


extern void *creal;
__attribute__((section(".dlist_so_export_creal")))
char const * __name_creal = "creal";
__attribute__((section(".dlist_so_export_creal")))
void ** __ptr_to_creal = (void **)&creal;


extern void *crealf;
__attribute__((section(".dlist_so_export_crealf")))
char const * __name_crealf = "crealf";
__attribute__((section(".dlist_so_export_crealf")))
void ** __ptr_to_crealf = (void **)&crealf;



	asm(""
	".section .data.export_creat \n"
"___export_creat_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_creat: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _creat \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_creat;
__attribute__((section(".dlist_so_export_creat")))
char const * __name_creat = "creat";
__attribute__((section(".dlist_so_export_creat")))
void ** __ptr_to_creat = &__export_creat;



	asm(""
	".section .data.export_csin \n"
"___export_csin_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_csin: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _csin \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_csin;
__attribute__((section(".dlist_so_export_csin")))
char const * __name_csin = "csin";
__attribute__((section(".dlist_so_export_csin")))
void ** __ptr_to_csin = &__export_csin;



	asm(""
	".section .data.export_csinf \n"
"___export_csinf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_csinf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _csinf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_csinf;
__attribute__((section(".dlist_so_export_csinf")))
char const * __name_csinf = "csinf";
__attribute__((section(".dlist_so_export_csinf")))
void ** __ptr_to_csinf = &__export_csinf;



	asm(""
	".section .data.export_csinh \n"
"___export_csinh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_csinh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _csinh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_csinh;
__attribute__((section(".dlist_so_export_csinh")))
char const * __name_csinh = "csinh";
__attribute__((section(".dlist_so_export_csinh")))
void ** __ptr_to_csinh = &__export_csinh;



	asm(""
	".section .data.export_csinhf \n"
"___export_csinhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_csinhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _csinhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_csinhf;
__attribute__((section(".dlist_so_export_csinhf")))
char const * __name_csinhf = "csinhf";
__attribute__((section(".dlist_so_export_csinhf")))
void ** __ptr_to_csinhf = &__export_csinhf;



	asm(""
	".section .data.export_csqrt \n"
"___export_csqrt_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_csqrt: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _csqrt \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_csqrt;
__attribute__((section(".dlist_so_export_csqrt")))
char const * __name_csqrt = "csqrt";
__attribute__((section(".dlist_so_export_csqrt")))
void ** __ptr_to_csqrt = &__export_csqrt;



	asm(""
	".section .data.export_csqrtf \n"
"___export_csqrtf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_csqrtf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _csqrtf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_csqrtf;
__attribute__((section(".dlist_so_export_csqrtf")))
char const * __name_csqrtf = "csqrtf";
__attribute__((section(".dlist_so_export_csqrtf")))
void ** __ptr_to_csqrtf = &__export_csqrtf;



	asm(""
	".section .data.export_ctan \n"
"___export_ctan_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ctan: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ctan \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ctan;
__attribute__((section(".dlist_so_export_ctan")))
char const * __name_ctan = "ctan";
__attribute__((section(".dlist_so_export_ctan")))
void ** __ptr_to_ctan = &__export_ctan;



	asm(""
	".section .data.export_ctanf \n"
"___export_ctanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ctanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ctanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ctanf;
__attribute__((section(".dlist_so_export_ctanf")))
char const * __name_ctanf = "ctanf";
__attribute__((section(".dlist_so_export_ctanf")))
void ** __ptr_to_ctanf = &__export_ctanf;



	asm(""
	".section .data.export_ctanh \n"
"___export_ctanh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ctanh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ctanh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ctanh;
__attribute__((section(".dlist_so_export_ctanh")))
char const * __name_ctanh = "ctanh";
__attribute__((section(".dlist_so_export_ctanh")))
void ** __ptr_to_ctanh = &__export_ctanh;



	asm(""
	".section .data.export_ctanhf \n"
"___export_ctanhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ctanhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ctanhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ctanhf;
__attribute__((section(".dlist_so_export_ctanhf")))
char const * __name_ctanhf = "ctanhf";
__attribute__((section(".dlist_so_export_ctanhf")))
void ** __ptr_to_ctanhf = &__export_ctanhf;



	asm(""
	".section .data.export_ctime \n"
"___export_ctime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ctime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ctime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ctime;
__attribute__((section(".dlist_so_export_ctime")))
char const * __name_ctime = "ctime";
__attribute__((section(".dlist_so_export_ctime")))
void ** __ptr_to_ctime = &__export_ctime;


extern void *_ctype___data;
__attribute__((section(".dlist_so_export__ctype___data")))
char const * __name__ctype___data = "_ctype___data";
__attribute__((section(".dlist_so_export__ctype___data")))
void ** __ptr_to__ctype___data = (void **)&_ctype___data;


extern void *dcgettext;
__attribute__((section(".dlist_so_export_dcgettext")))
char const * __name_dcgettext = "dcgettext";
__attribute__((section(".dlist_so_export_dcgettext")))
void ** __ptr_to_dcgettext = (void **)&dcgettext;


extern void *dgettext;
__attribute__((section(".dlist_so_export_dgettext")))
char const * __name_dgettext = "dgettext";
__attribute__((section(".dlist_so_export_dgettext")))
void ** __ptr_to_dgettext = (void **)&dgettext;


extern void *difftime;
__attribute__((section(".dlist_so_export_difftime")))
char const * __name_difftime = "difftime";
__attribute__((section(".dlist_so_export_difftime")))
void ** __ptr_to_difftime = (void **)&difftime;


extern void *dirname;
__attribute__((section(".dlist_so_export_dirname")))
char const * __name_dirname = "dirname";
__attribute__((section(".dlist_so_export_dirname")))
void ** __ptr_to_dirname = (void **)&dirname;



	asm(""
	".section .data.export_div \n"
"___export_div_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_div: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _div \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_div;
__attribute__((section(".dlist_so_export_div")))
char const * __name_div = "div";
__attribute__((section(".dlist_so_export_div")))
void ** __ptr_to_div = &__export_div;



	asm(""
	".section .data.export___divdf3 \n"
"___export___divdf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___divdf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___divdf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___divdf3;
__attribute__((section(".dlist_so_export___divdf3")))
char const * __name___divdf3 = "__divdf3";
__attribute__((section(".dlist_so_export___divdf3")))
void ** __ptr_to___divdf3 = &__export___divdf3;



	asm(""
	".section .data.export___divsf3 \n"
"___export___divsf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___divsf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___divsf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___divsf3;
__attribute__((section(".dlist_so_export___divsf3")))
char const * __name___divsf3 = "__divsf3";
__attribute__((section(".dlist_so_export___divsf3")))
void ** __ptr_to___divsf3 = &__export___divsf3;



	asm(""
	".section .data.export___divsi3 \n"
"___export___divsi3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___divsi3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___divsi3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___divsi3;
__attribute__((section(".dlist_so_export___divsi3")))
char const * __name___divsi3 = "__divsi3";
__attribute__((section(".dlist_so_export___divsi3")))
void ** __ptr_to___divsi3 = &__export___divsi3;



	asm(""
	".section .data.export_dlclose \n"
"___export_dlclose_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dlclose: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dlclose \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dlclose;
__attribute__((section(".dlist_so_export_dlclose")))
char const * __name_dlclose = "dlclose";
__attribute__((section(".dlist_so_export_dlclose")))
void ** __ptr_to_dlclose = &__export_dlclose;



	asm(""
	".section .data.export_dlerror \n"
"___export_dlerror_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dlerror: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dlerror \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dlerror;
__attribute__((section(".dlist_so_export_dlerror")))
char const * __name_dlerror = "dlerror";
__attribute__((section(".dlist_so_export_dlerror")))
void ** __ptr_to_dlerror = &__export_dlerror;



	asm(""
	".section .data.export_dlopen \n"
"___export_dlopen_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dlopen: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dlopen \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dlopen;
__attribute__((section(".dlist_so_export_dlopen")))
char const * __name_dlopen = "dlopen";
__attribute__((section(".dlist_so_export_dlopen")))
void ** __ptr_to_dlopen = &__export_dlopen;



	asm(""
	".section .data.export_dlsym \n"
"___export_dlsym_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dlsym: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dlsym \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dlsym;
__attribute__((section(".dlist_so_export_dlsym")))
char const * __name_dlsym = "dlsym";
__attribute__((section(".dlist_so_export_dlsym")))
void ** __ptr_to_dlsym = &__export_dlsym;



	asm(""
	".section .data.export_dlvsym \n"
"___export_dlvsym_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dlvsym: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dlvsym \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dlvsym;
__attribute__((section(".dlist_so_export_dlvsym")))
char const * __name_dlvsym = "dlvsym";
__attribute__((section(".dlist_so_export_dlvsym")))
void ** __ptr_to_dlvsym = &__export_dlvsym;



	asm(""
	".section .data.export_dotimer \n"
"___export_dotimer_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dotimer: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dotimer \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dotimer;
__attribute__((section(".dlist_so_export_dotimer")))
char const * __name_dotimer = "dotimer";
__attribute__((section(".dlist_so_export_dotimer")))
void ** __ptr_to_dotimer = &__export_dotimer;



	asm(""
	".section .data.export_drand48 \n"
"___export_drand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_drand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _drand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_drand48;
__attribute__((section(".dlist_so_export_drand48")))
char const * __name_drand48 = "drand48";
__attribute__((section(".dlist_so_export_drand48")))
void ** __ptr_to_drand48 = &__export_drand48;



	asm(""
	".section .data.export_dup \n"
"___export_dup_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dup: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dup \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dup;
__attribute__((section(".dlist_so_export_dup")))
char const * __name_dup = "dup";
__attribute__((section(".dlist_so_export_dup")))
void ** __ptr_to_dup = &__export_dup;



	asm(""
	".section .data.export_dup2 \n"
"___export_dup2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_dup2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _dup2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_dup2;
__attribute__((section(".dlist_so_export_dup2")))
char const * __name_dup2 = "dup2";
__attribute__((section(".dlist_so_export_dup2")))
void ** __ptr_to_dup2 = &__export_dup2;



	asm(""
	".section .data.export___eprintf \n"
"___export___eprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___eprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___eprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___eprintf;
__attribute__((section(".dlist_so_export___eprintf")))
char const * __name___eprintf = "__eprintf";
__attribute__((section(".dlist_so_export___eprintf")))
void ** __ptr_to___eprintf = &__export___eprintf;



	asm(""
	".section .data.export___eqdf2 \n"
"___export___eqdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___eqdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___eqdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___eqdf2;
__attribute__((section(".dlist_so_export___eqdf2")))
char const * __name___eqdf2 = "__eqdf2";
__attribute__((section(".dlist_so_export___eqdf2")))
void ** __ptr_to___eqdf2 = &__export___eqdf2;



	asm(""
	".section .data.export___eqsf2 \n"
"___export___eqsf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___eqsf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___eqsf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___eqsf2;
__attribute__((section(".dlist_so_export___eqsf2")))
char const * __name___eqsf2 = "__eqsf2";
__attribute__((section(".dlist_so_export___eqsf2")))
void ** __ptr_to___eqsf2 = &__export___eqsf2;



	asm(""
	".section .data.export___eqxf2 \n"
"___export___eqxf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___eqxf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___eqxf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___eqxf2;
__attribute__((section(".dlist_so_export___eqxf2")))
char const * __name___eqxf2 = "__eqxf2";
__attribute__((section(".dlist_so_export___eqxf2")))
void ** __ptr_to___eqxf2 = &__export___eqxf2;



	asm(""
	".section .data.export_erand48 \n"
"___export_erand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_erand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _erand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_erand48;
__attribute__((section(".dlist_so_export_erand48")))
char const * __name_erand48 = "erand48";
__attribute__((section(".dlist_so_export_erand48")))
void ** __ptr_to_erand48 = &__export_erand48;



	asm(""
	".section .data.export_erf \n"
"___export_erf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_erf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _erf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_erf;
__attribute__((section(".dlist_so_export_erf")))
char const * __name_erf = "erf";
__attribute__((section(".dlist_so_export_erf")))
void ** __ptr_to_erf = &__export_erf;



	asm(""
	".section .data.export_erfc \n"
"___export_erfc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_erfc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _erfc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_erfc;
__attribute__((section(".dlist_so_export_erfc")))
char const * __name_erfc = "erfc";
__attribute__((section(".dlist_so_export_erfc")))
void ** __ptr_to_erfc = &__export_erfc;



	asm(""
	".section .data.export_erfcf \n"
"___export_erfcf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_erfcf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _erfcf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_erfcf;
__attribute__((section(".dlist_so_export_erfcf")))
char const * __name_erfcf = "erfcf";
__attribute__((section(".dlist_so_export_erfcf")))
void ** __ptr_to_erfcf = &__export_erfcf;



	asm(""
	".section .data.export_erff \n"
"___export_erff_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_erff: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _erff \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_erff;
__attribute__((section(".dlist_so_export_erff")))
char const * __name_erff = "erff";
__attribute__((section(".dlist_so_export_erff")))
void ** __ptr_to_erff = &__export_erff;



	asm(""
	".section .data.export_execv \n"
"___export_execv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_execv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _execv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_execv;
__attribute__((section(".dlist_so_export_execv")))
char const * __name_execv = "execv";
__attribute__((section(".dlist_so_export_execv")))
void ** __ptr_to_execv = &__export_execv;



	asm(""
	".section .data.export_execve \n"
"___export_execve_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_execve: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _execve \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_execve;
__attribute__((section(".dlist_so_export_execve")))
char const * __name_execve = "execve";
__attribute__((section(".dlist_so_export_execve")))
void ** __ptr_to_execve = &__export_execve;



	asm(""
	".section .data.export_execvp \n"
"___export_execvp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_execvp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _execvp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_execvp;
__attribute__((section(".dlist_so_export_execvp")))
char const * __name_execvp = "execvp";
__attribute__((section(".dlist_so_export_execvp")))
void ** __ptr_to_execvp = &__export_execvp;



	asm(""
	".section .data.export___exitatexit \n"
"___export___exitatexit_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___exitatexit: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___exitatexit \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___exitatexit;
__attribute__((section(".dlist_so_export___exitatexit")))
char const * __name___exitatexit = "__exitatexit";
__attribute__((section(".dlist_so_export___exitatexit")))
void ** __ptr_to___exitatexit = &__export___exitatexit;



	asm(""
	".section .data.export___exitchdir \n"
"___export___exitchdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___exitchdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___exitchdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___exitchdir;
__attribute__((section(".dlist_so_export___exitchdir")))
char const * __name___exitchdir = "__exitchdir";
__attribute__((section(".dlist_so_export___exitchdir")))
void ** __ptr_to___exitchdir = &__export___exitchdir;


extern void *__exitcpp;
__attribute__((section(".dlist_so_export___exitcpp")))
char const * __name___exitcpp = "__exitcpp";
__attribute__((section(".dlist_so_export___exitcpp")))
void ** __ptr_to___exitcpp = (void **)&__exitcpp;



	asm(""
	".section .data.export___exitlibraries \n"
"___export___exitlibraries_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___exitlibraries: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___exitlibraries \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___exitlibraries;
__attribute__((section(".dlist_so_export___exitlibraries")))
char const * __name___exitlibraries = "__exitlibraries";
__attribute__((section(".dlist_so_export___exitlibraries")))
void ** __ptr_to___exitlibraries = &__export___exitlibraries;



	asm(""
	".section .data.export___exitlocale \n"
"___export___exitlocale_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___exitlocale: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___exitlocale \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___exitlocale;
__attribute__((section(".dlist_so_export___exitlocale")))
char const * __name___exitlocale = "__exitlocale";
__attribute__((section(".dlist_so_export___exitlocale")))
void ** __ptr_to___exitlocale = &__export___exitlocale;



	asm(""
	".section .data.export___exitmalloc \n"
"___export___exitmalloc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___exitmalloc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___exitmalloc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___exitmalloc;
__attribute__((section(".dlist_so_export___exitmalloc")))
char const * __name___exitmalloc = "__exitmalloc";
__attribute__((section(".dlist_so_export___exitmalloc")))
void ** __ptr_to___exitmalloc = &__export___exitmalloc;



	asm(""
	".section .data.export___exitstdio \n"
"___export___exitstdio_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___exitstdio: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___exitstdio \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___exitstdio;
__attribute__((section(".dlist_so_export___exitstdio")))
char const * __name___exitstdio = "__exitstdio";
__attribute__((section(".dlist_so_export___exitstdio")))
void ** __ptr_to___exitstdio = &__export___exitstdio;



	asm(""
	".section .data.export_exp \n"
"___export_exp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_exp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _exp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_exp;
__attribute__((section(".dlist_so_export_exp")))
char const * __name_exp = "exp";
__attribute__((section(".dlist_so_export_exp")))
void ** __ptr_to_exp = &__export_exp;



	asm(""
	".section .data.export_exp10 \n"
"___export_exp10_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_exp10: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _exp10 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_exp10;
__attribute__((section(".dlist_so_export_exp10")))
char const * __name_exp10 = "exp10";
__attribute__((section(".dlist_so_export_exp10")))
void ** __ptr_to_exp10 = &__export_exp10;



	asm(""
	".section .data.export_exp10f \n"
"___export_exp10f_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_exp10f: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _exp10f \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_exp10f;
__attribute__((section(".dlist_so_export_exp10f")))
char const * __name_exp10f = "exp10f";
__attribute__((section(".dlist_so_export_exp10f")))
void ** __ptr_to_exp10f = &__export_exp10f;



	asm(""
	".section .data.export_expf \n"
"___export_expf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_expf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _expf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_expf;
__attribute__((section(".dlist_so_export_expf")))
char const * __name_expf = "expf";
__attribute__((section(".dlist_so_export_expf")))
void ** __ptr_to_expf = &__export_expf;



	asm(""
	".section .data.export_expm1 \n"
"___export_expm1_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_expm1: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _expm1 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_expm1;
__attribute__((section(".dlist_so_export_expm1")))
char const * __name_expm1 = "expm1";
__attribute__((section(".dlist_so_export_expm1")))
void ** __ptr_to_expm1 = &__export_expm1;



	asm(""
	".section .data.export_expm1f \n"
"___export_expm1f_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_expm1f: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _expm1f \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_expm1f;
__attribute__((section(".dlist_so_export_expm1f")))
char const * __name_expm1f = "expm1f";
__attribute__((section(".dlist_so_export_expm1f")))
void ** __ptr_to_expm1f = &__export_expm1f;



	asm(""
	".section .data.export___extendsfdf2 \n"
"___export___extendsfdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___extendsfdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___extendsfdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___extendsfdf2;
__attribute__((section(".dlist_so_export___extendsfdf2")))
char const * __name___extendsfdf2 = "__extendsfdf2";
__attribute__((section(".dlist_so_export___extendsfdf2")))
void ** __ptr_to___extendsfdf2 = &__export___extendsfdf2;



	asm(""
	".section .data.export_fabs \n"
"___export_fabs_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fabs: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fabs \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fabs;
__attribute__((section(".dlist_so_export_fabs")))
char const * __name_fabs = "fabs";
__attribute__((section(".dlist_so_export_fabs")))
void ** __ptr_to_fabs = &__export_fabs;



	asm(""
	".section .data.export_fabsf \n"
"___export_fabsf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fabsf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fabsf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fabsf;
__attribute__((section(".dlist_so_export_fabsf")))
char const * __name_fabsf = "fabsf";
__attribute__((section(".dlist_so_export_fabsf")))
void ** __ptr_to_fabsf = &__export_fabsf;



	asm(""
	".section .data.export_fchdir \n"
"___export_fchdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fchdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fchdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fchdir;
__attribute__((section(".dlist_so_export_fchdir")))
char const * __name_fchdir = "fchdir";
__attribute__((section(".dlist_so_export_fchdir")))
void ** __ptr_to_fchdir = &__export_fchdir;



	asm(""
	".section .data.export___fclose \n"
"___export___fclose_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___fclose: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___fclose \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___fclose;
__attribute__((section(".dlist_so_export___fclose")))
char const * __name___fclose = "__fclose";
__attribute__((section(".dlist_so_export___fclose")))
void ** __ptr_to___fclose = &__export___fclose;



	asm(""
	".section .data.export_fclose \n"
"___export_fclose_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fclose: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fclose \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fclose;
__attribute__((section(".dlist_so_export_fclose")))
char const * __name_fclose = "fclose";
__attribute__((section(".dlist_so_export_fclose")))
void ** __ptr_to_fclose = &__export_fclose;


extern void *fcntl;
__attribute__((section(".dlist_so_export_fcntl")))
char const * __name_fcntl = "fcntl";
__attribute__((section(".dlist_so_export_fcntl")))
void ** __ptr_to_fcntl = (void **)&fcntl;


extern void *fdatasync;
__attribute__((section(".dlist_so_export_fdatasync")))
char const * __name_fdatasync = "fdatasync";
__attribute__((section(".dlist_so_export_fdatasync")))
void ** __ptr_to_fdatasync = (void **)&fdatasync;



	asm(""
	".section .data.export_fdim \n"
"___export_fdim_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fdim: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fdim \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fdim;
__attribute__((section(".dlist_so_export_fdim")))
char const * __name_fdim = "fdim";
__attribute__((section(".dlist_so_export_fdim")))
void ** __ptr_to_fdim = &__export_fdim;



	asm(""
	".section .data.export_fdimf \n"
"___export_fdimf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fdimf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fdimf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fdimf;
__attribute__((section(".dlist_so_export_fdimf")))
char const * __name_fdimf = "fdimf";
__attribute__((section(".dlist_so_export_fdimf")))
void ** __ptr_to_fdimf = &__export_fdimf;



	asm(""
	".section .data.export_fdopen \n"
"___export_fdopen_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fdopen: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fdopen \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fdopen;
__attribute__((section(".dlist_so_export_fdopen")))
char const * __name_fdopen = "fdopen";
__attribute__((section(".dlist_so_export_fdopen")))
void ** __ptr_to_fdopen = &__export_fdopen;



	asm(""
	".section .data.export_fdtofh \n"
"___export_fdtofh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fdtofh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fdtofh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fdtofh;
__attribute__((section(".dlist_so_export_fdtofh")))
char const * __name_fdtofh = "fdtofh";
__attribute__((section(".dlist_so_export_fdtofh")))
void ** __ptr_to_fdtofh = &__export_fdtofh;


extern void *feof;
__attribute__((section(".dlist_so_export_feof")))
char const * __name_feof = "feof";
__attribute__((section(".dlist_so_export_feof")))
void ** __ptr_to_feof = (void **)&feof;


extern void *ferror;
__attribute__((section(".dlist_so_export_ferror")))
char const * __name_ferror = "ferror";
__attribute__((section(".dlist_so_export_ferror")))
void ** __ptr_to_ferror = (void **)&ferror;



	asm(""
	".section .data.export___fflush \n"
"___export___fflush_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___fflush: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___fflush \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___fflush;
__attribute__((section(".dlist_so_export___fflush")))
char const * __name___fflush = "__fflush";
__attribute__((section(".dlist_so_export___fflush")))
void ** __ptr_to___fflush = &__export___fflush;



	asm(""
	".section .data.export_fflush \n"
"___export_fflush_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fflush: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fflush \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fflush;
__attribute__((section(".dlist_so_export_fflush")))
char const * __name_fflush = "fflush";
__attribute__((section(".dlist_so_export_fflush")))
void ** __ptr_to_fflush = &__export_fflush;


extern void *ffs;
__attribute__((section(".dlist_so_export_ffs")))
char const * __name_ffs = "ffs";
__attribute__((section(".dlist_so_export_ffs")))
void ** __ptr_to_ffs = (void **)&ffs;



	asm(""
	".section .data.export_fgetc \n"
"___export_fgetc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fgetc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fgetc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fgetc;
__attribute__((section(".dlist_so_export_fgetc")))
char const * __name_fgetc = "fgetc";
__attribute__((section(".dlist_so_export_fgetc")))
void ** __ptr_to_fgetc = &__export_fgetc;



	asm(""
	".section .data.export_fgetpos \n"
"___export_fgetpos_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fgetpos: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fgetpos \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fgetpos;
__attribute__((section(".dlist_so_export_fgetpos")))
char const * __name_fgetpos = "fgetpos";
__attribute__((section(".dlist_so_export_fgetpos")))
void ** __ptr_to_fgetpos = &__export_fgetpos;



	asm(""
	".section .data.export_fgets \n"
"___export_fgets_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fgets: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fgets \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fgets;
__attribute__((section(".dlist_so_export_fgets")))
char const * __name_fgets = "fgets";
__attribute__((section(".dlist_so_export_fgets")))
void ** __ptr_to_fgets = &__export_fgets;



	asm(""
	".section .data.export_fgetwc \n"
"___export_fgetwc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fgetwc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fgetwc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fgetwc;
__attribute__((section(".dlist_so_export_fgetwc")))
char const * __name_fgetwc = "fgetwc";
__attribute__((section(".dlist_so_export_fgetwc")))
void ** __ptr_to_fgetwc = &__export_fgetwc;


extern void *fileno;
__attribute__((section(".dlist_so_export_fileno")))
char const * __name_fileno = "fileno";
__attribute__((section(".dlist_so_export_fileno")))
void ** __ptr_to_fileno = (void **)&fileno;



	asm(""
	".section .data.export___fillenviron \n"
"___export___fillenviron_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___fillenviron: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___fillenviron \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___fillenviron;
__attribute__((section(".dlist_so_export___fillenviron")))
char const * __name___fillenviron = "__fillenviron";
__attribute__((section(".dlist_so_export___fillenviron")))
void ** __ptr_to___fillenviron = &__export___fillenviron;


extern void *finite;
__attribute__((section(".dlist_so_export_finite")))
char const * __name_finite = "finite";
__attribute__((section(".dlist_so_export_finite")))
void ** __ptr_to_finite = (void **)&finite;


extern void *finitef;
__attribute__((section(".dlist_so_export_finitef")))
char const * __name_finitef = "finitef";
__attribute__((section(".dlist_so_export_finitef")))
void ** __ptr_to_finitef = (void **)&finitef;



	asm(""
	".section .data.export_floor \n"
"___export_floor_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_floor: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _floor \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_floor;
__attribute__((section(".dlist_so_export_floor")))
char const * __name_floor = "floor";
__attribute__((section(".dlist_so_export_floor")))
void ** __ptr_to_floor = &__export_floor;



	asm(""
	".section .data.export_floorf \n"
"___export_floorf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_floorf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _floorf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_floorf;
__attribute__((section(".dlist_so_export_floorf")))
char const * __name_floorf = "floorf";
__attribute__((section(".dlist_so_export_floorf")))
void ** __ptr_to_floorf = &__export_floorf;



	asm(""
	".section .data.export___flush_cache \n"
"___export___flush_cache_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___flush_cache: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___flush_cache \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___flush_cache;
__attribute__((section(".dlist_so_export___flush_cache")))
char const * __name___flush_cache = "__flush_cache";
__attribute__((section(".dlist_so_export___flush_cache")))
void ** __ptr_to___flush_cache = &__export___flush_cache;



	asm(""
	".section .data.export_fma \n"
"___export_fma_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fma: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fma \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fma;
__attribute__((section(".dlist_so_export_fma")))
char const * __name_fma = "fma";
__attribute__((section(".dlist_so_export_fma")))
void ** __ptr_to_fma = &__export_fma;



	asm(""
	".section .data.export_fmaf \n"
"___export_fmaf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fmaf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fmaf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fmaf;
__attribute__((section(".dlist_so_export_fmaf")))
char const * __name_fmaf = "fmaf";
__attribute__((section(".dlist_so_export_fmaf")))
void ** __ptr_to_fmaf = &__export_fmaf;



	asm(""
	".section .data.export_fmax \n"
"___export_fmax_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fmax: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fmax \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fmax;
__attribute__((section(".dlist_so_export_fmax")))
char const * __name_fmax = "fmax";
__attribute__((section(".dlist_so_export_fmax")))
void ** __ptr_to_fmax = &__export_fmax;



	asm(""
	".section .data.export_fmaxf \n"
"___export_fmaxf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fmaxf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fmaxf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fmaxf;
__attribute__((section(".dlist_so_export_fmaxf")))
char const * __name_fmaxf = "fmaxf";
__attribute__((section(".dlist_so_export_fmaxf")))
void ** __ptr_to_fmaxf = &__export_fmaxf;



	asm(""
	".section .data.export_fmin \n"
"___export_fmin_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fmin: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fmin \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fmin;
__attribute__((section(".dlist_so_export_fmin")))
char const * __name_fmin = "fmin";
__attribute__((section(".dlist_so_export_fmin")))
void ** __ptr_to_fmin = &__export_fmin;



	asm(""
	".section .data.export_fminf \n"
"___export_fminf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fminf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fminf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fminf;
__attribute__((section(".dlist_so_export_fminf")))
char const * __name_fminf = "fminf";
__attribute__((section(".dlist_so_export_fminf")))
void ** __ptr_to_fminf = &__export_fminf;



	asm(""
	".section .data.export_fmod \n"
"___export_fmod_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fmod: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fmod \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fmod;
__attribute__((section(".dlist_so_export_fmod")))
char const * __name_fmod = "fmod";
__attribute__((section(".dlist_so_export_fmod")))
void ** __ptr_to_fmod = &__export_fmod;



	asm(""
	".section .data.export_fmodf \n"
"___export_fmodf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fmodf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fmodf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fmodf;
__attribute__((section(".dlist_so_export_fmodf")))
char const * __name_fmodf = "fmodf";
__attribute__((section(".dlist_so_export_fmodf")))
void ** __ptr_to_fmodf = &__export_fmodf;



	asm(""
	".section .data.export_fnmatch \n"
"___export_fnmatch_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fnmatch: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fnmatch \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fnmatch;
__attribute__((section(".dlist_so_export_fnmatch")))
char const * __name_fnmatch = "fnmatch";
__attribute__((section(".dlist_so_export_fnmatch")))
void ** __ptr_to_fnmatch = &__export_fnmatch;



	asm(""
	".section .data.export_fopen \n"
"___export_fopen_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fopen: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fopen \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fopen;
__attribute__((section(".dlist_so_export_fopen")))
char const * __name_fopen = "fopen";
__attribute__((section(".dlist_so_export_fopen")))
void ** __ptr_to_fopen = &__export_fopen;



	asm(""
	".section .data.export_fork \n"
"___export_fork_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fork: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fork \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fork;
__attribute__((section(".dlist_so_export_fork")))
char const * __name_fork = "fork";
__attribute__((section(".dlist_so_export_fork")))
void ** __ptr_to_fork = &__export_fork;


extern void *__fpclassifyd;
__attribute__((section(".dlist_so_export___fpclassifyd")))
char const * __name___fpclassifyd = "__fpclassifyd";
__attribute__((section(".dlist_so_export___fpclassifyd")))
void ** __ptr_to___fpclassifyd = (void **)&__fpclassifyd;


extern void *__fpclassifyf;
__attribute__((section(".dlist_so_export___fpclassifyf")))
char const * __name___fpclassifyf = "__fpclassifyf";
__attribute__((section(".dlist_so_export___fpclassifyf")))
void ** __ptr_to___fpclassifyf = (void **)&__fpclassifyf;



	asm(""
	".section .data.export_fprintf \n"
"___export_fprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fprintf;
__attribute__((section(".dlist_so_export_fprintf")))
char const * __name_fprintf = "fprintf";
__attribute__((section(".dlist_so_export_fprintf")))
void ** __ptr_to_fprintf = &__export_fprintf;


extern void *__fpucheck;
__attribute__((section(".dlist_so_export___fpucheck")))
char const * __name___fpucheck = "__fpucheck";
__attribute__((section(".dlist_so_export___fpucheck")))
void ** __ptr_to___fpucheck = (void **)&__fpucheck;



	asm(""
	".section .data.export_fputc \n"
"___export_fputc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fputc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fputc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fputc;
__attribute__((section(".dlist_so_export_fputc")))
char const * __name_fputc = "fputc";
__attribute__((section(".dlist_so_export_fputc")))
void ** __ptr_to_fputc = &__export_fputc;



	asm(""
	".section .data.export_fputs \n"
"___export_fputs_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fputs: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fputs \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fputs;
__attribute__((section(".dlist_so_export_fputs")))
char const * __name_fputs = "fputs";
__attribute__((section(".dlist_so_export_fputs")))
void ** __ptr_to_fputs = &__export_fputs;



	asm(""
	".section .data.export_fputwc \n"
"___export_fputwc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fputwc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fputwc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fputwc;
__attribute__((section(".dlist_so_export_fputwc")))
char const * __name_fputwc = "fputwc";
__attribute__((section(".dlist_so_export_fputwc")))
void ** __ptr_to_fputwc = &__export_fputwc;



	asm(""
	".section .data.export_fread \n"
"___export_fread_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fread: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fread \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fread;
__attribute__((section(".dlist_so_export_fread")))
char const * __name_fread = "fread";
__attribute__((section(".dlist_so_export_fread")))
void ** __ptr_to_fread = &__export_fread;



	asm(""
	".section .data.export_free \n"
"___export_free_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_free: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _free \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_free;
__attribute__((section(".dlist_so_export_free")))
char const * __name_free = "free";
__attribute__((section(".dlist_so_export_free")))
void ** __ptr_to_free = &__export_free;



	asm(""
	".section .data.export___freeBuff \n"
"___export___freeBuff_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___freeBuff: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___freeBuff \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___freeBuff;
__attribute__((section(".dlist_so_export___freeBuff")))
char const * __name___freeBuff = "__freeBuff";
__attribute__((section(".dlist_so_export___freeBuff")))
void ** __ptr_to___freeBuff = &__export___freeBuff;



	asm(""
	".section .data.export_freelocale \n"
"___export_freelocale_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_freelocale: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _freelocale \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_freelocale;
__attribute__((section(".dlist_so_export_freelocale")))
char const * __name_freelocale = "freelocale";
__attribute__((section(".dlist_so_export_freelocale")))
void ** __ptr_to_freelocale = &__export_freelocale;



	asm(""
	".section .data.export_freopen \n"
"___export_freopen_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_freopen: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _freopen \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_freopen;
__attribute__((section(".dlist_so_export_freopen")))
char const * __name_freopen = "freopen";
__attribute__((section(".dlist_so_export_freopen")))
void ** __ptr_to_freopen = &__export_freopen;



	asm(""
	".section .data.export_frexp \n"
"___export_frexp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_frexp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _frexp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_frexp;
__attribute__((section(".dlist_so_export_frexp")))
char const * __name_frexp = "frexp";
__attribute__((section(".dlist_so_export_frexp")))
void ** __ptr_to_frexp = &__export_frexp;



	asm(""
	".section .data.export_frexpf \n"
"___export_frexpf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_frexpf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _frexpf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_frexpf;
__attribute__((section(".dlist_so_export_frexpf")))
char const * __name_frexpf = "frexpf";
__attribute__((section(".dlist_so_export_frexpf")))
void ** __ptr_to_frexpf = &__export_frexpf;



	asm(""
	".section .data.export_fscanf \n"
"___export_fscanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fscanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fscanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fscanf;
__attribute__((section(".dlist_so_export_fscanf")))
char const * __name_fscanf = "fscanf";
__attribute__((section(".dlist_so_export_fscanf")))
void ** __ptr_to_fscanf = &__export_fscanf;



	asm(""
	".section .data.export_fseek \n"
"___export_fseek_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fseek: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fseek \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fseek;
__attribute__((section(".dlist_so_export_fseek")))
char const * __name_fseek = "fseek";
__attribute__((section(".dlist_so_export_fseek")))
void ** __ptr_to_fseek = &__export_fseek;



	asm(""
	".section .data.export_fsetpos \n"
"___export_fsetpos_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fsetpos: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fsetpos \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fsetpos;
__attribute__((section(".dlist_so_export_fsetpos")))
char const * __name_fsetpos = "fsetpos";
__attribute__((section(".dlist_so_export_fsetpos")))
void ** __ptr_to_fsetpos = &__export_fsetpos;



	asm(""
	".section .data.export_fstat \n"
"___export_fstat_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fstat: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fstat \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fstat;
__attribute__((section(".dlist_so_export_fstat")))
char const * __name_fstat = "fstat";
__attribute__((section(".dlist_so_export_fstat")))
void ** __ptr_to_fstat = &__export_fstat;


extern void *fsync;
__attribute__((section(".dlist_so_export_fsync")))
char const * __name_fsync = "fsync";
__attribute__((section(".dlist_so_export_fsync")))
void ** __ptr_to_fsync = (void **)&fsync;



	asm(""
	".section .data.export_ftell \n"
"___export_ftell_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ftell: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ftell \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ftell;
__attribute__((section(".dlist_so_export_ftell")))
char const * __name_ftell = "ftell";
__attribute__((section(".dlist_so_export_ftell")))
void ** __ptr_to_ftell = &__export_ftell;



	asm(""
	".section .data.export_ftruncate \n"
"___export_ftruncate_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ftruncate: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ftruncate \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ftruncate;
__attribute__((section(".dlist_so_export_ftruncate")))
char const * __name_ftruncate = "ftruncate";
__attribute__((section(".dlist_so_export_ftruncate")))
void ** __ptr_to_ftruncate = &__export_ftruncate;



	asm(""
	".section .data.export_fwrite \n"
"___export_fwrite_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_fwrite: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _fwrite \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_fwrite;
__attribute__((section(".dlist_so_export_fwrite")))
char const * __name_fwrite = "fwrite";
__attribute__((section(".dlist_so_export_fwrite")))
void ** __ptr_to_fwrite = &__export_fwrite;



	asm(""
	".section .data.export___gedf2 \n"
"___export___gedf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___gedf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___gedf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___gedf2;
__attribute__((section(".dlist_so_export___gedf2")))
char const * __name___gedf2 = "__gedf2";
__attribute__((section(".dlist_so_export___gedf2")))
void ** __ptr_to___gedf2 = &__export___gedf2;



	asm(""
	".section .data.export___gesf2 \n"
"___export___gesf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___gesf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___gesf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___gesf2;
__attribute__((section(".dlist_so_export___gesf2")))
char const * __name___gesf2 = "__gesf2";
__attribute__((section(".dlist_so_export___gesf2")))
void ** __ptr_to___gesf2 = &__export___gesf2;



	asm(""
	".section .data.export_getBstr \n"
"___export_getBstr_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getBstr: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getBstr \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getBstr;
__attribute__((section(".dlist_so_export_getBstr")))
char const * __name_getBstr = "getBstr";
__attribute__((section(".dlist_so_export_getBstr")))
void ** __ptr_to_getBstr = &__export_getBstr;



	asm(""
	".section .data.export_getc \n"
"___export_getc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getc;
__attribute__((section(".dlist_so_export_getc")))
char const * __name_getc = "getc";
__attribute__((section(".dlist_so_export_getc")))
void ** __ptr_to_getc = &__export_getc;



	asm(""
	".section .data.export_getchar \n"
"___export_getchar_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getchar: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getchar \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getchar;
__attribute__((section(".dlist_so_export_getchar")))
char const * __name_getchar = "getchar";
__attribute__((section(".dlist_so_export_getchar")))
void ** __ptr_to_getchar = &__export_getchar;



	asm(""
	".section .data.export_getcwd \n"
"___export_getcwd_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getcwd: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getcwd \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getcwd;
__attribute__((section(".dlist_so_export_getcwd")))
char const * __name_getcwd = "getcwd";
__attribute__((section(".dlist_so_export_getcwd")))
void ** __ptr_to_getcwd = &__export_getcwd;


extern void *getegid;
__attribute__((section(".dlist_so_export_getegid")))
char const * __name_getegid = "getegid";
__attribute__((section(".dlist_so_export_getegid")))
void ** __ptr_to_getegid = (void **)&getegid;



	asm(""
	".section .data.export_getenv \n"
"___export_getenv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getenv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getenv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getenv;
__attribute__((section(".dlist_so_export_getenv")))
char const * __name_getenv = "getenv";
__attribute__((section(".dlist_so_export_getenv")))
void ** __ptr_to_getenv = &__export_getenv;


extern void *geteuid;
__attribute__((section(".dlist_so_export_geteuid")))
char const * __name_geteuid = "geteuid";
__attribute__((section(".dlist_so_export_geteuid")))
void ** __ptr_to_geteuid = (void **)&geteuid;


extern void *getgid;
__attribute__((section(".dlist_so_export_getgid")))
char const * __name_getgid = "getgid";
__attribute__((section(".dlist_so_export_getgid")))
void ** __ptr_to_getgid = (void **)&getgid;



	asm(""
	".section .data.export_getopt \n"
"___export_getopt_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getopt: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getopt \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getopt;
__attribute__((section(".dlist_so_export_getopt")))
char const * __name_getopt = "getopt";
__attribute__((section(".dlist_so_export_getopt")))
void ** __ptr_to_getopt = &__export_getopt;



	asm(""
	".section .data.export_getopt_long \n"
"___export_getopt_long_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getopt_long: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getopt_long \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getopt_long;
__attribute__((section(".dlist_so_export_getopt_long")))
char const * __name_getopt_long = "getopt_long";
__attribute__((section(".dlist_so_export_getopt_long")))
void ** __ptr_to_getopt_long = &__export_getopt_long;



	asm(""
	".section .data.export_getopt_long_only \n"
"___export_getopt_long_only_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getopt_long_only: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getopt_long_only \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getopt_long_only;
__attribute__((section(".dlist_so_export_getopt_long_only")))
char const * __name_getopt_long_only = "getopt_long_only";
__attribute__((section(".dlist_so_export_getopt_long_only")))
void ** __ptr_to_getopt_long_only = &__export_getopt_long_only;



	asm(""
	".section .data.export___getopt_long_only_r \n"
"___export___getopt_long_only_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___getopt_long_only_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___getopt_long_only_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___getopt_long_only_r;
__attribute__((section(".dlist_so_export___getopt_long_only_r")))
char const * __name___getopt_long_only_r = "__getopt_long_only_r";
__attribute__((section(".dlist_so_export___getopt_long_only_r")))
void ** __ptr_to___getopt_long_only_r = &__export___getopt_long_only_r;



	asm(""
	".section .data.export___getopt_long_r \n"
"___export___getopt_long_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___getopt_long_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___getopt_long_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___getopt_long_r;
__attribute__((section(".dlist_so_export___getopt_long_r")))
char const * __name___getopt_long_r = "__getopt_long_r";
__attribute__((section(".dlist_so_export___getopt_long_r")))
void ** __ptr_to___getopt_long_r = &__export___getopt_long_r;



	asm(""
	".section .data.export___getopt_r \n"
"___export___getopt_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___getopt_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___getopt_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___getopt_r;
__attribute__((section(".dlist_so_export___getopt_r")))
char const * __name___getopt_r = "__getopt_r";
__attribute__((section(".dlist_so_export___getopt_r")))
void ** __ptr_to___getopt_r = &__export___getopt_r;



	asm(""
	".section .data.export_getpid \n"
"___export_getpid_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getpid: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getpid \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getpid;
__attribute__((section(".dlist_so_export_getpid")))
char const * __name_getpid = "getpid";
__attribute__((section(".dlist_so_export_getpid")))
void ** __ptr_to_getpid = &__export_getpid;


extern void *getppid;
__attribute__((section(".dlist_so_export_getppid")))
char const * __name_getppid = "getppid";
__attribute__((section(".dlist_so_export_getppid")))
void ** __ptr_to_getppid = (void **)&getppid;



	asm(""
	".section .data.export_getprogname \n"
"___export_getprogname_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getprogname: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getprogname \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getprogname;
__attribute__((section(".dlist_so_export_getprogname")))
char const * __name_getprogname = "getprogname";
__attribute__((section(".dlist_so_export_getprogname")))
void ** __ptr_to_getprogname = &__export_getprogname;


extern void *getrlimit;
__attribute__((section(".dlist_so_export_getrlimit")))
char const * __name_getrlimit = "getrlimit";
__attribute__((section(".dlist_so_export_getrlimit")))
void ** __ptr_to_getrlimit = (void **)&getrlimit;



	asm(""
	".section .data.export_get_run_time \n"
"___export_get_run_time_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_get_run_time: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _get_run_time \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_get_run_time;
__attribute__((section(".dlist_so_export_get_run_time")))
char const * __name_get_run_time = "get_run_time";
__attribute__((section(".dlist_so_export_get_run_time")))
void ** __ptr_to_get_run_time = &__export_get_run_time;



	asm(""
	".section .data.export_getruntime \n"
"___export_getruntime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getruntime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getruntime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getruntime;
__attribute__((section(".dlist_so_export_getruntime")))
char const * __name_getruntime = "getruntime";
__attribute__((section(".dlist_so_export_getruntime")))
void ** __ptr_to_getruntime = &__export_getruntime;



	asm(""
	".section .data.export_getrusage \n"
"___export_getrusage_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getrusage: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getrusage \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getrusage;
__attribute__((section(".dlist_so_export_getrusage")))
char const * __name_getrusage = "getrusage";
__attribute__((section(".dlist_so_export_getrusage")))
void ** __ptr_to_getrusage = &__export_getrusage;



	asm(""
	".section .data.export_gets \n"
"___export_gets_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_gets: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _gets \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_gets;
__attribute__((section(".dlist_so_export_gets")))
char const * __name_gets = "gets";
__attribute__((section(".dlist_so_export_gets")))
void ** __ptr_to_gets = &__export_gets;



	asm(""
	".section .data.export_getStandardPacket \n"
"___export_getStandardPacket_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getStandardPacket: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getStandardPacket \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getStandardPacket;
__attribute__((section(".dlist_so_export_getStandardPacket")))
char const * __name_getStandardPacket = "getStandardPacket";
__attribute__((section(".dlist_so_export_getStandardPacket")))
void ** __ptr_to_getStandardPacket = &__export_getStandardPacket;


extern void *gettext;
__attribute__((section(".dlist_so_export_gettext")))
char const * __name_gettext = "gettext";
__attribute__((section(".dlist_so_export_gettext")))
void ** __ptr_to_gettext = (void **)&gettext;



	asm(""
	".section .data.export_gettimeofday \n"
"___export_gettimeofday_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_gettimeofday: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _gettimeofday \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_gettimeofday;
__attribute__((section(".dlist_so_export_gettimeofday")))
char const * __name_gettimeofday = "gettimeofday";
__attribute__((section(".dlist_so_export_gettimeofday")))
void ** __ptr_to_gettimeofday = &__export_gettimeofday;


extern void *getuid;
__attribute__((section(".dlist_so_export_getuid")))
char const * __name_getuid = "getuid";
__attribute__((section(".dlist_so_export_getuid")))
void ** __ptr_to_getuid = (void **)&getuid;



	asm(""
	".section .data.export_getw \n"
"___export_getw_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getw: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getw \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getw;
__attribute__((section(".dlist_so_export_getw")))
char const * __name_getw = "getw";
__attribute__((section(".dlist_so_export_getw")))
void ** __ptr_to_getw = &__export_getw;



	asm(""
	".section .data.export_getwc \n"
"___export_getwc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getwc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getwc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getwc;
__attribute__((section(".dlist_so_export_getwc")))
char const * __name_getwc = "getwc";
__attribute__((section(".dlist_so_export_getwc")))
void ** __ptr_to_getwc = &__export_getwc;



	asm(""
	".section .data.export_getwd \n"
"___export_getwd_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_getwd: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _getwd \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_getwd;
__attribute__((section(".dlist_so_export_getwd")))
char const * __name_getwd = "getwd";
__attribute__((section(".dlist_so_export_getwd")))
void ** __ptr_to_getwd = &__export_getwd;



	asm(""
	".section .data.export___gexf2 \n"
"___export___gexf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___gexf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___gexf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___gexf2;
__attribute__((section(".dlist_so_export___gexf2")))
char const * __name___gexf2 = "__gexf2";
__attribute__((section(".dlist_so_export___gexf2")))
void ** __ptr_to___gexf2 = &__export___gexf2;



	asm(""
	".section .data.export_gmtime \n"
"___export_gmtime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_gmtime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _gmtime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_gmtime;
__attribute__((section(".dlist_so_export_gmtime")))
char const * __name_gmtime = "gmtime";
__attribute__((section(".dlist_so_export_gmtime")))
void ** __ptr_to_gmtime = &__export_gmtime;



	asm(""
	".section .data.export_gmtime_r \n"
"___export_gmtime_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_gmtime_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _gmtime_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_gmtime_r;
__attribute__((section(".dlist_so_export_gmtime_r")))
char const * __name_gmtime_r = "gmtime_r";
__attribute__((section(".dlist_so_export_gmtime_r")))
void ** __ptr_to_gmtime_r = &__export_gmtime_r;



	asm(""
	".section .data.export___gtdf2 \n"
"___export___gtdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___gtdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___gtdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___gtdf2;
__attribute__((section(".dlist_so_export___gtdf2")))
char const * __name___gtdf2 = "__gtdf2";
__attribute__((section(".dlist_so_export___gtdf2")))
void ** __ptr_to___gtdf2 = &__export___gtdf2;



	asm(""
	".section .data.export___gtsf2 \n"
"___export___gtsf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___gtsf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___gtsf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___gtsf2;
__attribute__((section(".dlist_so_export___gtsf2")))
char const * __name___gtsf2 = "__gtsf2";
__attribute__((section(".dlist_so_export___gtsf2")))
void ** __ptr_to___gtsf2 = &__export___gtsf2;



	asm(""
	".section .data.export___gtxf2 \n"
"___export___gtxf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___gtxf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___gtxf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___gtxf2;
__attribute__((section(".dlist_so_export___gtxf2")))
char const * __name___gtxf2 = "__gtxf2";
__attribute__((section(".dlist_so_export___gtxf2")))
void ** __ptr_to___gtxf2 = &__export___gtxf2;



	asm(""
	".section .data.export_hypot \n"
"___export_hypot_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_hypot: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _hypot \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_hypot;
__attribute__((section(".dlist_so_export_hypot")))
char const * __name_hypot = "hypot";
__attribute__((section(".dlist_so_export_hypot")))
void ** __ptr_to_hypot = &__export_hypot;



	asm(""
	".section .data.export_hypotf \n"
"___export_hypotf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_hypotf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _hypotf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_hypotf;
__attribute__((section(".dlist_so_export_hypotf")))
char const * __name_hypotf = "hypotf";
__attribute__((section(".dlist_so_export_hypotf")))
void ** __ptr_to_hypotf = &__export_hypotf;


extern void *ilogb;
__attribute__((section(".dlist_so_export_ilogb")))
char const * __name_ilogb = "ilogb";
__attribute__((section(".dlist_so_export_ilogb")))
void ** __ptr_to_ilogb = (void **)&ilogb;


extern void *ilogbf;
__attribute__((section(".dlist_so_export_ilogbf")))
char const * __name_ilogbf = "ilogbf";
__attribute__((section(".dlist_so_export_ilogbf")))
void ** __ptr_to_ilogbf = (void **)&ilogbf;


extern void *index;
__attribute__((section(".dlist_so_export_index")))
char const * __name_index = "index";
__attribute__((section(".dlist_so_export_index")))
void ** __ptr_to_index = (void **)&index;


extern void *infinity;
__attribute__((section(".dlist_so_export_infinity")))
char const * __name_infinity = "infinity";
__attribute__((section(".dlist_so_export_infinity")))
void ** __ptr_to_infinity = (void **)&infinity;


extern void *infinityf;
__attribute__((section(".dlist_so_export_infinityf")))
char const * __name_infinityf = "infinityf";
__attribute__((section(".dlist_so_export_infinityf")))
void ** __ptr_to_infinityf = (void **)&infinityf;



	asm(""
	".section .data.export___initamigapath \n"
"___export___initamigapath_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___initamigapath: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___initamigapath \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___initamigapath;
__attribute__((section(".dlist_so_export___initamigapath")))
char const * __name___initamigapath = "__initamigapath";
__attribute__((section(".dlist_so_export___initamigapath")))
void ** __ptr_to___initamigapath = &__export___initamigapath;



	asm(""
	".section .data.export___initchdir \n"
"___export___initchdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___initchdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___initchdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___initchdir;
__attribute__((section(".dlist_so_export___initchdir")))
char const * __name___initchdir = "__initchdir";
__attribute__((section(".dlist_so_export___initchdir")))
void ** __ptr_to___initchdir = &__export___initchdir;



	asm(""
	".section .data.export___initclock \n"
"___export___initclock_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___initclock: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___initclock \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___initclock;
__attribute__((section(".dlist_so_export___initclock")))
char const * __name___initclock = "__initclock";
__attribute__((section(".dlist_so_export___initclock")))
void ** __ptr_to___initclock = &__export___initclock;



	asm(""
	".section .data.export___initlocale \n"
"___export___initlocale_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___initlocale: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___initlocale \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___initlocale;
__attribute__((section(".dlist_so_export___initlocale")))
char const * __name___initlocale = "__initlocale";
__attribute__((section(".dlist_so_export___initlocale")))
void ** __ptr_to___initlocale = &__export___initlocale;



	asm(""
	".section .data.export___initmalloc \n"
"___export___initmalloc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___initmalloc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___initmalloc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___initmalloc;
__attribute__((section(".dlist_so_export___initmalloc")))
char const * __name___initmalloc = "__initmalloc";
__attribute__((section(".dlist_so_export___initmalloc")))
void ** __ptr_to___initmalloc = &__export___initmalloc;



	asm(""
	".section .data.export___initstdio \n"
"___export___initstdio_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___initstdio: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___initstdio \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___initstdio;
__attribute__((section(".dlist_so_export___initstdio")))
char const * __name___initstdio = "__initstdio";
__attribute__((section(".dlist_so_export___initstdio")))
void ** __ptr_to___initstdio = &__export___initstdio;



	asm(""
	".section .data.export___inittimer \n"
"___export___inittimer_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___inittimer: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___inittimer \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___inittimer;
__attribute__((section(".dlist_so_export___inittimer")))
char const * __name___inittimer = "__inittimer";
__attribute__((section(".dlist_so_export___inittimer")))
void ** __ptr_to___inittimer = &__export___inittimer;


extern void *ioctl;
__attribute__((section(".dlist_so_export_ioctl")))
char const * __name_ioctl = "ioctl";
__attribute__((section(".dlist_so_export_ioctl")))
void ** __ptr_to_ioctl = (void **)&ioctl;



	asm(""
	".section .data.export_isalnum \n"
"___export_isalnum_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isalnum: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isalnum \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isalnum;
__attribute__((section(".dlist_so_export_isalnum")))
char const * __name_isalnum = "isalnum";
__attribute__((section(".dlist_so_export_isalnum")))
void ** __ptr_to_isalnum = &__export_isalnum;



	asm(""
	".section .data.export_isalpha \n"
"___export_isalpha_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isalpha: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isalpha \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isalpha;
__attribute__((section(".dlist_so_export_isalpha")))
char const * __name_isalpha = "isalpha";
__attribute__((section(".dlist_so_export_isalpha")))
void ** __ptr_to_isalpha = &__export_isalpha;


extern void *isascii;
__attribute__((section(".dlist_so_export_isascii")))
char const * __name_isascii = "isascii";
__attribute__((section(".dlist_so_export_isascii")))
void ** __ptr_to_isascii = (void **)&isascii;



	asm(""
	".section .data.export_isatty \n"
"___export_isatty_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isatty: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isatty \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isatty;
__attribute__((section(".dlist_so_export_isatty")))
char const * __name_isatty = "isatty";
__attribute__((section(".dlist_so_export_isatty")))
void ** __ptr_to_isatty = &__export_isatty;


extern void *isblank;
__attribute__((section(".dlist_so_export_isblank")))
char const * __name_isblank = "isblank";
__attribute__((section(".dlist_so_export_isblank")))
void ** __ptr_to_isblank = (void **)&isblank;



	asm(""
	".section .data.export_iscntrl \n"
"___export_iscntrl_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iscntrl: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iscntrl \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iscntrl;
__attribute__((section(".dlist_so_export_iscntrl")))
char const * __name_iscntrl = "iscntrl";
__attribute__((section(".dlist_so_export_iscntrl")))
void ** __ptr_to_iscntrl = &__export_iscntrl;



	asm(""
	".section .data.export_isdigit \n"
"___export_isdigit_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isdigit: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isdigit \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isdigit;
__attribute__((section(".dlist_so_export_isdigit")))
char const * __name_isdigit = "isdigit";
__attribute__((section(".dlist_so_export_isdigit")))
void ** __ptr_to_isdigit = &__export_isdigit;



	asm(""
	".section .data.export_isgraph \n"
"___export_isgraph_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isgraph: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isgraph \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isgraph;
__attribute__((section(".dlist_so_export_isgraph")))
char const * __name_isgraph = "isgraph";
__attribute__((section(".dlist_so_export_isgraph")))
void ** __ptr_to_isgraph = &__export_isgraph;


extern void *isinf;
__attribute__((section(".dlist_so_export_isinf")))
char const * __name_isinf = "isinf";
__attribute__((section(".dlist_so_export_isinf")))
void ** __ptr_to_isinf = (void **)&isinf;


extern void *__isinfd;
__attribute__((section(".dlist_so_export___isinfd")))
char const * __name___isinfd = "__isinfd";
__attribute__((section(".dlist_so_export___isinfd")))
void ** __ptr_to___isinfd = (void **)&__isinfd;


extern void *__isinff;
__attribute__((section(".dlist_so_export___isinff")))
char const * __name___isinff = "__isinff";
__attribute__((section(".dlist_so_export___isinff")))
void ** __ptr_to___isinff = (void **)&__isinff;


extern void *isinff;
__attribute__((section(".dlist_so_export_isinff")))
char const * __name_isinff = "isinff";
__attribute__((section(".dlist_so_export_isinff")))
void ** __ptr_to_isinff = (void **)&isinff;



	asm(""
	".section .data.export_islower \n"
"___export_islower_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_islower: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _islower \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_islower;
__attribute__((section(".dlist_so_export_islower")))
char const * __name_islower = "islower";
__attribute__((section(".dlist_so_export_islower")))
void ** __ptr_to_islower = &__export_islower;


extern void *isnan;
__attribute__((section(".dlist_so_export_isnan")))
char const * __name_isnan = "isnan";
__attribute__((section(".dlist_so_export_isnan")))
void ** __ptr_to_isnan = (void **)&isnan;


extern void *__isnand;
__attribute__((section(".dlist_so_export___isnand")))
char const * __name___isnand = "__isnand";
__attribute__((section(".dlist_so_export___isnand")))
void ** __ptr_to___isnand = (void **)&__isnand;


extern void *__isnanf;
__attribute__((section(".dlist_so_export___isnanf")))
char const * __name___isnanf = "__isnanf";
__attribute__((section(".dlist_so_export___isnanf")))
void ** __ptr_to___isnanf = (void **)&__isnanf;


extern void *isnanf;
__attribute__((section(".dlist_so_export_isnanf")))
char const * __name_isnanf = "isnanf";
__attribute__((section(".dlist_so_export_isnanf")))
void ** __ptr_to_isnanf = (void **)&isnanf;



	asm(""
	".section .data.export_isprint \n"
"___export_isprint_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isprint: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isprint \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isprint;
__attribute__((section(".dlist_so_export_isprint")))
char const * __name_isprint = "isprint";
__attribute__((section(".dlist_so_export_isprint")))
void ** __ptr_to_isprint = &__export_isprint;



	asm(""
	".section .data.export_ispunct \n"
"___export_ispunct_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ispunct: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ispunct \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ispunct;
__attribute__((section(".dlist_so_export_ispunct")))
char const * __name_ispunct = "ispunct";
__attribute__((section(".dlist_so_export_ispunct")))
void ** __ptr_to_ispunct = &__export_ispunct;



	asm(""
	".section .data.export_isspace \n"
"___export_isspace_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isspace: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isspace \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isspace;
__attribute__((section(".dlist_so_export_isspace")))
char const * __name_isspace = "isspace";
__attribute__((section(".dlist_so_export_isspace")))
void ** __ptr_to_isspace = &__export_isspace;



	asm(""
	".section .data.export_isupper \n"
"___export_isupper_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isupper: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isupper \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isupper;
__attribute__((section(".dlist_so_export_isupper")))
char const * __name_isupper = "isupper";
__attribute__((section(".dlist_so_export_isupper")))
void ** __ptr_to_isupper = &__export_isupper;



	asm(""
	".section .data.export_iswalnum \n"
"___export_iswalnum_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswalnum: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswalnum \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswalnum;
__attribute__((section(".dlist_so_export_iswalnum")))
char const * __name_iswalnum = "iswalnum";
__attribute__((section(".dlist_so_export_iswalnum")))
void ** __ptr_to_iswalnum = &__export_iswalnum;



	asm(""
	".section .data.export_iswalpha \n"
"___export_iswalpha_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswalpha: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswalpha \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswalpha;
__attribute__((section(".dlist_so_export_iswalpha")))
char const * __name_iswalpha = "iswalpha";
__attribute__((section(".dlist_so_export_iswalpha")))
void ** __ptr_to_iswalpha = &__export_iswalpha;



	asm(""
	".section .data.export_iswblank \n"
"___export_iswblank_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswblank: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswblank \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswblank;
__attribute__((section(".dlist_so_export_iswblank")))
char const * __name_iswblank = "iswblank";
__attribute__((section(".dlist_so_export_iswblank")))
void ** __ptr_to_iswblank = &__export_iswblank;



	asm(""
	".section .data.export_iswcntrl \n"
"___export_iswcntrl_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswcntrl: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswcntrl \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswcntrl;
__attribute__((section(".dlist_so_export_iswcntrl")))
char const * __name_iswcntrl = "iswcntrl";
__attribute__((section(".dlist_so_export_iswcntrl")))
void ** __ptr_to_iswcntrl = &__export_iswcntrl;



	asm(""
	".section .data.export_iswctype \n"
"___export_iswctype_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswctype: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswctype \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswctype;
__attribute__((section(".dlist_so_export_iswctype")))
char const * __name_iswctype = "iswctype";
__attribute__((section(".dlist_so_export_iswctype")))
void ** __ptr_to_iswctype = &__export_iswctype;


extern void *iswdigit;
__attribute__((section(".dlist_so_export_iswdigit")))
char const * __name_iswdigit = "iswdigit";
__attribute__((section(".dlist_so_export_iswdigit")))
void ** __ptr_to_iswdigit = (void **)&iswdigit;



	asm(""
	".section .data.export_iswgraph \n"
"___export_iswgraph_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswgraph: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswgraph \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswgraph;
__attribute__((section(".dlist_so_export_iswgraph")))
char const * __name_iswgraph = "iswgraph";
__attribute__((section(".dlist_so_export_iswgraph")))
void ** __ptr_to_iswgraph = &__export_iswgraph;



	asm(""
	".section .data.export_iswlower \n"
"___export_iswlower_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswlower: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswlower \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswlower;
__attribute__((section(".dlist_so_export_iswlower")))
char const * __name_iswlower = "iswlower";
__attribute__((section(".dlist_so_export_iswlower")))
void ** __ptr_to_iswlower = &__export_iswlower;



	asm(""
	".section .data.export_iswprint \n"
"___export_iswprint_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswprint: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswprint \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswprint;
__attribute__((section(".dlist_so_export_iswprint")))
char const * __name_iswprint = "iswprint";
__attribute__((section(".dlist_so_export_iswprint")))
void ** __ptr_to_iswprint = &__export_iswprint;



	asm(""
	".section .data.export_iswpunct \n"
"___export_iswpunct_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswpunct: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswpunct \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswpunct;
__attribute__((section(".dlist_so_export_iswpunct")))
char const * __name_iswpunct = "iswpunct";
__attribute__((section(".dlist_so_export_iswpunct")))
void ** __ptr_to_iswpunct = &__export_iswpunct;



	asm(""
	".section .data.export_iswspace \n"
"___export_iswspace_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswspace: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswspace \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswspace;
__attribute__((section(".dlist_so_export_iswspace")))
char const * __name_iswspace = "iswspace";
__attribute__((section(".dlist_so_export_iswspace")))
void ** __ptr_to_iswspace = &__export_iswspace;



	asm(""
	".section .data.export_iswupper \n"
"___export_iswupper_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_iswupper: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _iswupper \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_iswupper;
__attribute__((section(".dlist_so_export_iswupper")))
char const * __name_iswupper = "iswupper";
__attribute__((section(".dlist_so_export_iswupper")))
void ** __ptr_to_iswupper = &__export_iswupper;


extern void *iswxdigit;
__attribute__((section(".dlist_so_export_iswxdigit")))
char const * __name_iswxdigit = "iswxdigit";
__attribute__((section(".dlist_so_export_iswxdigit")))
void ** __ptr_to_iswxdigit = (void **)&iswxdigit;



	asm(""
	".section .data.export_isxdigit \n"
"___export_isxdigit_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_isxdigit: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _isxdigit \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_isxdigit;
__attribute__((section(".dlist_so_export_isxdigit")))
char const * __name_isxdigit = "isxdigit";
__attribute__((section(".dlist_so_export_isxdigit")))
void ** __ptr_to_isxdigit = &__export_isxdigit;



	asm(""
	".section .data.export_itoa \n"
"___export_itoa_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_itoa: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _itoa \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_itoa;
__attribute__((section(".dlist_so_export_itoa")))
char const * __name_itoa = "itoa";
__attribute__((section(".dlist_so_export_itoa")))
void ** __ptr_to_itoa = &__export_itoa;



	asm(""
	".section .data.export_jrand48 \n"
"___export_jrand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_jrand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _jrand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_jrand48;
__attribute__((section(".dlist_so_export_jrand48")))
char const * __name_jrand48 = "jrand48";
__attribute__((section(".dlist_so_export_jrand48")))
void ** __ptr_to_jrand48 = &__export_jrand48;



	asm(""
	".section .data.export_kill \n"
"___export_kill_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_kill: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _kill \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_kill;
__attribute__((section(".dlist_so_export_kill")))
char const * __name_kill = "kill";
__attribute__((section(".dlist_so_export_kill")))
void ** __ptr_to_kill = &__export_kill;


extern void *labs;
__attribute__((section(".dlist_so_export_labs")))
char const * __name_labs = "labs";
__attribute__((section(".dlist_so_export_labs")))
void ** __ptr_to_labs = (void **)&labs;



	asm(""
	".section .data.export_lcong48 \n"
"___export_lcong48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lcong48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lcong48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lcong48;
__attribute__((section(".dlist_so_export_lcong48")))
char const * __name_lcong48 = "lcong48";
__attribute__((section(".dlist_so_export_lcong48")))
void ** __ptr_to_lcong48 = &__export_lcong48;



	asm(""
	".section .data.export_ldexp \n"
"___export_ldexp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ldexp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ldexp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ldexp;
__attribute__((section(".dlist_so_export_ldexp")))
char const * __name_ldexp = "ldexp";
__attribute__((section(".dlist_so_export_ldexp")))
void ** __ptr_to_ldexp = &__export_ldexp;



	asm(""
	".section .data.export_ldexpf \n"
"___export_ldexpf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ldexpf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ldexpf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ldexpf;
__attribute__((section(".dlist_so_export_ldexpf")))
char const * __name_ldexpf = "ldexpf";
__attribute__((section(".dlist_so_export_ldexpf")))
void ** __ptr_to_ldexpf = &__export_ldexpf;



	asm(""
	".section .data.export_ldiv \n"
"___export_ldiv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ldiv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ldiv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ldiv;
__attribute__((section(".dlist_so_export_ldiv")))
char const * __name_ldiv = "ldiv";
__attribute__((section(".dlist_so_export_ldiv")))
void ** __ptr_to_ldiv = &__export_ldiv;



	asm(""
	".section .data.export___ledf2 \n"
"___export___ledf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___ledf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___ledf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___ledf2;
__attribute__((section(".dlist_so_export___ledf2")))
char const * __name___ledf2 = "__ledf2";
__attribute__((section(".dlist_so_export___ledf2")))
void ** __ptr_to___ledf2 = &__export___ledf2;



	asm(""
	".section .data.export___lesf2 \n"
"___export___lesf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___lesf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___lesf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___lesf2;
__attribute__((section(".dlist_so_export___lesf2")))
char const * __name___lesf2 = "__lesf2";
__attribute__((section(".dlist_so_export___lesf2")))
void ** __ptr_to___lesf2 = &__export___lesf2;



	asm(""
	".section .data.export___lexf2 \n"
"___export___lexf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___lexf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___lexf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___lexf2;
__attribute__((section(".dlist_so_export___lexf2")))
char const * __name___lexf2 = "__lexf2";
__attribute__((section(".dlist_so_export___lexf2")))
void ** __ptr_to___lexf2 = &__export___lexf2;



	asm(""
	".section .data.export_link \n"
"___export_link_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_link: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _link \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_link;
__attribute__((section(".dlist_so_export_link")))
char const * __name_link = "link";
__attribute__((section(".dlist_so_export_link")))
void ** __ptr_to_link = &__export_link;



	asm(""
	".section .data.export_lldiv \n"
"___export_lldiv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lldiv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lldiv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lldiv;
__attribute__((section(".dlist_so_export_lldiv")))
char const * __name_lldiv = "lldiv";
__attribute__((section(".dlist_so_export_lldiv")))
void ** __ptr_to_lldiv = &__export_lldiv;



	asm(""
	".section .data.export_llrint \n"
"___export_llrint_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_llrint: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _llrint \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_llrint;
__attribute__((section(".dlist_so_export_llrint")))
char const * __name_llrint = "llrint";
__attribute__((section(".dlist_so_export_llrint")))
void ** __ptr_to_llrint = &__export_llrint;



	asm(""
	".section .data.export_llrintf \n"
"___export_llrintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_llrintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _llrintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_llrintf;
__attribute__((section(".dlist_so_export_llrintf")))
char const * __name_llrintf = "llrintf";
__attribute__((section(".dlist_so_export_llrintf")))
void ** __ptr_to_llrintf = &__export_llrintf;


extern void *llround;
__attribute__((section(".dlist_so_export_llround")))
char const * __name_llround = "llround";
__attribute__((section(".dlist_so_export_llround")))
void ** __ptr_to_llround = (void **)&llround;


extern void *llroundf;
__attribute__((section(".dlist_so_export_llroundf")))
char const * __name_llroundf = "llroundf";
__attribute__((section(".dlist_so_export_llroundf")))
void ** __ptr_to_llroundf = (void **)&llroundf;



	asm(""
	".section .data.export_localeconv \n"
"___export_localeconv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_localeconv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _localeconv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_localeconv;
__attribute__((section(".dlist_so_export_localeconv")))
char const * __name_localeconv = "localeconv";
__attribute__((section(".dlist_so_export_localeconv")))
void ** __ptr_to_localeconv = &__export_localeconv;


extern void *__locale_ctype_;
__attribute__((section(".dlist_so_export___locale_ctype_")))
char const * __name___locale_ctype_ = "__locale_ctype_";
__attribute__((section(".dlist_so_export___locale_ctype_")))
void ** __ptr_to___locale_ctype_ = (void **)&__locale_ctype_;



	asm(""
	".section .data.export___locale_mb_cur_max \n"
"___export___locale_mb_cur_max_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___locale_mb_cur_max: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___locale_mb_cur_max \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___locale_mb_cur_max;
__attribute__((section(".dlist_so_export___locale_mb_cur_max")))
char const * __name___locale_mb_cur_max = "__locale_mb_cur_max";
__attribute__((section(".dlist_so_export___locale_mb_cur_max")))
void ** __ptr_to___locale_mb_cur_max = &__export___locale_mb_cur_max;



	asm(""
	".section .data.export_localtime \n"
"___export_localtime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_localtime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _localtime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_localtime;
__attribute__((section(".dlist_so_export_localtime")))
char const * __name_localtime = "localtime";
__attribute__((section(".dlist_so_export_localtime")))
void ** __ptr_to_localtime = &__export_localtime;



	asm(""
	".section .data.export_localtime_r \n"
"___export_localtime_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_localtime_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _localtime_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_localtime_r;
__attribute__((section(".dlist_so_export_localtime_r")))
char const * __name_localtime_r = "localtime_r";
__attribute__((section(".dlist_so_export_localtime_r")))
void ** __ptr_to_localtime_r = &__export_localtime_r;



	asm(""
	".section .data.export_log \n"
"___export_log_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_log: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _log \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_log;
__attribute__((section(".dlist_so_export_log")))
char const * __name_log = "log";
__attribute__((section(".dlist_so_export_log")))
void ** __ptr_to_log = &__export_log;



	asm(""
	".section .data.export_log10 \n"
"___export_log10_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_log10: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _log10 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_log10;
__attribute__((section(".dlist_so_export_log10")))
char const * __name_log10 = "log10";
__attribute__((section(".dlist_so_export_log10")))
void ** __ptr_to_log10 = &__export_log10;



	asm(""
	".section .data.export_log10f \n"
"___export_log10f_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_log10f: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _log10f \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_log10f;
__attribute__((section(".dlist_so_export_log10f")))
char const * __name_log10f = "log10f";
__attribute__((section(".dlist_so_export_log10f")))
void ** __ptr_to_log10f = &__export_log10f;



	asm(""
	".section .data.export_log1p \n"
"___export_log1p_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_log1p: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _log1p \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_log1p;
__attribute__((section(".dlist_so_export_log1p")))
char const * __name_log1p = "log1p";
__attribute__((section(".dlist_so_export_log1p")))
void ** __ptr_to_log1p = &__export_log1p;



	asm(""
	".section .data.export_log1pf \n"
"___export_log1pf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_log1pf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _log1pf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_log1pf;
__attribute__((section(".dlist_so_export_log1pf")))
char const * __name_log1pf = "log1pf";
__attribute__((section(".dlist_so_export_log1pf")))
void ** __ptr_to_log1pf = &__export_log1pf;



	asm(""
	".section .data.export_log2 \n"
"___export_log2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_log2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _log2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_log2;
__attribute__((section(".dlist_so_export_log2")))
char const * __name_log2 = "log2";
__attribute__((section(".dlist_so_export_log2")))
void ** __ptr_to_log2 = &__export_log2;



	asm(""
	".section .data.export_logb \n"
"___export_logb_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_logb: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _logb \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_logb;
__attribute__((section(".dlist_so_export_logb")))
char const * __name_logb = "logb";
__attribute__((section(".dlist_so_export_logb")))
void ** __ptr_to_logb = &__export_logb;



	asm(""
	".section .data.export_logbf \n"
"___export_logbf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_logbf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _logbf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_logbf;
__attribute__((section(".dlist_so_export_logbf")))
char const * __name_logbf = "logbf";
__attribute__((section(".dlist_so_export_logbf")))
void ** __ptr_to_logbf = &__export_logbf;



	asm(""
	".section .data.export_logf \n"
"___export_logf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_logf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _logf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_logf;
__attribute__((section(".dlist_so_export_logf")))
char const * __name_logf = "logf";
__attribute__((section(".dlist_so_export_logf")))
void ** __ptr_to_logf = &__export_logf;



	asm(""
	".section .data.export_longjmp \n"
"___export_longjmp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_longjmp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _longjmp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_longjmp;
__attribute__((section(".dlist_so_export_longjmp")))
char const * __name_longjmp = "longjmp";
__attribute__((section(".dlist_so_export_longjmp")))
void ** __ptr_to_longjmp = &__export_longjmp;



	asm(""
	".section .data.export_lrand48 \n"
"___export_lrand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lrand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lrand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lrand48;
__attribute__((section(".dlist_so_export_lrand48")))
char const * __name_lrand48 = "lrand48";
__attribute__((section(".dlist_so_export_lrand48")))
void ** __ptr_to_lrand48 = &__export_lrand48;



	asm(""
	".section .data.export_lrint \n"
"___export_lrint_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lrint: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lrint \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lrint;
__attribute__((section(".dlist_so_export_lrint")))
char const * __name_lrint = "lrint";
__attribute__((section(".dlist_so_export_lrint")))
void ** __ptr_to_lrint = &__export_lrint;



	asm(""
	".section .data.export_lrintf \n"
"___export_lrintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lrintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lrintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lrintf;
__attribute__((section(".dlist_so_export_lrintf")))
char const * __name_lrintf = "lrintf";
__attribute__((section(".dlist_so_export_lrintf")))
void ** __ptr_to_lrintf = &__export_lrintf;



	asm(""
	".section .data.export_lround \n"
"___export_lround_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lround: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lround \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lround;
__attribute__((section(".dlist_so_export_lround")))
char const * __name_lround = "lround";
__attribute__((section(".dlist_so_export_lround")))
void ** __ptr_to_lround = &__export_lround;



	asm(""
	".section .data.export_lroundf \n"
"___export_lroundf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lroundf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lroundf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lroundf;
__attribute__((section(".dlist_so_export_lroundf")))
char const * __name_lroundf = "lroundf";
__attribute__((section(".dlist_so_export_lroundf")))
void ** __ptr_to_lroundf = &__export_lroundf;



	asm(""
	".section .data.export_lseek \n"
"___export_lseek_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lseek: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lseek \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lseek;
__attribute__((section(".dlist_so_export_lseek")))
char const * __name_lseek = "lseek";
__attribute__((section(".dlist_so_export_lseek")))
void ** __ptr_to_lseek = &__export_lseek;



	asm(""
	".section .data.export_lstat \n"
"___export_lstat_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_lstat: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _lstat \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_lstat;
__attribute__((section(".dlist_so_export_lstat")))
char const * __name_lstat = "lstat";
__attribute__((section(".dlist_so_export_lstat")))
void ** __ptr_to_lstat = &__export_lstat;



	asm(""
	".section .data.export___ltdf2 \n"
"___export___ltdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___ltdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___ltdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___ltdf2;
__attribute__((section(".dlist_so_export___ltdf2")))
char const * __name___ltdf2 = "__ltdf2";
__attribute__((section(".dlist_so_export___ltdf2")))
void ** __ptr_to___ltdf2 = &__export___ltdf2;



	asm(""
	".section .data.export_ltoa \n"
"___export_ltoa_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ltoa: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ltoa \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ltoa;
__attribute__((section(".dlist_so_export_ltoa")))
char const * __name_ltoa = "ltoa";
__attribute__((section(".dlist_so_export_ltoa")))
void ** __ptr_to_ltoa = &__export_ltoa;



	asm(""
	".section .data.export___ltsf2 \n"
"___export___ltsf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___ltsf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___ltsf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___ltsf2;
__attribute__((section(".dlist_so_export___ltsf2")))
char const * __name___ltsf2 = "__ltsf2";
__attribute__((section(".dlist_so_export___ltsf2")))
void ** __ptr_to___ltsf2 = &__export___ltsf2;



	asm(""
	".section .data.export___ltxf2 \n"
"___export___ltxf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___ltxf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___ltxf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___ltxf2;
__attribute__((section(".dlist_so_export___ltxf2")))
char const * __name___ltxf2 = "__ltxf2";
__attribute__((section(".dlist_so_export___ltxf2")))
void ** __ptr_to___ltxf2 = &__export___ltxf2;



	asm(""
	".section .data.export__lx_fhfromfd \n"
"___export__lx_fhfromfd_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export__lx_fhfromfd: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    __lx_fhfromfd \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export__lx_fhfromfd;
__attribute__((section(".dlist_so_export__lx_fhfromfd")))
char const * __name__lx_fhfromfd = "_lx_fhfromfd";
__attribute__((section(".dlist_so_export__lx_fhfromfd")))
void ** __ptr_to__lx_fhfromfd = &__export__lx_fhfromfd;



	asm(""
	".section .data.export_malloc \n"
"___export_malloc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_malloc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _malloc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_malloc;
__attribute__((section(".dlist_so_export_malloc")))
char const * __name_malloc = "malloc";
__attribute__((section(".dlist_so_export_malloc")))
void ** __ptr_to_malloc = &__export_malloc;



	asm(""
	".section .data.export___markstack \n"
"___export___markstack_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___markstack: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___markstack \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___markstack;
__attribute__((section(".dlist_so_export___markstack")))
char const * __name___markstack = "__markstack";
__attribute__((section(".dlist_so_export___markstack")))
void ** __ptr_to___markstack = &__export___markstack;


extern void *matherr;
__attribute__((section(".dlist_so_export_matherr")))
char const * __name_matherr = "matherr";
__attribute__((section(".dlist_so_export_matherr")))
void ** __ptr_to_matherr = (void **)&matherr;


extern void *mblen;
__attribute__((section(".dlist_so_export_mblen")))
char const * __name_mblen = "mblen";
__attribute__((section(".dlist_so_export_mblen")))
void ** __ptr_to_mblen = (void **)&mblen;


extern void *mbrtowc;
__attribute__((section(".dlist_so_export_mbrtowc")))
char const * __name_mbrtowc = "mbrtowc";
__attribute__((section(".dlist_so_export_mbrtowc")))
void ** __ptr_to_mbrtowc = (void **)&mbrtowc;


extern void *mbstowcs;
__attribute__((section(".dlist_so_export_mbstowcs")))
char const * __name_mbstowcs = "mbstowcs";
__attribute__((section(".dlist_so_export_mbstowcs")))
void ** __ptr_to_mbstowcs = (void **)&mbstowcs;


extern void *mbtowc;
__attribute__((section(".dlist_so_export_mbtowc")))
char const * __name_mbtowc = "mbtowc";
__attribute__((section(".dlist_so_export_mbtowc")))
void ** __ptr_to_mbtowc = (void **)&mbtowc;


extern void *memchr;
__attribute__((section(".dlist_so_export_memchr")))
char const * __name_memchr = "memchr";
__attribute__((section(".dlist_so_export_memchr")))
void ** __ptr_to_memchr = (void **)&memchr;


extern void *memcmp;
__attribute__((section(".dlist_so_export_memcmp")))
char const * __name_memcmp = "memcmp";
__attribute__((section(".dlist_so_export_memcmp")))
void ** __ptr_to_memcmp = (void **)&memcmp;



	asm(""
	".section .data.export_memcpy \n"
"___export_memcpy_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_memcpy: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _memcpy \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_memcpy;
__attribute__((section(".dlist_so_export_memcpy")))
char const * __name_memcpy = "memcpy";
__attribute__((section(".dlist_so_export_memcpy")))
void ** __ptr_to_memcpy = &__export_memcpy;


extern void *memmove;
__attribute__((section(".dlist_so_export_memmove")))
char const * __name_memmove = "memmove";
__attribute__((section(".dlist_so_export_memmove")))
void ** __ptr_to_memmove = (void **)&memmove;



	asm(""
	".section .data.export_mempcpy \n"
"___export_mempcpy_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mempcpy: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mempcpy \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mempcpy;
__attribute__((section(".dlist_so_export_mempcpy")))
char const * __name_mempcpy = "mempcpy";
__attribute__((section(".dlist_so_export_mempcpy")))
void ** __ptr_to_mempcpy = &__export_mempcpy;


extern void *memset;
__attribute__((section(".dlist_so_export_memset")))
char const * __name_memset = "memset";
__attribute__((section(".dlist_so_export_memset")))
void ** __ptr_to_memset = (void **)&memset;



	asm(""
	".section .data.export_mkdir \n"
"___export_mkdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mkdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mkdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mkdir;
__attribute__((section(".dlist_so_export_mkdir")))
char const * __name_mkdir = "mkdir";
__attribute__((section(".dlist_so_export_mkdir")))
void ** __ptr_to_mkdir = &__export_mkdir;



	asm(""
	".section .data.export_mkdtemp \n"
"___export_mkdtemp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mkdtemp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mkdtemp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mkdtemp;
__attribute__((section(".dlist_so_export_mkdtemp")))
char const * __name_mkdtemp = "mkdtemp";
__attribute__((section(".dlist_so_export_mkdtemp")))
void ** __ptr_to_mkdtemp = &__export_mkdtemp;



	asm(""
	".section .data.export_mkstemp \n"
"___export_mkstemp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mkstemp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mkstemp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mkstemp;
__attribute__((section(".dlist_so_export_mkstemp")))
char const * __name_mkstemp = "mkstemp";
__attribute__((section(".dlist_so_export_mkstemp")))
void ** __ptr_to_mkstemp = &__export_mkstemp;



	asm(""
	".section .data.export_mktemp \n"
"___export_mktemp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mktemp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mktemp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mktemp;
__attribute__((section(".dlist_so_export_mktemp")))
char const * __name_mktemp = "mktemp";
__attribute__((section(".dlist_so_export_mktemp")))
void ** __ptr_to_mktemp = &__export_mktemp;



	asm(""
	".section .data.export_mktime \n"
"___export_mktime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mktime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mktime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mktime;
__attribute__((section(".dlist_so_export_mktime")))
char const * __name_mktime = "mktime";
__attribute__((section(".dlist_so_export_mktime")))
void ** __ptr_to_mktime = &__export_mktime;



	asm(""
	".section .data.export_modf \n"
"___export_modf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_modf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _modf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_modf;
__attribute__((section(".dlist_so_export_modf")))
char const * __name_modf = "modf";
__attribute__((section(".dlist_so_export_modf")))
void ** __ptr_to_modf = &__export_modf;



	asm(""
	".section .data.export_modff \n"
"___export_modff_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_modff: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _modff \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_modff;
__attribute__((section(".dlist_so_export_modff")))
char const * __name_modff = "modff";
__attribute__((section(".dlist_so_export_modff")))
void ** __ptr_to_modff = &__export_modff;



	asm(""
	".section .data.export___modsi3 \n"
"___export___modsi3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___modsi3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___modsi3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___modsi3;
__attribute__((section(".dlist_so_export___modsi3")))
char const * __name___modsi3 = "__modsi3";
__attribute__((section(".dlist_so_export___modsi3")))
void ** __ptr_to___modsi3 = &__export___modsi3;



	asm(""
	".section .data.export_mrand48 \n"
"___export_mrand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_mrand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _mrand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_mrand48;
__attribute__((section(".dlist_so_export_mrand48")))
char const * __name_mrand48 = "mrand48";
__attribute__((section(".dlist_so_export_mrand48")))
void ** __ptr_to_mrand48 = &__export_mrand48;



	asm(""
	".section .data.export___muldf3 \n"
"___export___muldf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___muldf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___muldf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___muldf3;
__attribute__((section(".dlist_so_export___muldf3")))
char const * __name___muldf3 = "__muldf3";
__attribute__((section(".dlist_so_export___muldf3")))
void ** __ptr_to___muldf3 = &__export___muldf3;



	asm(""
	".section .data.export___mulsf3 \n"
"___export___mulsf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___mulsf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___mulsf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___mulsf3;
__attribute__((section(".dlist_so_export___mulsf3")))
char const * __name___mulsf3 = "__mulsf3";
__attribute__((section(".dlist_so_export___mulsf3")))
void ** __ptr_to___mulsf3 = &__export___mulsf3;



	asm(""
	".section .data.export___mulsi3 \n"
"___export___mulsi3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___mulsi3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___mulsi3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___mulsi3;
__attribute__((section(".dlist_so_export___mulsi3")))
char const * __name___mulsi3 = "__mulsi3";
__attribute__((section(".dlist_so_export___mulsi3")))
void ** __ptr_to___mulsi3 = &__export___mulsi3;



	asm(""
	".section .data.export_nan \n"
"___export_nan_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nan: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nan \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nan;
__attribute__((section(".dlist_so_export_nan")))
char const * __name_nan = "nan";
__attribute__((section(".dlist_so_export_nan")))
void ** __ptr_to_nan = &__export_nan;


extern void *nanf;
__attribute__((section(".dlist_so_export_nanf")))
char const * __name_nanf = "nanf";
__attribute__((section(".dlist_so_export_nanf")))
void ** __ptr_to_nanf = (void **)&nanf;



	asm(""
	".section .data.export_nanosleep \n"
"___export_nanosleep_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nanosleep: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nanosleep \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nanosleep;
__attribute__((section(".dlist_so_export_nanosleep")))
char const * __name_nanosleep = "nanosleep";
__attribute__((section(".dlist_so_export_nanosleep")))
void ** __ptr_to_nanosleep = &__export_nanosleep;



	asm(""
	".section .data.export_nearbyint \n"
"___export_nearbyint_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nearbyint: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nearbyint \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nearbyint;
__attribute__((section(".dlist_so_export_nearbyint")))
char const * __name_nearbyint = "nearbyint";
__attribute__((section(".dlist_so_export_nearbyint")))
void ** __ptr_to_nearbyint = &__export_nearbyint;



	asm(""
	".section .data.export_nearbyintf \n"
"___export_nearbyintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nearbyintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nearbyintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nearbyintf;
__attribute__((section(".dlist_so_export_nearbyintf")))
char const * __name_nearbyintf = "nearbyintf";
__attribute__((section(".dlist_so_export_nearbyintf")))
void ** __ptr_to_nearbyintf = &__export_nearbyintf;



	asm(""
	".section .data.export___nedf2 \n"
"___export___nedf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___nedf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___nedf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___nedf2;
__attribute__((section(".dlist_so_export___nedf2")))
char const * __name___nedf2 = "__nedf2";
__attribute__((section(".dlist_so_export___nedf2")))
void ** __ptr_to___nedf2 = &__export___nedf2;



	asm(""
	".section .data.export___negdf2 \n"
"___export___negdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___negdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___negdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___negdf2;
__attribute__((section(".dlist_so_export___negdf2")))
char const * __name___negdf2 = "__negdf2";
__attribute__((section(".dlist_so_export___negdf2")))
void ** __ptr_to___negdf2 = &__export___negdf2;



	asm(""
	".section .data.export___negsf2 \n"
"___export___negsf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___negsf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___negsf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___negsf2;
__attribute__((section(".dlist_so_export___negsf2")))
char const * __name___negsf2 = "__negsf2";
__attribute__((section(".dlist_so_export___negsf2")))
void ** __ptr_to___negsf2 = &__export___negsf2;



	asm(""
	".section .data.export___nesf2 \n"
"___export___nesf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___nesf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___nesf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___nesf2;
__attribute__((section(".dlist_so_export___nesf2")))
char const * __name___nesf2 = "__nesf2";
__attribute__((section(".dlist_so_export___nesf2")))
void ** __ptr_to___nesf2 = &__export___nesf2;



	asm(""
	".section .data.export_newlocale \n"
"___export_newlocale_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_newlocale: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _newlocale \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_newlocale;
__attribute__((section(".dlist_so_export_newlocale")))
char const * __name_newlocale = "newlocale";
__attribute__((section(".dlist_so_export_newlocale")))
void ** __ptr_to_newlocale = &__export_newlocale;



	asm(""
	".section .data.export___nexf2 \n"
"___export___nexf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___nexf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___nexf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___nexf2;
__attribute__((section(".dlist_so_export___nexf2")))
char const * __name___nexf2 = "__nexf2";
__attribute__((section(".dlist_so_export___nexf2")))
void ** __ptr_to___nexf2 = &__export___nexf2;



	asm(""
	".section .data.export_nextafter \n"
"___export_nextafter_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nextafter: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nextafter \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nextafter;
__attribute__((section(".dlist_so_export_nextafter")))
char const * __name_nextafter = "nextafter";
__attribute__((section(".dlist_so_export_nextafter")))
void ** __ptr_to_nextafter = &__export_nextafter;



	asm(""
	".section .data.export_nextafterf \n"
"___export_nextafterf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nextafterf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nextafterf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nextafterf;
__attribute__((section(".dlist_so_export_nextafterf")))
char const * __name_nextafterf = "nextafterf";
__attribute__((section(".dlist_so_export_nextafterf")))
void ** __ptr_to_nextafterf = &__export_nextafterf;


extern void *nl_langinfo;
__attribute__((section(".dlist_so_export_nl_langinfo")))
char const * __name_nl_langinfo = "nl_langinfo";
__attribute__((section(".dlist_so_export_nl_langinfo")))
void ** __ptr_to_nl_langinfo = (void **)&nl_langinfo;



	asm(""
	".section .data.export_nrand48 \n"
"___export_nrand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_nrand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _nrand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_nrand48;
__attribute__((section(".dlist_so_export_nrand48")))
char const * __name_nrand48 = "nrand48";
__attribute__((section(".dlist_so_export_nrand48")))
void ** __ptr_to_nrand48 = &__export_nrand48;



	asm(""
	".section .data.export_open \n"
"___export_open_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_open: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _open \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_open;
__attribute__((section(".dlist_so_export_open")))
char const * __name_open = "open";
__attribute__((section(".dlist_so_export_open")))
void ** __ptr_to_open = &__export_open;



	asm(""
	".section .data.export_opendir \n"
"___export_opendir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_opendir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _opendir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_opendir;
__attribute__((section(".dlist_so_export_opendir")))
char const * __name_opendir = "opendir";
__attribute__((section(".dlist_so_export_opendir")))
void ** __ptr_to_opendir = &__export_opendir;



	asm(""
	".section .data.export_openlog \n"
"___export_openlog_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_openlog: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _openlog \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_openlog;
__attribute__((section(".dlist_so_export_openlog")))
char const * __name_openlog = "openlog";
__attribute__((section(".dlist_so_export_openlog")))
void ** __ptr_to_openlog = &__export_openlog;


extern void *pathconf;
__attribute__((section(".dlist_so_export_pathconf")))
char const * __name_pathconf = "pathconf";
__attribute__((section(".dlist_so_export_pathconf")))
void ** __ptr_to_pathconf = (void **)&pathconf;



	asm(""
	".section .data.export_perror \n"
"___export_perror_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_perror: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _perror \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_perror;
__attribute__((section(".dlist_so_export_perror")))
char const * __name_perror = "perror";
__attribute__((section(".dlist_so_export_perror")))
void ** __ptr_to_perror = &__export_perror;



	asm(""
	".section .data.export_pipe \n"
"___export_pipe_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_pipe: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _pipe \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_pipe;
__attribute__((section(".dlist_so_export_pipe")))
char const * __name_pipe = "pipe";
__attribute__((section(".dlist_so_export_pipe")))
void ** __ptr_to_pipe = &__export_pipe;



	asm(""
	".section .data.export_popen \n"
"___export_popen_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_popen: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _popen \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_popen;
__attribute__((section(".dlist_so_export_popen")))
char const * __name_popen = "popen";
__attribute__((section(".dlist_so_export_popen")))
void ** __ptr_to_popen = &__export_popen;



	asm(""
	".section .data.export_pow \n"
"___export_pow_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_pow: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _pow \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_pow;
__attribute__((section(".dlist_so_export_pow")))
char const * __name_pow = "pow";
__attribute__((section(".dlist_so_export_pow")))
void ** __ptr_to_pow = &__export_pow;



	asm(""
	".section .data.export_pow10 \n"
"___export_pow10_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_pow10: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _pow10 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_pow10;
__attribute__((section(".dlist_so_export_pow10")))
char const * __name_pow10 = "pow10";
__attribute__((section(".dlist_so_export_pow10")))
void ** __ptr_to_pow10 = &__export_pow10;



	asm(""
	".section .data.export_pow10f \n"
"___export_pow10f_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_pow10f: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _pow10f \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_pow10f;
__attribute__((section(".dlist_so_export_pow10f")))
char const * __name_pow10f = "pow10f";
__attribute__((section(".dlist_so_export_pow10f")))
void ** __ptr_to_pow10f = &__export_pow10f;



	asm(""
	".section .data.export_powf \n"
"___export_powf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_powf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _powf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_powf;
__attribute__((section(".dlist_so_export_powf")))
char const * __name_powf = "powf";
__attribute__((section(".dlist_so_export_powf")))
void ** __ptr_to_powf = &__export_powf;



	asm(""
	".section .data.export_printf \n"
"___export_printf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_printf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _printf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_printf;
__attribute__((section(".dlist_so_export_printf")))
char const * __name_printf = "printf";
__attribute__((section(".dlist_so_export_printf")))
void ** __ptr_to_printf = &__export_printf;



	asm(""
	".section .data.export_putc \n"
"___export_putc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_putc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _putc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_putc;
__attribute__((section(".dlist_so_export_putc")))
char const * __name_putc = "putc";
__attribute__((section(".dlist_so_export_putc")))
void ** __ptr_to_putc = &__export_putc;



	asm(""
	".section .data.export_putchar \n"
"___export_putchar_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_putchar: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _putchar \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_putchar;
__attribute__((section(".dlist_so_export_putchar")))
char const * __name_putchar = "putchar";
__attribute__((section(".dlist_so_export_putchar")))
void ** __ptr_to_putchar = &__export_putchar;



	asm(""
	".section .data.export_putenv \n"
"___export_putenv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_putenv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _putenv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_putenv;
__attribute__((section(".dlist_so_export_putenv")))
char const * __name_putenv = "putenv";
__attribute__((section(".dlist_so_export_putenv")))
void ** __ptr_to_putenv = &__export_putenv;



	asm(""
	".section .data.export_puts \n"
"___export_puts_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_puts: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _puts \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_puts;
__attribute__((section(".dlist_so_export_puts")))
char const * __name_puts = "puts";
__attribute__((section(".dlist_so_export_puts")))
void ** __ptr_to_puts = &__export_puts;



	asm(""
	".section .data.export_putw \n"
"___export_putw_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_putw: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _putw \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_putw;
__attribute__((section(".dlist_so_export_putw")))
char const * __name_putw = "putw";
__attribute__((section(".dlist_so_export_putw")))
void ** __ptr_to_putw = &__export_putw;



	asm(""
	".section .data.export_putwc \n"
"___export_putwc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_putwc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _putwc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_putwc;
__attribute__((section(".dlist_so_export_putwc")))
char const * __name_putwc = "putwc";
__attribute__((section(".dlist_so_export_putwc")))
void ** __ptr_to_putwc = &__export_putwc;



	asm(""
	".section .data.export_qsort \n"
"___export_qsort_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_qsort: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _qsort \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_qsort;
__attribute__((section(".dlist_so_export_qsort")))
char const * __name_qsort = "qsort";
__attribute__((section(".dlist_so_export_qsort")))
void ** __ptr_to_qsort = &__export_qsort;



	asm(""
	".section .data.export_raise \n"
"___export_raise_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_raise: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _raise \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_raise;
__attribute__((section(".dlist_so_export_raise")))
char const * __name_raise = "raise";
__attribute__((section(".dlist_so_export_raise")))
void ** __ptr_to_raise = &__export_raise;



	asm(""
	".section .data.export_rand \n"
"___export_rand_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rand: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rand \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rand;
__attribute__((section(".dlist_so_export_rand")))
char const * __name_rand = "rand";
__attribute__((section(".dlist_so_export_rand")))
void ** __ptr_to_rand = &__export_rand;



	asm(""
	".section .data.export_read \n"
"___export_read_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_read: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _read \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_read;
__attribute__((section(".dlist_so_export_read")))
char const * __name_read = "read";
__attribute__((section(".dlist_so_export_read")))
void ** __ptr_to_read = &__export_read;



	asm(""
	".section .data.export_readdir \n"
"___export_readdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_readdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _readdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_readdir;
__attribute__((section(".dlist_so_export_readdir")))
char const * __name_readdir = "readdir";
__attribute__((section(".dlist_so_export_readdir")))
void ** __ptr_to_readdir = &__export_readdir;



	asm(""
	".section .data.export_readlink \n"
"___export_readlink_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_readlink: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _readlink \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_readlink;
__attribute__((section(".dlist_so_export_readlink")))
char const * __name_readlink = "readlink";
__attribute__((section(".dlist_so_export_readlink")))
void ** __ptr_to_readlink = &__export_readlink;



	asm(""
	".section .data.export_realloc \n"
"___export_realloc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_realloc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _realloc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_realloc;
__attribute__((section(".dlist_so_export_realloc")))
char const * __name_realloc = "realloc";
__attribute__((section(".dlist_so_export_realloc")))
void ** __ptr_to_realloc = &__export_realloc;



	asm(""
	".section .data.export_remainder \n"
"___export_remainder_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_remainder: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _remainder \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_remainder;
__attribute__((section(".dlist_so_export_remainder")))
char const * __name_remainder = "remainder";
__attribute__((section(".dlist_so_export_remainder")))
void ** __ptr_to_remainder = &__export_remainder;



	asm(""
	".section .data.export_remainderf \n"
"___export_remainderf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_remainderf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _remainderf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_remainderf;
__attribute__((section(".dlist_so_export_remainderf")))
char const * __name_remainderf = "remainderf";
__attribute__((section(".dlist_so_export_remainderf")))
void ** __ptr_to_remainderf = &__export_remainderf;



	asm(""
	".section .data.export_remove \n"
"___export_remove_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_remove: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _remove \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_remove;
__attribute__((section(".dlist_so_export_remove")))
char const * __name_remove = "remove";
__attribute__((section(".dlist_so_export_remove")))
void ** __ptr_to_remove = &__export_remove;



	asm(""
	".section .data.export_remquo \n"
"___export_remquo_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_remquo: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _remquo \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_remquo;
__attribute__((section(".dlist_so_export_remquo")))
char const * __name_remquo = "remquo";
__attribute__((section(".dlist_so_export_remquo")))
void ** __ptr_to_remquo = &__export_remquo;



	asm(""
	".section .data.export_remquof \n"
"___export_remquof_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_remquof: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _remquof \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_remquof;
__attribute__((section(".dlist_so_export_remquof")))
char const * __name_remquof = "remquof";
__attribute__((section(".dlist_so_export_remquof")))
void ** __ptr_to_remquof = &__export_remquof;



	asm(""
	".section .data.export_rename \n"
"___export_rename_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rename: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rename \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rename;
__attribute__((section(".dlist_so_export_rename")))
char const * __name_rename = "rename";
__attribute__((section(".dlist_so_export_rename")))
void ** __ptr_to_rename = &__export_rename;



	asm(""
	".section .data.export___request \n"
"___export___request_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___request: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___request \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___request;
__attribute__((section(".dlist_so_export___request")))
char const * __name___request = "__request";
__attribute__((section(".dlist_so_export___request")))
void ** __ptr_to___request = &__export___request;



	asm(""
	".section .data.export_rewind \n"
"___export_rewind_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rewind: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rewind \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rewind;
__attribute__((section(".dlist_so_export_rewind")))
char const * __name_rewind = "rewind";
__attribute__((section(".dlist_so_export_rewind")))
void ** __ptr_to_rewind = &__export_rewind;



	asm(""
	".section .data.export_rewinddir \n"
"___export_rewinddir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rewinddir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rewinddir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rewinddir;
__attribute__((section(".dlist_so_export_rewinddir")))
char const * __name_rewinddir = "rewinddir";
__attribute__((section(".dlist_so_export_rewinddir")))
void ** __ptr_to_rewinddir = &__export_rewinddir;


extern void *rindex;
__attribute__((section(".dlist_so_export_rindex")))
char const * __name_rindex = "rindex";
__attribute__((section(".dlist_so_export_rindex")))
void ** __ptr_to_rindex = (void **)&rindex;



	asm(""
	".section .data.export_rint \n"
"___export_rint_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rint: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rint \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rint;
__attribute__((section(".dlist_so_export_rint")))
char const * __name_rint = "rint";
__attribute__((section(".dlist_so_export_rint")))
void ** __ptr_to_rint = &__export_rint;



	asm(""
	".section .data.export_rintf \n"
"___export_rintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rintf;
__attribute__((section(".dlist_so_export_rintf")))
char const * __name_rintf = "rintf";
__attribute__((section(".dlist_so_export_rintf")))
void ** __ptr_to_rintf = &__export_rintf;



	asm(""
	".section .data.export_rmdir \n"
"___export_rmdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_rmdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _rmdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_rmdir;
__attribute__((section(".dlist_so_export_rmdir")))
char const * __name_rmdir = "rmdir";
__attribute__((section(".dlist_so_export_rmdir")))
void ** __ptr_to_rmdir = &__export_rmdir;



	asm(""
	".section .data.export_round \n"
"___export_round_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_round: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _round \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_round;
__attribute__((section(".dlist_so_export_round")))
char const * __name_round = "round";
__attribute__((section(".dlist_so_export_round")))
void ** __ptr_to_round = &__export_round;



	asm(""
	".section .data.export_roundf \n"
"___export_roundf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_roundf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _roundf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_roundf;
__attribute__((section(".dlist_so_export_roundf")))
char const * __name_roundf = "roundf";
__attribute__((section(".dlist_so_export_roundf")))
void ** __ptr_to_roundf = &__export_roundf;



	asm(""
	".section .data.export_scalb \n"
"___export_scalb_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scalb: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scalb \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scalb;
__attribute__((section(".dlist_so_export_scalb")))
char const * __name_scalb = "scalb";
__attribute__((section(".dlist_so_export_scalb")))
void ** __ptr_to_scalb = &__export_scalb;



	asm(""
	".section .data.export_scalbf \n"
"___export_scalbf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scalbf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scalbf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scalbf;
__attribute__((section(".dlist_so_export_scalbf")))
char const * __name_scalbf = "scalbf";
__attribute__((section(".dlist_so_export_scalbf")))
void ** __ptr_to_scalbf = &__export_scalbf;



	asm(""
	".section .data.export_scalbln \n"
"___export_scalbln_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scalbln: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scalbln \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scalbln;
__attribute__((section(".dlist_so_export_scalbln")))
char const * __name_scalbln = "scalbln";
__attribute__((section(".dlist_so_export_scalbln")))
void ** __ptr_to_scalbln = &__export_scalbln;



	asm(""
	".section .data.export_scalblnf \n"
"___export_scalblnf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scalblnf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scalblnf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scalblnf;
__attribute__((section(".dlist_so_export_scalblnf")))
char const * __name_scalblnf = "scalblnf";
__attribute__((section(".dlist_so_export_scalblnf")))
void ** __ptr_to_scalblnf = &__export_scalblnf;



	asm(""
	".section .data.export_scalbn \n"
"___export_scalbn_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scalbn: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scalbn \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scalbn;
__attribute__((section(".dlist_so_export_scalbn")))
char const * __name_scalbn = "scalbn";
__attribute__((section(".dlist_so_export_scalbn")))
void ** __ptr_to_scalbn = &__export_scalbn;



	asm(""
	".section .data.export_scalbnf \n"
"___export_scalbnf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scalbnf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scalbnf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scalbnf;
__attribute__((section(".dlist_so_export_scalbnf")))
char const * __name_scalbnf = "scalbnf";
__attribute__((section(".dlist_so_export_scalbnf")))
void ** __ptr_to_scalbnf = &__export_scalbnf;



	asm(""
	".section .data.export_scandir \n"
"___export_scandir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scandir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scandir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scandir;
__attribute__((section(".dlist_so_export_scandir")))
char const * __name_scandir = "scandir";
__attribute__((section(".dlist_so_export_scandir")))
void ** __ptr_to_scandir = &__export_scandir;



	asm(""
	".section .data.export_scanf \n"
"___export_scanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_scanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _scanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_scanf;
__attribute__((section(".dlist_so_export_scanf")))
char const * __name_scanf = "scanf";
__attribute__((section(".dlist_so_export_scanf")))
void ** __ptr_to_scanf = &__export_scanf;


extern void *sched_get_priority_max;
__attribute__((section(".dlist_so_export_sched_get_priority_max")))
char const * __name_sched_get_priority_max = "sched_get_priority_max";
__attribute__((section(".dlist_so_export_sched_get_priority_max")))
void ** __ptr_to_sched_get_priority_max = (void **)&sched_get_priority_max;


extern void *sched_get_priority_min;
__attribute__((section(".dlist_so_export_sched_get_priority_min")))
char const * __name_sched_get_priority_min = "sched_get_priority_min";
__attribute__((section(".dlist_so_export_sched_get_priority_min")))
void ** __ptr_to_sched_get_priority_min = (void **)&sched_get_priority_min;



	asm(""
	".section .data.export_seed48 \n"
"___export_seed48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_seed48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _seed48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_seed48;
__attribute__((section(".dlist_so_export_seed48")))
char const * __name_seed48 = "seed48";
__attribute__((section(".dlist_so_export_seed48")))
void ** __ptr_to_seed48 = &__export_seed48;



	asm(""
	".section .data.export_seekdir \n"
"___export_seekdir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_seekdir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _seekdir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_seekdir;
__attribute__((section(".dlist_so_export_seekdir")))
char const * __name_seekdir = "seekdir";
__attribute__((section(".dlist_so_export_seekdir")))
void ** __ptr_to_seekdir = &__export_seekdir;



	asm(""
	".section .data.export_setbuf \n"
"___export_setbuf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setbuf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setbuf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setbuf;
__attribute__((section(".dlist_so_export_setbuf")))
char const * __name_setbuf = "setbuf";
__attribute__((section(".dlist_so_export_setbuf")))
void ** __ptr_to_setbuf = &__export_setbuf;



	asm(""
	".section .data.export_setbuffer \n"
"___export_setbuffer_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setbuffer: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setbuffer \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setbuffer;
__attribute__((section(".dlist_so_export_setbuffer")))
char const * __name_setbuffer = "setbuffer";
__attribute__((section(".dlist_so_export_setbuffer")))
void ** __ptr_to_setbuffer = &__export_setbuffer;



	asm(""
	".section .data.export_setenv \n"
"___export_setenv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setenv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setenv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setenv;
__attribute__((section(".dlist_so_export_setenv")))
char const * __name_setenv = "setenv";
__attribute__((section(".dlist_so_export_setenv")))
void ** __ptr_to_setenv = &__export_setenv;



	asm(""
	".section .data.export___seterrno \n"
"___export___seterrno_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___seterrno: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___seterrno \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___seterrno;
__attribute__((section(".dlist_so_export___seterrno")))
char const * __name___seterrno = "__seterrno";
__attribute__((section(".dlist_so_export___seterrno")))
void ** __ptr_to___seterrno = &__export___seterrno;


extern void *setjmp;
__attribute__((section(".dlist_so_export_setjmp")))
char const * __name_setjmp = "setjmp";
__attribute__((section(".dlist_so_export_setjmp")))
void ** __ptr_to_setjmp = (void **)&setjmp;



	asm(""
	".section .data.export_setlinebuf \n"
"___export_setlinebuf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setlinebuf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setlinebuf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setlinebuf;
__attribute__((section(".dlist_so_export_setlinebuf")))
char const * __name_setlinebuf = "setlinebuf";
__attribute__((section(".dlist_so_export_setlinebuf")))
void ** __ptr_to_setlinebuf = &__export_setlinebuf;



	asm(""
	".section .data.export_setlocale \n"
"___export_setlocale_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setlocale: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setlocale \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setlocale;
__attribute__((section(".dlist_so_export_setlocale")))
char const * __name_setlocale = "setlocale";
__attribute__((section(".dlist_so_export_setlocale")))
void ** __ptr_to_setlocale = &__export_setlocale;



	asm(""
	".section .data.export_setPrintfBufferSize \n"
"___export_setPrintfBufferSize_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setPrintfBufferSize: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setPrintfBufferSize \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setPrintfBufferSize;
__attribute__((section(".dlist_so_export_setPrintfBufferSize")))
char const * __name_setPrintfBufferSize = "setPrintfBufferSize";
__attribute__((section(".dlist_so_export_setPrintfBufferSize")))
void ** __ptr_to_setPrintfBufferSize = &__export_setPrintfBufferSize;


extern void *setrlimit;
__attribute__((section(".dlist_so_export_setrlimit")))
char const * __name_setrlimit = "setrlimit";
__attribute__((section(".dlist_so_export_setrlimit")))
void ** __ptr_to_setrlimit = (void **)&setrlimit;



	asm(""
	".section .data.export__setup_file \n"
"___export__setup_file_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export__setup_file: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    __setup_file \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export__setup_file;
__attribute__((section(".dlist_so_export__setup_file")))
char const * __name__setup_file = "_setup_file";
__attribute__((section(".dlist_so_export__setup_file")))
void ** __ptr_to__setup_file = &__export__setup_file;



	asm(""
	".section .data.export_setvbuf \n"
"___export_setvbuf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_setvbuf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _setvbuf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_setvbuf;
__attribute__((section(".dlist_so_export_setvbuf")))
char const * __name_setvbuf = "setvbuf";
__attribute__((section(".dlist_so_export_setvbuf")))
void ** __ptr_to_setvbuf = &__export_setvbuf;



	asm(""
	".section .data.export_signal \n"
"___export_signal_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_signal: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _signal \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_signal;
__attribute__((section(".dlist_so_export_signal")))
char const * __name_signal = "signal";
__attribute__((section(".dlist_so_export_signal")))
void ** __ptr_to_signal = &__export_signal;


extern void *__signbitd;
__attribute__((section(".dlist_so_export___signbitd")))
char const * __name___signbitd = "__signbitd";
__attribute__((section(".dlist_so_export___signbitd")))
void ** __ptr_to___signbitd = (void **)&__signbitd;


extern void *__signbitf;
__attribute__((section(".dlist_so_export___signbitf")))
char const * __name___signbitf = "__signbitf";
__attribute__((section(".dlist_so_export___signbitf")))
void ** __ptr_to___signbitf = (void **)&__signbitf;



	asm(""
	".section .data.export_significand \n"
"___export_significand_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_significand: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _significand \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_significand;
__attribute__((section(".dlist_so_export_significand")))
char const * __name_significand = "significand";
__attribute__((section(".dlist_so_export_significand")))
void ** __ptr_to_significand = &__export_significand;



	asm(""
	".section .data.export_significandf \n"
"___export_significandf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_significandf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _significandf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_significandf;
__attribute__((section(".dlist_so_export_significandf")))
char const * __name_significandf = "significandf";
__attribute__((section(".dlist_so_export_significandf")))
void ** __ptr_to_significandf = &__export_significandf;



	asm(""
	".section .data.export_sin \n"
"___export_sin_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sin: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sin \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sin;
__attribute__((section(".dlist_so_export_sin")))
char const * __name_sin = "sin";
__attribute__((section(".dlist_so_export_sin")))
void ** __ptr_to_sin = &__export_sin;



	asm(""
	".section .data.export_sinf \n"
"___export_sinf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sinf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sinf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sinf;
__attribute__((section(".dlist_so_export_sinf")))
char const * __name_sinf = "sinf";
__attribute__((section(".dlist_so_export_sinf")))
void ** __ptr_to_sinf = &__export_sinf;



	asm(""
	".section .data.export_sinh \n"
"___export_sinh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sinh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sinh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sinh;
__attribute__((section(".dlist_so_export_sinh")))
char const * __name_sinh = "sinh";
__attribute__((section(".dlist_so_export_sinh")))
void ** __ptr_to_sinh = &__export_sinh;



	asm(""
	".section .data.export_sinhf \n"
"___export_sinhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sinhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sinhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sinhf;
__attribute__((section(".dlist_so_export_sinhf")))
char const * __name_sinhf = "sinhf";
__attribute__((section(".dlist_so_export_sinhf")))
void ** __ptr_to_sinhf = &__export_sinhf;



	asm(""
	".section .data.export_sleep \n"
"___export_sleep_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sleep: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sleep \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sleep;
__attribute__((section(".dlist_so_export_sleep")))
char const * __name_sleep = "sleep";
__attribute__((section(".dlist_so_export_sleep")))
void ** __ptr_to_sleep = &__export_sleep;



	asm(""
	".section .data.export_snprintf \n"
"___export_snprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_snprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _snprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_snprintf;
__attribute__((section(".dlist_so_export_snprintf")))
char const * __name_snprintf = "snprintf";
__attribute__((section(".dlist_so_export_snprintf")))
void ** __ptr_to_snprintf = &__export_snprintf;


extern void *__spinLock;
__attribute__((section(".dlist_so_export___spinLock")))
char const * __name___spinLock = "__spinLock";
__attribute__((section(".dlist_so_export___spinLock")))
void ** __ptr_to___spinLock = (void **)&__spinLock;



	asm(""
	".section .data.export_sprintf \n"
"___export_sprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sprintf;
__attribute__((section(".dlist_so_export_sprintf")))
char const * __name_sprintf = "sprintf";
__attribute__((section(".dlist_so_export_sprintf")))
void ** __ptr_to_sprintf = &__export_sprintf;



	asm(""
	".section .data.export_sqrt \n"
"___export_sqrt_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sqrt: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sqrt \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sqrt;
__attribute__((section(".dlist_so_export_sqrt")))
char const * __name_sqrt = "sqrt";
__attribute__((section(".dlist_so_export_sqrt")))
void ** __ptr_to_sqrt = &__export_sqrt;



	asm(""
	".section .data.export_sqrtf \n"
"___export_sqrtf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sqrtf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sqrtf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sqrtf;
__attribute__((section(".dlist_so_export_sqrtf")))
char const * __name_sqrtf = "sqrtf";
__attribute__((section(".dlist_so_export_sqrtf")))
void ** __ptr_to_sqrtf = &__export_sqrtf;



	asm(""
	".section .data.export_srand \n"
"___export_srand_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_srand: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _srand \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_srand;
__attribute__((section(".dlist_so_export_srand")))
char const * __name_srand = "srand";
__attribute__((section(".dlist_so_export_srand")))
void ** __ptr_to_srand = &__export_srand;



	asm(""
	".section .data.export_srand48 \n"
"___export_srand48_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_srand48: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _srand48 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_srand48;
__attribute__((section(".dlist_so_export_srand48")))
char const * __name_srand48 = "srand48";
__attribute__((section(".dlist_so_export_srand48")))
void ** __ptr_to_srand48 = &__export_srand48;



	asm(""
	".section .data.export___srget \n"
"___export___srget_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___srget: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___srget \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___srget;
__attribute__((section(".dlist_so_export___srget")))
char const * __name___srget = "__srget";
__attribute__((section(".dlist_so_export___srget")))
void ** __ptr_to___srget = &__export___srget;



	asm(""
	".section .data.export_sscanf \n"
"___export_sscanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sscanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sscanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sscanf;
__attribute__((section(".dlist_so_export_sscanf")))
char const * __name_sscanf = "sscanf";
__attribute__((section(".dlist_so_export_sscanf")))
void ** __ptr_to_sscanf = &__export_sscanf;



	asm(""
	".section .data.export___stat \n"
"___export___stat_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___stat: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___stat \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___stat;
__attribute__((section(".dlist_so_export___stat")))
char const * __name___stat = "__stat";
__attribute__((section(".dlist_so_export___stat")))
void ** __ptr_to___stat = &__export___stat;



	asm(""
	".section .data.export_stat \n"
"___export_stat_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_stat: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _stat \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_stat;
__attribute__((section(".dlist_so_export_stat")))
char const * __name_stat = "stat";
__attribute__((section(".dlist_so_export_stat")))
void ** __ptr_to_stat = &__export_stat;


extern void *stpcpy;
__attribute__((section(".dlist_so_export_stpcpy")))
char const * __name_stpcpy = "stpcpy";
__attribute__((section(".dlist_so_export_stpcpy")))
void ** __ptr_to_stpcpy = (void **)&stpcpy;


extern void *stpncpy;
__attribute__((section(".dlist_so_export_stpncpy")))
char const * __name_stpncpy = "stpncpy";
__attribute__((section(".dlist_so_export_stpncpy")))
void ** __ptr_to_stpncpy = (void **)&stpncpy;



	asm(""
	".section .data.export_strcasecmp \n"
"___export_strcasecmp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strcasecmp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strcasecmp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strcasecmp;
__attribute__((section(".dlist_so_export_strcasecmp")))
char const * __name_strcasecmp = "strcasecmp";
__attribute__((section(".dlist_so_export_strcasecmp")))
void ** __ptr_to_strcasecmp = &__export_strcasecmp;


extern void *strcat;
__attribute__((section(".dlist_so_export_strcat")))
char const * __name_strcat = "strcat";
__attribute__((section(".dlist_so_export_strcat")))
void ** __ptr_to_strcat = (void **)&strcat;


extern void *strchr;
__attribute__((section(".dlist_so_export_strchr")))
char const * __name_strchr = "strchr";
__attribute__((section(".dlist_so_export_strchr")))
void ** __ptr_to_strchr = (void **)&strchr;


extern void *strcmp;
__attribute__((section(".dlist_so_export_strcmp")))
char const * __name_strcmp = "strcmp";
__attribute__((section(".dlist_so_export_strcmp")))
void ** __ptr_to_strcmp = (void **)&strcmp;


extern void *strcoll;
__attribute__((section(".dlist_so_export_strcoll")))
char const * __name_strcoll = "strcoll";
__attribute__((section(".dlist_so_export_strcoll")))
void ** __ptr_to_strcoll = (void **)&strcoll;


extern void *strcpy;
__attribute__((section(".dlist_so_export_strcpy")))
char const * __name_strcpy = "strcpy";
__attribute__((section(".dlist_so_export_strcpy")))
void ** __ptr_to_strcpy = (void **)&strcpy;


extern void *strcspn;
__attribute__((section(".dlist_so_export_strcspn")))
char const * __name_strcspn = "strcspn";
__attribute__((section(".dlist_so_export_strcspn")))
void ** __ptr_to_strcspn = (void **)&strcspn;



	asm(""
	".section .data.export_strdup \n"
"___export_strdup_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strdup: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strdup \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strdup;
__attribute__((section(".dlist_so_export_strdup")))
char const * __name_strdup = "strdup";
__attribute__((section(".dlist_so_export_strdup")))
void ** __ptr_to_strdup = &__export_strdup;



	asm(""
	".section .data.export_strerror \n"
"___export_strerror_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strerror: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strerror \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strerror;
__attribute__((section(".dlist_so_export_strerror")))
char const * __name_strerror = "strerror";
__attribute__((section(".dlist_so_export_strerror")))
void ** __ptr_to_strerror = &__export_strerror;



	asm(""
	".section .data.export_strerror_l \n"
"___export_strerror_l_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strerror_l: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strerror_l \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strerror_l;
__attribute__((section(".dlist_so_export_strerror_l")))
char const * __name_strerror_l = "strerror_l";
__attribute__((section(".dlist_so_export_strerror_l")))
void ** __ptr_to_strerror_l = &__export_strerror_l;



	asm(""
	".section .data.export_strerror_r \n"
"___export_strerror_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strerror_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strerror_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strerror_r;
__attribute__((section(".dlist_so_export_strerror_r")))
char const * __name_strerror_r = "strerror_r";
__attribute__((section(".dlist_so_export_strerror_r")))
void ** __ptr_to_strerror_r = &__export_strerror_r;



	asm(""
	".section .data.export_strftime \n"
"___export_strftime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strftime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strftime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strftime;
__attribute__((section(".dlist_so_export_strftime")))
char const * __name_strftime = "strftime";
__attribute__((section(".dlist_so_export_strftime")))
void ** __ptr_to_strftime = &__export_strftime;



	asm(""
	".section .data.export_stricmp \n"
"___export_stricmp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_stricmp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _stricmp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_stricmp;
__attribute__((section(".dlist_so_export_stricmp")))
char const * __name_stricmp = "stricmp";
__attribute__((section(".dlist_so_export_stricmp")))
void ** __ptr_to_stricmp = &__export_stricmp;


extern void *strlcpy;
__attribute__((section(".dlist_so_export_strlcpy")))
char const * __name_strlcpy = "strlcpy";
__attribute__((section(".dlist_so_export_strlcpy")))
void ** __ptr_to_strlcpy = (void **)&strlcpy;


extern void *strlen;
__attribute__((section(".dlist_so_export_strlen")))
char const * __name_strlen = "strlen";
__attribute__((section(".dlist_so_export_strlen")))
void ** __ptr_to_strlen = (void **)&strlen;


extern void *strlen_plus_one;
__attribute__((section(".dlist_so_export_strlen_plus_one")))
char const * __name_strlen_plus_one = "strlen_plus_one";
__attribute__((section(".dlist_so_export_strlen_plus_one")))
void ** __ptr_to_strlen_plus_one = (void **)&strlen_plus_one;


extern void *strlower;
__attribute__((section(".dlist_so_export_strlower")))
char const * __name_strlower = "strlower";
__attribute__((section(".dlist_so_export_strlower")))
void ** __ptr_to_strlower = (void **)&strlower;


extern void *strlwr;
__attribute__((section(".dlist_so_export_strlwr")))
char const * __name_strlwr = "strlwr";
__attribute__((section(".dlist_so_export_strlwr")))
void ** __ptr_to_strlwr = (void **)&strlwr;



	asm(""
	".section .data.export_strncasecmp \n"
"___export_strncasecmp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strncasecmp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strncasecmp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strncasecmp;
__attribute__((section(".dlist_so_export_strncasecmp")))
char const * __name_strncasecmp = "strncasecmp";
__attribute__((section(".dlist_so_export_strncasecmp")))
void ** __ptr_to_strncasecmp = &__export_strncasecmp;


extern void *strncat;
__attribute__((section(".dlist_so_export_strncat")))
char const * __name_strncat = "strncat";
__attribute__((section(".dlist_so_export_strncat")))
void ** __ptr_to_strncat = (void **)&strncat;


extern void *strncmp;
__attribute__((section(".dlist_so_export_strncmp")))
char const * __name_strncmp = "strncmp";
__attribute__((section(".dlist_so_export_strncmp")))
void ** __ptr_to_strncmp = (void **)&strncmp;


extern void *strncpy;
__attribute__((section(".dlist_so_export_strncpy")))
char const * __name_strncpy = "strncpy";
__attribute__((section(".dlist_so_export_strncpy")))
void ** __ptr_to_strncpy = (void **)&strncpy;



	asm(""
	".section .data.export_strndup \n"
"___export_strndup_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strndup: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strndup \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strndup;
__attribute__((section(".dlist_so_export_strndup")))
char const * __name_strndup = "strndup";
__attribute__((section(".dlist_so_export_strndup")))
void ** __ptr_to_strndup = &__export_strndup;



	asm(""
	".section .data.export_strnicmp \n"
"___export_strnicmp_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strnicmp: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strnicmp \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strnicmp;
__attribute__((section(".dlist_so_export_strnicmp")))
char const * __name_strnicmp = "strnicmp";
__attribute__((section(".dlist_so_export_strnicmp")))
void ** __ptr_to_strnicmp = &__export_strnicmp;


extern void *strpbrk;
__attribute__((section(".dlist_so_export_strpbrk")))
char const * __name_strpbrk = "strpbrk";
__attribute__((section(".dlist_so_export_strpbrk")))
void ** __ptr_to_strpbrk = (void **)&strpbrk;


extern void *strrchr;
__attribute__((section(".dlist_so_export_strrchr")))
char const * __name_strrchr = "strrchr";
__attribute__((section(".dlist_so_export_strrchr")))
void ** __ptr_to_strrchr = (void **)&strrchr;


extern void *strsep;
__attribute__((section(".dlist_so_export_strsep")))
char const * __name_strsep = "strsep";
__attribute__((section(".dlist_so_export_strsep")))
void ** __ptr_to_strsep = (void **)&strsep;


extern void *strspn;
__attribute__((section(".dlist_so_export_strspn")))
char const * __name_strspn = "strspn";
__attribute__((section(".dlist_so_export_strspn")))
void ** __ptr_to_strspn = (void **)&strspn;


extern void *strstr;
__attribute__((section(".dlist_so_export_strstr")))
char const * __name_strstr = "strstr";
__attribute__((section(".dlist_so_export_strstr")))
void ** __ptr_to_strstr = (void **)&strstr;



	asm(""
	".section .data.export_strtod \n"
"___export_strtod_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtod: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtod \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtod;
__attribute__((section(".dlist_so_export_strtod")))
char const * __name_strtod = "strtod";
__attribute__((section(".dlist_so_export_strtod")))
void ** __ptr_to_strtod = &__export_strtod;



	asm(""
	".section .data.export_strtof \n"
"___export_strtof_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtof: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtof \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtof;
__attribute__((section(".dlist_so_export_strtof")))
char const * __name_strtof = "strtof";
__attribute__((section(".dlist_so_export_strtof")))
void ** __ptr_to_strtof = &__export_strtof;



	asm(""
	".section .data.export_strtoimax \n"
"___export_strtoimax_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtoimax: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtoimax \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtoimax;
__attribute__((section(".dlist_so_export_strtoimax")))
char const * __name_strtoimax = "strtoimax";
__attribute__((section(".dlist_so_export_strtoimax")))
void ** __ptr_to_strtoimax = &__export_strtoimax;



	asm(""
	".section .data.export_strtok \n"
"___export_strtok_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtok: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtok \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtok;
__attribute__((section(".dlist_so_export_strtok")))
char const * __name_strtok = "strtok";
__attribute__((section(".dlist_so_export_strtok")))
void ** __ptr_to_strtok = &__export_strtok;



	asm(""
	".section .data.export_strtok_r \n"
"___export_strtok_r_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtok_r: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtok_r \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtok_r;
__attribute__((section(".dlist_so_export_strtok_r")))
char const * __name_strtok_r = "strtok_r";
__attribute__((section(".dlist_so_export_strtok_r")))
void ** __ptr_to_strtok_r = &__export_strtok_r;



	asm(""
	".section .data.export_strtol \n"
"___export_strtol_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtol: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtol \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtol;
__attribute__((section(".dlist_so_export_strtol")))
char const * __name_strtol = "strtol";
__attribute__((section(".dlist_so_export_strtol")))
void ** __ptr_to_strtol = &__export_strtol;



	asm(""
	".section .data.export_strtold \n"
"___export_strtold_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtold: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtold \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtold;
__attribute__((section(".dlist_so_export_strtold")))
char const * __name_strtold = "strtold";
__attribute__((section(".dlist_so_export_strtold")))
void ** __ptr_to_strtold = &__export_strtold;



	asm(""
	".section .data.export_strtoll \n"
"___export_strtoll_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtoll: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtoll \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtoll;
__attribute__((section(".dlist_so_export_strtoll")))
char const * __name_strtoll = "strtoll";
__attribute__((section(".dlist_so_export_strtoll")))
void ** __ptr_to_strtoll = &__export_strtoll;



	asm(""
	".section .data.export_strtoul \n"
"___export_strtoul_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtoul: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtoul \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtoul;
__attribute__((section(".dlist_so_export_strtoul")))
char const * __name_strtoul = "strtoul";
__attribute__((section(".dlist_so_export_strtoul")))
void ** __ptr_to_strtoul = &__export_strtoul;



	asm(""
	".section .data.export_strtoull \n"
"___export_strtoull_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtoull: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtoull \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtoull;
__attribute__((section(".dlist_so_export_strtoull")))
char const * __name_strtoull = "strtoull";
__attribute__((section(".dlist_so_export_strtoull")))
void ** __ptr_to_strtoull = &__export_strtoull;



	asm(""
	".section .data.export_strtoumax \n"
"___export_strtoumax_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_strtoumax: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _strtoumax \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_strtoumax;
__attribute__((section(".dlist_so_export_strtoumax")))
char const * __name_strtoumax = "strtoumax";
__attribute__((section(".dlist_so_export_strtoumax")))
void ** __ptr_to_strtoumax = &__export_strtoumax;


extern void *strupper;
__attribute__((section(".dlist_so_export_strupper")))
char const * __name_strupper = "strupper";
__attribute__((section(".dlist_so_export_strupper")))
void ** __ptr_to_strupper = (void **)&strupper;


extern void *strupr;
__attribute__((section(".dlist_so_export_strupr")))
char const * __name_strupr = "strupr";
__attribute__((section(".dlist_so_export_strupr")))
void ** __ptr_to_strupr = (void **)&strupr;


extern void *strxfrm;
__attribute__((section(".dlist_so_export_strxfrm")))
char const * __name_strxfrm = "strxfrm";
__attribute__((section(".dlist_so_export_strxfrm")))
void ** __ptr_to_strxfrm = (void **)&strxfrm;



	asm(""
	".section .data.export___subdf3 \n"
"___export___subdf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___subdf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___subdf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___subdf3;
__attribute__((section(".dlist_so_export___subdf3")))
char const * __name___subdf3 = "__subdf3";
__attribute__((section(".dlist_so_export___subdf3")))
void ** __ptr_to___subdf3 = &__export___subdf3;



	asm(""
	".section .data.export___subsf3 \n"
"___export___subsf3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___subsf3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___subsf3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___subsf3;
__attribute__((section(".dlist_so_export___subsf3")))
char const * __name___subsf3 = "__subsf3";
__attribute__((section(".dlist_so_export___subsf3")))
void ** __ptr_to___subsf3 = &__export___subsf3;



	asm(""
	".section .data.export___swbuf \n"
"___export___swbuf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___swbuf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___swbuf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___swbuf;
__attribute__((section(".dlist_so_export___swbuf")))
char const * __name___swbuf = "__swbuf";
__attribute__((section(".dlist_so_export___swbuf")))
void ** __ptr_to___swbuf = &__export___swbuf;



	asm(""
	".section .data.export_swprintf \n"
"___export_swprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_swprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _swprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_swprintf;
__attribute__((section(".dlist_so_export_swprintf")))
char const * __name_swprintf = "swprintf";
__attribute__((section(".dlist_so_export_swprintf")))
void ** __ptr_to_swprintf = &__export_swprintf;



	asm(""
	".section .data.export_symlink \n"
"___export_symlink_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_symlink: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _symlink \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_symlink;
__attribute__((section(".dlist_so_export_symlink")))
char const * __name_symlink = "symlink";
__attribute__((section(".dlist_so_export_symlink")))
void ** __ptr_to_symlink = &__export_symlink;



	asm(""
	".section .data.export_sysconf \n"
"___export_sysconf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_sysconf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _sysconf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_sysconf;
__attribute__((section(".dlist_so_export_sysconf")))
char const * __name_sysconf = "sysconf";
__attribute__((section(".dlist_so_export_sysconf")))
void ** __ptr_to_sysconf = &__export_sysconf;



	asm(""
	".section .data.export_syslog \n"
"___export_syslog_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_syslog: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _syslog \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_syslog;
__attribute__((section(".dlist_so_export_syslog")))
char const * __name_syslog = "syslog";
__attribute__((section(".dlist_so_export_syslog")))
void ** __ptr_to_syslog = &__export_syslog;



	asm(""
	".section .data.export_system \n"
"___export_system_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_system: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _system \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_system;
__attribute__((section(".dlist_so_export_system")))
char const * __name_system = "system";
__attribute__((section(".dlist_so_export_system")))
void ** __ptr_to_system = &__export_system;



	asm(""
	".section .data.export_tan \n"
"___export_tan_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tan: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tan \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tan;
__attribute__((section(".dlist_so_export_tan")))
char const * __name_tan = "tan";
__attribute__((section(".dlist_so_export_tan")))
void ** __ptr_to_tan = &__export_tan;



	asm(""
	".section .data.export_tanf \n"
"___export_tanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tanf;
__attribute__((section(".dlist_so_export_tanf")))
char const * __name_tanf = "tanf";
__attribute__((section(".dlist_so_export_tanf")))
void ** __ptr_to_tanf = &__export_tanf;



	asm(""
	".section .data.export_tanh \n"
"___export_tanh_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tanh: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tanh \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tanh;
__attribute__((section(".dlist_so_export_tanh")))
char const * __name_tanh = "tanh";
__attribute__((section(".dlist_so_export_tanh")))
void ** __ptr_to_tanh = &__export_tanh;



	asm(""
	".section .data.export_tanhf \n"
"___export_tanhf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tanhf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tanhf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tanhf;
__attribute__((section(".dlist_so_export_tanhf")))
char const * __name_tanhf = "tanhf";
__attribute__((section(".dlist_so_export_tanhf")))
void ** __ptr_to_tanhf = &__export_tanhf;



	asm(""
	".section .data.export_tcgetattr \n"
"___export_tcgetattr_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tcgetattr: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tcgetattr \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tcgetattr;
__attribute__((section(".dlist_so_export_tcgetattr")))
char const * __name_tcgetattr = "tcgetattr";
__attribute__((section(".dlist_so_export_tcgetattr")))
void ** __ptr_to_tcgetattr = &__export_tcgetattr;



	asm(""
	".section .data.export_tcsetattr \n"
"___export_tcsetattr_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tcsetattr: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tcsetattr \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tcsetattr;
__attribute__((section(".dlist_so_export_tcsetattr")))
char const * __name_tcsetattr = "tcsetattr";
__attribute__((section(".dlist_so_export_tcsetattr")))
void ** __ptr_to_tcsetattr = &__export_tcsetattr;



	asm(""
	".section .data.export_telldir \n"
"___export_telldir_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_telldir: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _telldir \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_telldir;
__attribute__((section(".dlist_so_export_telldir")))
char const * __name_telldir = "telldir";
__attribute__((section(".dlist_so_export_telldir")))
void ** __ptr_to_telldir = &__export_telldir;



	asm(""
	".section .data.export_textdomain \n"
"___export_textdomain_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_textdomain: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _textdomain \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_textdomain;
__attribute__((section(".dlist_so_export_textdomain")))
char const * __name_textdomain = "textdomain";
__attribute__((section(".dlist_so_export_textdomain")))
void ** __ptr_to_textdomain = &__export_textdomain;



	asm(""
	".section .data.export_time \n"
"___export_time_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_time: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _time \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_time;
__attribute__((section(".dlist_so_export_time")))
char const * __name_time = "time";
__attribute__((section(".dlist_so_export_time")))
void ** __ptr_to_time = &__export_time;



	asm(""
	".section .data.export_timer \n"
"___export_timer_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_timer: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _timer \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_timer;
__attribute__((section(".dlist_so_export_timer")))
char const * __name_timer = "timer";
__attribute__((section(".dlist_so_export_timer")))
void ** __ptr_to_timer = &__export_timer;



	asm(""
	".section .data.export_timeradd \n"
"___export_timeradd_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_timeradd: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _timeradd \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_timeradd;
__attribute__((section(".dlist_so_export_timeradd")))
char const * __name_timeradd = "timeradd";
__attribute__((section(".dlist_so_export_timeradd")))
void ** __ptr_to_timeradd = &__export_timeradd;



	asm(""
	".section .data.export_timersub \n"
"___export_timersub_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_timersub: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _timersub \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_timersub;
__attribute__((section(".dlist_so_export_timersub")))
char const * __name_timersub = "timersub";
__attribute__((section(".dlist_so_export_timersub")))
void ** __ptr_to_timersub = &__export_timersub;



	asm(""
	".section .data.export_times \n"
"___export_times_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_times: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _times \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_times;
__attribute__((section(".dlist_so_export_times")))
char const * __name_times = "times";
__attribute__((section(".dlist_so_export_times")))
void ** __ptr_to_times = &__export_times;



	asm(""
	".section .data.export_tmpfile \n"
"___export_tmpfile_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tmpfile: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tmpfile \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tmpfile;
__attribute__((section(".dlist_so_export_tmpfile")))
char const * __name_tmpfile = "tmpfile";
__attribute__((section(".dlist_so_export_tmpfile")))
void ** __ptr_to_tmpfile = &__export_tmpfile;



	asm(""
	".section .data.export_tmpnam \n"
"___export_tmpnam_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tmpnam: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tmpnam \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tmpnam;
__attribute__((section(".dlist_so_export_tmpnam")))
char const * __name_tmpnam = "tmpnam";
__attribute__((section(".dlist_so_export_tmpnam")))
void ** __ptr_to_tmpnam = &__export_tmpnam;



	asm(""
	".section .data.export_tolower \n"
"___export_tolower_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tolower: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tolower \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tolower;
__attribute__((section(".dlist_so_export_tolower")))
char const * __name_tolower = "tolower";
__attribute__((section(".dlist_so_export_tolower")))
void ** __ptr_to_tolower = &__export_tolower;



	asm(""
	".section .data.export_toupper \n"
"___export_toupper_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_toupper: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _toupper \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_toupper;
__attribute__((section(".dlist_so_export_toupper")))
char const * __name_toupper = "toupper";
__attribute__((section(".dlist_so_export_toupper")))
void ** __ptr_to_toupper = &__export_toupper;



	asm(""
	".section .data.export_towlower \n"
"___export_towlower_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_towlower: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _towlower \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_towlower;
__attribute__((section(".dlist_so_export_towlower")))
char const * __name_towlower = "towlower";
__attribute__((section(".dlist_so_export_towlower")))
void ** __ptr_to_towlower = &__export_towlower;



	asm(""
	".section .data.export_towupper \n"
"___export_towupper_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_towupper: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _towupper \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_towupper;
__attribute__((section(".dlist_so_export_towupper")))
char const * __name_towupper = "towupper";
__attribute__((section(".dlist_so_export_towupper")))
void ** __ptr_to_towupper = &__export_towupper;



	asm(""
	".section .data.export_trunc \n"
"___export_trunc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_trunc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _trunc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_trunc;
__attribute__((section(".dlist_so_export_trunc")))
char const * __name_trunc = "trunc";
__attribute__((section(".dlist_so_export_trunc")))
void ** __ptr_to_trunc = &__export_trunc;



	asm(""
	".section .data.export_truncate \n"
"___export_truncate_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_truncate: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _truncate \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_truncate;
__attribute__((section(".dlist_so_export_truncate")))
char const * __name_truncate = "truncate";
__attribute__((section(".dlist_so_export_truncate")))
void ** __ptr_to_truncate = &__export_truncate;



	asm(""
	".section .data.export___truncdfsf2 \n"
"___export___truncdfsf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___truncdfsf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___truncdfsf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___truncdfsf2;
__attribute__((section(".dlist_so_export___truncdfsf2")))
char const * __name___truncdfsf2 = "__truncdfsf2";
__attribute__((section(".dlist_so_export___truncdfsf2")))
void ** __ptr_to___truncdfsf2 = &__export___truncdfsf2;



	asm(""
	".section .data.export_truncf \n"
"___export_truncf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_truncf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _truncf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_truncf;
__attribute__((section(".dlist_so_export_truncf")))
char const * __name_truncf = "truncf";
__attribute__((section(".dlist_so_export_truncf")))
void ** __ptr_to_truncf = &__export_truncf;



	asm(""
	".section .data.export___truncxfdf2 \n"
"___export___truncxfdf2_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___truncxfdf2: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___truncxfdf2 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___truncxfdf2;
__attribute__((section(".dlist_so_export___truncxfdf2")))
char const * __name___truncxfdf2 = "__truncxfdf2";
__attribute__((section(".dlist_so_export___truncxfdf2")))
void ** __ptr_to___truncxfdf2 = &__export___truncxfdf2;



	asm(""
	".section .data.export_tzset \n"
"___export_tzset_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_tzset: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _tzset \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_tzset;
__attribute__((section(".dlist_so_export_tzset")))
char const * __name_tzset = "tzset";
__attribute__((section(".dlist_so_export_tzset")))
void ** __ptr_to_tzset = &__export_tzset;



	asm(""
	".section .data.export___udivsi3 \n"
"___export___udivsi3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___udivsi3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___udivsi3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___udivsi3;
__attribute__((section(".dlist_so_export___udivsi3")))
char const * __name___udivsi3 = "__udivsi3";
__attribute__((section(".dlist_so_export___udivsi3")))
void ** __ptr_to___udivsi3 = &__export___udivsi3;



	asm(""
	".section .data.export___ulldivus \n"
"___export___ulldivus_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___ulldivus: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___ulldivus \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___ulldivus;
__attribute__((section(".dlist_so_export___ulldivus")))
char const * __name___ulldivus = "__ulldivus";
__attribute__((section(".dlist_so_export___ulldivus")))
void ** __ptr_to___ulldivus = &__export___ulldivus;



	asm(""
	".section .data.export_ultoa \n"
"___export_ultoa_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ultoa: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ultoa \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ultoa;
__attribute__((section(".dlist_so_export_ultoa")))
char const * __name_ultoa = "ultoa";
__attribute__((section(".dlist_so_export_ultoa")))
void ** __ptr_to_ultoa = &__export_ultoa;


extern void *umask;
__attribute__((section(".dlist_so_export_umask")))
char const * __name_umask = "umask";
__attribute__((section(".dlist_so_export_umask")))
void ** __ptr_to_umask = (void **)&umask;



	asm(""
	".section .data.export___umodsi3 \n"
"___export___umodsi3_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___umodsi3: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___umodsi3 \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___umodsi3;
__attribute__((section(".dlist_so_export___umodsi3")))
char const * __name___umodsi3 = "__umodsi3";
__attribute__((section(".dlist_so_export___umodsi3")))
void ** __ptr_to___umodsi3 = &__export___umodsi3;



	asm(""
	".section .data.export_uname \n"
"___export_uname_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_uname: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _uname \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_uname;
__attribute__((section(".dlist_so_export_uname")))
char const * __name_uname = "uname";
__attribute__((section(".dlist_so_export_uname")))
void ** __ptr_to_uname = &__export_uname;



	asm(""
	".section .data.export_ungetc \n"
"___export_ungetc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ungetc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ungetc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ungetc;
__attribute__((section(".dlist_so_export_ungetc")))
char const * __name_ungetc = "ungetc";
__attribute__((section(".dlist_so_export_ungetc")))
void ** __ptr_to_ungetc = &__export_ungetc;



	asm(""
	".section .data.export_ungetwc \n"
"___export_ungetwc_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_ungetwc: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _ungetwc \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_ungetwc;
__attribute__((section(".dlist_so_export_ungetwc")))
char const * __name_ungetwc = "ungetwc";
__attribute__((section(".dlist_so_export_ungetwc")))
void ** __ptr_to_ungetwc = &__export_ungetwc;



	asm(""
	".section .data.export_unlink \n"
"___export_unlink_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_unlink: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _unlink \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_unlink;
__attribute__((section(".dlist_so_export_unlink")))
char const * __name_unlink = "unlink";
__attribute__((section(".dlist_so_export_unlink")))
void ** __ptr_to_unlink = &__export_unlink;



	asm(""
	".section .data.export_unsetenv \n"
"___export_unsetenv_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_unsetenv: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _unsetenv \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_unsetenv;
__attribute__((section(".dlist_so_export_unsetenv")))
char const * __name_unsetenv = "unsetenv";
__attribute__((section(".dlist_so_export_unsetenv")))
void ** __ptr_to_unsetenv = &__export_unsetenv;



	asm(""
	".section .data.export_uselocale \n"
"___export_uselocale_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_uselocale: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _uselocale \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_uselocale;
__attribute__((section(".dlist_so_export_uselocale")))
char const * __name_uselocale = "uselocale";
__attribute__((section(".dlist_so_export_uselocale")))
void ** __ptr_to_uselocale = &__export_uselocale;



	asm(""
	".section .data.export_usleep \n"
"___export_usleep_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_usleep: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _usleep \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_usleep;
__attribute__((section(".dlist_so_export_usleep")))
char const * __name_usleep = "usleep";
__attribute__((section(".dlist_so_export_usleep")))
void ** __ptr_to_usleep = &__export_usleep;



	asm(""
	".section .data.export_utime \n"
"___export_utime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_utime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _utime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_utime;
__attribute__((section(".dlist_so_export_utime")))
char const * __name_utime = "utime";
__attribute__((section(".dlist_so_export_utime")))
void ** __ptr_to_utime = &__export_utime;



	asm(""
	".section .data.export_utimes \n"
"___export_utimes_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_utimes: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _utimes \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_utimes;
__attribute__((section(".dlist_so_export_utimes")))
char const * __name_utimes = "utimes";
__attribute__((section(".dlist_so_export_utimes")))
void ** __ptr_to_utimes = &__export_utimes;



	asm(""
	".section .data.export_utoa \n"
"___export_utoa_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_utoa: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _utoa \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_utoa;
__attribute__((section(".dlist_so_export_utoa")))
char const * __name_utoa = "utoa";
__attribute__((section(".dlist_so_export_utoa")))
void ** __ptr_to_utoa = &__export_utoa;



	asm(""
	".section .data.export_vasprintf \n"
"___export_vasprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vasprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vasprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vasprintf;
__attribute__((section(".dlist_so_export_vasprintf")))
char const * __name_vasprintf = "vasprintf";
__attribute__((section(".dlist_so_export_vasprintf")))
void ** __ptr_to_vasprintf = &__export_vasprintf;



	asm(""
	".section .data.export_vfprintf \n"
"___export_vfprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vfprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vfprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vfprintf;
__attribute__((section(".dlist_so_export_vfprintf")))
char const * __name_vfprintf = "vfprintf";
__attribute__((section(".dlist_so_export_vfprintf")))
void ** __ptr_to_vfprintf = &__export_vfprintf;



	asm(""
	".section .data.export___vfprintf_total_size \n"
"___export___vfprintf_total_size_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___vfprintf_total_size: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___vfprintf_total_size \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___vfprintf_total_size;
__attribute__((section(".dlist_so_export___vfprintf_total_size")))
char const * __name___vfprintf_total_size = "__vfprintf_total_size";
__attribute__((section(".dlist_so_export___vfprintf_total_size")))
void ** __ptr_to___vfprintf_total_size = &__export___vfprintf_total_size;



	asm(""
	".section .data.export_vfscanf \n"
"___export_vfscanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vfscanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vfscanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vfscanf;
__attribute__((section(".dlist_so_export_vfscanf")))
char const * __name_vfscanf = "vfscanf";
__attribute__((section(".dlist_so_export_vfscanf")))
void ** __ptr_to_vfscanf = &__export_vfscanf;



	asm(""
	".section .data.export_vprintf \n"
"___export_vprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vprintf;
__attribute__((section(".dlist_so_export_vprintf")))
char const * __name_vprintf = "vprintf";
__attribute__((section(".dlist_so_export_vprintf")))
void ** __ptr_to_vprintf = &__export_vprintf;



	asm(""
	".section .data.export_vscanf \n"
"___export_vscanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vscanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vscanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vscanf;
__attribute__((section(".dlist_so_export_vscanf")))
char const * __name_vscanf = "vscanf";
__attribute__((section(".dlist_so_export_vscanf")))
void ** __ptr_to_vscanf = &__export_vscanf;



	asm(""
	".section .data.export_vsnprintf \n"
"___export_vsnprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vsnprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vsnprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vsnprintf;
__attribute__((section(".dlist_so_export_vsnprintf")))
char const * __name_vsnprintf = "vsnprintf";
__attribute__((section(".dlist_so_export_vsnprintf")))
void ** __ptr_to_vsnprintf = &__export_vsnprintf;



	asm(""
	".section .data.export_vsprintf \n"
"___export_vsprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vsprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vsprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vsprintf;
__attribute__((section(".dlist_so_export_vsprintf")))
char const * __name_vsprintf = "vsprintf";
__attribute__((section(".dlist_so_export_vsprintf")))
void ** __ptr_to_vsprintf = &__export_vsprintf;



	asm(""
	".section .data.export_vsscanf \n"
"___export_vsscanf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vsscanf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vsscanf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vsscanf;
__attribute__((section(".dlist_so_export_vsscanf")))
char const * __name_vsscanf = "vsscanf";
__attribute__((section(".dlist_so_export_vsscanf")))
void ** __ptr_to_vsscanf = &__export_vsscanf;



	asm(""
	".section .data.export_vswprintf \n"
"___export_vswprintf_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_vswprintf: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _vswprintf \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_vswprintf;
__attribute__((section(".dlist_so_export_vswprintf")))
char const * __name_vswprintf = "vswprintf";
__attribute__((section(".dlist_so_export_vswprintf")))
void ** __ptr_to_vswprintf = &__export_vswprintf;



	asm(""
	".section .data.export___vwfprintf_total_size \n"
"___export___vwfprintf_total_size_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export___vwfprintf_total_size: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    ___vwfprintf_total_size \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export___vwfprintf_total_size;
__attribute__((section(".dlist_so_export___vwfprintf_total_size")))
char const * __name___vwfprintf_total_size = "__vwfprintf_total_size";
__attribute__((section(".dlist_so_export___vwfprintf_total_size")))
void ** __ptr_to___vwfprintf_total_size = &__export___vwfprintf_total_size;


extern void *wait;
__attribute__((section(".dlist_so_export_wait")))
char const * __name_wait = "wait";
__attribute__((section(".dlist_so_export_wait")))
void ** __ptr_to_wait = (void **)&wait;


extern void *waitpid;
__attribute__((section(".dlist_so_export_waitpid")))
char const * __name_waitpid = "waitpid";
__attribute__((section(".dlist_so_export_waitpid")))
void ** __ptr_to_waitpid = (void **)&waitpid;


extern void *wcrtomb;
__attribute__((section(".dlist_so_export_wcrtomb")))
char const * __name_wcrtomb = "wcrtomb";
__attribute__((section(".dlist_so_export_wcrtomb")))
void ** __ptr_to_wcrtomb = (void **)&wcrtomb;


extern void *wcschr;
__attribute__((section(".dlist_so_export_wcschr")))
char const * __name_wcschr = "wcschr";
__attribute__((section(".dlist_so_export_wcschr")))
void ** __ptr_to_wcschr = (void **)&wcschr;


extern void *wcscmp;
__attribute__((section(".dlist_so_export_wcscmp")))
char const * __name_wcscmp = "wcscmp";
__attribute__((section(".dlist_so_export_wcscmp")))
void ** __ptr_to_wcscmp = (void **)&wcscmp;


extern void *wcscoll;
__attribute__((section(".dlist_so_export_wcscoll")))
char const * __name_wcscoll = "wcscoll";
__attribute__((section(".dlist_so_export_wcscoll")))
void ** __ptr_to_wcscoll = (void **)&wcscoll;


extern void *wcscpy;
__attribute__((section(".dlist_so_export_wcscpy")))
char const * __name_wcscpy = "wcscpy";
__attribute__((section(".dlist_so_export_wcscpy")))
void ** __ptr_to_wcscpy = (void **)&wcscpy;



	asm(""
	".section .data.export_wcsftime \n"
"___export_wcsftime_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_wcsftime: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _wcsftime \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_wcsftime;
__attribute__((section(".dlist_so_export_wcsftime")))
char const * __name_wcsftime = "wcsftime";
__attribute__((section(".dlist_so_export_wcsftime")))
void ** __ptr_to_wcsftime = &__export_wcsftime;


extern void *wcslcpy;
__attribute__((section(".dlist_so_export_wcslcpy")))
char const * __name_wcslcpy = "wcslcpy";
__attribute__((section(".dlist_so_export_wcslcpy")))
void ** __ptr_to_wcslcpy = (void **)&wcslcpy;


extern void *wcslen;
__attribute__((section(".dlist_so_export_wcslen")))
char const * __name_wcslen = "wcslen";
__attribute__((section(".dlist_so_export_wcslen")))
void ** __ptr_to_wcslen = (void **)&wcslen;


extern void *wcsncmp;
__attribute__((section(".dlist_so_export_wcsncmp")))
char const * __name_wcsncmp = "wcsncmp";
__attribute__((section(".dlist_so_export_wcsncmp")))
void ** __ptr_to_wcsncmp = (void **)&wcsncmp;


extern void *wcsncpy;
__attribute__((section(".dlist_so_export_wcsncpy")))
char const * __name_wcsncpy = "wcsncpy";
__attribute__((section(".dlist_so_export_wcsncpy")))
void ** __ptr_to_wcsncpy = (void **)&wcsncpy;


extern void *wcsrchr;
__attribute__((section(".dlist_so_export_wcsrchr")))
char const * __name_wcsrchr = "wcsrchr";
__attribute__((section(".dlist_so_export_wcsrchr")))
void ** __ptr_to_wcsrchr = (void **)&wcsrchr;


extern void *wcstok;
__attribute__((section(".dlist_so_export_wcstok")))
char const * __name_wcstok = "wcstok";
__attribute__((section(".dlist_so_export_wcstok")))
void ** __ptr_to_wcstok = (void **)&wcstok;



	asm(""
	".section .data.export_wcstol \n"
"___export_wcstol_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_wcstol: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _wcstol \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_wcstol;
__attribute__((section(".dlist_so_export_wcstol")))
char const * __name_wcstol = "wcstol";
__attribute__((section(".dlist_so_export_wcstol")))
void ** __ptr_to_wcstol = &__export_wcstol;


extern void *wcstombs;
__attribute__((section(".dlist_so_export_wcstombs")))
char const * __name_wcstombs = "wcstombs";
__attribute__((section(".dlist_so_export_wcstombs")))
void ** __ptr_to_wcstombs = (void **)&wcstombs;


extern void *wcsxfrm;
__attribute__((section(".dlist_so_export_wcsxfrm")))
char const * __name_wcsxfrm = "wcsxfrm";
__attribute__((section(".dlist_so_export_wcsxfrm")))
void ** __ptr_to_wcsxfrm = (void **)&wcsxfrm;


extern void *wctob;
__attribute__((section(".dlist_so_export_wctob")))
char const * __name_wctob = "wctob";
__attribute__((section(".dlist_so_export_wctob")))
void ** __ptr_to_wctob = (void **)&wctob;


extern void *wctomb;
__attribute__((section(".dlist_so_export_wctomb")))
char const * __name_wctomb = "wctomb";
__attribute__((section(".dlist_so_export_wctomb")))
void ** __ptr_to_wctomb = (void **)&wctomb;



	asm(""
	".section .data.export_wctype \n"
"___export_wctype_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_wctype: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _wctype \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_wctype;
__attribute__((section(".dlist_so_export_wctype")))
char const * __name_wctype = "wctype";
__attribute__((section(".dlist_so_export_wctype")))
void ** __ptr_to_wctype = &__export_wctype;


extern void *wmemchr;
__attribute__((section(".dlist_so_export_wmemchr")))
char const * __name_wmemchr = "wmemchr";
__attribute__((section(".dlist_so_export_wmemchr")))
void ** __ptr_to_wmemchr = (void **)&wmemchr;


extern void *wmemcmp;
__attribute__((section(".dlist_so_export_wmemcmp")))
char const * __name_wmemcmp = "wmemcmp";
__attribute__((section(".dlist_so_export_wmemcmp")))
void ** __ptr_to_wmemcmp = (void **)&wmemcmp;



	asm(""
	".section .data.export_wmemcpy \n"
"___export_wmemcpy_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_wmemcpy: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _wmemcpy \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_wmemcpy;
__attribute__((section(".dlist_so_export_wmemcpy")))
char const * __name_wmemcpy = "wmemcpy";
__attribute__((section(".dlist_so_export_wmemcpy")))
void ** __ptr_to_wmemcpy = &__export_wmemcpy;


extern void *wmemmove;
__attribute__((section(".dlist_so_export_wmemmove")))
char const * __name_wmemmove = "wmemmove";
__attribute__((section(".dlist_so_export_wmemmove")))
void ** __ptr_to_wmemmove = (void **)&wmemmove;


extern void *wmemset;
__attribute__((section(".dlist_so_export_wmemset")))
char const * __name_wmemset = "wmemset";
__attribute__((section(".dlist_so_export_wmemset")))
void ** __ptr_to_wmemset = (void **)&wmemset;



	asm(""
	".section .data.export_write \n"
"___export_write_a4: \n"
"	.long 0 | <-- contains the a4 value to use \n"
"___export_write: \n"
"	move.l a4,-(sp) \n"
"	move.l -8(pc),a4 | <-- read the correct a4 value \n"
"	move.l (sp)+,(___save_a4:W,a4) \n"
"	move.l (sp)+,(___save_sp:W,a4) \n"
"	jsr    _write \n"
"	move.l (___save_sp:W,a4),-(sp) \n"
"	move.l (___save_a4:W,a4),a4 \n"
"	rts \n");

extern void * __export_write;
__attribute__((section(".dlist_so_export_write")))
char const * __name_write = "write";
__attribute__((section(".dlist_so_export_write")))
void ** __ptr_to_write = &__export_write;


extern void *Yield;
__attribute__((section(".dlist_so_export_Yield")))
char const * __name_Yield = "Yield";
__attribute__((section(".dlist_so_export_Yield")))
void ** __ptr_to_Yield = (void **)&Yield;



extern void * __sF__data;
__attribute__((section(".dlist_so_export___sF")))
char const * __name___sF = "__sF";
__attribute__((section(".dlist_so_export___sF")))
void ** __ptr_to___sF = (void**)&__sF__data;



extern void * __errno__data;
__attribute__((section(".dlist_so_export___errno")))
char const * __name___errno = "__errno";
__attribute__((section(".dlist_so_export___errno")))
void ** __ptr_to___errno = (void**)&__errno__data;



extern void * _ctype___data;
__attribute__((section(".dlist_so_export__ctype_")))
char const * __name__ctype_ = "_ctype_";
__attribute__((section(".dlist_so_export__ctype_")))
void ** __ptr_to__ctype_ = (void**)&_ctype___data;



extern void * environ_ptr__data;
__attribute__((section(".dlist_so_export_environ_ptr")))
char const * __name_environ_ptr = "environ_ptr";
__attribute__((section(".dlist_so_export_environ_ptr")))
void ** __ptr_to_environ_ptr = (void**)&environ_ptr__data;



extern void * __timezone__data;
__attribute__((section(".dlist_so_export___timezone")))
char const * __name___timezone = "__timezone";
__attribute__((section(".dlist_so_export___timezone")))
void ** __ptr_to___timezone = (void**)&__timezone__data;



extern void * __daylight__data;
__attribute__((section(".dlist_so_export___daylight")))
char const * __name___daylight = "__daylight";
__attribute__((section(".dlist_so_export___daylight")))
void ** __ptr_to___daylight = (void**)&__daylight__data;



extern void * __tzname__data;
__attribute__((section(".dlist_so_export___tzname")))
char const * __name___tzname = "__tzname";
__attribute__((section(".dlist_so_export___tzname")))
void ** __ptr_to___tzname = (void**)&__tzname__data;



extern void * __decimalpoint__data;
__attribute__((section(".dlist_so_export___decimalpoint")))
char const * __name___decimalpoint = "__decimalpoint";
__attribute__((section(".dlist_so_export___decimalpoint")))
void ** __ptr_to___decimalpoint = (void**)&__decimalpoint__data;



extern void * _impure_ptr__data;
__attribute__((section(".dlist_so_export__impure_ptr")))
char const * __name__impure_ptr = "_impure_ptr";
__attribute__((section(".dlist_so_export__impure_ptr")))
void ** __ptr_to__impure_ptr = (void**)&_impure_ptr__data;