#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>

static int __J_102_inside_counter=0;
#ifdef memcpy
  #undef memcpy
#endif
void *memcpy(void *par_1,const void *par_2,size_t par_3) {
	char fname[]="memcpy";
	void *ret;
	void *(*call)(void *,const void *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memcpy(");
		fprintf(stderr,"(void *)%X ",par_1);
		fprintf(stderr,"(const void *)%X ",par_2);
		fprintf(stderr,"(size_t )%u ",par_3);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(void *,const void *,size_t )) dlget(fname);
	ret = (*call)(par_1,par_2,par_3);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef memmove
  #undef memmove
#endif
void *memmove(void *par_4,const void *par_5,size_t par_6) {
	char fname[]="memmove";
	void *ret;
	void *(*call)(void *,const void *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memmove(");
		fprintf(stderr,"(void *)%X ",par_4);
		fprintf(stderr,"(const void *)%X ",par_5);
		fprintf(stderr,"(size_t )%u ",par_6);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(void *,const void *,size_t )) dlget(fname);
	ret = (*call)(par_4,par_5,par_6);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strcpy
  #undef strcpy
#endif
char *strcpy(char *par_7,const char *par_8) {
	char fname[]="strcpy";
	char *ret;
	char *(*call)(char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strcpy(");
		fprintf(stderr,"(char *)%X ",par_7);
		fprintf(stderr,"\"%s\" ",((par_7)==NULL) ? ( "NULL" ) : (par_7) );
		fprintf(stderr,"(const char *)%X ",par_8);
		fprintf(stderr,"\"%s\" ",((par_8)==NULL) ? ( "NULL" ) : (par_8) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,const char *)) dlget(fname);
	ret = (*call)(par_7,par_8);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strncpy
  #undef strncpy
#endif
char *strncpy(char *par_9,const char *par_10,size_t par_11) {
	char fname[]="strncpy";
	char *ret;
	char *(*call)(char *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strncpy(");
		fprintf(stderr,"(char *)%X ",par_9);
		fprintf(stderr,"\"%s\" ",((par_9)==NULL) ? ( "NULL" ) : (par_9) );
		fprintf(stderr,"(const char *)%X ",par_10);
		fprintf(stderr,"\"%s\" ",((par_10)==NULL) ? ( "NULL" ) : (par_10) );
		fprintf(stderr,"(size_t )%u ",par_11);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_9,par_10,par_11);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strcat
  #undef strcat
#endif
char *strcat(char *par_12,const char *par_13) {
	char fname[]="strcat";
	char *ret;
	char *(*call)(char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strcat(");
		fprintf(stderr,"(char *)%X ",par_12);
		fprintf(stderr,"\"%s\" ",((par_12)==NULL) ? ( "NULL" ) : (par_12) );
		fprintf(stderr,"(const char *)%X ",par_13);
		fprintf(stderr,"\"%s\" ",((par_13)==NULL) ? ( "NULL" ) : (par_13) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,const char *)) dlget(fname);
	ret = (*call)(par_12,par_13);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strncat
  #undef strncat
#endif
char *strncat(char *par_14,const char *par_15,size_t par_16) {
	char fname[]="strncat";
	char *ret;
	char *(*call)(char *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strncat(");
		fprintf(stderr,"(char *)%X ",par_14);
		fprintf(stderr,"\"%s\" ",((par_14)==NULL) ? ( "NULL" ) : (par_14) );
		fprintf(stderr,"(const char *)%X ",par_15);
		fprintf(stderr,"\"%s\" ",((par_15)==NULL) ? ( "NULL" ) : (par_15) );
		fprintf(stderr,"(size_t )%u ",par_16);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_14,par_15,par_16);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef memcmp
  #undef memcmp
#endif
int memcmp(const void *par_17,const void *par_18,size_t par_19) {
	char fname[]="memcmp";
	int ret;
	int (*call)(const void *,const void *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memcmp(");
		fprintf(stderr,"(const void *)%X ",par_17);
		fprintf(stderr,"(const void *)%X ",par_18);
		fprintf(stderr,"(size_t )%u ",par_19);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const void *,const void *,size_t )) dlget(fname);
	ret = (*call)(par_17,par_18,par_19);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strcmp
  #undef strcmp
#endif
int strcmp(const char *par_20,const char *par_21) {
	char fname[]="strcmp";
	int ret;
	int (*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strcmp(");
		fprintf(stderr,"(const char *)%X ",par_20);
		fprintf(stderr,"\"%s\" ",((par_20)==NULL) ? ( "NULL" ) : (par_20) );
		fprintf(stderr,"(const char *)%X ",par_21);
		fprintf(stderr,"\"%s\" ",((par_21)==NULL) ? ( "NULL" ) : (par_21) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_20,par_21);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strcoll
  #undef strcoll
#endif
int strcoll(const char *par_22,const char *par_23) {
	char fname[]="strcoll";
	int ret;
	int (*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strcoll(");
		fprintf(stderr,"(const char *)%X ",par_22);
		fprintf(stderr,"\"%s\" ",((par_22)==NULL) ? ( "NULL" ) : (par_22) );
		fprintf(stderr,"(const char *)%X ",par_23);
		fprintf(stderr,"\"%s\" ",((par_23)==NULL) ? ( "NULL" ) : (par_23) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_22,par_23);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strncmp
  #undef strncmp
#endif
int strncmp(const char *par_24,const char *par_25,size_t par_26) {
	char fname[]="strncmp";
	int ret;
	int (*call)(const char *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strncmp(");
		fprintf(stderr,"(const char *)%X ",par_24);
		fprintf(stderr,"\"%s\" ",((par_24)==NULL) ? ( "NULL" ) : (par_24) );
		fprintf(stderr,"(const char *)%X ",par_25);
		fprintf(stderr,"\"%s\" ",((par_25)==NULL) ? ( "NULL" ) : (par_25) );
		fprintf(stderr,"(size_t )%u ",par_26);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_24,par_25,par_26);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strxfrm
  #undef strxfrm
#endif
size_t strxfrm(char *par_27,const char *par_28,size_t par_29) {
	char fname[]="strxfrm";
	size_t ret;
	size_t (*call)(char *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strxfrm(");
		fprintf(stderr,"(char *)%X ",par_27);
		fprintf(stderr,"\"%s\" ",((par_27)==NULL) ? ( "NULL" ) : (par_27) );
		fprintf(stderr,"(const char *)%X ",par_28);
		fprintf(stderr,"\"%s\" ",((par_28)==NULL) ? ( "NULL" ) : (par_28) );
		fprintf(stderr,"(size_t )%u ",par_29);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(char *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_27,par_28,par_29);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef memchr
  #undef memchr
#endif
void *memchr(const void *par_30,int par_31,size_t par_32) {
	char fname[]="memchr";
	void *ret;
	void *(*call)(const void *,int ,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memchr(");
		fprintf(stderr,"(const void *)%X ",par_30);
		fprintf(stderr,"(int )%d ",par_31);
		fprintf(stderr,"(size_t )%u ",par_32);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(const void *,int ,size_t )) dlget(fname);
	ret = (*call)(par_30,par_31,par_32);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strchr
  #undef strchr
#endif
char *strchr(const char *par_33,int par_34) {
	char fname[]="strchr";
	char *ret;
	char *(*call)(const char *,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strchr(");
		fprintf(stderr,"(const char *)%X ",par_33);
		fprintf(stderr,"\"%s\" ",((par_33)==NULL) ? ( "NULL" ) : (par_33) );
		fprintf(stderr,"(int )%d ",par_34);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *,int )) dlget(fname);
	ret = (*call)(par_33,par_34);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strcspn
  #undef strcspn
#endif
size_t strcspn(const char *par_35,const char *par_36) {
	char fname[]="strcspn";
	size_t ret;
	size_t (*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strcspn(");
		fprintf(stderr,"(const char *)%X ",par_35);
		fprintf(stderr,"\"%s\" ",((par_35)==NULL) ? ( "NULL" ) : (par_35) );
		fprintf(stderr,"(const char *)%X ",par_36);
		fprintf(stderr,"\"%s\" ",((par_36)==NULL) ? ( "NULL" ) : (par_36) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_35,par_36);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strpbrk
  #undef strpbrk
#endif
char *strpbrk(const char *par_37,const char *par_38) {
	char fname[]="strpbrk";
	char *ret;
	char *(*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strpbrk(");
		fprintf(stderr,"(const char *)%X ",par_37);
		fprintf(stderr,"\"%s\" ",((par_37)==NULL) ? ( "NULL" ) : (par_37) );
		fprintf(stderr,"(const char *)%X ",par_38);
		fprintf(stderr,"\"%s\" ",((par_38)==NULL) ? ( "NULL" ) : (par_38) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_37,par_38);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strrchr
  #undef strrchr
#endif
char *strrchr(const char *par_39,int par_40) {
	char fname[]="strrchr";
	char *ret;
	char *(*call)(const char *,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strrchr(");
		fprintf(stderr,"(const char *)%X ",par_39);
		fprintf(stderr,"\"%s\" ",((par_39)==NULL) ? ( "NULL" ) : (par_39) );
		fprintf(stderr,"(int )%d ",par_40);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *,int )) dlget(fname);
	ret = (*call)(par_39,par_40);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strspn
  #undef strspn
#endif
size_t strspn(const char *par_41,const char *par_42) {
	char fname[]="strspn";
	size_t ret;
	size_t (*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strspn(");
		fprintf(stderr,"(const char *)%X ",par_41);
		fprintf(stderr,"\"%s\" ",((par_41)==NULL) ? ( "NULL" ) : (par_41) );
		fprintf(stderr,"(const char *)%X ",par_42);
		fprintf(stderr,"\"%s\" ",((par_42)==NULL) ? ( "NULL" ) : (par_42) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_41,par_42);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strstr
  #undef strstr
#endif
char *strstr(const char *par_43,const char *par_44) {
	char fname[]="strstr";
	char *ret;
	char *(*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strstr(");
		fprintf(stderr,"(const char *)%X ",par_43);
		fprintf(stderr,"\"%s\" ",((par_43)==NULL) ? ( "NULL" ) : (par_43) );
		fprintf(stderr,"(const char *)%X ",par_44);
		fprintf(stderr,"\"%s\" ",((par_44)==NULL) ? ( "NULL" ) : (par_44) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_43,par_44);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strtok
  #undef strtok
#endif
char *strtok(char *par_45,const char *par_46) {
	char fname[]="strtok";
	char *ret;
	char *(*call)(char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strtok(");
		fprintf(stderr,"(char *)%X ",par_45);
		fprintf(stderr,"\"%s\" ",((par_45)==NULL) ? ( "NULL" ) : (par_45) );
		fprintf(stderr,"(const char *)%X ",par_46);
		fprintf(stderr,"\"%s\" ",((par_46)==NULL) ? ( "NULL" ) : (par_46) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,const char *)) dlget(fname);
	ret = (*call)(par_45,par_46);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef memset
  #undef memset
#endif
void *memset(void *par_47,int par_48,size_t par_49) {
	char fname[]="memset";
	void *ret;
	void *(*call)(void *,int ,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memset(");
		fprintf(stderr,"(void *)%X ",par_47);
		fprintf(stderr,"(int )%d ",par_48);
		fprintf(stderr,"(size_t )%u ",par_49);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(void *,int ,size_t )) dlget(fname);
	ret = (*call)(par_47,par_48,par_49);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strerror
  #undef strerror
#endif
char *strerror(int par_50) {
	char fname[]="strerror";
	char *ret;
	char *(*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strerror(");
		fprintf(stderr,"(int )%d ",par_50);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(int )) dlget(fname);
	ret = (*call)(par_50);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strlen
  #undef strlen
#endif
size_t strlen(const char *par_51) {
	char fname[]="strlen";
	size_t ret;
	size_t (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strlen(");
		fprintf(stderr,"(const char *)%X ",par_51);
		fprintf(stderr,"\"%s\" ",((par_51)==NULL) ? ( "NULL" ) : (par_51) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(const char *)) dlget(fname);
	ret = (*call)(par_51);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef memccpy
  #undef memccpy
#endif
void *memccpy(void *par_52,const void *par_53,int par_54,size_t par_55) {
	char fname[]="memccpy";
	void *ret;
	void *(*call)(void *,const void *,int ,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memccpy(");
		fprintf(stderr,"(void *)%X ",par_52);
		fprintf(stderr,"(const void *)%X ",par_53);
		fprintf(stderr,"(int )%d ",par_54);
		fprintf(stderr,"(size_t )%u ",par_55);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(void *,const void *,int ,size_t )) dlget(fname);
	ret = (*call)(par_52,par_53,par_54,par_55);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strdup
  #undef strdup
#endif
char *strdup(const char *par_56) {
	char fname[]="strdup";
	char *ret;
	char *(*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strdup(");
		fprintf(stderr,"(const char *)%X ",par_56);
		fprintf(stderr,"\"%s\" ",((par_56)==NULL) ? ( "NULL" ) : (par_56) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *)) dlget(fname);
	ret = (*call)(par_56);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strsignal
  #undef strsignal
#endif
char *strsignal(int par_57) {
	char fname[]="strsignal";
	char *ret;
	char *(*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strsignal(");
		fprintf(stderr,"(int )%d ",par_57);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(int )) dlget(fname);
	ret = (*call)(par_57);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ffs
  #undef ffs
#endif
int ffs(const int par_58) {
	char fname[]="ffs";
	int ret;
	int (*call)(const int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ffs(");
		fprintf(stderr,"(const int )%d ",par_58);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const int )) dlget(fname);
	ret = (*call)(par_58);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strcasecmp
  #undef strcasecmp
#endif
int strcasecmp(const char *par_59,const char *par_60) {
	char fname[]="strcasecmp";
	int ret;
	int (*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strcasecmp(");
		fprintf(stderr,"(const char *)%X ",par_59);
		fprintf(stderr,"\"%s\" ",((par_59)==NULL) ? ( "NULL" ) : (par_59) );
		fprintf(stderr,"(const char *)%X ",par_60);
		fprintf(stderr,"\"%s\" ",((par_60)==NULL) ? ( "NULL" ) : (par_60) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_59,par_60);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strncasecmp
  #undef strncasecmp
#endif
int strncasecmp(const char *par_61,const char *par_62,size_t par_63) {
	char fname[]="strncasecmp";
	int ret;
	int (*call)(const char *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strncasecmp(");
		fprintf(stderr,"(const char *)%X ",par_61);
		fprintf(stderr,"\"%s\" ",((par_61)==NULL) ? ( "NULL" ) : (par_61) );
		fprintf(stderr,"(const char *)%X ",par_62);
		fprintf(stderr,"\"%s\" ",((par_62)==NULL) ? ( "NULL" ) : (par_62) );
		fprintf(stderr,"(size_t )%u ",par_63);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_61,par_62,par_63);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef remove
  #undef remove
#endif
int remove(const char *par_64) {
	char fname[]="remove";
	int ret;
	int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"remove(");
		fprintf(stderr,"(const char *)%X ",par_64);
		fprintf(stderr,"\"%s\" ",((par_64)==NULL) ? ( "NULL" ) : (par_64) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *)) dlget(fname);
	ret = (*call)(par_64);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef rename
  #undef rename
#endif
int rename(const char *par_65,const char *par_66) {
	char fname[]="rename";
	int ret;
	int (*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"rename(");
		fprintf(stderr,"(const char *)%X ",par_65);
		fprintf(stderr,"\"%s\" ",((par_65)==NULL) ? ( "NULL" ) : (par_65) );
		fprintf(stderr,"(const char *)%X ",par_66);
		fprintf(stderr,"\"%s\" ",((par_66)==NULL) ? ( "NULL" ) : (par_66) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_65,par_66);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef tmpfile
  #undef tmpfile
#endif
FILE *tmpfile(void) {
	char fname[]="tmpfile";
	FILE *ret;
	FILE *(*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"tmpfile(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (FILE *(*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (FILE *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef tmpnam
  #undef tmpnam
#endif
char *tmpnam(char *par_68) {
	char fname[]="tmpnam";
	char *ret;
	char *(*call)(char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"tmpnam(");
		fprintf(stderr,"(char *)%X ",par_68);
		fprintf(stderr,"\"%s\" ",((par_68)==NULL) ? ( "NULL" ) : (par_68) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *)) dlget(fname);
	ret = (*call)(par_68);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fclose
  #undef fclose
#endif
int fclose(FILE *par_69) {
	char fname[]="fclose";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fclose(");
		fprintf(stderr,"(FILE *)%X ",par_69);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_69);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fflush
  #undef fflush
#endif
int fflush(FILE *par_70) {
	char fname[]="fflush";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fflush(");
		fprintf(stderr,"(FILE *)%X ",par_70);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_70);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fopen
  #undef fopen
#endif
FILE *fopen(const char *par_71,const char *par_72) {
	char fname[]="fopen";
	FILE *ret;
	FILE *(*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fopen(");
		fprintf(stderr,"(const char *)%X ",par_71);
		fprintf(stderr,"\"%s\" ",((par_71)==NULL) ? ( "NULL" ) : (par_71) );
		fprintf(stderr,"(const char *)%X ",par_72);
		fprintf(stderr,"\"%s\" ",((par_72)==NULL) ? ( "NULL" ) : (par_72) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (FILE *(*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_71,par_72);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (FILE *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef freopen
  #undef freopen
#endif
FILE *freopen(const char *par_73,const char *par_74,FILE *par_75) {
	char fname[]="freopen";
	FILE *ret;
	FILE *(*call)(const char *,const char *,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"freopen(");
		fprintf(stderr,"(const char *)%X ",par_73);
		fprintf(stderr,"\"%s\" ",((par_73)==NULL) ? ( "NULL" ) : (par_73) );
		fprintf(stderr,"(const char *)%X ",par_74);
		fprintf(stderr,"\"%s\" ",((par_74)==NULL) ? ( "NULL" ) : (par_74) );
		fprintf(stderr,"(FILE *)%X ",par_75);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (FILE *(*)(const char *,const char *,FILE *)) dlget(fname);
	ret = (*call)(par_73,par_74,par_75);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (FILE *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef setbuf
  #undef setbuf
#endif
void setbuf(FILE *par_76,char *par_77) {
	char fname[]="setbuf";
	void (*call)(FILE *,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"setbuf(");
		fprintf(stderr,"(FILE *)%X ",par_76);
		fprintf(stderr,"(char *)%X ",par_77);
		fprintf(stderr,"\"%s\" ",((par_77)==NULL) ? ( "NULL" ) : (par_77) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(FILE *,char *)) dlget(fname);
	(*call)(par_76,par_77);
}

#ifdef setvbuf
  #undef setvbuf
#endif
int setvbuf(FILE *par_78,char *par_79,int par_80,size_t par_81) {
	char fname[]="setvbuf";
	int ret;
	int (*call)(FILE *,char *,int ,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"setvbuf(");
		fprintf(stderr,"(FILE *)%X ",par_78);
		fprintf(stderr,"(char *)%X ",par_79);
		fprintf(stderr,"\"%s\" ",((par_79)==NULL) ? ( "NULL" ) : (par_79) );
		fprintf(stderr,"(int )%d ",par_80);
		fprintf(stderr,"(size_t )%u ",par_81);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,char *,int ,size_t )) dlget(fname);
	ret = (*call)(par_78,par_79,par_80,par_81);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fprintf
  #undef fprintf
#endif
int fprintf(FILE *par_82,const char *par_83,... ) {
	va_list valist;
	char fname[]="vfprintf";
	int ret;
	int (*call)(FILE *,const char *,... );
	va_start(valist,par_83);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fprintf(");
		fprintf(stderr,"(FILE *)%X ",par_82);
		fprintf(stderr,"(const char *)%X ",par_83);
		fprintf(stderr,"\"%s\" ",((par_83)==NULL) ? ( "NULL" ) : (par_83) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,const char *,... )) dlget(fname);
	ret = (*call)(par_82,par_83,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fscanf
  #undef fscanf
#endif
int fscanf(FILE *par_84,const char *par_85,... ) {
	va_list valist;
	char fname[]="vfscanf";
	int ret;
	int (*call)(FILE *,const char *,... );
	va_start(valist,par_85);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fscanf(");
		fprintf(stderr,"(FILE *)%X ",par_84);
		fprintf(stderr,"(const char *)%X ",par_85);
		fprintf(stderr,"\"%s\" ",((par_85)==NULL) ? ( "NULL" ) : (par_85) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,const char *,... )) dlget(fname);
	ret = (*call)(par_84,par_85,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef printf
  #undef printf
#endif
int printf(const char *par_86,... ) {
	va_list valist;
	char fname[]="vprintf";
	int ret;
	int (*call)(const char *,... );
	va_start(valist,par_86);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"printf(");
		fprintf(stderr,"(const char *)%X ",par_86);
		fprintf(stderr,"\"%s\" ",((par_86)==NULL) ? ( "NULL" ) : (par_86) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,... )) dlget(fname);
	ret = (*call)(par_86,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef scanf
  #undef scanf
#endif
int scanf(const char *par_87,... ) {
	va_list valist;
	char fname[]="vscanf";
	int ret;
	int (*call)(const char *,... );
	va_start(valist,par_87);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"scanf(");
		fprintf(stderr,"(const char *)%X ",par_87);
		fprintf(stderr,"\"%s\" ",((par_87)==NULL) ? ( "NULL" ) : (par_87) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,... )) dlget(fname);
	ret = (*call)(par_87,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef sprintf
  #undef sprintf
#endif
int sprintf(char *par_88,const char *par_89,... ) {
	va_list valist;
	char fname[]="vsprintf";
	int ret;
	int (*call)(char *,const char *,... );
	va_start(valist,par_89);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"sprintf(");
		fprintf(stderr,"(char *)%X ",par_88);
		fprintf(stderr,"\"%s\" ",((par_88)==NULL) ? ( "NULL" ) : (par_88) );
		fprintf(stderr,"(const char *)%X ",par_89);
		fprintf(stderr,"\"%s\" ",((par_89)==NULL) ? ( "NULL" ) : (par_89) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(char *,const char *,... )) dlget(fname);
	ret = (*call)(par_88,par_89,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef sscanf
  #undef sscanf
#endif
int sscanf(const char *par_90,const char *par_91,... ) {
	va_list valist;
	char fname[]="vsscanf";
	int ret;
	int (*call)(const char *,const char *,... );
	va_start(valist,par_91);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"sscanf(");
		fprintf(stderr,"(const char *)%X ",par_90);
		fprintf(stderr,"\"%s\" ",((par_90)==NULL) ? ( "NULL" ) : (par_90) );
		fprintf(stderr,"(const char *)%X ",par_91);
		fprintf(stderr,"\"%s\" ",((par_91)==NULL) ? ( "NULL" ) : (par_91) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,const char *,... )) dlget(fname);
	ret = (*call)(par_90,par_91,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef vfprintf
  #undef vfprintf
#endif
int vfprintf(FILE *par_92,const char *par_93,__va_list par_94) {
	char fname[]="vfprintf";
	int ret;
	int (*call)(FILE *,const char *,__va_list );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"vfprintf(");
		fprintf(stderr,"(FILE *)%X ",par_92);
		fprintf(stderr,"(const char *)%X ",par_93);
		fprintf(stderr,"\"%s\" ",((par_93)==NULL) ? ( "NULL" ) : (par_93) );
		fprintf(stderr,"(__va_list )%X ",par_94);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,const char *,__va_list )) dlget(fname);
	ret = (*call)(par_92,par_93,par_94);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef vprintf
  #undef vprintf
#endif
int vprintf(const char *par_95,__va_list par_96) {
	char fname[]="vprintf";
	int ret;
	int (*call)(const char *,__va_list );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"vprintf(");
		fprintf(stderr,"(const char *)%X ",par_95);
		fprintf(stderr,"\"%s\" ",((par_95)==NULL) ? ( "NULL" ) : (par_95) );
		fprintf(stderr,"(__va_list )%X ",par_96);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,__va_list )) dlget(fname);
	ret = (*call)(par_95,par_96);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef vsprintf
  #undef vsprintf
#endif
int vsprintf(char *par_97,const char *par_98,__va_list par_99) {
	char fname[]="vsprintf";
	int ret;
	int (*call)(char *,const char *,__va_list );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"vsprintf(");
		fprintf(stderr,"(char *)%X ",par_97);
		fprintf(stderr,"\"%s\" ",((par_97)==NULL) ? ( "NULL" ) : (par_97) );
		fprintf(stderr,"(const char *)%X ",par_98);
		fprintf(stderr,"\"%s\" ",((par_98)==NULL) ? ( "NULL" ) : (par_98) );
		fprintf(stderr,"(__va_list )%X ",par_99);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(char *,const char *,__va_list )) dlget(fname);
	ret = (*call)(par_97,par_98,par_99);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fgetc
  #undef fgetc
#endif
int fgetc(FILE *par_100) {
	char fname[]="fgetc";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fgetc(");
		fprintf(stderr,"(FILE *)%X ",par_100);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_100);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fgets
  #undef fgets
#endif
char *fgets(char *par_101,int par_102,FILE *par_103) {
	char fname[]="fgets";
	char *ret;
	char *(*call)(char *,int ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fgets(");
		fprintf(stderr,"(char *)%X ",par_101);
		fprintf(stderr,"\"%s\" ",((par_101)==NULL) ? ( "NULL" ) : (par_101) );
		fprintf(stderr,"(int )%d ",par_102);
		fprintf(stderr,"(FILE *)%X ",par_103);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,int ,FILE *)) dlget(fname);
	ret = (*call)(par_101,par_102,par_103);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fputc
  #undef fputc
#endif
int fputc(int par_104,FILE *par_105) {
	char fname[]="fputc";
	int ret;
	int (*call)(int ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fputc(");
		fprintf(stderr,"(int )%d ",par_104);
		fprintf(stderr,"(FILE *)%X ",par_105);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,FILE *)) dlget(fname);
	ret = (*call)(par_104,par_105);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fputs
  #undef fputs
#endif
int fputs(const char *par_106,FILE *par_107) {
	char fname[]="fputs";
	int ret;
	int (*call)(const char *,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fputs(");
		fprintf(stderr,"(const char *)%X ",par_106);
		fprintf(stderr,"\"%s\" ",((par_106)==NULL) ? ( "NULL" ) : (par_106) );
		fprintf(stderr,"(FILE *)%X ",par_107);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,FILE *)) dlget(fname);
	ret = (*call)(par_106,par_107);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getc
  #undef getc
#endif
int getc(FILE *par_108) {
	char fname[]="getc";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getc(");
		fprintf(stderr,"(FILE *)%X ",par_108);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_108);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getchar
  #undef getchar
#endif
int getchar(void) {
	char fname[]="getchar";
	int ret;
	int (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getchar(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef gets
  #undef gets
#endif
char *gets(char *par_110) {
	char fname[]="gets";
	char *ret;
	char *(*call)(char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"gets(");
		fprintf(stderr,"(char *)%X ",par_110);
		fprintf(stderr,"\"%s\" ",((par_110)==NULL) ? ( "NULL" ) : (par_110) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *)) dlget(fname);
	ret = (*call)(par_110);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef putc
  #undef putc
#endif
int putc(int par_111,FILE *par_112) {
	char fname[]="putc";
	int ret;
	int (*call)(int ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"putc(");
		fprintf(stderr,"(int )%d ",par_111);
		fprintf(stderr,"(FILE *)%X ",par_112);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,FILE *)) dlget(fname);
	ret = (*call)(par_111,par_112);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef putchar
  #undef putchar
#endif
int putchar(int par_113) {
	char fname[]="putchar";
	int ret;
	int (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"putchar(");
		fprintf(stderr,"(int )%d ",par_113);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int )) dlget(fname);
	ret = (*call)(par_113);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef puts
  #undef puts
#endif
int puts(const char *par_114) {
	char fname[]="puts";
	int ret;
	int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"puts(");
		fprintf(stderr,"(const char *)%X ",par_114);
		fprintf(stderr,"\"%s\" ",((par_114)==NULL) ? ( "NULL" ) : (par_114) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *)) dlget(fname);
	ret = (*call)(par_114);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ungetc
  #undef ungetc
#endif
int ungetc(int par_115,FILE *par_116) {
	char fname[]="ungetc";
	int ret;
	int (*call)(int ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ungetc(");
		fprintf(stderr,"(int )%d ",par_115);
		fprintf(stderr,"(FILE *)%X ",par_116);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,FILE *)) dlget(fname);
	ret = (*call)(par_115,par_116);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fread
  #undef fread
#endif
size_t fread(void *par_117,size_t par_118,size_t par_119,FILE *par_120) {
	char fname[]="fread";
	size_t ret;
	size_t (*call)(void *,size_t ,size_t ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fread(");
		fprintf(stderr,"(void *)%X ",par_117);
		fprintf(stderr,"(size_t )%u ",par_118);
		fprintf(stderr,"(size_t )%u ",par_119);
		fprintf(stderr,"(FILE *)%X ",par_120);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(void *,size_t ,size_t ,FILE *)) dlget(fname);
	ret = (*call)(par_117,par_118,par_119,par_120);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fwrite
  #undef fwrite
#endif
size_t fwrite(const void *par_121,size_t par_122,size_t par_123,FILE *par_124) {
	char fname[]="fwrite";
	size_t ret;
	size_t (*call)(const void *,size_t ,size_t ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fwrite(");
		fprintf(stderr,"(const void *)%X ",par_121);
		fprintf(stderr,"(size_t )%u ",par_122);
		fprintf(stderr,"(size_t )%u ",par_123);
		fprintf(stderr,"(FILE *)%X ",par_124);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(const void *,size_t ,size_t ,FILE *)) dlget(fname);
	ret = (*call)(par_121,par_122,par_123,par_124);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fgetpos
  #undef fgetpos
#endif
int fgetpos(FILE *par_125,fpos_t *par_126) {
	char fname[]="fgetpos";
	int ret;
	int (*call)(FILE *,fpos_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fgetpos(");
		fprintf(stderr,"(FILE *)%X ",par_125);
		fprintf(stderr,"(fpos_t *)%X ",par_126);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,fpos_t *)) dlget(fname);
	ret = (*call)(par_125,par_126);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fseek
  #undef fseek
#endif
int fseek(FILE *par_127,long int par_128,int par_129) {
	char fname[]="fseek";
	int ret;
	int (*call)(FILE *,long int ,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fseek(");
		fprintf(stderr,"(FILE *)%X ",par_127);
		fprintf(stderr,"(long int )%ld ",par_128);
		fprintf(stderr,"(int )%d ",par_129);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,long int ,int )) dlget(fname);
	ret = (*call)(par_127,par_128,par_129);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fsetpos
  #undef fsetpos
#endif
int fsetpos(FILE *par_130,const fpos_t *par_131) {
	char fname[]="fsetpos";
	int ret;
	int (*call)(FILE *,const fpos_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fsetpos(");
		fprintf(stderr,"(FILE *)%X ",par_130);
		fprintf(stderr,"(const fpos_t *)%X ",par_131);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *,const fpos_t *)) dlget(fname);
	ret = (*call)(par_130,par_131);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ftell
  #undef ftell
#endif
long int ftell(FILE *par_132) {
	char fname[]="ftell";
	long int ret;
	long int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ftell(");
		fprintf(stderr,"(FILE *)%X ",par_132);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_132);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef rewind
  #undef rewind
#endif
void rewind(FILE *par_133) {
	char fname[]="rewind";
	void (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"rewind(");
		fprintf(stderr,"(FILE *)%X ",par_133);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(FILE *)) dlget(fname);
	(*call)(par_133);
}

#ifdef clearerr
  #undef clearerr
#endif
void clearerr(FILE *par_134) {
	char fname[]="clearerr";
	void (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"clearerr(");
		fprintf(stderr,"(FILE *)%X ",par_134);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(FILE *)) dlget(fname);
	(*call)(par_134);
}

#ifdef feof
  #undef feof
#endif
int feof(FILE *par_135) {
	char fname[]="feof";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"feof(");
		fprintf(stderr,"(FILE *)%X ",par_135);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_135);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ferror
  #undef ferror
#endif
int ferror(FILE *par_136) {
	char fname[]="ferror";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ferror(");
		fprintf(stderr,"(FILE *)%X ",par_136);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_136);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef perror
  #undef perror
#endif
void perror(const char *par_137) {
	char fname[]="perror";
	void (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"perror(");
		fprintf(stderr,"(const char *)%X ",par_137);
		fprintf(stderr,"\"%s\" ",((par_137)==NULL) ? ( "NULL" ) : (par_137) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(const char *)) dlget(fname);
	(*call)(par_137);
}

#ifdef __filbuf
  #undef __filbuf
#endif
int __filbuf(FILE *par_138) {
	char fname[]="__filbuf";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"__filbuf(");
		fprintf(stderr,"(FILE *)%X ",par_138);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_138);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef __flsbuf
  #undef __flsbuf
#endif
int __flsbuf(int par_139,FILE *par_140) {
	char fname[]="__flsbuf";
	int ret;
	int (*call)(int ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"__flsbuf(");
		fprintf(stderr,"(int )%d ",par_139);
		fprintf(stderr,"(FILE *)%X ",par_140);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,FILE *)) dlget(fname);
	ret = (*call)(par_139,par_140);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fdopen
  #undef fdopen
#endif
FILE *fdopen(int par_141,const char *par_142) {
	char fname[]="fdopen";
	FILE *ret;
	FILE *(*call)(int ,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fdopen(");
		fprintf(stderr,"(int )%d ",par_141);
		fprintf(stderr,"(const char *)%X ",par_142);
		fprintf(stderr,"\"%s\" ",((par_142)==NULL) ? ( "NULL" ) : (par_142) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (FILE *(*)(int ,const char *)) dlget(fname);
	ret = (*call)(par_141,par_142);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (FILE *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ctermid
  #undef ctermid
#endif
char *ctermid(char *par_143) {
	char fname[]="ctermid";
	char *ret;
	char *(*call)(char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ctermid(");
		fprintf(stderr,"(char *)%X ",par_143);
		fprintf(stderr,"\"%s\" ",((par_143)==NULL) ? ( "NULL" ) : (par_143) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *)) dlget(fname);
	ret = (*call)(par_143);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fileno
  #undef fileno
#endif
int fileno(FILE *par_144) {
	char fname[]="fileno";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fileno(");
		fprintf(stderr,"(FILE *)%X ",par_144);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_144);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef popen
  #undef popen
#endif
FILE *popen(const char *par_145,const char *par_146) {
	char fname[]="popen";
	FILE *ret;
	FILE *(*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"popen(");
		fprintf(stderr,"(const char *)%X ",par_145);
		fprintf(stderr,"\"%s\" ",((par_145)==NULL) ? ( "NULL" ) : (par_145) );
		fprintf(stderr,"(const char *)%X ",par_146);
		fprintf(stderr,"\"%s\" ",((par_146)==NULL) ? ( "NULL" ) : (par_146) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (FILE *(*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_145,par_146);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (FILE *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef cuserid
  #undef cuserid
#endif
char *cuserid(char *par_147) {
	char fname[]="cuserid";
	char *ret;
	char *(*call)(char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"cuserid(");
		fprintf(stderr,"(char *)%X ",par_147);
		fprintf(stderr,"\"%s\" ",((par_147)==NULL) ? ( "NULL" ) : (par_147) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *)) dlget(fname);
	ret = (*call)(par_147);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef tempnam
  #undef tempnam
#endif
char *tempnam(const char *par_148,const char *par_149) {
	char fname[]="tempnam";
	char *ret;
	char *(*call)(const char *,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"tempnam(");
		fprintf(stderr,"(const char *)%X ",par_148);
		fprintf(stderr,"\"%s\" ",((par_148)==NULL) ? ( "NULL" ) : (par_148) );
		fprintf(stderr,"(const char *)%X ",par_149);
		fprintf(stderr,"\"%s\" ",((par_149)==NULL) ? ( "NULL" ) : (par_149) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *,const char *)) dlget(fname);
	ret = (*call)(par_148,par_149);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getopt
  #undef getopt
#endif
int getopt(int par_150,char * const * par_151,const char *par_152) {
	char fname[]="getopt";
	int ret;
	int (*call)(int ,char * const * ,const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getopt(");
		fprintf(stderr,"(int )%d ",par_150);
		fprintf(stderr,"(char * const * )%X ",par_151);
		fprintf(stderr,"(const char *)%X ",par_152);
		fprintf(stderr,"\"%s\" ",((par_152)==NULL) ? ( "NULL" ) : (par_152) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,char * const * ,const char *)) dlget(fname);
	ret = (*call)(par_150,par_151,par_152);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getsubopt
  #undef getsubopt
#endif
int getsubopt(char **par_153,char * const * par_154,char **par_155) {
	char fname[]="getsubopt";
	int ret;
	int (*call)(char **,char * const * ,char **);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getsubopt(");
		fprintf(stderr,"(char **)%X ",par_153);
		fprintf(stderr,"(char * const * )%X ",par_154);
		fprintf(stderr,"(char **)%X ",par_155);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(char **,char * const * ,char **)) dlget(fname);
	ret = (*call)(par_153,par_154,par_155);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getw
  #undef getw
#endif
int getw(FILE *par_156) {
	char fname[]="getw";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getw(");
		fprintf(stderr,"(FILE *)%X ",par_156);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_156);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef putw
  #undef putw
#endif
int putw(int par_157,FILE *par_158) {
	char fname[]="putw";
	int ret;
	int (*call)(int ,FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"putw(");
		fprintf(stderr,"(int )%d ",par_157);
		fprintf(stderr,"(FILE *)%X ",par_158);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,FILE *)) dlget(fname);
	ret = (*call)(par_157,par_158);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef pclose
  #undef pclose
#endif
int pclose(FILE *par_159) {
	char fname[]="pclose";
	int ret;
	int (*call)(FILE *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"pclose(");
		fprintf(stderr,"(FILE *)%X ",par_159);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(FILE *)) dlget(fname);
	ret = (*call)(par_159);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef atof
  #undef atof
#endif
double atof(const char *par_160) {
	char fname[]="atof";
	double ret;
	double (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"atof(");
		fprintf(stderr,"(const char *)%X ",par_160);
		fprintf(stderr,"\"%s\" ",((par_160)==NULL) ? ( "NULL" ) : (par_160) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (double (*)(const char *)) dlget(fname);
	ret = (*call)(par_160);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (double )%f\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef atoi
  #undef atoi
#endif
int atoi(const char *par_161) {
	char fname[]="atoi";
	int ret;
	int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"atoi(");
		fprintf(stderr,"(const char *)%X ",par_161);
		fprintf(stderr,"\"%s\" ",((par_161)==NULL) ? ( "NULL" ) : (par_161) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *)) dlget(fname);
	ret = (*call)(par_161);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef atol
  #undef atol
#endif
long int atol(const char *par_162) {
	char fname[]="atol";
	long int ret;
	long int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"atol(");
		fprintf(stderr,"(const char *)%X ",par_162);
		fprintf(stderr,"\"%s\" ",((par_162)==NULL) ? ( "NULL" ) : (par_162) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(const char *)) dlget(fname);
	ret = (*call)(par_162);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strtod
  #undef strtod
#endif
double strtod(const char *par_163,char **par_164) {
	char fname[]="strtod";
	double ret;
	double (*call)(const char *,char **);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strtod(");
		fprintf(stderr,"(const char *)%X ",par_163);
		fprintf(stderr,"\"%s\" ",((par_163)==NULL) ? ( "NULL" ) : (par_163) );
		fprintf(stderr,"(char **)%X ",par_164);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (double (*)(const char *,char **)) dlget(fname);
	ret = (*call)(par_163,par_164);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (double )%f\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strtol
  #undef strtol
#endif
long int strtol(const char *par_165,char **par_166,int par_167) {
	char fname[]="strtol";
	long int ret;
	long int (*call)(const char *,char **,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strtol(");
		fprintf(stderr,"(const char *)%X ",par_165);
		fprintf(stderr,"\"%s\" ",((par_165)==NULL) ? ( "NULL" ) : (par_165) );
		fprintf(stderr,"(char **)%X ",par_166);
		fprintf(stderr,"(int )%d ",par_167);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(const char *,char **,int )) dlget(fname);
	ret = (*call)(par_165,par_166,par_167);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strtoul
  #undef strtoul
#endif
unsigned long int strtoul(const char *par_168,char **par_169,int par_170) {
	char fname[]="strtoul";
	unsigned long int ret;
	unsigned long int (*call)(const char *,char **,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strtoul(");
		fprintf(stderr,"(const char *)%X ",par_168);
		fprintf(stderr,"\"%s\" ",((par_168)==NULL) ? ( "NULL" ) : (par_168) );
		fprintf(stderr,"(char **)%X ",par_169);
		fprintf(stderr,"(int )%d ",par_170);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (unsigned long int (*)(const char *,char **,int )) dlget(fname);
	ret = (*call)(par_168,par_169,par_170);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (unsigned long int )%lu\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef rand
  #undef rand
#endif
int rand(void) {
	char fname[]="rand";
	int ret;
	int (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"rand(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef srand
  #undef srand
#endif
void srand(unsigned int par_172) {
	char fname[]="srand";
	void (*call)(unsigned int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"srand(");
		fprintf(stderr,"(unsigned int )%u ",par_172);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(unsigned int )) dlget(fname);
	(*call)(par_172);
}

#ifdef calloc
  #undef calloc
#endif
void *calloc(size_t par_173,size_t par_174) {
	char fname[]="calloc";
	void *ret;
	void *(*call)(size_t ,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"calloc(");
		fprintf(stderr,"(size_t )%u ",par_173);
		fprintf(stderr,"(size_t )%u ",par_174);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(size_t ,size_t )) dlget(fname);
	ret = (*call)(par_173,par_174);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef free
  #undef free
#endif
void free(void *par_175) {
	char fname[]="free";
	void (*call)(void *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"free(");
		fprintf(stderr,"(void *)%X ",par_175);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(void *)) dlget(fname);
	(*call)(par_175);
}

#ifdef malloc
  #undef malloc
#endif
void *malloc(size_t par_176) {
	char fname[]="malloc";
	void *ret;
	void *(*call)(size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"malloc(");
		fprintf(stderr,"(size_t )%u ",par_176);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(size_t )) dlget(fname);
	ret = (*call)(par_176);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef realloc
  #undef realloc
#endif
void *realloc(void *par_177,size_t par_178) {
	char fname[]="realloc";
	void *ret;
	void *(*call)(void *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"realloc(");
		fprintf(stderr,"(void *)%X ",par_177);
		fprintf(stderr,"(size_t )%u ",par_178);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(void *,size_t )) dlget(fname);
	ret = (*call)(par_177,par_178);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef abort
  #undef abort
#endif
void abort(void) {
	char fname[]="abort";
	void (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"abort(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(void)) dlget(fname);
	(*call)();
}

#ifdef atexit
  #undef atexit
#endif
int atexit(void (*par_181)(void)) {
	char fname[]="atexit";
	int ret;
	int (*call)(void (*)(void));
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"atexit(");
		fprintf(stderr,"(void (*)(void))%X ",par_181);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(void (*)(void))) dlget(fname);
	ret = (*call)(par_181);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef exit
  #undef exit
#endif
void exit(int par_182) {
	char fname[]="exit";
	void (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"exit(");
		fprintf(stderr,"(int )%d ",par_182);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(int )) dlget(fname);
	(*call)(par_182);
}

#ifdef getenv
  #undef getenv
#endif
char *getenv(const char *par_183) {
	char fname[]="getenv";
	char *ret;
	char *(*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getenv(");
		fprintf(stderr,"(const char *)%X ",par_183);
		fprintf(stderr,"\"%s\" ",((par_183)==NULL) ? ( "NULL" ) : (par_183) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *)) dlget(fname);
	ret = (*call)(par_183);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef system
  #undef system
#endif
int system(const char *par_184) {
	char fname[]="system";
	int ret;
	int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"system(");
		fprintf(stderr,"(const char *)%X ",par_184);
		fprintf(stderr,"\"%s\" ",((par_184)==NULL) ? ( "NULL" ) : (par_184) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *)) dlget(fname);
	ret = (*call)(par_184);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef bsearch
  #undef bsearch
#endif
void *bsearch(const void *par_185,const void *par_186,size_t par_187,size_t par_188,int (*par_191)(const void *par_189,const void *par_190)) {
	char fname[]="bsearch";
	void *ret;
	void *(*call)(const void *,const void *,size_t ,size_t ,int (*)(const void *,const void *));
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"bsearch(");
		fprintf(stderr,"(const void *)%X ",par_185);
		fprintf(stderr,"(const void *)%X ",par_186);
		fprintf(stderr,"(size_t )%u ",par_187);
		fprintf(stderr,"(size_t )%u ",par_188);
		fprintf(stderr,"(int (*)(const void *,const void *))%X ",par_191);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(const void *,const void *,size_t ,size_t ,int (*)(const void *,const void *))) dlget(fname);
	ret = (*call)(par_185,par_186,par_187,par_188,par_191);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef qsort
  #undef qsort
#endif
void qsort(void *par_192,size_t par_193,size_t par_194,int (*par_197)(const void *par_195,const void *par_196)) {
	char fname[]="qsort";
	void (*call)(void *,size_t ,size_t ,int (*)(const void *,const void *));
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"qsort(");
		fprintf(stderr,"(void *)%X ",par_192);
		fprintf(stderr,"(size_t )%u ",par_193);
		fprintf(stderr,"(size_t )%u ",par_194);
		fprintf(stderr,"(int (*)(const void *,const void *))%X ",par_197);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(void *,size_t ,size_t ,int (*)(const void *,const void *))) dlget(fname);
	(*call)(par_192,par_193,par_194,par_197);
}

#ifdef abs
  #undef abs
#endif
int abs(int par_198) {
	char fname[]="abs";
	int ret;
	int (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"abs(");
		fprintf(stderr,"(int )%d ",par_198);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int )) dlget(fname);
	ret = (*call)(par_198);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef div
  #undef div
#endif
div_t div(int par_199,int par_200) {
	char fname[]="div";
	div_t ret;
	div_t (*call)(int ,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"div(");
		fprintf(stderr,"(int )%d ",par_199);
		fprintf(stderr,"(int )%d ",par_200);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (div_t (*)(int ,int )) dlget(fname);
	ret = (*call)(par_199,par_200);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (div_t )\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef labs
  #undef labs
#endif
long int labs(long int par_201) {
	char fname[]="labs";
	long int ret;
	long int (*call)(long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"labs(");
		fprintf(stderr,"(long int )%ld ",par_201);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(long int )) dlget(fname);
	ret = (*call)(par_201);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ldiv
  #undef ldiv
#endif
ldiv_t ldiv(long int par_202,long int par_203) {
	char fname[]="ldiv";
	ldiv_t ret;
	ldiv_t (*call)(long int ,long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ldiv(");
		fprintf(stderr,"(long int )%ld ",par_202);
		fprintf(stderr,"(long int )%ld ",par_203);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (ldiv_t (*)(long int ,long int )) dlget(fname);
	ret = (*call)(par_202,par_203);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (ldiv_t )\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef mbtowc
  #undef mbtowc
#endif
int mbtowc(wchar_t *par_204,const char *par_205,size_t par_206) {
	char fname[]="mbtowc";
	int ret;
	int (*call)(wchar_t *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"mbtowc(");
		fprintf(stderr,"(wchar_t *)%X ",par_204);
		fprintf(stderr,"(const char *)%X ",par_205);
		fprintf(stderr,"\"%s\" ",((par_205)==NULL) ? ( "NULL" ) : (par_205) );
		fprintf(stderr,"(size_t )%u ",par_206);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(wchar_t *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_204,par_205,par_206);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef mblen
  #undef mblen
#endif
int mblen(const char *par_207,size_t par_208) {
	char fname[]="mblen";
	int ret;
	int (*call)(const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"mblen(");
		fprintf(stderr,"(const char *)%X ",par_207);
		fprintf(stderr,"\"%s\" ",((par_207)==NULL) ? ( "NULL" ) : (par_207) );
		fprintf(stderr,"(size_t )%u ",par_208);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,size_t )) dlget(fname);
	ret = (*call)(par_207,par_208);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef wctomb
  #undef wctomb
#endif
int wctomb(char *par_209,wchar_t par_210) {
	char fname[]="wctomb";
	int ret;
	int (*call)(char *,wchar_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"wctomb(");
		fprintf(stderr,"(char *)%X ",par_209);
		fprintf(stderr,"\"%s\" ",((par_209)==NULL) ? ( "NULL" ) : (par_209) );
		fprintf(stderr,"(wchar_t )%ld ",par_210);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(char *,wchar_t )) dlget(fname);
	ret = (*call)(par_209,par_210);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef mbstowcs
  #undef mbstowcs
#endif
size_t mbstowcs(wchar_t *par_211,const char *par_212,size_t par_213) {
	char fname[]="mbstowcs";
	size_t ret;
	size_t (*call)(wchar_t *,const char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"mbstowcs(");
		fprintf(stderr,"(wchar_t *)%X ",par_211);
		fprintf(stderr,"(const char *)%X ",par_212);
		fprintf(stderr,"\"%s\" ",((par_212)==NULL) ? ( "NULL" ) : (par_212) );
		fprintf(stderr,"(size_t )%u ",par_213);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(wchar_t *,const char *,size_t )) dlget(fname);
	ret = (*call)(par_211,par_212,par_213);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef wcstombs
  #undef wcstombs
#endif
size_t wcstombs(char *par_214,const wchar_t *par_215,size_t par_216) {
	char fname[]="wcstombs";
	size_t ret;
	size_t (*call)(char *,const wchar_t *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"wcstombs(");
		fprintf(stderr,"(char *)%X ",par_214);
		fprintf(stderr,"\"%s\" ",((par_214)==NULL) ? ( "NULL" ) : (par_214) );
		fprintf(stderr,"(const wchar_t *)%X ",par_215);
		fprintf(stderr,"(size_t )%u ",par_216);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(char *,const wchar_t *,size_t )) dlget(fname);
	ret = (*call)(par_214,par_215,par_216);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef drand48
  #undef drand48
#endif
double drand48(void) {
	char fname[]="drand48";
	double ret;
	double (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"drand48(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (double (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (double )%f\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef erand48
  #undef erand48
#endif
double erand48(unsigned short int *par_218) {
	char fname[]="erand48";
	double ret;
	double (*call)(unsigned short int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"erand48(");
		fprintf(stderr,"(unsigned short int *)%X ",par_218);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (double (*)(unsigned short int *)) dlget(fname);
	ret = (*call)(par_218);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (double )%f\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef jrand48
  #undef jrand48
#endif
long int jrand48(unsigned short int *par_219) {
	char fname[]="jrand48";
	long int ret;
	long int (*call)(unsigned short int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"jrand48(");
		fprintf(stderr,"(unsigned short int *)%X ",par_219);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(unsigned short int *)) dlget(fname);
	ret = (*call)(par_219);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef lcong48
  #undef lcong48
#endif
void lcong48(unsigned short int *par_220) {
	char fname[]="lcong48";
	void (*call)(unsigned short int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"lcong48(");
		fprintf(stderr,"(unsigned short int *)%X ",par_220);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(unsigned short int *)) dlget(fname);
	(*call)(par_220);
}

#ifdef lrand48
  #undef lrand48
#endif
long int lrand48(void) {
	char fname[]="lrand48";
	long int ret;
	long int (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"lrand48(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef mrand48
  #undef mrand48
#endif
long int mrand48(void) {
	char fname[]="mrand48";
	long int ret;
	long int (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"mrand48(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef nrand48
  #undef nrand48
#endif
long int nrand48(unsigned short int *par_223) {
	char fname[]="nrand48";
	long int ret;
	long int (*call)(unsigned short int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"nrand48(");
		fprintf(stderr,"(unsigned short int *)%X ",par_223);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(unsigned short int *)) dlget(fname);
	ret = (*call)(par_223);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef seed48
  #undef seed48
#endif
unsigned short int *seed48(unsigned short int *par_224) {
	char fname[]="seed48";
	unsigned short int *ret;
	unsigned short int *(*call)(unsigned short int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"seed48(");
		fprintf(stderr,"(unsigned short int *)%X ",par_224);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (unsigned short int *(*)(unsigned short int *)) dlget(fname);
	ret = (*call)(par_224);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (unsigned short int *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef srand48
  #undef srand48
#endif
void srand48(long int par_225) {
	char fname[]="srand48";
	void (*call)(long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"srand48(");
		fprintf(stderr,"(long int )%ld ",par_225);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(long int )) dlget(fname);
	(*call)(par_225);
}

#ifdef putenv
  #undef putenv
#endif
int putenv(const char *par_226) {
	char fname[]="putenv";
	int ret;
	int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"putenv(");
		fprintf(stderr,"(const char *)%X ",par_226);
		fprintf(stderr,"\"%s\" ",((par_226)==NULL) ? ( "NULL" ) : (par_226) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *)) dlget(fname);
	ret = (*call)(par_226);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef setkey
  #undef setkey
#endif
void setkey(const char *par_227) {
	char fname[]="setkey";
	void (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"setkey(");
		fprintf(stderr,"(const char *)%X ",par_227);
		fprintf(stderr,"\"%s\" ",((par_227)==NULL) ? ( "NULL" ) : (par_227) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(const char *)) dlget(fname);
	(*call)(par_227);
}

#ifdef swab
  #undef swab
#endif
void swab(const char *par_228,char *par_229,int par_230) {
	char fname[]="swab";
	void (*call)(const char *,char *,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"swab(");
		fprintf(stderr,"(const char *)%X ",par_228);
		fprintf(stderr,"\"%s\" ",((par_228)==NULL) ? ( "NULL" ) : (par_228) );
		fprintf(stderr,"(char *)%X ",par_229);
		fprintf(stderr,"\"%s\" ",((par_229)==NULL) ? ( "NULL" ) : (par_229) );
		fprintf(stderr,"(int )%d ",par_230);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(const char *,char *,int )) dlget(fname);
	(*call)(par_228,par_229,par_230);
}

#ifdef a64l
  #undef a64l
#endif
long int a64l(const char *par_231) {
	char fname[]="a64l";
	long int ret;
	long int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"a64l(");
		fprintf(stderr,"(const char *)%X ",par_231);
		fprintf(stderr,"\"%s\" ",((par_231)==NULL) ? ( "NULL" ) : (par_231) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(const char *)) dlget(fname);
	ret = (*call)(par_231);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef dup2
  #undef dup2
#endif
int dup2(int par_232,int par_233) {
	char fname[]="dup2";
	int ret;
	int (*call)(int ,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"dup2(");
		fprintf(stderr,"(int )%d ",par_232);
		fprintf(stderr,"(int )%d ",par_233);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,int )) dlget(fname);
	ret = (*call)(par_232,par_233);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ecvt
  #undef ecvt
#endif
char *ecvt(double par_234,int par_235,int *par_236,int *par_237) {
	char fname[]="ecvt";
	char *ret;
	char *(*call)(double ,int ,int *,int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ecvt(");
		fprintf(stderr,"(double )%f ",par_234);
		fprintf(stderr,"(int )%d ",par_235);
		fprintf(stderr,"(int *)%X ",par_236);
		fprintf(stderr,"(int *)%X ",par_237);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(double ,int ,int *,int *)) dlget(fname);
	ret = (*call)(par_234,par_235,par_236,par_237);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fcvt
  #undef fcvt
#endif
char *fcvt(double par_238,int par_239,int *par_240,int *par_241) {
	char fname[]="fcvt";
	char *ret;
	char *(*call)(double ,int ,int *,int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fcvt(");
		fprintf(stderr,"(double )%f ",par_238);
		fprintf(stderr,"(int )%d ",par_239);
		fprintf(stderr,"(int *)%X ",par_240);
		fprintf(stderr,"(int *)%X ",par_241);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(double ,int ,int *,int *)) dlget(fname);
	ret = (*call)(par_238,par_239,par_240,par_241);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef qecvt
  #undef qecvt
#endif
char *qecvt(long double par_242,int par_243,int *par_244,int *par_245) {
	char fname[]="qecvt";
	char *ret;
	char *(*call)(long double ,int ,int *,int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"qecvt(");
		fprintf(stderr,"(long double )%f ",par_242);
		fprintf(stderr,"(int )%d ",par_243);
		fprintf(stderr,"(int *)%X ",par_244);
		fprintf(stderr,"(int *)%X ",par_245);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(long double ,int ,int *,int *)) dlget(fname);
	ret = (*call)(par_242,par_243,par_244,par_245);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef qfcvt
  #undef qfcvt
#endif
char *qfcvt(long double par_246,int par_247,int *par_248,int *par_249) {
	char fname[]="qfcvt";
	char *ret;
	char *(*call)(long double ,int ,int *,int *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"qfcvt(");
		fprintf(stderr,"(long double )%f ",par_246);
		fprintf(stderr,"(int )%d ",par_247);
		fprintf(stderr,"(int *)%X ",par_248);
		fprintf(stderr,"(int *)%X ",par_249);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(long double ,int ,int *,int *)) dlget(fname);
	ret = (*call)(par_246,par_247,par_248,par_249);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef qgcvt
  #undef qgcvt
#endif
char *qgcvt(long double par_250,int par_251,char *par_252) {
	char fname[]="qgcvt";
	char *ret;
	char *(*call)(long double ,int ,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"qgcvt(");
		fprintf(stderr,"(long double )%f ",par_250);
		fprintf(stderr,"(int )%d ",par_251);
		fprintf(stderr,"(char *)%X ",par_252);
		fprintf(stderr,"\"%s\" ",((par_252)==NULL) ? ( "NULL" ) : (par_252) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(long double ,int ,char *)) dlget(fname);
	ret = (*call)(par_250,par_251,par_252);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getcwd
  #undef getcwd
#endif
char *getcwd(char *par_253,size_t par_254) {
	char fname[]="getcwd";
	char *ret;
	char *(*call)(char *,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getcwd(");
		fprintf(stderr,"(char *)%X ",par_253);
		fprintf(stderr,"\"%s\" ",((par_253)==NULL) ? ( "NULL" ) : (par_253) );
		fprintf(stderr,"(size_t )%u ",par_254);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,size_t )) dlget(fname);
	ret = (*call)(par_253,par_254);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getlogin
  #undef getlogin
#endif
char *getlogin(void) {
	char fname[]="getlogin";
	char *ret;
	char *(*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getlogin(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getpass
  #undef getpass
#endif
char *getpass(const char *par_262) {
	char fname[]="getpass";
	char *ret;
	char *(*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getpass(");
		fprintf(stderr,"(const char *)%X ",par_262);
		fprintf(stderr,"\"%s\" ",((par_262)==NULL) ? ( "NULL" ) : (par_262) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *)) dlget(fname);
	ret = (*call)(par_262);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getpw
  #undef getpw
#endif
int getpw(uid_t par_263,char *par_264) {
	char fname[]="getpw";
	int ret;
	int (*call)(uid_t ,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getpw(");
		fprintf(stderr,"(uid_t )%ld ",par_263);
		fprintf(stderr,"(char *)%X ",par_264);
		fprintf(stderr,"\"%s\" ",((par_264)==NULL) ? ( "NULL" ) : (par_264) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(uid_t ,char *)) dlget(fname);
	ret = (*call)(par_263,par_264);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef gcvt
  #undef gcvt
#endif
char *gcvt(double par_265,int par_266,char *par_267) {
	char fname[]="gcvt";
	char *ret;
	char *(*call)(double ,int ,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"gcvt(");
		fprintf(stderr,"(double )%f ",par_265);
		fprintf(stderr,"(int )%d ",par_266);
		fprintf(stderr,"(char *)%X ",par_267);
		fprintf(stderr,"\"%s\" ",((par_267)==NULL) ? ( "NULL" ) : (par_267) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(double ,int ,char *)) dlget(fname);
	ret = (*call)(par_265,par_266,par_267);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef isatty
  #undef isatty
#endif
int isatty(int par_268) {
	char fname[]="isatty";
	int ret;
	int (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"isatty(");
		fprintf(stderr,"(int )%d ",par_268);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int )) dlget(fname);
	ret = (*call)(par_268);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef l64a
  #undef l64a
#endif
char *l64a(long int par_269) {
	char fname[]="l64a";
	char *ret;
	char *(*call)(long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"l64a(");
		fprintf(stderr,"(long int )%ld ",par_269);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(long int )) dlget(fname);
	ret = (*call)(par_269);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef memalign
  #undef memalign
#endif
void *memalign(size_t par_270,size_t par_271) {
	char fname[]="memalign";
	void *ret;
	void *(*call)(size_t ,size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"memalign(");
		fprintf(stderr,"(size_t )%u ",par_270);
		fprintf(stderr,"(size_t )%u ",par_271);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(size_t ,size_t )) dlget(fname);
	ret = (*call)(par_270,par_271);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef mktemp
  #undef mktemp
#endif
char *mktemp(char *par_272) {
	char fname[]="mktemp";
	char *ret;
	char *(*call)(char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"mktemp(");
		fprintf(stderr,"(char *)%X ",par_272);
		fprintf(stderr,"\"%s\" ",((par_272)==NULL) ? ( "NULL" ) : (par_272) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *)) dlget(fname);
	ret = (*call)(par_272);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef realpath
  #undef realpath
#endif
char *realpath(char *par_273,char *par_274) {
	char fname[]="realpath";
	char *ret;
	char *(*call)(char *,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"realpath(");
		fprintf(stderr,"(char *)%X ",par_273);
		fprintf(stderr,"\"%s\" ",((par_273)==NULL) ? ( "NULL" ) : (par_273) );
		fprintf(stderr,"(char *)%X ",par_274);
		fprintf(stderr,"\"%s\" ",((par_274)==NULL) ? ( "NULL" ) : (par_274) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(char *,char *)) dlget(fname);
	ret = (*call)(par_273,par_274);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ttyname
  #undef ttyname
#endif
char *ttyname(int par_275) {
	char fname[]="ttyname";
	char *ret;
	char *(*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ttyname(");
		fprintf(stderr,"(int )%d ",par_275);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(int )) dlget(fname);
	ret = (*call)(par_275);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ttyslot
  #undef ttyslot
#endif
int ttyslot(void) {
	char fname[]="ttyslot";
	int ret;
	int (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ttyslot(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef valloc
  #undef valloc
#endif
void *valloc(size_t par_277) {
	char fname[]="valloc";
	void *ret;
	void *(*call)(size_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"valloc(");
		fprintf(stderr,"(size_t )%u ",par_277);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void *(*)(size_t )) dlget(fname);
	ret = (*call)(par_277);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (void *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ptsname
  #undef ptsname
#endif
char *ptsname(int par_278) {
	char fname[]="ptsname";
	char *ret;
	char *(*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ptsname(");
		fprintf(stderr,"(int )%d ",par_278);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(int )) dlget(fname);
	ret = (*call)(par_278);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef grantpt
  #undef grantpt
#endif
int grantpt(int par_279) {
	char fname[]="grantpt";
	int ret;
	int (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"grantpt(");
		fprintf(stderr,"(int )%d ",par_279);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int )) dlget(fname);
	ret = (*call)(par_279);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef unlockpt
  #undef unlockpt
#endif
int unlockpt(int par_280) {
	char fname[]="unlockpt";
	int ret;
	int (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"unlockpt(");
		fprintf(stderr,"(int )%d ",par_280);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int )) dlget(fname);
	ret = (*call)(par_280);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef atoll
  #undef atoll
#endif
long long int atoll(const char *par_281) {
	char fname[]="atoll";
	long long int ret;
	long long int (*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"atoll(");
		fprintf(stderr,"(const char *)%X ",par_281);
		fprintf(stderr,"\"%s\" ",((par_281)==NULL) ? ( "NULL" ) : (par_281) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long long int (*)(const char *)) dlget(fname);
	ret = (*call)(par_281);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef llabs
  #undef llabs
#endif
long long int llabs(long long int par_282) {
	char fname[]="llabs";
	long long int ret;
	long long int (*call)(long long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"llabs(");
		fprintf(stderr,"(long long int )%ld ",par_282);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long long int (*)(long long int )) dlget(fname);
	ret = (*call)(par_282);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef lldiv
  #undef lldiv
#endif
lldiv_t lldiv(long long int par_283,long long int par_284) {
	char fname[]="lldiv";
	lldiv_t ret;
	lldiv_t (*call)(long long int ,long long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"lldiv(");
		fprintf(stderr,"(long long int )%ld ",par_283);
		fprintf(stderr,"(long long int )%ld ",par_284);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (lldiv_t (*)(long long int ,long long int )) dlget(fname);
	ret = (*call)(par_283,par_284);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (lldiv_t )\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef lltostr
  #undef lltostr
#endif
char *lltostr(long long int par_285,char *par_286) {
	char fname[]="lltostr";
	char *ret;
	char *(*call)(long long int ,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"lltostr(");
		fprintf(stderr,"(long long int )%ld ",par_285);
		fprintf(stderr,"(char *)%X ",par_286);
		fprintf(stderr,"\"%s\" ",((par_286)==NULL) ? ( "NULL" ) : (par_286) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(long long int ,char *)) dlget(fname);
	ret = (*call)(par_285,par_286);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strtoll
  #undef strtoll
#endif
long long int strtoll(const char *par_287,char **par_288,int par_289) {
	char fname[]="strtoll";
	long long int ret;
	long long int (*call)(const char *,char **,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strtoll(");
		fprintf(stderr,"(const char *)%X ",par_287);
		fprintf(stderr,"\"%s\" ",((par_287)==NULL) ? ( "NULL" ) : (par_287) );
		fprintf(stderr,"(char **)%X ",par_288);
		fprintf(stderr,"(int )%d ",par_289);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long long int (*)(const char *,char **,int )) dlget(fname);
	ret = (*call)(par_287,par_288,par_289);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strtoull
  #undef strtoull
#endif
unsigned long long int strtoull(const char *par_290,char **par_291,int par_292) {
	char fname[]="strtoull";
	unsigned long long int ret;
	unsigned long long int (*call)(const char *,char **,int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strtoull(");
		fprintf(stderr,"(const char *)%X ",par_290);
		fprintf(stderr,"\"%s\" ",((par_290)==NULL) ? ( "NULL" ) : (par_290) );
		fprintf(stderr,"(char **)%X ",par_291);
		fprintf(stderr,"(int )%d ",par_292);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (unsigned long long int (*)(const char *,char **,int )) dlget(fname);
	ret = (*call)(par_290,par_291,par_292);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (unsigned long long int )%lu\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ulltostr
  #undef ulltostr
#endif
char *ulltostr(unsigned long long int par_293,char *par_294) {
	char fname[]="ulltostr";
	char *ret;
	char *(*call)(unsigned long long int ,char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ulltostr(");
		fprintf(stderr,"(unsigned long long int )%lu ",par_293);
		fprintf(stderr,"(char *)%X ",par_294);
		fprintf(stderr,"\"%s\" ",((par_294)==NULL) ? ( "NULL" ) : (par_294) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(unsigned long long int ,char *)) dlget(fname);
	ret = (*call)(par_293,par_294);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef adjtime
  #undef adjtime
#endif
int adjtime(struct  timeval *par_295,struct  timeval *par_296) {
	char fname[]="adjtime";
	int ret;
	int (*call)(struct  timeval *,struct  timeval *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"adjtime(");
		fprintf(stderr,"(struct  timeval *)%X ",par_295);
		fprintf(stderr,"(struct  timeval *)%X ",par_296);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(struct  timeval *,struct  timeval *)) dlget(fname);
	ret = (*call)(par_295,par_296);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getitimer
  #undef getitimer
#endif
int getitimer(int par_297,struct  itimerval *par_298) {
	char fname[]="getitimer";
	int ret;
	int (*call)(int ,struct  itimerval *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getitimer(");
		fprintf(stderr,"(int )%d ",par_297);
		fprintf(stderr,"(struct  itimerval *)%X ",par_298);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,struct  itimerval *)) dlget(fname);
	ret = (*call)(par_297,par_298);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef setitimer
  #undef setitimer
#endif
int setitimer(int par_299,const struct  itimerval *par_300,struct  itimerval *par_301) {
	char fname[]="setitimer";
	int ret;
	int (*call)(int ,const struct  itimerval *,struct  itimerval *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"setitimer(");
		fprintf(stderr,"(int )%d ",par_299);
		fprintf(stderr,"(const struct  itimerval *)%X ",par_300);
		fprintf(stderr,"(struct  itimerval *)%X ",par_301);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,const struct  itimerval *,struct  itimerval *)) dlget(fname);
	ret = (*call)(par_299,par_300,par_301);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef gettimeofday
  #undef gettimeofday
#endif
int gettimeofday(struct  timeval *par_302,void *par_303) {
	char fname[]="gettimeofday";
	int ret;
	int (*call)(struct  timeval *,void *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"gettimeofday(");
		fprintf(stderr,"(struct  timeval *)%X ",par_302);
		fprintf(stderr,"(void *)%X ",par_303);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(struct  timeval *,void *)) dlget(fname);
	ret = (*call)(par_302,par_303);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef settimeofday
  #undef settimeofday
#endif
int settimeofday(struct  timeval *par_304,void *par_305) {
	char fname[]="settimeofday";
	int ret;
	int (*call)(struct  timeval *,void *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"settimeofday(");
		fprintf(stderr,"(struct  timeval *)%X ",par_304);
		fprintf(stderr,"(void *)%X ",par_305);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(struct  timeval *,void *)) dlget(fname);
	ret = (*call)(par_304,par_305);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef gethrtime
  #undef gethrtime
#endif
hrtime_t gethrtime(void) {
	char fname[]="gethrtime";
	hrtime_t ret;
	hrtime_t (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"gethrtime(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (hrtime_t (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (hrtime_t )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef gethrvtime
  #undef gethrvtime
#endif
hrtime_t gethrvtime(void) {
	char fname[]="gethrvtime";
	hrtime_t ret;
	hrtime_t (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"gethrvtime(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (hrtime_t (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (hrtime_t )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef clock
  #undef clock
#endif
clock_t clock(void) {
	char fname[]="clock";
	clock_t ret;
	clock_t (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"clock(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (clock_t (*)(void)) dlget(fname);
	ret = (*call)();
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (clock_t )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef difftime
  #undef difftime
#endif
double difftime(time_t par_309,time_t par_310) {
	char fname[]="difftime";
	double ret;
	double (*call)(time_t ,time_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"difftime(");
		fprintf(stderr,"(time_t )%ld ",par_309);
		fprintf(stderr,"(time_t )%ld ",par_310);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (double (*)(time_t ,time_t )) dlget(fname);
	ret = (*call)(par_309,par_310);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (double )%f\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef mktime
  #undef mktime
#endif
time_t mktime(struct  tm *par_311) {
	char fname[]="mktime";
	time_t ret;
	time_t (*call)(struct  tm *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"mktime(");
		fprintf(stderr,"(struct  tm *)%X ",par_311);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (time_t (*)(struct  tm *)) dlget(fname);
	ret = (*call)(par_311);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (time_t )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef time
  #undef time
#endif
time_t time(time_t *par_312) {
	char fname[]="time";
	time_t ret;
	time_t (*call)(time_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"time(");
		fprintf(stderr,"(time_t *)%X ",par_312);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (time_t (*)(time_t *)) dlget(fname);
	ret = (*call)(par_312);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (time_t )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef asctime
  #undef asctime
#endif
char *asctime(const struct  tm *par_313) {
	char fname[]="asctime";
	char *ret;
	char *(*call)(const struct  tm *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"asctime(");
		fprintf(stderr,"(const struct  tm *)%X ",par_313);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const struct  tm *)) dlget(fname);
	ret = (*call)(par_313);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ctime
  #undef ctime
#endif
char *ctime(const time_t *par_314) {
	char fname[]="ctime";
	char *ret;
	char *(*call)(const time_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ctime(");
		fprintf(stderr,"(const time_t *)%X ",par_314);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const time_t *)) dlget(fname);
	ret = (*call)(par_314);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef gmtime
  #undef gmtime
#endif
struct  tm *gmtime(const time_t *par_315) {
	char fname[]="gmtime";
	struct  tm *ret;
	struct  tm *(*call)(const time_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"gmtime(");
		fprintf(stderr,"(const time_t *)%X ",par_315);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (struct  tm *(*)(const time_t *)) dlget(fname);
	ret = (*call)(par_315);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (struct  tm *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef localtime
  #undef localtime
#endif
struct  tm *localtime(const time_t *par_316) {
	char fname[]="localtime";
	struct  tm *ret;
	struct  tm *(*call)(const time_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"localtime(");
		fprintf(stderr,"(const time_t *)%X ",par_316);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (struct  tm *(*)(const time_t *)) dlget(fname);
	ret = (*call)(par_316);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (struct  tm *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strftime
  #undef strftime
#endif
size_t strftime(char *par_317,size_t par_318,const char *par_319,const struct  tm *par_320) {
	char fname[]="strftime";
	size_t ret;
	size_t (*call)(char *,size_t ,const char *,const struct  tm *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strftime(");
		fprintf(stderr,"(char *)%X ",par_317);
		fprintf(stderr,"\"%s\" ",((par_317)==NULL) ? ( "NULL" ) : (par_317) );
		fprintf(stderr,"(size_t )%u ",par_318);
		fprintf(stderr,"(const char *)%X ",par_319);
		fprintf(stderr,"\"%s\" ",((par_319)==NULL) ? ( "NULL" ) : (par_319) );
		fprintf(stderr,"(const struct  tm *)%X ",par_320);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (size_t (*)(char *,size_t ,const char *,const struct  tm *)) dlget(fname);
	ret = (*call)(par_317,par_318,par_319,par_320);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (size_t )%u\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef strptime
  #undef strptime
#endif
char *strptime(const char *par_321,const char *par_322,struct  tm *par_323) {
	char fname[]="strptime";
	char *ret;
	char *(*call)(const char *,const char *,struct  tm *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"strptime(");
		fprintf(stderr,"(const char *)%X ",par_321);
		fprintf(stderr,"\"%s\" ",((par_321)==NULL) ? ( "NULL" ) : (par_321) );
		fprintf(stderr,"(const char *)%X ",par_322);
		fprintf(stderr,"\"%s\" ",((par_322)==NULL) ? ( "NULL" ) : (par_322) );
		fprintf(stderr,"(struct  tm *)%X ",par_323);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (char *(*)(const char *,const char *,struct  tm *)) dlget(fname);
	ret = (*call)(par_321,par_322,par_323);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (char *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef clock_getres
  #undef clock_getres
#endif
int clock_getres(clockid_t par_326,struct  timespec *par_327) {
	char fname[]="clock_getres";
	int ret;
	int (*call)(clockid_t ,struct  timespec *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"clock_getres(");
		fprintf(stderr,"(clockid_t )%d ",par_326);
		fprintf(stderr,"(struct  timespec *)%X ",par_327);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(clockid_t ,struct  timespec *)) dlget(fname);
	ret = (*call)(par_326,par_327);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef clock_gettime
  #undef clock_gettime
#endif
int clock_gettime(clockid_t par_328,struct  timespec *par_329) {
	char fname[]="clock_gettime";
	int ret;
	int (*call)(clockid_t ,struct  timespec *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"clock_gettime(");
		fprintf(stderr,"(clockid_t )%d ",par_328);
		fprintf(stderr,"(struct  timespec *)%X ",par_329);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(clockid_t ,struct  timespec *)) dlget(fname);
	ret = (*call)(par_328,par_329);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef clock_settime
  #undef clock_settime
#endif
int clock_settime(clockid_t par_330,const struct  timespec *par_331) {
	char fname[]="clock_settime";
	int ret;
	int (*call)(clockid_t ,const struct  timespec *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"clock_settime(");
		fprintf(stderr,"(clockid_t )%d ",par_330);
		fprintf(stderr,"(const struct  timespec *)%X ",par_331);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(clockid_t ,const struct  timespec *)) dlget(fname);
	ret = (*call)(par_330,par_331);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef timer_create
  #undef timer_create
#endif
int timer_create(clockid_t par_332,struct  sigevent *par_333,timer_t *par_334) {
	char fname[]="timer_create";
	int ret;
	int (*call)(clockid_t ,struct  sigevent *,timer_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"timer_create(");
		fprintf(stderr,"(clockid_t )%d ",par_332);
		fprintf(stderr,"(struct  sigevent *)%X ",par_333);
		fprintf(stderr,"(timer_t *)%X ",par_334);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(clockid_t ,struct  sigevent *,timer_t *)) dlget(fname);
	ret = (*call)(par_332,par_333,par_334);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef timer_delete
  #undef timer_delete
#endif
int timer_delete(timer_t par_335) {
	char fname[]="timer_delete";
	int ret;
	int (*call)(timer_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"timer_delete(");
		fprintf(stderr,"(timer_t )%d ",par_335);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(timer_t )) dlget(fname);
	ret = (*call)(par_335);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef timer_getoverrun
  #undef timer_getoverrun
#endif
int timer_getoverrun(timer_t par_336) {
	char fname[]="timer_getoverrun";
	int ret;
	int (*call)(timer_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"timer_getoverrun(");
		fprintf(stderr,"(timer_t )%d ",par_336);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(timer_t )) dlget(fname);
	ret = (*call)(par_336);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef timer_gettime
  #undef timer_gettime
#endif
int timer_gettime(timer_t par_337,struct  itimerspec *par_338) {
	char fname[]="timer_gettime";
	int ret;
	int (*call)(timer_t ,struct  itimerspec *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"timer_gettime(");
		fprintf(stderr,"(timer_t )%d ",par_337);
		fprintf(stderr,"(struct  itimerspec *)%X ",par_338);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(timer_t ,struct  itimerspec *)) dlget(fname);
	ret = (*call)(par_337,par_338);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef timer_settime
  #undef timer_settime
#endif
int timer_settime(timer_t par_339,int par_340,const struct  itimerspec *par_341,struct  itimerspec *par_342) {
	char fname[]="timer_settime";
	int ret;
	int (*call)(timer_t ,int ,const struct  itimerspec *,struct  itimerspec *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"timer_settime(");
		fprintf(stderr,"(timer_t )%d ",par_339);
		fprintf(stderr,"(int )%d ",par_340);
		fprintf(stderr,"(const struct  itimerspec *)%X ",par_341);
		fprintf(stderr,"(struct  itimerspec *)%X ",par_342);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(timer_t ,int ,const struct  itimerspec *,struct  itimerspec *)) dlget(fname);
	ret = (*call)(par_339,par_340,par_341,par_342);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef nanosleep
  #undef nanosleep
#endif
int nanosleep(const struct  timespec *par_343,struct  timespec *par_344) {
	char fname[]="nanosleep";
	int ret;
	int (*call)(const struct  timespec *,struct  timespec *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"nanosleep(");
		fprintf(stderr,"(const struct  timespec *)%X ",par_343);
		fprintf(stderr,"(struct  timespec *)%X ",par_344);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const struct  timespec *,struct  timespec *)) dlget(fname);
	ret = (*call)(par_343,par_344);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef tzset
  #undef tzset
#endif
void tzset(void) {
	char fname[]="tzset";
	void (*call)(void);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"tzset(");
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(void)) dlget(fname);
	(*call)();
}

#ifdef _sysconf
  #undef _sysconf
#endif
long int _sysconf(int par_346) {
	char fname[]="_sysconf";
	long int ret;
	long int (*call)(int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"_sysconf(");
		fprintf(stderr,"(int )%d ",par_346);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(int )) dlget(fname);
	ret = (*call)(par_346);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef cftime
  #undef cftime
#endif
int cftime(char *par_347,char *par_348,const time_t *par_349) {
	char fname[]="cftime";
	int ret;
	int (*call)(char *,char *,const time_t *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"cftime(");
		fprintf(stderr,"(char *)%X ",par_347);
		fprintf(stderr,"\"%s\" ",((par_347)==NULL) ? ( "NULL" ) : (par_347) );
		fprintf(stderr,"(char *)%X ",par_348);
		fprintf(stderr,"\"%s\" ",((par_348)==NULL) ? ( "NULL" ) : (par_348) );
		fprintf(stderr,"(const time_t *)%X ",par_349);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(char *,char *,const time_t *)) dlget(fname);
	ret = (*call)(par_347,par_348,par_349);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef ascftime
  #undef ascftime
#endif
int ascftime(char *par_350,const char *par_351,const struct  tm *par_352) {
	char fname[]="ascftime";
	int ret;
	int (*call)(char *,const char *,const struct  tm *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"ascftime(");
		fprintf(stderr,"(char *)%X ",par_350);
		fprintf(stderr,"\"%s\" ",((par_350)==NULL) ? ( "NULL" ) : (par_350) );
		fprintf(stderr,"(const char *)%X ",par_351);
		fprintf(stderr,"\"%s\" ",((par_351)==NULL) ? ( "NULL" ) : (par_351) );
		fprintf(stderr,"(const struct  tm *)%X ",par_352);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(char *,const char *,const struct  tm *)) dlget(fname);
	ret = (*call)(par_350,par_351,par_352);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getdate
  #undef getdate
#endif
struct  tm *getdate(const char *par_353) {
	char fname[]="getdate";
	struct  tm *ret;
	struct  tm *(*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getdate(");
		fprintf(stderr,"(const char *)%X ",par_353);
		fprintf(stderr,"\"%s\" ",((par_353)==NULL) ? ( "NULL" ) : (par_353) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (struct  tm *(*)(const char *)) dlget(fname);
	ret = (*call)(par_353);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (struct  tm *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef select
  #undef select
#endif
int select(int par_354,fd_set *par_355,fd_set *par_356,fd_set *par_357,struct  timeval *par_358) {
	char fname[]="select";
	int ret;
	int (*call)(int ,fd_set *,fd_set *,fd_set *,struct  timeval *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"select(");
		fprintf(stderr,"(int )%d ",par_354);
		fprintf(stderr,"(fd_set *)%X ",par_355);
		fprintf(stderr,"(fd_set *)%X ",par_356);
		fprintf(stderr,"(fd_set *)%X ",par_357);
		fprintf(stderr,"(struct  timeval *)%X ",par_358);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,fd_set *,fd_set *,fd_set *,struct  timeval *)) dlget(fname);
	ret = (*call)(par_354,par_355,par_356,par_357,par_358);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef opendir
  #undef opendir
#endif
DIR *opendir(const char *par_359) {
	char fname[]="opendir";
	DIR *ret;
	DIR *(*call)(const char *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"opendir(");
		fprintf(stderr,"(const char *)%X ",par_359);
		fprintf(stderr,"\"%s\" ",((par_359)==NULL) ? ( "NULL" ) : (par_359) );
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (DIR *(*)(const char *)) dlget(fname);
	ret = (*call)(par_359);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (DIR *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef readdir
  #undef readdir
#endif
struct  dirent *readdir(DIR *par_360) {
	char fname[]="readdir";
	struct  dirent *ret;
	struct  dirent *(*call)(DIR *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"readdir(");
		fprintf(stderr,"(DIR *)%X ",par_360);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (struct  dirent *(*)(DIR *)) dlget(fname);
	ret = (*call)(par_360);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (struct  dirent *)%X\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef telldir
  #undef telldir
#endif
long int telldir(DIR *par_361) {
	char fname[]="telldir";
	long int ret;
	long int (*call)(DIR *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"telldir(");
		fprintf(stderr,"(DIR *)%X ",par_361);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (long int (*)(DIR *)) dlget(fname);
	ret = (*call)(par_361);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (long int )%ld\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef seekdir
  #undef seekdir
#endif
void seekdir(DIR *par_362,long int par_363) {
	char fname[]="seekdir";
	void (*call)(DIR *,long int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"seekdir(");
		fprintf(stderr,"(DIR *)%X ",par_362);
		fprintf(stderr,"(long int )%ld ",par_363);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(DIR *,long int )) dlget(fname);
	(*call)(par_362,par_363);
}

#ifdef rewinddir
  #undef rewinddir
#endif
void rewinddir(DIR *par_364) {
	char fname[]="rewinddir";
	void (*call)(DIR *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"rewinddir(");
		fprintf(stderr,"(DIR *)%X ",par_364);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (void (*)(DIR *)) dlget(fname);
	(*call)(par_364);
}

#ifdef closedir
  #undef closedir
#endif
int closedir(DIR *par_365) {
	char fname[]="closedir";
	int ret;
	int (*call)(DIR *);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"closedir(");
		fprintf(stderr,"(DIR *)%X ",par_365);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(DIR *)) dlget(fname);
	ret = (*call)(par_365);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef getdents
  #undef getdents
#endif
int getdents(int par_366,struct  dirent *par_367,unsigned int par_368) {
	char fname[]="getdents";
	int ret;
	int (*call)(int ,struct  dirent *,unsigned int );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"getdents(");
		fprintf(stderr,"(int )%d ",par_366);
		fprintf(stderr,"(struct  dirent *)%X ",par_367);
		fprintf(stderr,"(unsigned int )%u ",par_368);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,struct  dirent *,unsigned int )) dlget(fname);
	ret = (*call)(par_366,par_367,par_368);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef fcntl
  #undef fcntl
#endif
int fcntl(int par_369,int par_370,... ) {
	va_list valist;
	char fname[]="vfcntl";
	int ret;
	int (*call)(int ,int ,... );
	va_start(valist,par_370);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"fcntl(");
		fprintf(stderr,"(int )%d ",par_369);
		fprintf(stderr,"(int )%d ",par_370);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(int ,int ,... )) dlget(fname);
	ret = (*call)(par_369,par_370,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef open
  #undef open
#endif
int open(const char *par_371,int par_372,... ) {
	va_list valist;
	char fname[]="vopen";
	int ret;
	int (*call)(const char *,int ,... );
	va_start(valist,par_372);
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"open(");
		fprintf(stderr,"(const char *)%X ",par_371);
		fprintf(stderr,"\"%s\" ",((par_371)==NULL) ? ( "NULL" ) : (par_371) );
		fprintf(stderr,"(int )%d ",par_372);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,int ,... )) dlget(fname);
	ret = (*call)(par_371,par_372,valist);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}

#ifdef creat
  #undef creat
#endif
int creat(const char *par_373,mode_t par_374) {
	char fname[]="creat";
	int ret;
	int (*call)(const char *,mode_t );
	__J_102_inside_counter++;
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"creat(");
		fprintf(stderr,"(const char *)%X ",par_373);
		fprintf(stderr,"\"%s\" ",((par_373)==NULL) ? ( "NULL" ) : (par_373) );
		fprintf(stderr,"(mode_t )%lu ",par_374);
		fprintf(stderr,")\n");
		fflush(stderr);

	}
	call = (int (*)(const char *,mode_t )) dlget(fname);
	ret = (*call)(par_373,par_374);
	if(__J_102_inside_counter==1) {
		fprintf(stderr,"Returns: (int )%d\n",ret);
	}
	__J_102_inside_counter--;
	return ret;
}