xlc -P proto_crypt.c

extern void __assert(const char *, const char *, int);
extern void __assert_c99(const char *, const char *, int, const char *);





























































































typedef signed char		int8_t;
typedef signed short		int16_t;
typedef signed int		int32_t;
typedef	signed long long	int64_t;

typedef unsigned char		uint8_t;
typedef unsigned short		uint16_t;
typedef unsigned int		uint32_t;
typedef unsigned long long	uint64_t;


typedef int64_t			intmax_t;
typedef uint64_t		uintmax_t;


typedef signed long		intptr_t;
typedef unsigned long		uintptr_t;


typedef signed char		int_least8_t;
typedef signed short		int_least16_t;
typedef signed int		int_least32_t;
typedef signed long long	int_least64_t;

typedef unsigned char		uint_least8_t;
typedef unsigned short		uint_least16_t;
typedef unsigned int		uint_least32_t;
typedef unsigned long long	uint_least64_t;




typedef signed char	int_fast8_t;
typedef int16_t		int_fast16_t;
typedef int32_t		int_fast32_t;
typedef unsigned char	uint_fast8_t;
typedef uint16_t	uint_fast16_t;
typedef uint32_t	uint_fast32_t;
typedef int64_t		int_fast64_t;
typedef uint64_t	uint_fast64_t;


























































typedef unsigned long	size_t;

typedef signed long	ssize_t;



typedef long	fpos_t;

typedef long long fpos64_t;














typedef struct {
	unsigned char	*_ptr;
	int	_cnt;
	unsigned char	*_base;
	unsigned char   *_bufendp;
	short	_flag;
	short	_file;
	int	__stdioid;
	char	*__newbase;
	void	*_lock;
} FILE;

extern FILE	_iob[16];


extern size_t 		fread(void *restrict, size_t, size_t, FILE *restrict);
extern size_t		fwrite(const void *restrict, size_t, size_t,FILE *restrict);






















typedef	char *va_list;

extern int  vscanf(const char *restrict, va_list);
extern int  vfscanf(FILE *restrict, const char *restrict, va_list);
extern int  vsscanf(const char *restrict, const char *restrict, va_list);


extern int	__flsbuf(unsigned char, FILE *);
extern int	__filbuf(FILE *);
extern int 	ferror(FILE *);
extern int 	feof(FILE *);
extern void 	clearerr(FILE *);
extern int 	putchar(int);
extern int 	getchar(void);
extern int 	putc(int, FILE *);
extern int 	getc(FILE *);
extern int	remove(const char *);
extern int	rename(const char *, const char *);
extern int	renameat(int, const char *, int, const char *);
extern FILE 	*tmpfile(void);
extern char 	*tmpnam(char *);
extern int 	fclose(FILE *);
extern int 	fflush(FILE *);
extern FILE *	fopen(const char *restrict, const char *restrict);
extern FILE *	freopen(const char *restrict, const char *restrict, FILE *restrict);
extern FILE *	fmemopen(void *restrict, size_t, const char *restrict);
extern FILE *	open_memstream(char **, size_t *);
extern void 	setbuf(FILE *restrict, char *restrict);
extern int 	setvbuf(FILE *restrict, char *restrict, int, size_t);
extern int	fprintf(FILE *restrict, const char *restrict, ...);
extern int	fscanf(FILE *restrict, const char *restrict, ...);
extern int      dprintf(int, const char * restrict, ...);
extern int	printf(const char *restrict, ...);
extern int	scanf(const char *restrict, ...);
extern int	sprintf(char *restrict, const char *restrict, ...);
extern int	snprintf(char *restrict, size_t, const char *restrict, ...);
extern int	sscanf(const char *restrict, const char *restrict, ...);

extern int	vfprintf(FILE *restrict, const char *restrict, va_list);
extern int	vprintf(const char *restrict, va_list);
extern int	vsprintf(char *restrict, const char *restrict, va_list);
extern int	vsnprintf(char *restrict, size_t, const char *restrict, va_list);
extern int vdprintf(int, const char *restrict, va_list);

extern int 	fgetc(FILE *);
extern char *	fgets(char *restrict, int, FILE *restrict);
extern int 	fputc(int, FILE *);
extern int 	fputs(const char *restrict, FILE *restrict);
extern char 	*gets(char *);
extern int 	puts(const char *);
extern int	ungetc(int, FILE *);
extern int	fgetpos(FILE *restrict, fpos_t *restrict);
extern int 	fseek(FILE *, long int, int);
extern int	fsetpos(FILE *, const fpos_t *);
extern long	ftell(FILE *);
extern void	rewind(FILE *);
extern void 	perror(const char *);


extern int	getc_unlocked(FILE *);
extern int	getchar_unlocked(void);
extern int	putc_unlocked(int, FILE *);
extern int	putchar_unlocked(int);
extern ssize_t	getdelim(char **, size_t *, int, FILE *);
extern ssize_t	getline(char **, size_t *, FILE *);






















































































typedef struct {
	intmax_t quot;
	intmax_t rem;
} imaxdiv_t;

extern intmax_t __strtollmax(const char * restrict, char ** restrict, int);
static intmax_t
strtoimax (const char * restrict __nptr, char ** restrict __endptr, int __base) {
	return __strtollmax (__nptr, __endptr, __base);
}

extern intmax_t imaxabs(intmax_t);
extern imaxdiv_t imaxdiv (intmax_t, intmax_t);
extern uintmax_t strtoumax(const char * restrict, char ** restrict, int);

typedef unsigned short  wchar_t;
extern intmax_t wcstoimax(const wchar_t * restrict, wchar_t ** restrict, int );
extern uintmax_t wcstoumax(const wchar_t * restrict, wchar_t ** restrict, int);


typedef int32_t         intfast_t;
typedef uint32_t        uintfast_t;
























































typedef signed long	__long32_t;
typedef unsigned long	__ulong32_t;


typedef signed int	__long64_t;
typedef unsigned int	__ulong64_t;


typedef signed int	int32long64_t;
typedef unsigned int	uint32long64_t;


typedef signed long	long32int64_t;
typedef unsigned long	ulong32int64_t;




typedef signed char		int8;
typedef signed short		int16;
typedef signed int		int32;
typedef	signed long long	int64;

typedef unsigned char		u_int8;
typedef unsigned char		u_int8_t;
typedef unsigned short		u_int16;
typedef unsigned short		u_int16_t;
typedef unsigned int		u_int32;
typedef unsigned int		u_int32_t;
typedef unsigned long long	u_int64;
typedef unsigned long long	u_int64_t;































typedef long		ptrdiff_t;


typedef unsigned int	wctype_t;


typedef int		time_t;

typedef int		clock_t;




typedef	unsigned char	uchar_t;

typedef	unsigned short	ushort_t;
typedef	unsigned int	uint_t;
typedef unsigned long	ulong_t;



typedef int		level_t;
typedef	__long64_t	daddr_t;
typedef	int		daddr32_t;
typedef	int64_t		daddr64_t;
typedef	char *		caddr_t;
typedef	__ulong64_t	ino_t;
typedef	uint_t 		ino32_t;
typedef	uint64_t 	ino64_t;
typedef short		cnt_t;
typedef	__ulong64_t	dev_t;
typedef uint_t 		dev32_t;
typedef uint64_t 	dev64_t;
typedef	int		chan_t;
typedef int		time32_t;
typedef int		pid32_t;
typedef int		tid32_t;
typedef uint64_t     pid64_t;
typedef uint64_t     tid64_t;
typedef int64_t      time64_t;


typedef void * __ptr32;
typedef char * __cptr32;

typedef int soff_t;

typedef long		off_t;

typedef long long 	off64_t;

typedef	long		paddr_t;


typedef	int32long64_t	key_t;

typedef __long64_t	timer_t;
typedef int		timer32_t;
typedef int64_t 	timer64_t;
typedef	short		nlink_t;


typedef	uint_t		mode_t;


typedef uint_t		uid_t;
typedef uint_t		gid_t;
typedef uint_t		rid_t;

typedef ushort_t        authnum_t;
typedef	__ptr32 	mid_t;

typedef	int32long64_t	pid_t;

typedef __long64_t	tid_t;
typedef char		slab_t[12];
typedef long		mtyp_t;
typedef int             boolean_t;
typedef int     	crid_t;

typedef __long64_t	blkcnt_t;
typedef __long64_t	blksize_t;

typedef int		blkcnt32_t;
typedef int		blksize32_t;
typedef uint64_t	blkcnt64_t;
typedef uint64_t	blksize64_t;


typedef ulong_t 	fsblkcnt_t;
typedef ulong_t		fsfilcnt_t;

	typedef	int		wint_t;

typedef uint32long64_t	id_t;
typedef unsigned int	useconds_t;
typedef signed   int	suseconds_t;
typedef long long       clockid_t;



typedef struct sigset_t	{
	unsigned int losigs;
	unsigned int hisigs;
} sigset_t;

typedef struct {
	unsigned int losigs, hisigs;
} sigset32_t;

typedef struct {
	uint64_t ss_set[4];
} sigset64_t;

typedef int signal_t;


typedef struct fsid_t {
	unsigned int val[2];
} fsid_t;


typedef struct fsid64_t {
	uint64_t val[2];
} fsid64_t;

typedef void *pthread_attr_t;
typedef	void *pthread_condattr_t;
typedef	void *pthread_mutexattr_t;

typedef	void *pthread_rwlockattr_t;

typedef	void *pthread_barrierattr_t;

typedef unsigned int pthread_t;
typedef unsigned int pthread_key_t;

typedef struct
{
	int	__mt_word[13];
}
pthread_mutex_t;

typedef struct
{
	int	__cv_word[11];
}
pthread_cond_t;

typedef struct
{
        int     __on_word[28];
}
pthread_once_t;

typedef struct
{
	int	__sp_word[6];
}
pthread_spinlock_t;

typedef struct
{
	int	__br_word[8];
}
pthread_barrier_t;

typedef struct
{
	int	__rw_word[52];
}
pthread_rwlock_t;


typedef void *trace_attr_t;
typedef unsigned trace_event_id_t;
typedef unsigned trace_id_t;
typedef uint64_t trace_event_set_t;


typedef struct  _quad { int val[2]; } quad;
















































typedef long            vmid_t;
typedef ulong_t		vmhandle_t;
typedef int             vmid32_t;
typedef uint_t		vmhandle32_t;


typedef long32int64_t	kvmid_t;
typedef ulong32int64_t	kvmhandle_t;

typedef long long	vmid64_t;
typedef long long	rpn64_t;
typedef long long       cnt64_t;
typedef long long       psize_t;

typedef int32long64_t	vmidx_t;

typedef uint32long64_t  vmfkey_t;

typedef uint32long64_t  vmprkey_t;
typedef int32long64_t	vmkey_t;
typedef int32long64_t	vmhwkey_t;
typedef int             vmhkey_t;
typedef int32long64_t	vpn_t;
typedef int32long64_t	rpn_t;

typedef unsigned long   ptex_t;
typedef unsigned long   swhatx_t;

typedef uint32long64_t  esid_t;

typedef ushort_t	aptx_t;

typedef int             pdtx_t;
typedef short           psx_t;
typedef ushort_t        pshift_t;
typedef ushort_t        sshift_t;


typedef uint_t		vm_mpss_t;

typedef int             unidx_t;
typedef int             snidx_t;
typedef int             vmnodeidx_t;

typedef int		kvpn_t;
   typedef int		krpn_t;
typedef int32long64_t   vmsize_t;

typedef int32long64_t   vmm_lock_t;

typedef uint_t          amef_t;
typedef int             vmcbpx_t;

typedef uint32_t	cnt32_t;

typedef unsigned long ureg_t;



typedef struct
vmaddr_t
{
	vmhandle_t	srval;
	caddr_t		offset;
} vmaddr_t;


typedef struct
adspace_t
{
	ulong32int64_t	alloc;
	vmhandle_t	srval[16];
} adspace_t;



typedef struct
adspace32_t
{
        uint_t alloc;
        uint_t srval[16];
} adspace32_t;



typedef enum _MR_ATTR_TYPE {
  BadAttr = 0,
  VirtAddr = 1
} MR_ATTR_TYPE;

typedef enum _MR_LABEL_TYPE {
  BadMem = 0,
  FreeMem = 1,
  IPLCB = 2,
  RMALLOC = 3,
  PM_HEAP = 4,
  RTAS_HEAP = 5,
  TCE_TABLE = 6,
  IO_SPACE = 7,
  HUGE_PAGE = 8
} MR_LABEL_TYPE;



typedef struct {
	unsigned long long	mr_addr;
	unsigned long long	mr_size;
	unsigned char	mr_att;
	unsigned char	mr_label;
	unsigned short	mr_nodeid;
	unsigned short  mr_flags;
	char	reserved[2];
} iplcb_map_reg_t;






typedef vmhandle_t      vmlpghandle_t;




typedef struct label_t
{
    long __opaque[25];
} label_t;

typedef int32long64_t	ext_t;







typedef unsigned long long ptr64_t;

typedef unsigned long long __ptr64;
typedef unsigned long long __cptr64;




typedef ushort_t	UniChar;
typedef uint_t		UTF32Char;


typedef	uchar_t		uchar;
typedef	ushort_t	ushort;
typedef	uint_t		uint;
typedef ulong_t		ulong;

typedef	struct { int r[1]; } *	physadr_t;
typedef	physadr_t	physadr;


typedef	unsigned char	u_char;
typedef	unsigned short	u_short;
typedef	unsigned int	u_int;
typedef	unsigned long	u_long;

typedef	int	swblk_t;



struct sigset	{
	unsigned int losigs;
	unsigned int hisigs;
};


struct fsid {
	unsigned int	val[2];
};



struct fileid {
	uint_t	fid_len;
	ino32_t	fid_ino;
	uint_t	fid_gen;
	char	fid_x[20 - (sizeof(ino32_t) + 2) - sizeof(uint_t)];
};


struct fid {
	uint_t	fid_len;
	char	fid_data[20];
};
typedef struct fid fid_t;


struct fhandle {
	char x[32];
};
typedef struct fhandle fhandle_t;

struct filehandle {
	fsid_t		fh_fsid;
	struct fileid	fh_fid;
};



struct unique_id {
       __ulong32_t word1;
       __ulong32_t word2;
       __ulong32_t word3;
       __ulong32_t word4;
};
typedef struct unique_id unique_id_t;


typedef	long long  offset_t;

typedef long long ssize64_t;

typedef long long longlong_t;
typedef unsigned long long u_longlong_t;

typedef unsigned int class_id_t;



typedef uint_t          liobn_t;
typedef unsigned long long unit_addr_t;


typedef uint8_t			eye_catch1b_t;
typedef uint16_t		eye_catch2b_t;
typedef uint32_t		eye_catch4b_t;
typedef uint64_t		eye_catch8b_t;


typedef unsigned long		eye_catch_t;


typedef unsigned long long size64_t;





extern int 	fileno(FILE *);
extern FILE 	*fdopen(int,const char *);
extern char	*ctermid(char *);
extern FILE 	*popen(const char *, const char *);
extern int 	pclose(FILE *);

extern void	flockfile(FILE *);
extern void	funlockfile(FILE *);
extern int	fseeko(FILE *, off_t, int);
extern off_t	ftello(FILE *);
extern int	ftrylockfile(FILE *);
extern void	funlockfile(FILE *);



























extern	char	*optarg;
extern	int	opterr;
extern	int	optind;
extern	int	optopt;


extern int 	getw(FILE *);
extern int      getopt(int, char * const [], const char*);
extern char     *cuserid(char *);
extern int 	putw(int, FILE *);
extern char 	*tempnam(const char*, const char*);














































































































































	extern  unsigned   int SINFINITY;
	extern  unsigned   int _DBLINF[2];
	extern  unsigned   int SQNAN;
	extern  unsigned   int DQNAN[2];
	extern  unsigned   int SSNAN;
	extern  unsigned   int DSNAN[2];





typedef	unsigned short fprnd_t;


fprnd_t fp_read_rnd(void);
fprnd_t fp_swap_rnd(fprnd_t rnd);






















































extern int fgetpos64(FILE *, fpos64_t *);
extern FILE *fopen64(const char *, const char *);
extern FILE *freopen64(const char *, const char *, FILE *);
extern int fseeko64(FILE *, off64_t, int);
extern int fsetpos64(FILE *, const fpos64_t *);
extern off64_t ftello64(FILE *);

extern void setbuffer(FILE *, char *, size_t);
extern void setlinebuf(FILE *);















































# pragma info(none)



































typedef struct div_t  {
	int quot;
	int rem;
} div_t;

typedef struct ldiv_t  {
	long int quot;
	long int rem;
} ldiv_t;



extern size_t __getmbcurmax (void);
extern int __getmaxdispwidth (void);


        extern double   strtod(const char * restrict, char ** restrict);        extern long int strtol(const char * restrict, char ** restrict,
int);
        extern unsigned long int strtoul(const char * restrict, char ** restrict, int);


	extern void     	_Exit(int);
	extern float    	strtof(const char * restrict, char ** restrict);



typedef struct lldiv_t {
     long long int quot;
     long long int rem ;
} lldiv_t;

extern long long int    atoll(const char *);
extern long long int llabs( long long int );
extern lldiv_t lldiv( long long int, long long int );
extern long long int strtoll(
     const char * restrict,
     char ** restrict,
     int );
extern unsigned long long int strtoull(
     const char * restrict,
     char ** restrict,
     int );


static long double
strtold(const char * restrict __a, char ** restrict __b) {
	return ((long double)strtod (__a, __b));
}



	extern int	 	mblen(const char *, size_t);
	extern size_t 	mbstowcs(wchar_t * restrict, const char * restrict, size_t);
	extern int		mbtowc(wchar_t * restrict, const char * restrict, size_t);
	extern size_t	wcstombs(char * restrict, const wchar_t * restrict, size_t);
	extern int		wctomb(char *, const wchar_t);



	extern double 	atof(const char *);
	extern int 	atoi(const char *);
	extern long int atol(const char *);
	extern int 	rand(void);
	extern void	srand(unsigned int);
	extern void 	*calloc(size_t, size_t);
	extern void	free(void *);
	extern void	*malloc(size_t);
	extern void 	*realloc(void *, size_t);
	extern void	abort(void);
	extern int	atexit(void (*)(void));
	extern void	exit(int);
	extern char	*getenv(const char *);
	extern int 	system(const char *);
	extern void 	*bsearch(const void *, const void *, size_t, size_t, int(*)(const void *,const void *));
	extern void 	qsort(void *, size_t, size_t, int(*)(const void *,const void *));



	extern int 	abs(int);
	extern struct div_t	div(int, int);
	extern long int	labs(long int);
	extern struct ldiv_t 	ldiv(long int, long int);





extern int posix_memalign(void **,size_t,size_t);










































































































































struct timeval {
	time_t		tv_sec;
	suseconds_t	tv_usec;
};


struct timeval32 {
    int32_t tv_sec;
    int32_t tv_usec;
};


struct timeval64 {
    int64_t tv_sec;
    int32_t tv_usec;
};


struct timezone {
	int		tz_minuteswest;
	int		tz_dsttime;
};



struct	itimerval {
	struct		timeval it_interval;
	struct		timeval it_value;
};

extern int getitimer(int, struct itimerval *);
extern int setitimer(int, const struct itimerval *restrict, struct itimerval *restrict);
extern int gettimeofday(struct timeval *restrict, void *restrict);
extern int settimeofday(struct timeval *, struct timezone *);
extern int utimes(const char *, const struct timeval *);






typedef struct
fd_set
{
        long fds_bits[(65534/(sizeof(long) * 8)+1)];
} fd_set;


struct timespec {
	time_t tv_sec;
	long   tv_nsec;
};

extern int pselect(int, void *restrict, void *restrict, void *restrict, const struct timespec *restrict, const sigset_t *restrict);


extern int __fd_select(int, fd_set *restrict, fd_set *restrict,
			fd_set *restrict, struct timeval *restrict);
static int select(int __fds,
		fd_set *restrict __readlist,
		fd_set *restrict __writelist,
		fd_set *restrict __exceptlist,
		struct timeval *restrict __timeout)
		{
			return __fd_select(__fds, __readlist, __writelist,
						__exceptlist, __timeout);
		}























struct timestruc_t {
        time_t		tv_sec;
        suseconds_t	tv_nsec;
};



struct timestruc32_t {
    int32_t     tv_sec;
    int32_t     tv_nsec;
};


struct timestruc64_t {
    int64_t     tv_sec;
    int32_t     tv_nsec;
};




struct itimerstruc_t {
        struct  timestruc_t it_interval;
        struct  timestruc_t it_value;
};



struct itimerstruc32_t {
    struct  timestruc32_t it_interval;
    struct  timestruc32_t it_value;
};


struct itimerstruc64_t {
    struct  timestruc64_t it_interval;
    struct  timestruc64_t it_value;
};




typedef struct timebasestruct {
	int		flag;
	unsigned int	tb_high;
	unsigned int	tb_low;
	} timebasestruct_t;

int read_real_time(timebasestruct_t *, size_t);
int read_wall_time(timebasestruct_t *, size_t);
int time_base_to_time(timebasestruct_t *, size_t);





























typedef unsigned long 	rlim_t;
struct rlimit {
	rlim_t		rlim_cur;
	rlim_t		rlim_max;
};



typedef unsigned int 	rlim32_t;

struct rlimit32 {
	rlim32_t	rlim_cur;
	rlim32_t	rlim_max;
};


typedef unsigned long long rlim64_t;
struct rlimit64 {
	rlim64_t	rlim_cur;
	rlim64_t	rlim_max;
};







struct	rusage
{
	struct timeval 	ru_utime;
	struct timeval 	ru_stime;
	long		ru_maxrss;
	long		ru_ixrss;
	long		ru_idrss;
	long		ru_isrss;
	long		ru_minflt;
	long		ru_majflt;
	long		ru_nswap;
	long		ru_inblock;
	long		ru_oublock;
	long		ru_msgsnd;
	long		ru_msgrcv;
	long		ru_nsignals;
	long		ru_nvcsw;
	long		ru_nivcsw;

};


struct rusage32
{
	struct timeval32 ru_utime;
	struct timeval32 ru_stime;
	signed int	ru_maxrss;
	signed int	ru_ixrss;
	signed int	ru_idrss;
	signed int	ru_isrss;
	signed int	ru_minflt;
	signed int	ru_majflt;
	signed int	ru_nswap;
	signed int	ru_inblock;
	signed int	ru_oublock;
	signed int	ru_msgsnd;
	signed int	ru_msgrcv;
	signed int	ru_nsignals;
	signed int	ru_nvcsw;
	signed int	ru_nivcsw;
};


struct	rusage64
{
	struct timeval ru_utime;
	struct timeval ru_stime;
	long long	ru_maxrss;
	long long	ru_ixrss;
	long long	ru_idrss;
	long long	ru_isrss;
	long long	ru_minflt;
	long long	ru_majflt;
	long long	ru_nswap;
	long long	ru_inblock;
	long long	ru_oublock;
	long long	ru_msgsnd;
	long long	ru_msgrcv;
	long long	ru_nsignals;
	long long	ru_nvcsw;
	long long	ru_nivcsw;
};


struct	trusage64
{
	struct timeval64 ru_utime;
	struct timeval64 ru_stime;
	longlong_t	 ru_maxrss;
	longlong_t	 ru_ixrss;
	longlong_t	 ru_idrss;
	longlong_t	 ru_isrss;
	longlong_t	 ru_minflt;
	longlong_t	 ru_majflt;
	longlong_t	 ru_nswap;
	longlong_t	 ru_inblock;
	longlong_t	 ru_oublock;
	longlong_t	 ru_msgsnd;
	longlong_t	 ru_msgrcv;
	longlong_t	 ru_nsignals;
	longlong_t	 ru_nvcsw;
	longlong_t	 ru_nivcsw;
};


struct trusage32
{
        struct timeval32 ru_utime;
        struct timeval32 ru_stime;
        signed int      ru_maxrss;
        signed int      ru_ixrss;
        signed int      ru_idrss;
        signed int      ru_isrss;
        signed int      ru_minflt;
        signed int      ru_majflt;
        signed int      ru_nswap;
        signed int      ru_inblock;
        signed int      ru_oublock;
        signed int      ru_msgsnd;
        signed int      ru_msgrcv;
        signed int      ru_nsignals;
        signed int      ru_nvcsw;
        signed int      ru_nivcsw;
};








extern int getpriority(int, id_t);
extern int setpriority(int, id_t, int);
extern int getrlimit(int, struct rlimit *);
extern int setrlimit(int, const struct rlimit *);

extern int getrlimit64(int, struct rlimit64 *);
extern int setrlimit64(int, const struct rlimit64 *);

extern int getrusage(int, struct rusage *);
extern int getrusage64(int, struct rusage64 *);






































extern void (*signal(int, void (*)(int)))(int);


extern int raise(int);

typedef volatile int sig_atomic_t;



















union sigval
{
        void *  sival_ptr;
        int     sival_int;
};



typedef struct {
	int si_signo;
	int si_errno;
	int si_code;


	pid_t si_pid;

	uid_t si_uid;



	void *si_addr;
	int si_status;

	long si_band;

        union sigval si_value;

        int __si_flags;
        int __pad[6];

} siginfo_t;




struct sigaction {
   union {
	void	(*__su_handler)(int);
	void    (*__su_sigaction) (int, siginfo_t *, void *);
    } sa_union;
	sigset_t sa_mask;
	int	sa_flags;
};































































































































struct
mstsave
{
	struct mstsave *prev;
	label_t		*kjmpbuf;
	char		*stackfix;
	char		intpri;
	char		backt;
	char		rsvd[2];
	pid_t		curid;

	int		excp_type;
	ulong_t		iar;
	ulong_t		msr;
	ulong_t		cr;
	ulong_t		lr;
	ulong_t		ctr;
	ulong_t		xer;
	ulong_t		mq;
 	ulong_t		tid;
	ulong_t		fpscr;
	char		fpeu;
	char            fpinfo;
	uchar		fpscr24_31;
	char            pad[1];
	ulong_t         except[5];
	char            pad1[4];
	ulong_t         o_iar;
	ulong_t         o_toc;
	ulong_t         o_arg1;
	ulong_t		excbranch;
	ulong_t         fpscrx;
	ulong_t         o_vaddr;
	ulong_t		cachealign[7];
	adspace_t	as;
	ulong_t		gpr[32];
	double		fpr[32];
};


struct mstsave32
{
	__ptr32		prev;
	__ptr32		kjmpbuf;
	__cptr32	stackfix;
	char		intpri;
	char		backt;
	char		rsvd[2];
	int		curid;

	int		excp_type;
	uint_t		iar;
	uint_t		msr;
	uint_t		cr;
	uint_t		lr;
	uint_t		ctr;
	uint_t		xer;
	uint_t		mq;
 	uint_t		tid;
	uint_t		fpscr;
	char		fpeu;
	char            fpinfo;
	uchar_t		fpscr24_31;
	char            pad[1];
	uint_t		except[5];
	char            pad1[4];
	uint_t	     	o_iar;
	uint_t	     	o_toc;
	uint_t	     	o_arg1;
	uint_t		excbranch;
	uint_t	     	fpscrx;
	uint_t     	o_vaddr;
	uint_t		cachealign[7];
	adspace32_t	as;
	uint_t		gpr[32];
	double		fpr[32];
};




















extern char __pmap_stack[];
















typedef struct {
	void  *ss_sp;
	size_t ss_size;

	int    ss_flags;

	int    __pad[4];

} stack_t;


typedef struct {
        unsigned long long ss_sp;
        unsigned long long ss_size;
        int                ss_flags;
        int                __pad[4];
} stack64_t;


typedef struct {
	__ptr32 ss_sp;
	uint_t ss_size;
	int    ss_flags;

	int    __pad[4];

} stack32_t;







struct __context64 {
	unsigned long long	gpr[32];
	unsigned long long	msr;
	unsigned long long	iar;
	unsigned long long	lr;
	unsigned long long	ctr;
	unsigned int		cr;
	unsigned int		xer;
	unsigned int		fpscr;
	unsigned int		fpscrx;
        unsigned long long      except[1];
	double  		fpr[32];
	char			fpeu;
	char			fpinfo;
	char			fpscr24_31;
        char                    pad[1];
        int                     excp_type;
};





struct sigcontext64 {
	int  		   sc_onstack;
	sigset64_t	sc_mask;
	int 		   sc_uerror;
	struct __context64 sc_context;
};









typedef struct {
	unsigned int __v[4];
} __vmxreg_t;

typedef struct __vmx_context {
	__vmxreg_t 	__vr[32];
	unsigned int	__pad1[3];
	unsigned int	__vscr;
	unsigned int	__vrsave;
	unsigned int	__pad2[3];
} __vmx_context_t;



typedef struct __vsx_context {
	unsigned long long __vsr_dw1[32];
} __vsx_context_t;













typedef struct __extctx {
	unsigned int	__flags;
	unsigned int	__rsvd1[3];
	__vmx_context_t	__vmx;

	unsigned int	__ukeys[2];


	__vsx_context_t	__vsx;
	char	__reserved[(4096 - sizeof(__vmx_context_t) - (7 * sizeof(int)) - (sizeof(__vsx_context_t)))];


	int		__extctx_magic;



} __extctx_t;


struct	__jmpbuf {
	struct	mstsave jmp_context;
};



struct	__jmpbuf32 {
	struct	mstsave32 jmp_context;
};


struct	__sigcontext {
	int		sc_onstack;
	sigset_t	sc_mask;
	int		sc_uerror;
	struct __jmpbuf sc_jmpbuf;
};



typedef struct __jmpbuf   mcontext_t;

typedef struct ucontext_t {
	int	    __sc_onstack;
        sigset_t    uc_sigmask;
        int	    __sc_uerror;
	mcontext_t  uc_mcontext;
	struct ucontext_t *uc_link;

	stack_t     uc_stack;
	__extctx_t  *__extctx;

	int	__extctx_magic;
	int	    __pad[2];
} ucontext_t;


typedef struct __jmpbuf32   mcontext32_t;

typedef struct ucontext32_t {
	int	    __sc_onstack;
        sigset32_t    uc_sigmask;
        int	    __sc_uerror;
	mcontext32_t uc_mcontext;
	__ptr32  uc_link;

	stack32_t     uc_stack;
	__ptr32	    __extctx;

	int	__extctx_magic;
	int	    __pad[2];
} ucontext32_t;



struct	sigstack {
	void	*ss_sp;
	int	ss_onstack;
};


















extern int sigmask(int);






























struct sigevent {
	union sigval		sigev_value;
	int			sigev_signo;
	int			sigev_notify;
	void			(*sigev_notify_function)(union sigval);
	pthread_attr_t *	sigev_notify_attributes;
};







struct osigevent {
	void		*sevt_value;
	signal_t	sevt_signo;
};























































struct	sigvec {


   union {
	void    (*sv_handler)(int);

        void    (*sv_sigaction) (int, siginfo_t *, void *);
   } sv_union;
	int     sv_mask;
	int     sv_flags;
};






extern int sigblock(int);
extern int siglocalmask(int, const sigset_t *);
extern int sigvec(int, struct sigvec *, struct sigvec *);

extern int siggetmask(void);
extern int sigsetmask(int);




extern int kill(pid_t, int);
extern int sigprocmask(int, const sigset_t *restrict, sigset_t *restrict);
extern int sigsuspend(const sigset_t *);

extern int sigwait(const sigset_t *restrict, int *restrict);

extern int sigaction(int, const struct sigaction *restrict, struct sigaction *restrict);
extern int sigemptyset(sigset_t *);
extern int sigfillset(sigset_t *);
extern int sigaddset(sigset_t *, int);
extern int sigdelset(sigset_t *, int);
extern int sigismember(const sigset_t *, int);
extern int sigpending(sigset_t *);

extern void (*bsd_signal (int, void (*)(int)))(int);
extern int killpg(pid_t, int);
extern int sighold(int);
extern int sigignore(int);
extern int siginterrupt(int, int);
extern int sigpause(int);
extern int sigrelse(int);
extern void (*sigset(int, void(*)(int)))(int);
extern int sigaltstack(const stack_t *restrict, stack_t *restrict);
extern int sigstack(struct sigstack *, struct sigstack *);

extern int pthread_kill(pthread_t, int);
extern int pthread_sigmask(int, const sigset_t *, sigset_t *);
extern int sigqueue(pid_t, int, const union sigval);
struct timespec;
extern int sigtimedwait(const sigset_t *restrict, siginfo_t *restrict, const struct timespec *restrict);
extern int sigwaitinfo(const sigset_t *restrict, siginfo_t *restrict);



























typedef enum {P_ALL, P_PID, P_PGID} idtype_t;



extern pid_t wait(int *);
extern pid_t waitpid(pid_t, int *, int);


extern int waitid(idtype_t, id_t, siginfo_t *, int);
extern pid_t wait3(int *, int, struct rusage *);

extern pid_t kwaitpid(int *, pid_t, int, struct rusage *, siginfo_t *);
extern pid_t kwaitpid64(int *, pid_t, int, struct rusage64 *, siginfo_t *);
extern pid_t wait364(int *, int, struct rusage64 *);



extern pid_t wait4(pid_t, int *, int, struct rusage *);








	extern double 		drand48(void);
	extern double 		erand48(unsigned short[]);
	extern long 		jrand48(unsigned short[]);
	extern void 		lcong48(unsigned short int *);
	extern long 		lrand48(void);
	extern long 		mrand48(void);
	extern long 		nrand48(unsigned short[]);
	extern unsigned short 	*seed48(unsigned short[]);
	extern void 		setkey(const char *);
	extern void 		srand48(long);
	extern int 		putenv(char *);



	extern	int	rand_r(unsigned int *);

	extern long a64l(const char *);
	extern char *ecvt(double, int, int *, int *);
	extern char *fcvt(double, int, int *, int *);
	extern char *gcvt(double, int, char *);
	extern int  getsubopt(char **, char *const *, char **);
	extern int  grantpt(int);
	extern char *initstate(unsigned, char *, size_t);
	extern char *l64a(long);
	extern char *mktemp(char *);
	extern int  mkstemp(char *);
	extern char *mkdtemp(char *);
	extern int  mkstemp64(char *);
	extern char *ptsname(int);
	extern long random(void);
	extern char *realpath(const char *, char *);
	extern char *setstate(const char *);
	extern void srandom(unsigned);
	extern int  unlockpt(int);

	extern int  	posix_openpt	(int);
	extern int      setenv		(const char *, const char *, int);
	extern int      unsetenv	(const char *);





































struct __LC_locale;
struct _LC_locale_objhdl;






























































typedef struct {

    unsigned short
	__type_id,
	__magic;
    unsigned long
	__version;

    size_t  __size;

} _LC_object_t;















typedef struct {

    _LC_object_t  __hdr;



    int __catgets;
    int __catclose;


    int __compress;
    int __decompress;
    int __start_compress;
    int __end_compress;


    int __init;
    void    *__data;
} _LC_core_car_t;

typedef struct {

    _LC_object_t  __hdr;


    int __nl_langinfo;


    int __mbtowc;
    int __mbstowcs;
    int __wctomb;
    int __wcstombs;


    int __mblen;


    int __wcswidth;
    int __wcwidth;


    int __mbtopc;
    int __mbstopcs;
    int __pctomb;
    int __pcstombs;


    int __csid;
    int __wcsid;


    int __init;
    void     *__data;
} _LC_core_charmap_t;


typedef struct {

    _LC_object_t  __hdr;


    int __towupper;
    int __towlower;


    int __get_wctype;
    int __is_wctype;


    int __init;
    void     *__data;
} _LC_core_ctype_t;

typedef struct {

    _LC_object_t  __hdr;


    int __strcoll;
    int __strxfrm;


    int __wcscoll;
    int __wcsxfrm;


    int __fnmatch;


    int __regcomp;
    int __regerror;
    int __regexec;
    int __regfree;


    int __init;
    void     *__data;
} _LC_core_collate_t;


typedef struct {

    _LC_object_t  __hdr;


    int __nl_langinfo;


    int __strftime;
    int __strptime;


    int __wcsftime;


    int __init;
    void     *__data;
} _LC_core_time_t;


typedef struct {

    _LC_object_t  __hdr;


    int __nl_langinfo;


    int __strfmon;


    int __init;
    void     *__data;
} _LC_core_monetary_t;


typedef struct {

    _LC_object_t  __hdr;


    int __nl_langinfo;


    int __init;
    void     *__data;
} _LC_core_numeric_t;


typedef struct {

    _LC_object_t  __hdr;


    int __nl_langinfo;


    int __rpmatch;


    int __init;
    void        *__data;
} _LC_core_resp_t;

typedef struct {

    _LC_object_t __hdr;


    int __nl_langinfo;
    int __localeconv;


    int __init;
    void         *__data;
} _LC_core_locale_t;































struct lconv {
   char *decimal_point;
   char *thousands_sep;
   char *grouping;
   char *int_curr_symbol;
   char *currency_symbol;
   char *mon_decimal_point;
   char *mon_thousands_sep;
   char *mon_grouping;
   char *positive_sign;
   char *negative_sign;
   char int_frac_digits;
   char frac_digits;
   char p_cs_precedes;
   char p_sep_by_space;
   char n_cs_precedes;
   char n_sep_by_space;
   char p_sign_posn;
   char n_sign_posn;

   char *left_parenthesis;
   char *right_parenthesis;

   char int_p_cs_precedes;
   char int_p_sep_by_space;
   char int_n_cs_precedes;
   char int_n_sep_by_space;
   char int_p_sign_posn;
   char int_n_sign_posn;
} ;




typedef void* locale_t;



struct lconv *localeconv(void);
char   *setlocale(int, const char *);
locale_t newlocale(int, const char *, locale_t);
locale_t duplocale(locale_t);
locale_t uselocale(locale_t);
void freelocale(locale_t);



typedef struct lconv lconv;
























typedef struct  coldesc  {
	short     cd_stroff;
	short	  cd_repoff;
	short     cd_cval;
	short	  cd_cuniq;
} coldesc_t;


typedef struct collation_table {
	short    lc_version;
	short	 lc_length;
	char     *lc_locale_name;
	int      len_collate;
	short    *lc_collate;
	int      len_coluniq;
	short    *lc_coluniq;
	int      len_coldesc;
	coldesc_t *lc_coldesc;
	int	 len_strings;
	wchar_t  *lc_strings;
	int	 high_cvalue;
} col_t;



typedef struct char_classification_table {
	short      lc_version;
	short	   lc_length;
	short      lc_code_type;
	short      mb_cur_max;
	short      mb_cur_min;
	short      lc_dsp_width;
	char       *lc_locale_name;
	int        len_caseconv;
	wchar_t    *lc_caseconv;
	int	   len_ctype;
	unsigned short *lc_ctype;
} ctype_t;


typedef	struct lc_monetary_table {
	short  	lc_version;
	short 	lc_length;
	char   	*lc_locale_name;
	char 	*int_curr_symbol;
	char 	*currency_symbol;
	char 	*mon_decimal_point;
	char 	*mon_thousands_sep;
	char 	*mon_grouping;
	char 	*positive_sign;
	char 	*negative_sign;
	char 	int_frac_digits;
	char 	frac_digits;
	char 	p_cs_precedes;
	char 	p_sep_by_space;
	char 	n_cs_precedes;
	char 	n_sep_by_space;
	char 	p_sign_posn;
	char 	n_sign_posn;
} mon_t;


typedef struct numeric_table {
	short	lc_version;
	short	lc_length;
	char    *lc_locale_name;
	char 	*decimal_point;
	char 	*thousands_sep;
	char	*grouping;
} num_t;


typedef struct lc_messages_table {
	short	lc_version;
	short	lc_length;
	char    *lc_locale_name;
	char 	*messages;
	char 	*yes_string;
	char 	*no_string;
} msg_t;


typedef struct lc_time_table {
	short   lc_version;
	short	lc_length;
	char    *lc_locale_name;
	char    *t_fmt;
	char    *d_fmt;
	char    *nlldate;
	char    *d_t_fmt;
	char    *abday;
	char    *day;
	char    *abmon;
	char    *mon;

	char    *misc;
	char    *tstrs;
	char    *tunits;

	char	*year;
	char    *am_pm;
} tim_t;



typedef struct wchar_mapping_table {
	short    lc_version;
	short	 lc_length;
	char     *lc_identifier;
} map_t;





typedef struct localeinfo_table {
	char     lc_mag0, lc_mag1;
	short    lc_version;
	short    lc_code_type;
	short	 lc_length;
	col_t    *lc_coltbl;
	ctype_t  *lc_chrtbl;
	mon_t    *lc_montbl;
	num_t    *lc_numtbl;
	tim_t    *lc_timtbl;
	msg_t    *lc_msgtbl;
	map_t    *lc_maptbl;
} loc_t;




typedef struct {

    _LC_core_charmap_t core;

    char     *cm_csname;

    size_t   cm_mb_cur_max;
    size_t   cm_mb_cur_min;

    unsigned char
	     cm_max_disp_width;


    unsigned
	char *cm_cstab;

    struct __LC_locale
             *loc_rec;

    void     *__meth_ptr;
    void     *__data_ptr;

} _LC_charmap_t;

typedef struct _LC_charmap_objhdl _LC_charmap_objhdl_t;

struct _LC_charmap_objhdl {
	_LC_charmap_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};



typedef	struct {

    _LC_core_monetary_t   core;

    char *int_curr_symbol;
    char *currency_symbol;
    char *mon_decimal_point;
    char *mon_thousands_sep;
    char *mon_grouping;
    char *positive_sign;
    char *negative_sign;
    signed char int_frac_digits;
    signed char frac_digits;
    signed char p_cs_precedes;
    signed char p_sep_by_space;
    signed char n_cs_precedes;
    signed char n_sep_by_space;
    signed char p_sign_posn;
    signed char n_sign_posn;
    char *debit_sign;
    char *credit_sign;
    char *left_parenthesis;
    char *right_parenthesis;

    struct __LC_locale
             *loc_rec;

    void     *__meth_ptr;
    void     *__data_ptr;

    signed char int_p_cs_precedes;
    signed char int_p_sep_by_space;
    signed char int_n_cs_precedes;
    signed char int_n_sep_by_space;
    signed char int_p_sign_posn;
    signed char int_n_sign_posn;

} _LC_monetary_t;

typedef struct _LC_monetary_objhdl _LC_monetary_objhdl_t;
struct _LC_monetary_objhdl {
	_LC_monetary_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};


typedef struct {

    _LC_core_numeric_t core;

    char     *decimal_point;
    char     *thousands_sep;
    char     *grouping;

    struct __LC_locale
             *loc_rec;

    void     *__meth_ptr;
    void     *__data_ptr;

} _LC_numeric_t;

typedef struct _LC_numeric_objhdl _LC_numeric_objhdl_t;
struct _LC_numeric_objhdl {
	_LC_numeric_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};



typedef struct  {

    _LC_core_resp_t core;

    char     *yesexpr;
    char     *noexpr;
    char     *yesstr;
    char     *nostr;

    struct __LC_locale
             *loc_rec;

    void     *__meth_ptr;
    void     *__data_ptr;

} _LC_resp_t;

typedef struct _LC_resp_objhdl _LC_resp_objhdl_t;
struct _LC_resp_objhdl {
	_LC_resp_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};



typedef struct {

    _LC_core_time_t core;

    char *d_fmt;
    char *t_fmt;
    char *d_t_fmt;
    char *t_fmt_ampm;
    char *abday[7];
    char *day[7];
    char *abmon[12];
    char *mon[12];
    char *am_pm[2];
    char *era;
    char *era_year;
    char *era_d_fmt;
    char *alt_digits;
    char *era_d_t_fmt;
    char *era_t_fmt;

    struct __LC_locale
             *loc_rec;

    void     *__meth_ptr;
    void     *__data_ptr;

} _LC_time_t;

typedef struct _LC_time_objhdl _LC_time_objhdl_t;
struct _LC_time_objhdl {
	_LC_time_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};



typedef struct {
    unsigned
	short  n[4+1];
} _LC_weight_t;



typedef struct {

    char         *ce_sym;
    _LC_weight_t ce_wgt;

} _LC_collel_t;



typedef struct {
    _LC_weight_t   ct_wgt;


    _LC_collel_t   *ct_collel;

} _LC_coltbl_t;








typedef struct {
    char *tgt_wgt_str[4+1];


} _LC_subs_t;



typedef struct {

    _LC_core_collate_t core;

    unsigned
	char    co_nord;

    _LC_weight_t co_sort;


    wchar_t     co_wc_min;
    wchar_t     co_wc_max;

    wchar_t     co_col_min;
    wchar_t     co_col_max;

    _LC_coltbl_t *co_coltbl;

    unsigned
	int 	co_nsubs;
    _LC_subs_t  *co_subs;

    unsigned
	short	co_special;




    struct __LC_locale
                *loc_rec;

    void        *__meth_ptr;
    void        *__data_ptr;

} _LC_collate_t;

typedef struct _LC_collate_objhdl _LC_collate_objhdl_t;
struct _LC_collate_objhdl {
	_LC_collate_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};




typedef struct {

    char    *name;
    unsigned
	int mask;

} _LC_classnm_t;



typedef struct {

  _LC_core_ctype_t core;


  wchar_t      min_wc;
  wchar_t      max_wc;


  wchar_t      *upper;
  wchar_t      *lower;


  unsigned
      int      *mask;
  unsigned
      int      *qmask;
  unsigned
      char     *qidx;


  unsigned
      char     nclasses;
 _LC_classnm_t *classnms;

    struct __LC_locale
               *loc_rec;

    void       *__meth_ptr;
    void       *__data_ptr;

} _LC_ctype_t;

typedef struct _LC_ctype_objhdl _LC_ctype_objhdl_t;
struct _LC_ctype_objhdl {
	_LC_ctype_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};






typedef struct __LC_locale {

    _LC_core_locale_t core;

    char           *nl_info[63];
    struct lconv   *nl_lconv;

    _LC_charmap_objhdl_t  lc_charmap;
    _LC_collate_objhdl_t  lc_collate;
    _LC_ctype_objhdl_t    lc_ctype;
    _LC_monetary_objhdl_t lc_monetary;
    _LC_numeric_objhdl_t  lc_numeric;
    _LC_resp_objhdl_t     lc_resp;
    _LC_time_objhdl_t     lc_time;

    struct __LC_locale    *loc_rec;


    void                  *__meth_ptr;
    void                  *__data_ptr;

    char		  *__nl_yesstr;
    char		  *__nl_nostr;
    char		  *__nl_crncystr;

} _LC_locale_t;

typedef struct _LC_locale_objhdl _LC_locale_objhdl_t;
struct _LC_locale_objhdl {
	_LC_locale_t *obj;

	void *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};



typedef struct _LC_object_handle _LC_object_handle_t;
struct _LC_object_handle {
    union {
	_LC_object_t	      lc_object;
	_LC_locale_objhdl_t   lc_locale;
        _LC_charmap_objhdl_t  lc_charmap;
        _LC_collate_objhdl_t  lc_collate;
        _LC_ctype_objhdl_t    lc_ctype;
        _LC_monetary_objhdl_t lc_monetary;
        _LC_numeric_objhdl_t  lc_numeric;
        _LC_resp_objhdl_t     lc_resp;
        _LC_time_objhdl_t     lc_time;
    } obj;

    void    *(**meth)();

struct _LC_locale_objhdl *loc_hdl;


};


typedef struct {
    _LC_object_t	hdr;
    _LC_locale_objhdl_t handle;
} _LC_load_object_t;




typedef struct _LC_thread_locale {
	_LC_charmap_objhdl_t  *__lc_charmap_ptr;
	_LC_collate_objhdl_t  *__lc_collate_ptr;
	_LC_ctype_objhdl_t    *__lc_ctype_ptr;
	_LC_monetary_objhdl_t *__lc_monetary_ptr;
	_LC_numeric_objhdl_t  *__lc_numeric_ptr;
	_LC_resp_objhdl_t     *__lc_resp_ptr;
	_LC_time_objhdl_t     *__lc_time_ptr;
	_LC_locale_objhdl_t   *__lc_locale_ptr;
	int __lc_isiso1;

} _LC_thread_locale_t;

typedef _LC_thread_locale_t*  __locale_t;
extern locale_t cur_locale;



extern _LC_charmap_objhdl_t  *__lc_charmap_ptr;
extern _LC_collate_objhdl_t  *__lc_collate_ptr;
extern _LC_ctype_objhdl_t    *__lc_ctype_ptr;
extern _LC_monetary_objhdl_t *__lc_monetary_ptr;
extern _LC_numeric_objhdl_t  *__lc_numeric_ptr;
extern _LC_resp_objhdl_t     *__lc_resp_ptr;
extern _LC_time_objhdl_t     *__lc_time_ptr;
extern _LC_locale_objhdl_t   *__lc_locale_ptr;


extern _LC_charmap_objhdl_t  __lc_charmap;
extern _LC_collate_objhdl_t  __lc_collate;
extern _LC_ctype_objhdl_t    __lc_ctype;
extern _LC_monetary_objhdl_t __lc_monetary;
extern _LC_numeric_objhdl_t  __lc_numeric;
extern _LC_resp_objhdl_t     __lc_resp;
extern _LC_time_objhdl_t     __lc_time;
extern _LC_locale_objhdl_t   __lc_locale;

extern _LC_charmap_objhdl_t  *__get_lc_charmap_ptr();
extern _LC_collate_objhdl_t  *__get_lc_collate_ptr();
extern _LC_ctype_objhdl_t    *__get_lc_ctype_ptr();
extern _LC_monetary_objhdl_t *__get_lc_monetary_ptr();
extern _LC_numeric_objhdl_t  *__get_lc_numeric_ptr();
extern _LC_resp_objhdl_t     *__get_lc_resp_ptr();
extern _LC_time_objhdl_t     *__get_lc_time_ptr();
extern _LC_locale_objhdl_t   *__get_lc_locale_ptr();
extern int __get_lc_isiso1();

extern int __n_pthreads;












extern char *optarg;
extern int optind;
extern int opterr;




	extern float    atoff(char *);
	extern void     imul_dbl(long, long, long *);
	extern void     umul_dbl(unsigned long, unsigned long, unsigned long *);
	extern int	on_exit(void (*)(int, void *), void *);
	extern int      unatexit(void (*)(void));


	extern double	 		wcstod(const wchar_t *, wchar_t **);
	extern long int	 		wcstol(const wchar_t *, wchar_t **, int);
	extern unsigned long int 	wcstoul(const wchar_t *, wchar_t **, int);

	extern int			rpmatch(const char *);
	extern int			clearenv(void);
	extern int			getopt(int, char* const*, const char*);
	extern char			*getpass(const char *);
        extern int  			ttyslot(void);
        extern void 			*valloc(size_t);






extern void *vec_malloc(size_t);
extern void *vec_calloc(size_t, size_t);










# pragma info(restore)


















# pragma info(none)




































        extern void     	*memchr(const void *, int, size_t);
	extern void     *memcpy(void * restrict, const void * restrict, size_t);
        extern void     *memset(void *, int, size_t);
        extern size_t   strcspn(const char *, const char *);
        extern size_t   strlen(const char *);
        extern size_t   strspn(const char *, const char *);


	extern char		*strchr(const char *, int);
	extern char		*strpbrk(const char *, const char *);
	extern char		*strrchr(const char *, int);
	extern char		*strstr(const char *, const char *);

        extern void     *memmove(void *, const void *, size_t);
        extern char     *strcpy(char * restrict, const char * restrict);
        extern char     *strncpy(char * restrict, const char * restrict, size_t);
        extern char     *strcat(char * restrict, const char * restrict);
        extern char     *strncat(char * restrict, const char * restrict, size_t);
        extern int      memcmp(const void *, const void *,size_t);
        extern int      strcmp(const char *, const char *);
        extern int      strncmp(const char *,const char *,size_t);
        extern int      strncollen(const char *, const int );
        extern char     *strtok(char * restrict, const char * restrict);
        extern char     *strerror(int);
        extern int      strcoll(const char *, const char *);
        extern size_t strxfrm(char * restrict, const char * restrict, size_t);
		extern int      strcoll_l(const char *, const char *, locale_t);
		extern size_t strxfrm_l(char * restrict, const char * restrict, size_t, locale_t);
		extern char *strtok_r(char *, const char *, char **);
	    extern int	strerror_r(int, char *, size_t);


        extern void     *memccpy(void * restrict, const void * restrict, int, size_t);



extern char *strdup(const char *);




	extern wchar_t		*wcschr(const wchar_t *, wchar_t);
	extern wchar_t		*wcspbrk(const wchar_t *, const wchar_t *);
	extern wchar_t		*wcsrchr(const wchar_t *, wchar_t);
        extern char     *index(const char *, int);
        extern char     *rindex(const char *, int);
	extern void     swab(const void *, void *, ssize_t);
        extern wchar_t  *wcscat(wchar_t *, const wchar_t *);
        extern int      wcscmp(const wchar_t *, const wchar_t *);
        extern wchar_t  *wcscpy(wchar_t *, const wchar_t *);
        extern size_t   wcscspn(const wchar_t *, const wchar_t *);
        extern size_t   wcslen(const wchar_t *);
        extern wchar_t  *wcsncat(wchar_t *, const wchar_t *, size_t);
        extern int      wcsncmp(const wchar_t *, const wchar_t *, size_t);
        extern wchar_t  *wcsncpy(wchar_t *, const wchar_t *, size_t);
        extern size_t   wcsspn(const wchar_t *, const wchar_t *);
        extern wchar_t  *wcswcs(const wchar_t *, const wchar_t *);
        extern int      wcswidth(const wchar_t *, size_t);
        extern int      wcwidth(wchar_t);
        extern int      wcscoll(const wchar_t *, const wchar_t *);
        extern size_t	wcsxfrm(wchar_t *, const wchar_t *, size_t);
		extern int      wcscoll_l(const wchar_t *, const wchar_t *, locale_t);
		extern size_t   wcsxfrm_l(wchar_t *, const wchar_t *, size_t, locale_t);
		extern char	*__linux_strerror_r(int, char *, size_t);
	extern char *	strndup(const char *, size_t);
	extern size_t	strnlen(const char *, size_t);
	extern char *	strsep(char **, const char *);
	extern void *	memmem(const void *, size_t, const void *, size_t);
	extern char *	stpcpy(char *, const char *);
	extern char *	stpncpy(char *, const char *, size_t);
	extern char *	strsignal(int);
	extern int	strcasecmp(const char *, const char *);
	extern int	strncasecmp(const char *, const char *, size_t);














# pragma info(restore)


























































struct crypto_aes_key;


struct crypto_aes_key * crypto_aes_key_expand(const uint8_t *, size_t);


void crypto_aes_encrypt_block(const uint8_t *, uint8_t *,
    const struct crypto_aes_key *);


void crypto_aes_key_free(struct crypto_aes_key *);







































struct crypto_aes_key;


struct crypto_aesctr * crypto_aesctr_init(const struct crypto_aes_key *,
    uint64_t);


void crypto_aesctr_stream(struct crypto_aesctr *, const uint8_t *,
    uint8_t *, size_t);


void crypto_aesctr_free(struct crypto_aesctr *);


void crypto_aesctr_buf(const struct crypto_aes_key *, uint64_t,
    const uint8_t *, uint8_t *, size_t);







































uint8_t crypto_verify_bytes(const uint8_t *, const uint8_t *, size_t);









































typedef struct {
	uint32_t state[8];
	uint64_t count;
	uint8_t buf[64];
} libcperciva_SHA256_CTX;


void libcperciva_SHA256_Init(libcperciva_SHA256_CTX *);


void libcperciva_SHA256_Update(libcperciva_SHA256_CTX *, const void *, size_t);


void libcperciva_SHA256_Final(uint8_t[32], libcperciva_SHA256_CTX *);


void libcperciva_SHA256_Buf(const void *, size_t, uint8_t[32]);


typedef struct {
	libcperciva_SHA256_CTX ictx;
	libcperciva_SHA256_CTX octx;
} libcperciva_HMAC_SHA256_CTX;


void libcperciva_HMAC_SHA256_Init(libcperciva_HMAC_SHA256_CTX *, const void *, size_t);


void libcperciva_HMAC_SHA256_Update(libcperciva_HMAC_SHA256_CTX *, const void *, size_t);


void libcperciva_HMAC_SHA256_Final(uint8_t[32], libcperciva_HMAC_SHA256_CTX *);


void libcperciva_HMAC_SHA256_Buf(const void *, size_t, const void *, size_t, uint8_t[32]);


void PBKDF2_SHA256(const uint8_t *, size_t, const uint8_t *, size_t,
    uint64_t, uint8_t *, size_t);






















static inline uint16_t
libcperciva_be16dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint16_t)(p[1]) + ((uint16_t)(p[0]) << 8));
}

static inline void
libcperciva_be16enc(void * pp, uint16_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[1] = x & 0xff;
	p[0] = (x >> 8) & 0xff;
}

static inline uint32_t
libcperciva_be32dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +
	    ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));
}

static inline void
libcperciva_be32enc(void * pp, uint32_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[3] = x & 0xff;
	p[2] = (x >> 8) & 0xff;
	p[1] = (x >> 16) & 0xff;
	p[0] = (x >> 24) & 0xff;
}

static inline uint64_t
libcperciva_be64dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) +
	    ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) +
	    ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) +
	    ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56));
}

static inline void
libcperciva_be64enc(void * pp, uint64_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[7] = x & 0xff;
	p[6] = (x >> 8) & 0xff;
	p[5] = (x >> 16) & 0xff;
	p[4] = (x >> 24) & 0xff;
	p[3] = (x >> 32) & 0xff;
	p[2] = (x >> 40) & 0xff;
	p[1] = (x >> 48) & 0xff;
	p[0] = (x >> 56) & 0xff;
}

static inline uint16_t
libcperciva_le16dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint16_t)(p[0]) + ((uint16_t)(p[1]) << 8));
}

static inline void
libcperciva_le16enc(void * pp, uint16_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[0] = x & 0xff;
	p[1] = (x >> 8) & 0xff;
}

static inline uint32_t
libcperciva_le32dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) +
	    ((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24));
}

static inline void
libcperciva_le32enc(void * pp, uint32_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[0] = x & 0xff;
	p[1] = (x >> 8) & 0xff;
	p[2] = (x >> 16) & 0xff;
	p[3] = (x >> 24) & 0xff;
}

static inline uint64_t
libcperciva_le64dec(const void * pp)
{
	const uint8_t * p = (uint8_t const *)pp;

	return ((uint64_t)(p[0]) + ((uint64_t)(p[1]) << 8) +
	    ((uint64_t)(p[2]) << 16) + ((uint64_t)(p[3]) << 24) +
	    ((uint64_t)(p[4]) << 32) + ((uint64_t)(p[5]) << 40) +
	    ((uint64_t)(p[6]) << 48) + ((uint64_t)(p[7]) << 56));
}

static inline void
libcperciva_le64enc(void * pp, uint64_t x)
{
	uint8_t * p = (uint8_t *)pp;

	p[0] = x & 0xff;
	p[1] = (x >> 8) & 0xff;
	p[2] = (x >> 16) & 0xff;
	p[3] = (x >> 24) & 0xff;
	p[4] = (x >> 32) & 0xff;
	p[5] = (x >> 40) & 0xff;
	p[6] = (x >> 48) & 0xff;
	p[7] = (x >> 56) & 0xff;
}













































extern int errno;




extern	char	*sys_errlist[];
extern	int	sys_nerr;

















































void warnp_setprogname(const char *);


void libcperciva_warn(const char *, ...);
void libcperciva_warnx(const char *, ...);

















































































































































	extern char *acl_get(char *);
	extern char *acl_fget(int);
	extern int   acl_chg(char *, int, int, int);
	extern int   acl_fchg(int, int, int, int);
	extern int   acl_put(char *, char *, int);
	extern int   acl_fput(int, char *, int);
	extern int   acl_set(char *, int, int, int);
	extern int   acl_fset(int, int, int, int);
	extern int   accessx(char *, int, int);
	extern int   accessxat(int, char *, int, int);










extern int access(const char *, int);
extern int faccessat(int, const char *, int, int);
extern unsigned int alarm(unsigned int);
extern int chdir(const char *);
extern int chown(const char *, uid_t, gid_t);
extern int fchownat(int, const char *, uid_t, gid_t, int);
extern int close(int);
extern char *ctermid(char *);
extern int dup(int);
extern int dup2(int, int);
extern int execl(const char *, const char *, ...);
extern int execv(const char *, char *const []);
extern int execle(const char *, const char *, ...);
extern int execve(const char *, char *const [], char *const []);
extern int fexecve(int, char *const [], char *const []);
extern int execlp(const char *, const char *, ...);
extern int execvp(const char *, char *const []);
extern void _exit(int);
extern pid_t fork(void);
extern long fpathconf(int, int);
extern char *getcwd(char *, size_t);
extern gid_t getegid(void);
extern uid_t geteuid(void);
extern gid_t getgid(void);
extern int getgroups(int, gid_t []);
extern char *getlogin(void);
extern pid_t getpgrp(void);
extern pid_t getpid(void);
extern pid_t getppid(void);
extern uid_t getuid(void);
extern int isatty(int);
extern int link(const char *, const char *);
extern int linkat(int, const char *, int, const char *, int);
extern off_t lseek(int, off_t, int);
extern off64_t	lseek64(int, off64_t, int);
extern long pathconf(const char *, int);
extern int pause(void);
extern int pipe(int []);
extern int pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
extern ssize_t read(int, void *, size_t);
extern int rmdir(const char *);
extern int setgid(gid_t);
extern int setpgid(pid_t, pid_t);
extern pid_t setsid(void);
extern int setuid(uid_t);
extern unsigned int sleep(unsigned int);
extern long sysconf(int);
extern pid_t tcgetpgrp(int);
extern int tcsetpgrp(int, pid_t);
extern char *ttyname(int);
extern int unlink(const char *);
extern int unlinkat(int, const char *, int);
extern ssize_t write(int, const void *, size_t);

















extern  char    *optarg;
extern  int     optind, opterr, optopt;

	extern	size_t	confstr(int, char*, size_t);
	extern  char    *crypt(const char *, const char *);
	extern  void    encrypt(char *, int);
	extern  int     fsync(int);
	extern	int	getopt(int, char* const*, const char*);
	extern	int	nice(int);
	extern  void    swab(const void *, void *, ssize_t);
	extern int	fdatasync(int);
	extern  char    *getpass(const char *);
	extern  int     chroot(const char *);
















































































































































































































































































typedef struct st_timespec {
	time_t	tv_sec;
	int	tv_nsec;
} st_timespec_t;


struct	stat
{
	dev_t	st_dev;
	ino_t	st_ino;
	mode_t	st_mode;
	nlink_t st_nlink;
	ushort_t st_flag;
	uid_t	st_uid;
	gid_t	st_gid;

	dev_t	st_rdev;
	off_t	st_size;
	st_timespec_t st_atim;
	st_timespec_t st_mtim;
	st_timespec_t st_ctim;
	blksize_t st_blksize;
	blkcnt_t st_blocks;
	int	st_vfstype;
	uint_t	st_vfs;
	uint_t	st_type;
	uint_t	st_gen;


	uint_t	st_reserved[9];
};





struct timespec64 {
	time64_t	tv_sec;
	int32_t		tv_nsec;
	int32_t		tv_pad;
};


struct	stat64
{
	dev_t	st_dev;
	ino_t	st_ino;
	mode_t	st_mode;
	nlink_t st_nlink;
	ushort_t st_flag;
	uid_t	st_uid;
	gid_t	st_gid;
	dev_t	st_rdev;
	soff_t	st_ssize;
	st_timespec_t st_atim;
	st_timespec_t st_mtim;
	st_timespec_t st_ctim;
	blksize_t st_blksize;
	blkcnt_t st_blocks;
	int	st_vfstype;
	uint_t	st_vfs;
	uint_t	st_type;
	uint_t	st_gen;
	uint_t	st_reserved[10];
	off64_t		st_size;
};


struct stat64x
{
	dev64_t		st_dev;
	ino64_t		st_ino;
	mode_t		st_mode;
	nlink_t		st_nlink;
	ushort_t	st_flag;
	uid_t		st_uid;
	gid_t		st_gid;
	dev64_t		st_rdev;
	off64_t		st_size;

	struct timespec64 st_atim;
	struct timespec64 st_mtim;
	struct timespec64 st_ctim;
	blksize64_t	st_blksize;
	blkcnt64_t	st_blocks;
	int32_t		st_vfstype;
	uint32_t	st_vfs;
	uint32_t	st_type;
	uint32_t	st_gen;
	uint32_t	st_reserved[11];
};


	extern int	stat64x(const char *restrict, struct stat64x *restrict);
	extern int	fstat64x(int, struct stat64x *restrict);
	extern int	lstat64x(const char *restrict, struct stat64x *restrict);
	extern int  stat64xat(int, const char *restrict, struct stat64x *restrict, int);




	extern mode_t	umask(mode_t);


	extern int	mkdir(const char *, mode_t);
	extern int	mkdirat(int, const char *, mode_t);
	extern int	stat(const char *restrict, struct stat *restrict);
	extern int	fstat(int, struct stat *);
	extern int  fstatat(int, const char *restrict, struct stat *restrict, int);
	extern int	stat64(const char *restrict, struct stat64 *restrict);
	extern int	fstat64(int, struct stat64 *);
	extern int  stat64at(int,const char *restrict, struct stat64 *restrict, int);

	extern int	chmod(const char *, mode_t);
	extern int	fchmodat(int, const char *, mode_t, int);

	extern int	fchmod(int, mode_t);
	extern int	lstat(const char *restrict, struct stat *restrict);
	extern int	lstat64(const char *restrict, struct stat64 *restrict);

	extern int	mknod(const char *, mode_t, dev_t);
	extern int	mknodat(int, const char *, mode_t, dev_t);



	extern int	mkfifo(const char *, mode_t);
	extern int	mkfifoat(int, const char *, mode_t);
	extern int	futimens(int, const struct timespec *);
	extern int	utimensat(int, const char *, const struct timespec *,
				int);















int statx(char *, struct stat *, int, int);
int fstatx(int, struct stat *, int, int);
int statxat(int, char *, struct stat *, int, int);






	extern int lockf (int, int, off_t);
	extern int lockf64 (int, int, off64_t);




	extern int		brk(void *);
	extern int              getpagesize(void);
	extern int		__fd_getdtablesize(void);
	static int		getdtablesize()
				{
					return __fd_getdtablesize();
				}
        extern void             *sbrk(intptr_t);
	extern int		fchdir(int);
	extern int		fchown(int, uid_t, gid_t);
	extern int		ftruncate(int, off_t);
	extern int		ftruncate64(int, off64_t);
	extern int		gethostname(char *, size_t);
	extern long		gethostid(void);
	extern pid_t		getpgid(pid_t);
	extern pid_t		getsid(pid_t);
	extern char		*getwd(char *);
	extern int		lchown(const char *, uid_t, gid_t);

	extern int readlink(const char *, char *, size_t);
	extern int readlinkat(int, const char *, char *, size_t);

	extern pid_t		setpgrp(void);
	extern int		setregid(gid_t, gid_t);
	extern int		setreuid(uid_t, uid_t);
	extern int		symlink(const char *, const char *);
	extern int		symlinkat(const char *, int, const char *);
	extern void		sync(void);
	extern int		truncate(const char *, off_t);
	extern int		truncate64(const char *, off64_t);
	extern useconds_t	ualarm(useconds_t, useconds_t);
	extern int		usleep(useconds_t);
	extern pid_t		vfork(void);
	extern int		getlogin_r(char *, size_t);
	extern int		ttyname_r(int, char *, size_t);


	extern ssize_t		pread(int, void *, size_t, off_t);
	extern ssize_t		pwrite(int, const void *, size_t, off_t);
	extern ssize_t		pread64(int, void *, size_t, off64_t);
	extern ssize_t		pwrite64(int, const void *, size_t, off64_t);




extern char **environ;

	extern pid_t		f_fork(void);

	extern char *		cuserid(char *);
	extern int		setegid(gid_t);
	extern int		seteuid(uid_t);
	extern int		setrgid(gid_t);
	extern int		setruid(uid_t);
	extern int		ioctl(int, int, ...);
	extern int		setgroups(int, gid_t []);
	extern int		setroles(rid_t [], int);
	extern int		getroles(pid_t, rid_t [], int);
	extern int		open64x(char *, int64_t, mode_t, ext_t);
	extern int		open64xat(int, char *, int64_t, mode_t, ext_t);
	extern ssize_t 		read64x(int, char *, ssize_t, long);
	extern ssize_t 		write64x(int, char *, ssize_t, long);
	extern int	readx(int, char*, unsigned, long);
	extern int	writex(int, char*, unsigned, long);

	extern off_t	fclear(int, off_t);
	extern int	fsync_range(int, int, off_t, off_t);
	extern off64_t	fclear64(int, off64_t);
	extern int	fsync_range64(int, int, off64_t, off64_t);
	extern offset_t llseek(int, offset_t, int);
	extern char *	getusershell(void);
	extern void	setusershell(void);
	extern void	endusershell(void);
	extern char *	get_current_dir_name(void);
	extern int	sysfs(int, ...);
	extern int	finfo(const char *, int, void *, int32long64_t);
	extern int	ffinfo(int, int, void *, int32long64_t);





























int crypto_dh_generate_pub(uint8_t[256],
    const uint8_t[32]);


int crypto_dh_generate(uint8_t[256], uint8_t[32]);


int crypto_dh_compute(const uint8_t[256],
    const uint8_t[32], uint8_t[256]);


int crypto_dh_sanitycheck(const uint8_t[256]);


struct proto_keys;
struct proto_secret;










struct proto_secret * proto_crypt_secret(const char *);


void proto_crypt_dhmac(const struct proto_secret *,
    const uint8_t[32], const uint8_t[32],
    uint8_t[32], uint8_t[32], int);


int proto_crypt_dh_validate(const uint8_t[(256 + 32)],
    const uint8_t[32], int);


int proto_crypt_dh_generate(uint8_t[(256 + 32)], uint8_t[32],
    const uint8_t[32], int);


int proto_crypt_mkkeys(const struct proto_secret *,
    const uint8_t[32], const uint8_t[32],
    const uint8_t[(256 + 32)], const uint8_t[32], int, int,
    struct proto_keys **, struct proto_keys **);






void proto_crypt_enc(uint8_t *, size_t, uint8_t[(1024 + 4 + 32 )],
    struct proto_keys *);


ssize_t proto_crypt_dec(uint8_t[(1024 + 4 + 32 )], uint8_t *, struct proto_keys *);


void proto_crypt_free(struct proto_keys *);


struct proto_secret {
	uint8_t K[32];
};

struct proto_keys {
	struct crypto_aes_key * k_aes;
	uint8_t k_hmac[32];
	uint64_t pnum;
};


static struct proto_keys *
mkkeypair(uint8_t kbuf[64])
{
	struct proto_keys * k;


	if ((k = malloc(sizeof(struct proto_keys))) == 0)
		goto err0;


	if ((k->k_aes = crypto_aes_key_expand(&kbuf[0], 32)) == 0)
		goto err1;


	__memcpy(k->k_hmac,&kbuf[32],32);


	k->pnum = 0;


	return (k);

err1:
	free(k);
err0:

	return (0);
}


struct proto_secret *
proto_crypt_secret(const char * filename)
{
	libcperciva_SHA256_CTX ctx;
	FILE * f;
	struct proto_secret * K;
	uint8_t buf[4096];
	size_t lenread;


	if ((K = malloc(sizeof(struct proto_secret))) == 0)
		goto err0;


	if ((f = fopen(filename, "r")) == 0) {
		do {  ; if (errno != 0) { libcperciva_warn("Cannot open file: %s", filename); errno = 0; } else libcperciva_warnx("Cannot open file: %s", filename); } while (0);
		goto err1;
	}


	libcperciva_SHA256_Init(&ctx);


	while ((lenread = fread(buf, 1, 4096, f)) > 0)
		libcperciva_SHA256_Update(&ctx, buf, lenread);


	if (!((f)->_flag & 0020)) {
		do {  ; if (errno != 0) { libcperciva_warn("Error reading file: %s", filename); errno = 0; } else libcperciva_warnx("Error reading file: %s", filename); } while (0);
		goto err2;
	}


	fclose(f);


	libcperciva_SHA256_Final(K->K, &ctx);


	return (K);

err2:
	fclose(f);
err1:
	free(K);
err0:

	return (0);
}


void
proto_crypt_dhmac(const struct proto_secret * K,
    const uint8_t nonce_l[32],
    const uint8_t nonce_r[32],
    uint8_t dhmac_l[32], uint8_t dhmac_r[32],
    int decr)
{
	uint8_t nonce_CS[32 * 2];
	uint8_t dk_1[32 * 2];
	const uint8_t * nonce_c, * nonce_s;
	uint8_t * dhmac_c, * dhmac_s;


	nonce_c = decr ? nonce_r : nonce_l;
	dhmac_c = decr ? dhmac_r : dhmac_l;
	nonce_s = decr ? nonce_l : nonce_r;
	dhmac_s = decr ? dhmac_l : dhmac_r;


	__memcpy(&nonce_CS[0],nonce_c,32);
	__memcpy(&nonce_CS[32],nonce_s,32);


	PBKDF2_SHA256(K->K, 32, nonce_CS, 32 * 2, 1,
	    dk_1, 32 * 2);


	__memcpy(dhmac_c,&dk_1[0],32);
	__memcpy(dhmac_s,&dk_1[32],32);
}


static int
is_not_one(const uint8_t * x, size_t len)
{
	size_t i;
	char y;

	for (i = 0, y = 0; i < len - 1; i++) {
		y |= x[i];
	}

	return (y | (x[len - 1] - 1));
}


int
proto_crypt_dh_validate(const uint8_t yh_r[(256 + 32)],
    const uint8_t dhmac_r[32], int requirefps)
{
	uint8_t hbuf[32];


	libcperciva_HMAC_SHA256_Buf(dhmac_r, 32, yh_r, 256,
	    hbuf);


	if (crypto_verify_bytes(&yh_r[256], hbuf, 32))
		return (1);


	if (crypto_dh_sanitycheck(&yh_r[0]))
		return (1);


	if (requirefps) {
		if (! is_not_one(&yh_r[0], 256))
			return (1);
	}


	return (0);
}


int
proto_crypt_dh_generate(uint8_t yh_l[(256 + 32)], uint8_t x[32],
    const uint8_t dhmac_l[32], int nofps)
{


	if (nofps) {

		__memset(yh_l,0,256 - 1);
		yh_l[256 - 1] = 1;
	} else {

		if (crypto_dh_generate(yh_l, x))
			goto err0;
	}


	libcperciva_HMAC_SHA256_Buf(dhmac_l, 32, yh_l, 256,
	    &yh_l[256]);


	return (0);

err0:

	return (-1);
}


int
proto_crypt_mkkeys(const struct proto_secret * K,
    const uint8_t nonce_l[32],
    const uint8_t nonce_r[32],
    const uint8_t yh_r[(256 + 32)], const uint8_t x[32],
    int nofps, int decr,
    struct proto_keys ** eh_c, struct proto_keys ** eh_s)
{
	uint8_t nonce_y[32 * 2 + 256];
	uint8_t dk_2[128];
	const uint8_t * nonce_c, * nonce_s;


	nonce_c = decr ? nonce_r : nonce_l;
	nonce_s = decr ? nonce_l : nonce_r;
	__memcpy(&nonce_y[0],nonce_c,32);
	__memcpy(&nonce_y[32],nonce_s,32);


	if (nofps) {

		__memset(&nonce_y[32 * 2],0,256 - 1);
		nonce_y[32 * 2 + 256 - 1] = 1;
	} else {

		if (crypto_dh_compute(yh_r, x,
		    &nonce_y[32 * 2]))
			goto err0;
	}


	PBKDF2_SHA256(K->K, 32, nonce_y,
	    32 * 2 + 256, 1, dk_2, 128);


	if ((*eh_c = mkkeypair(&dk_2[0])) == 0)
		goto err0;
	if ((*eh_s = mkkeypair(&dk_2[64])) == 0)
		goto err1;


	return (0);

err1:
	proto_crypt_free(*eh_c);
err0:

	return (-1);
}


void
proto_crypt_enc(uint8_t * ibuf, size_t len, uint8_t obuf[(1024 + 4 + 32 )],
    struct proto_keys * k)
{
	libcperciva_HMAC_SHA256_CTX ctx;
	uint8_t pnum_exp[8];


	((len <= 1024) ? ((void)0) : __assert("len <= PCRYPT_MAXDSZ", "./proto/proto_crypt.c", 311));


	__memcpy(obuf,ibuf,len);


	__memset(&obuf[len],0,1024 - len);


	libcperciva_be32enc(&obuf[1024], len);


	crypto_aesctr_buf(k->k_aes, k->pnum, obuf, obuf, 1024 + 4);


	libcperciva_be64enc(pnum_exp, k->pnum);
	libcperciva_HMAC_SHA256_Init(&ctx, k->k_hmac, 32);
	libcperciva_HMAC_SHA256_Update(&ctx, obuf, 1024 + 4);
	libcperciva_HMAC_SHA256_Update(&ctx, pnum_exp, 8);
	libcperciva_HMAC_SHA256_Final(&obuf[1024 + 4], &ctx);


	k->pnum += 1;
}


ssize_t proto_crypt_dec(uint8_t ibuf[(1024 + 4 + 32 )], uint8_t * obuf,
    struct proto_keys * k)
{
	libcperciva_HMAC_SHA256_CTX ctx;
	uint8_t hbuf[32];
	uint8_t pnum_exp[8];
	size_t len;


	libcperciva_be64enc(pnum_exp, k->pnum);
	libcperciva_HMAC_SHA256_Init(&ctx, k->k_hmac, 32);
	libcperciva_HMAC_SHA256_Update(&ctx, ibuf, 1024 + 4);
	libcperciva_HMAC_SHA256_Update(&ctx, pnum_exp, 8);
	libcperciva_HMAC_SHA256_Final(hbuf, &ctx);
	if (crypto_verify_bytes(hbuf, &ibuf[1024 + 4], 32))
		return (-1);


	crypto_aesctr_buf(k->k_aes, k->pnum, ibuf, ibuf, 1024 + 4);


	k->pnum += 1;


	len = libcperciva_be32dec(&ibuf[1024]);


	if ((len == 0) || (len > 1024))
		return (-1);


	__memcpy(obuf,ibuf,len);


	return (len);
}


void
proto_crypt_free(struct proto_keys * k)
{


	crypto_aes_key_free(k->k_aes);


	free(k);
}