This is the mail archive of the gcc@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

Re: i386 performance problem due to regmove.c change


Attached is zzz.i.  The i386 assembly code shows some interesting
differences as a result of the regmove.c change.  A partial diff
follows:

*** 19980608-regmove/zzz.s	Tue Jun 30 00:49:12 1998
--- 19980621-regmove/zzz.s	Tue Jun 30 00:51:21 1998
***************
*** 203,210 ****
  	pushl $1
  	call _MakeMove
  	movl 8(%ebp),%edx
! 	xorl $1,%edx
! 	pushl %edx
  	pushl $2
  	call _RepetitionCheck
  	movl %eax,%edi
--- 203,212 ----
  	pushl $1
  	call _MakeMove
  	movl 8(%ebp),%edx
! 	movl %edx,-164(%ebp)
! 	xorb $1,-164(%ebp)
! 	movl -164(%ebp),%ecx
! 	pushl %ecx
  	pushl $2
  	call _RepetitionCheck
  	movl %eax,%edi
***************
*** 480,487 ****
  	pushl $1
  	call _MakeMove
  	movl 8(%ebp),%edx
! 	xorl $1,%edx
! 	pushl %edx
  	pushl $2
  	call _RepetitionCheck
  	movl %eax,%edi
--- 482,491 ----
  	pushl $1
  	call _MakeMove
  	movl 8(%ebp),%edx
! 	movl %edx,-164(%ebp)
! 	xorb $1,-164(%ebp)
! 	movl -164(%ebp),%ecx
! 	pushl %ecx
  	pushl $2
  	call _RepetitionCheck
  	movl %eax,%edi

It appears that registers are sometimes being copied to pseudos when
using the new regmove.

One thing of interest is that regmove has the following comment:

	  /* Now scan through the operands looking for a destination operand
	     which is supposed to match a source operand.
	     Then scan backward for an instruction which sets the source
	     operand.  If safe, then replace the source operand with the
	     dest operand in both instructions.  */

followed later by:

	  /* If we weren't able to replace any of the alternatives, try an
	     alternative appoach of copying the source to the destination.  */
	  if (!success && copy_src != NULL_RTX)
	    copy_src_to_dest (insn, copy_src, copy_dst, loop_depth);

which a naive look at the code suggests that upon encountering:

  [(set (match_operand:SI 0 "nonimmediate_operand" "=r,rm,r")
	(plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,r")
		 (match_operand:SI 2 "general_operand" "rmi,ri,ri")))]

regmove will attempt to locate an instruction which can be changed.
Failing that it will call copy_src_to_dest even though the pattern
in question can handle the case of the source operand not matching
the destination operand.

I have not yet come up with a small runnable test case which demostrates
the problem resulting from the recent change to regmove.  I can continue
to pursue this if the enclosed information isn't sufficient.

-- John
------------------------8<-------------------------8<--------------------
# 1 "zzz.c"
# 1 "/usr/include/stdio.h" 1 3
 









































# 1 "/usr/include/sys/cdefs.h" 1 3
 

















































 





























# 106 "/usr/include/sys/cdefs.h" 3


 





































# 164 "/usr/include/sys/cdefs.h" 3


































# 43 "/usr/include/stdio.h" 2 3

# 1 "/usr/include/machine/ansi.h" 1 3
 






































 





















 










 











 












 







typedef	int __attribute__((__mode__(__DI__)))		 __int64_t;
typedef	unsigned int __attribute__((__mode__(__DI__)))	__uint64_t;






# 44 "/usr/include/stdio.h" 2 3



typedef	unsigned int 	size_t;







typedef	__int64_t 	fpos_t;



 





 
struct __sbuf {
	unsigned char *_base;
	int	_size;
};

 

























typedef	struct __sFILE {
	unsigned char *_p;	 
	int	_r;		 
	int	_w;		 
	short	_flags;		 
	short	_file;		 
	struct	__sbuf _bf;	 
	int	_lbfsize;	 

	 
	void	*_cookie;	 
	int	(*_close)  (void *)  ;
	int	(*_read)   (void *, char *, int)  ;
	fpos_t	(*_seek)   (void *, fpos_t, int)  ;
	int	(*_write)  (void *, const char *, int)  ;

	 
	struct	__sbuf _ub;	 
	unsigned char *_up;	 
	int	_ur;		 

	 
	unsigned char _ubuf[3];	 
	unsigned char _nbuf[1];	 

	 
	struct	__sbuf _lb;	 

	 
	int	_blksize;	 
	fpos_t	_offset;	 
} FILE;

 
extern FILE __sF[];
 





	 











 















 




				 



 




















 


 
void	 clearerr  (FILE *)  ;
int	 fclose  (FILE *)  ;
int	 feof  (FILE *)  ;
int	 ferror  (FILE *)  ;
int	 fflush  (FILE *)  ;
int	 fgetc  (FILE *)  ;
int	 fgetpos  (FILE *, fpos_t *)  ;
char	*fgets  (char *, int, FILE *)  ;
FILE	*fopen  (const char *, const char *)  ;
int	 fprintf  (FILE *, const char *, ...)  ;
int	 fputc  (int, FILE *)  ;
int	 fputs  (const char *, FILE *)  ;
size_t	 fread  (void *, size_t, size_t, FILE *)  ;
FILE	*freopen  (const char *, const char *, FILE *)  ;
int	 fscanf  (FILE *, const char *, ...)  ;
int	 fseek  (FILE *, long, int)  ;
int	 fsetpos  (FILE *, const fpos_t *)  ;
long	 ftell  (FILE *)  ;
size_t	 fwrite  (const void *, size_t, size_t, FILE *)  ;
int	 getc  (FILE *)  ;
int	 getchar  (void)  ;
char	*gets  (char *)  ;

extern const  int sys_nerr;		 
extern const  char * const  sys_errlist[];

void	 perror  (const char *)  ;
int	 printf  (const char *, ...)  ;
int	 putc  (int, FILE *)  ;
int	 putchar  (int)  ;
int	 puts  (const char *)  ;
int	 remove  (const char *)  ;
int	 rename   (const char *, const char *)  ;
void	 rewind  (FILE *)  ;
int	 scanf  (const char *, ...)  ;
void	 setbuf  (FILE *, char *)  ;
int	 setvbuf  (FILE *, char *, int, size_t)  ;
int	 sprintf  (char *, const char *, ...)  ;
int	 sscanf  (const char *, const char *, ...)  ;
FILE	*tmpfile  (void)  ;
char	*tmpnam  (char *)  ;
int	 ungetc  (int, FILE *)  ;
int	 vfprintf  (FILE *, const char *, char * )  ;
int	 vprintf  (const char *, char * )  ;
int	 vsprintf  (char *, const char *, char * )  ;
 

 



 




 
char	*ctermid  (char *)  ;
FILE	*fdopen  (int, const char *)  ;
int	 fileno  (FILE *)  ;
int	 ftrylockfile  (FILE *)  ;
void	 flockfile  (FILE *)  ;
void	 funlockfile  (FILE *)  ;
 


 



 


int	 ftruncate  (int, __int64_t )  ;



__int64_t  lseek  (int, __int64_t , int)  ;



char	*mmap  (void *, size_t, int, int, int, __int64_t )  ;



int	 truncate  (const char *, __int64_t )  ;

 


 



 
int	 asprintf  (char **, const char *, ...)  ;
char	*fgetln  (FILE *, size_t *)  ;
int	 fpurge  (FILE *)  ;
int	 getw  (FILE *)  ;
int	 pclose  (FILE *)  ;
FILE	*popen  (const char *, const char *)  ;
int	 putw  (int, FILE *)  ;
void	 setbuffer  (FILE *, char *, int)  ;
int	 setlinebuf  (FILE *)  ;
char	*tempnam  (const char *, const char *)  ;
int	 snprintf  (char *, size_t, const char *, ...)  ;
int	 vasprintf  (char **, const char *, char * )  ;
int	 vsnprintf  (char *, size_t, const char *, char * )  ;
int	 vscanf  (const char *, char * )  ;
int	 vsscanf  (const char *, const char *, char * )  ;
 

 






 


 
FILE	*funopen  (const void *,
		int (*)(void *, char *, int),
		int (*)(void *, const char *, int),
		fpos_t (*)(void *, fpos_t, int),
		int (*)(void *))  ;
 




 


 
int	__srget  (FILE *)  ;
int	__svfscanf  (FILE *, const char *, char * )  ;
int	__swbuf  (int, FILE *)  ;
 

 





static __inline int __sputc(int _c, FILE *_p) {
	if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
		return (*_p->_p++ = _c);
	else
		return (__swbuf(_c, _p));
}
# 366 "/usr/include/stdio.h" 3







 
























# 431 "/usr/include/stdio.h" 3












# 1 "zzz.c" 2

# 1 "/usr/include/stdlib.h" 1 3
 










































# 1 "/usr/include/machine/types.h" 1 3
 







































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

typedef struct label_t {
	int val[6];
} label_t;


typedef	unsigned int	vm_offset_t;
typedef	__int64_t	vm_ooffset_t;
typedef	unsigned int	vm_pindex_t;
typedef	unsigned int	vm_size_t;

 



typedef	signed  char		   int8_t;
typedef	unsigned char		 u_int8_t;
typedef	short			  int16_t;
typedef	unsigned short		u_int16_t;
typedef	int			  int32_t;
typedef	unsigned int		u_int32_t;
typedef	__int64_t		  int64_t;
typedef	__uint64_t		u_int64_t;

typedef	int32_t			register_t;

typedef int32_t			ufs_daddr_t;





 
typedef u_int32_t		intrmask_t;

 
typedef	void			inthand2_t  (void *_cookie)  ;


# 44 "/usr/include/stdlib.h" 2 3



typedef	int  	rune_t;










typedef	int  	wchar_t;



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

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










extern int __mb_cur_max;


 
void	 abort  (void)   __attribute__((__noreturn__)) ;
int	 abs  (int)   __attribute__((__const__)) ;
int	 atexit  (void (*)(void))  ;
double	 atof  (const char *)  ;
int	 atoi  (const char *)  ;
long	 atol  (const char *)  ;
void	*bsearch  (const void *, const void *, size_t,
	    size_t, int (*)(const void *, const void *))  ;
void	*calloc  (size_t, size_t)  ;
div_t	 div  (int, int)   __attribute__((__const__)) ;
void	 exit  (int)   __attribute__((__noreturn__)) ;
void	 free  (void *)  ;
char	*getenv  (const char *)  ;
long	 labs  (long)   __attribute__((__const__)) ;
ldiv_t	 ldiv  (long, long)   __attribute__((__const__)) ;
void	*malloc  (size_t)  ;
void	 qsort  (void *, size_t, size_t,
	    int (*)(const void *, const void *))  ;
int	 rand  (void)  ;
void	*realloc  (void *, size_t)  ;
void	 srand  (unsigned)  ;
double	 strtod  (const char *, char **)  ;
long	 strtol  (const char *, char **, int)  ;
unsigned long
	 strtoul  (const char *, char **, int)  ;
int	 system  (const char *)  ;

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


int	 putenv  (const char *)  ;
int	 setenv  (const char *, const char *, int)  ;

double	 drand48  (void)  ;
double	 erand48  (unsigned short[3])  ;
long	 jrand48  (unsigned short[3])  ;
void	 lcong48  (unsigned short[7])  ;
long	 lrand48  (void)  ;
long	 mrand48  (void)  ;
long	 nrand48  (unsigned short[3])  ;
unsigned short
	*seed48  (unsigned short[3])  ;
void	 srand48  (long)  ;

void	*alloca  (size_t)  ;		 
					 
u_int32_t
	 arc4random  (void)  ;
void	 arc4random_addrandom  (unsigned char *dat, int datlen)  ;
void	 arc4random_stir  (void)  ;
char	*getbsize  (int *, long *)  ;
char	*cgetcap  (char *, char *, int)  ;
int	 cgetclose  (void)  ;
int	 cgetent  (char **, char **, char *)  ;
int	 cgetfirst  (char **, char **)  ;
int	 cgetmatch  (char *, char *)  ;
int	 cgetnext  (char **, char **)  ;
int	 cgetnum  (char *, char *, long *)  ;
int	 cgetset  (char *)  ;
int	 cgetstr  (char *, char *, char **)  ;
int	 cgetustr  (char *, char *, char **)  ;

int	 daemon  (int, int)  ;
char	*devname  (int, int)  ;
int	 getloadavg  (double [], int)  ;

char	*group_from_gid  (unsigned long, int)  ;
int	 heapsort  (void *, size_t, size_t,
	    int (*)(const void *, const void *))  ;
char	*initstate  (unsigned long, char *, long)  ;
int	 mergesort  (void *, size_t, size_t,
	    int (*)(const void *, const void *))  ;
int	 radixsort  (const unsigned char **, int, const unsigned char *,
	    unsigned)  ;
int	 sradixsort  (const unsigned char **, int, const unsigned char *,
	    unsigned)  ;
long	 random  (void)  ;
char	*realpath  (const char *, char resolved_path[])  ;
char	*setstate  (char *)  ;
void	 srandom  (unsigned long)  ;
void	 srandomdev  (void)  ;
char	*user_from_uid  (unsigned long, int)  ;

int64_t	 strtoq  (const char *, char **, int)  ;
u_int64_t
	 strtouq  (const char *, char **, int)  ;

void	 unsetenv  (const char *)  ;

 


# 2 "zzz.c" 2

# 1 "../egcs-current/gcc/include/math.h" 1 3




# 1 "/usr/include/math.h" 1 3
 










 







 


extern char __infinity[];


 


















extern int signgam;


enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix};




 






extern  enum fdversion   _fdlib_version ;







struct exception {
	int type;
	char *name;
	double arg1;
	double arg2;
	double retval;
};




 


















 
 


extern double acos  (double)  ;
extern double asin  (double)  ;
extern double atan  (double)  ;
extern double atan2  (double, double)  ;
extern double cos  (double)  ;
extern double sin  (double)  ;
extern double tan  (double)  ;

extern double cosh  (double)  ;
extern double sinh  (double)  ;
extern double tanh  (double)  ;

extern double exp  (double)  ;
extern double frexp  (double, int *)  ;
extern double ldexp  (double, int)  ;
extern double log  (double)  ;
extern double log10  (double)  ;
extern double modf  (double, double *)  ;

extern double pow  (double, double)  ;
extern double sqrt  (double)  ;

extern double ceil  (double)  ;
extern double fabs  (double)  ;
extern double floor  (double)  ;
extern double fmod  (double, double)  ;


extern double erf  (double)  ;
extern double erfc  (double)  ;
extern double gamma  (double)  ;
extern double hypot  (double, double)  ;
extern int isinf  (double)  ;
extern int isnan  (double)  ;
extern int finite  (double)  ;
extern double j0  (double)  ;
extern double j1  (double)  ;
extern double jn  (int, double)  ;
extern double lgamma  (double)  ;
extern double y0  (double)  ;
extern double y1  (double)  ;
extern double yn  (int, double)  ;


extern double acosh  (double)  ;
extern double asinh  (double)  ;
extern double atanh  (double)  ;
extern double cbrt  (double)  ;
extern double logb  (double)  ;
extern double nextafter  (double, double)  ;
extern double remainder  (double, double)  ;
extern double scalb  (double, double)  ;


extern int matherr  (struct exception *)  ;


 


extern double significand  (double)  ;

 


extern double copysign  (double, double)  ;
extern int ilogb  (double)  ;
extern double rint  (double)  ;
extern double scalbn  (double, int)  ;

 


extern double cabs();
extern double drem  (double, double)  ;
extern double expm1  (double)  ;
extern double log1p  (double)  ;

 









 
extern float acosf  (float)  ;
extern float asinf  (float)  ;
extern float atanf  (float)  ;
extern float atan2f  (float, float)  ;
extern float cosf  (float)  ;
extern float sinf  (float)  ;
extern float tanf  (float)  ;

extern float coshf  (float)  ;
extern float sinhf  (float)  ;
extern float tanhf  (float)  ;

extern float expf  (float)  ;
extern float frexpf  (float, int *)  ;
extern float ldexpf  (float, int)  ;
extern float logf  (float)  ;
extern float log10f  (float)  ;
extern float modff  (float, float *)  ;

extern float powf  (float, float)  ;
extern float sqrtf  (float)  ;

extern float ceilf  (float)  ;
extern float fabsf  (float)  ;
extern float floorf  (float)  ;
extern float fmodf  (float, float)  ;

extern float erff  (float)  ;
extern float erfcf  (float)  ;
extern float gammaf  (float)  ;
extern float hypotf  (float, float)  ;
extern int isnanf  (float)  ;
extern int finitef  (float)  ;
extern float j0f  (float)  ;
extern float j1f  (float)  ;
extern float jnf  (int, float)  ;
extern float lgammaf  (float)  ;
extern float y0f  (float)  ;
extern float y1f  (float)  ;
extern float ynf  (int, float)  ;

extern float acoshf  (float)  ;
extern float asinhf  (float)  ;
extern float atanhf  (float)  ;
extern float cbrtf  (float)  ;
extern float logbf  (float)  ;
extern float nextafterf  (float, float)  ;
extern float remainderf  (float, float)  ;
extern float scalbf  (float, float)  ;

 


extern float significandf  (float)  ;

 



extern float copysignf  (float, float)  ;
extern int ilogbf  (float)  ;
extern float rintf  (float)  ;
extern float scalbnf  (float, int)  ;

 


extern float cabsf ();
extern float dremf  (float, float)  ;
extern float expm1f  (float)  ;
extern float log1pf  (float)  ;

 











 


# 5 "../egcs-current/gcc/include/math.h" 2 3






# 3 "zzz.c" 2

# 1 "/usr/include/string.h" 1 3
 

















































 
void	*memchr  (const void *, int, size_t)  ;
int	 memcmp  (const void *, const void *, size_t)  ;
void	*memcpy  (void *, const void *, size_t)  ;
void	*memmove  (void *, const void *, size_t)  ;
void	*memset  (void *, int, size_t)  ;
char	*strcat  (char *, const char *)  ;
char	*strchr  (const char *, int)  ;
int	 strcmp  (const char *, const char *)  ;
int	 strcoll  (const char *, const char *)  ;
char	*strcpy  (char *, const char *)  ;
size_t	 strcspn  (const char *, const char *)  ;
char	*strerror  (int)  ;
size_t	 strlen  (const char *)  ;
char	*strncat  (char *, const char *, size_t)  ;
int	 strncmp  (const char *, const char *, size_t)  ;
char	*strncpy  (char *, const char *, size_t)  ;
char	*strpbrk  (const char *, const char *)  ;
char	*strrchr  (const char *, int)  ;
size_t	 strspn  (const char *, const char *)  ;
char	*strstr  (const char *, const char *)  ;
char	*strtok  (char *, const char *)  ;
size_t	 strxfrm  (char *, const char *, size_t)  ;

 

int	 bcmp  (const void *, const void *, size_t)  ;
void	 bcopy  (const void *, void *, size_t)  ;
void	 bzero  (void *, size_t)  ;
int	 ffs  (int)  ;
char	*index  (const char *, int)  ;
void	*memccpy  (void *, const void *, int, size_t)  ;
char	*rindex  (const char *, int)  ;
int	 strcasecmp  (const char *, const char *)  ;
char	*strdup  (const char *)  ;
void	 strmode  (int, char *)  ;
int	 strncasecmp  (const char *, const char *, size_t)  ;
char	*strsep  (char **, const char *)  ;
void	 swab  (const void *, void *, size_t)  ;

 


# 4 "zzz.c" 2

# 1 "chess.h" 1
 





































































































































# 147 "chess.h"
















 
























  






       typedef unsigned long long BITBOARD;



# 1 "/usr/include/time.h" 1 3
 











































# 1 "/usr/include/sys/_posix.h" 1 3



 




























 








# 70 "/usr/include/sys/_posix.h" 3


 





 



















# 45 "/usr/include/time.h" 2 3



 






 







typedef	unsigned long 	clock_t;




typedef	long 	time_t;








 



 



typedef	int 	clockid_t;




typedef	int 	timer_t;





struct timespec {
	time_t	tv_sec;		 
	long	tv_nsec;	 
};



struct tm {
	int	tm_sec;		 
	int	tm_min;		 
	int	tm_hour;	 
	int	tm_mday;	 
	int	tm_mon;		 
	int	tm_year;	 
	int	tm_wday;	 
	int	tm_yday;	 
	int	tm_isdst;	 
	long	tm_gmtoff;	 
	char	*tm_zone;	 
};



 
char *asctime  (const struct tm *)  ;
clock_t clock  (void)  ;
char *ctime  (const time_t *)  ;
double difftime  (time_t, time_t)  ;
struct tm *gmtime  (const time_t *)  ;
struct tm *localtime  (const time_t *)  ;
time_t mktime  (struct tm *)  ;
size_t strftime  (char *, size_t, const char *, const struct tm *)  ;
time_t time  (time_t *)  ;









void tzset  (void)  ;



const char *strptime  (const char *, const char *, struct tm *)  ;
char *timezone  (int, int)  ;
void tzsetwall  (void)  ;
time_t timelocal  (struct tm * const)  ;
time_t timegm  (struct tm * const)  ;



 
int clock_getres  (clockid_t, struct timespec *)  ;
int clock_gettime  (clockid_t, struct timespec *)  ;
int clock_settime  (clockid_t, const struct timespec *)  ;
int nanosleep  (const struct timespec *, struct timespec *)  ;

 


# 199 "chess.h" 2




  typedef enum { A1,B1,C1,D1,E1,F1,G1,H1,
                 A2,B2,C2,D2,E2,F2,G2,H2,
                 A3,B3,C3,D3,E3,F3,G3,H3,
                 A4,B4,C4,D4,E4,F4,G4,H4,
                 A5,B5,C5,D5,E5,F5,G5,H5,
                 A6,B6,C6,D6,E6,F6,G6,H6,
                 A7,B7,C7,D7,E7,F7,G7,H7,
                 A8,B8,C8,D8,E8,F8,G8,H8,
                 BAD_SQUARE } squares;

  typedef enum {FILEA, FILEB, FILEC, FILED, FILEE, FILEF, FILEG, FILEH} files;

  typedef enum {RANK1, RANK2, RANK3, RANK4, RANK5, RANK6, RANK7, RANK8} ranks;

  typedef enum {empty=0, pawn=1, knight=2, king=3, 
                bishop=5, rook=6, queen=7} PIECE;
  
  typedef enum {empty_v=0, pawn_v=1, knight_v=2, 
                bishop_v=3, rook_v=5, queen_v=9} PIECE_V;
  
  typedef enum {no_extension=0, check_extension=1, recapture_extension=2,
                passed_pawn_extension=4, one_reply_extension=8} EXTENSIONS;
  
  typedef enum {cpu, elapsed, microseconds} TIME_TYPE;

  typedef enum {think=1, puzzle=2, book=3, annotate=4} SEARCH_TYPE;

  typedef enum {normal_mode, tournament_mode} PLAYING_MODE;

  typedef enum {crafty, opponent} PLAYER;

  typedef enum {book_learning=1, position_learning=2,
                result_learning=4} LEARNING_MODE;
  
  typedef struct {
    unsigned char enpassant_target;
    signed   char w_castle;
    signed   char b_castle;
    unsigned char rule_50_moves;
  } SEARCH_POSITION;

  typedef  struct {
    BITBOARD       w_occupied;
    BITBOARD       b_occupied;
    BITBOARD       occupied_rl90;
    BITBOARD       occupied_rl45;
    BITBOARD       occupied_rr45;
    BITBOARD       rooks_queens;
    BITBOARD       bishops_queens;
    BITBOARD       w_pawn;
    BITBOARD       w_knight;
    BITBOARD       w_bishop;
    BITBOARD       w_rook;
    BITBOARD       w_queen;
    BITBOARD       b_pawn;
    BITBOARD       b_knight;
    BITBOARD       b_bishop;
    BITBOARD       b_rook;
    BITBOARD       b_queen;
    BITBOARD       hash_key;
    unsigned int   pawn_hash_key;
    int            material_evaluation;
    signed char    white_king;
    signed char    black_king;
    signed char    board[64];
    signed char    white_pieces;
    signed char    white_pawns;
    signed char    black_pieces;
    signed char    black_pawns;
    signed char    total_pieces;
  } CHESS_POSITION;
  
  typedef struct {
    BITBOARD word1;
    BITBOARD word2;
  } HASH_ENTRY;

  typedef struct {
    unsigned int key;
    short    p_score;
    unsigned char black_protected;
    unsigned char black_pof;
    unsigned char weak_b;
    unsigned char passed_b;
    unsigned char black_defects_k;
    unsigned char black_defects_q;
    unsigned char white_protected;
    unsigned char white_pof;
    unsigned char weak_w;
    unsigned char passed_w;
    unsigned char white_defects_k;
    unsigned char white_defects_q;
    unsigned char outside;
  } PAWN_HASH_ENTRY;
  
  typedef struct {
    int path[65 ];
    unsigned char path_hashed;
    unsigned char path_length;
    unsigned char path_iteration_depth;
  } CHESS_PATH;
  
  typedef struct {
    int phase;
    int remaining;
    int *last;
  } NEXT_MOVE;

  typedef struct {
    BITBOARD position;
    BITBOARD status;
    float learn;
  } BOOK_POSITION;

# 341 "chess.h"


 



























 

    BITBOARD     Mask(int);
    int          PopCnt(BITBOARD);
    int          FirstOne(BITBOARD);
    int          LastOne(BITBOARD);

  
  void           Analyze();
  void           Annotate();
  int            Attacked(int, int);
  BITBOARD       AttacksFrom(int, int);
  BITBOARD       AttacksTo(int);
  void           Bench();
  int            Book(int,int);
  int            BookMask(char*);
  void           BookUp(char*,int,char**);



    int            BookUpCompare(const void *, const void *);

  BOOK_POSITION  BookUpNextPosition(int,int);
  int            CheckInput(void);
  void           ClearHashTables(void);
  void           ComputeAttacksAndMobility(void);
  void           Delay232(int);
  void           DisplayBitBoard(BITBOARD);
  void           DisplayChessBoard(FILE*, CHESS_POSITION);
  char*          DisplayEvaluation(int);
  char*          DisplayEvaluationWhisper(int);
  void           DisplayFT(int, int, int);
  char*          DisplayHHMM(unsigned int);
  void           DisplayPieceBoards(int*, int*);
  void           DisplayPV(int,int,int,int,CHESS_PATH);
  char*          DisplayTime(unsigned int);
  char*          DisplayTimeWhisper(unsigned int);
  void           Display2BitBoards(BITBOARD, BITBOARD);
  void           DisplayChessMove(char*, int);
  int            DrawScore(void);
  int            Drawn(int);
  void           Edit(void);
  int            EnPrise(int, int);
  int            Evaluate(int, int, int, int);
  int            EvaluateDevelopment(int);
  int            EvaluateDraws();
  int            EvaluateMate(void);
  int            EvaluatePassedPawns(void);
  int            EvaluatePassedPawnRaces(int);
  int            EvaluatePawns(void);
  char*          FormatPV(int,CHESS_PATH);
  int*           GenerateCaptures(int, int, int*);
  int*           GenerateCheckEvasions(int, int, int*);
  int*           GenerateNonCaptures(int, int, int*);
  unsigned int   ReadClock(TIME_TYPE);
  int            HasOpposition(int, int, int);
  void           HistoryBest(int, int, int);
  void           HistoryRefutation(int, int, int);
  void           Initialize(int);
  void           InitializeAttackBoards(void);
  void           InitializeChessBoard(SEARCH_POSITION*);
  int            InitializeFindAttacks(int, int, int);
  void           InitializeHashTables(void);
  void           InitializeMasks(void);
  void           InitializePawnMasks(void);
  void           InitializePieceMasks(void);
  void           InitializeRandomHash(void);
  void           InitializeZeroMasks(void);
  int            InputMove(char*, int, int, int, int);
  int            InputMoveICS(char*, int, int, int, int);
  BITBOARD       InterposeSquares(int, int, int);
  void           Interrupt(int);
  int            Iterate(int, int, int);
  int            KingPawnSquare(int, int, int, int);
  void           LearnBook(int,int,int,int,int);
  void           LearnBookUpdate(int,int,float);
  int            LearnFunction(int,int,int,int);
  void           LearnImport(int,char**);
  void           LearnImportBook(int,char**);
  void           LearnImportPosition(int,char**);
  void           LearnPosition(int,int,int);
  void           LearnPositionLoad(void);
  void           LearnResult(int);
  int            LookUp(int, int, int, int*, int*, int*);
  void           MakeMove(int, int, int);
  void           MakeMoveRoot(int, int);
  void           NewGame(int);
  int            NextEvasion(int, int);
  int            NextMove(int, int);
  int            NextRootMove(int);
  char*          Normal(void);
  int            Option(void);
  int            OptionMatch(char*, char*);
  void           OptionPerft(int,int,int);
  char*          OutputMove(int*, int, int);
  char*          OutputMoveICS(int*);
  int            OutputGood(char*, int, int);
  int            ParseTime(char*);
  void           Phase(void);
  int            PinnedOnKing(int,int);
  int            Ponder(int);
  void           PreEvaluate(int);
  void           Print(int, char*, ...);
  int            Quiesce(int, int, int, int);
  unsigned int   Random32(void);
  BITBOARD       Random64(void);
  int            Read(int, char*);
  int            ReadChessMove(FILE*, int, int);
  void           ReadClear();
  int            ReadPGN(FILE*,int);
  int            ReadNextMove(char*, int, int);
  int            ReadParse(char*, char *args[], char*);
  int            ReadRaw();
  int            RepetitionCheck(int,int);
  int            RepetitionDraw(int);
  void           ResignOrDraw(int,int);
  char*          Reverse(void);
  void           RootMoveList(int);
  int            Search(int, int, int, int, int, int);
  void           SearchOutput(int,int);
  int            SearchRoot(int, int, int, int);
  void           SearchTrace(int,int,int,int,int,char*,int);
  void           SetBoard(int,char**,int);
  void           SetChessBitBoards(SEARCH_POSITION*);
  int            Singular(int, int, int, int);
  void           StoreBest(int,int,int,int,int,int);
  void           StorePV(int,int);
  void           StoreRefutation(int,int,int,int,int);
  int            Swap(int, int, int);
  BITBOARD       SwapXray(BITBOARD, int, int);
  void           EVTest(char *);
  void           Test(char *);
  int            Threat(int, int, int, int, int, int);
  void           TimeAdjust(int,PLAYER);
  int            TimeCheck(int);
  void           TimeSet(int);
  void           UnMakeMove(int, int, int);
  int            ValidMove(int, int, int);
  void           ValidatePosition(int,int,char*);
  BITBOARD       ValidateComputeBishopAttacks(int);
  BITBOARD       ValidateComputeRookAttacks(int);
  void           Whisper(int, int, int, int, unsigned int, int, char*);
  
# 545 "chess.h"













 





 







 




















# 672 "chess.h"















 











# 739 "chess.h"















 













 

















































 











































# 5 "zzz.c" 2

# 1 "data.h" 1



   extern char           version[6];
   extern PLAYING_MODE   mode;
   extern int            batch_mode;
   extern int            call_flag;
   extern int            crafty_rating;
   extern int            opponent_rating;
   extern int            number_auto_kibitzers;
   extern int            number_of_computers;
   extern int            number_of_GMs;
   extern int            number_of_IMs;
   extern int            number_of_specials;
   extern int            time_used;
   extern int            time_used_opponent;
   extern int            auto_kibitzing;
   extern int            total_moves;
   extern int            initialized;
   extern int            early_exit;
   extern int            new_game;
   extern char           auto_kibitz_list[64][20];
   extern char           GM_list[256][20];
   extern char           IM_list[256][20];
   extern char           computer_list[256][20];
   extern char           special_list[256][20];
   extern FILE           *input_stream;
   extern FILE           *book_file;
   extern FILE           *books_file;
   extern FILE           *history_file;
   extern FILE           *log_file;
   extern FILE           *auto_file;
   extern FILE           *book_lrn_file;
   extern FILE           *position_file;
   extern FILE           *position_lrn_file;
   extern int            log_id;
   extern int            output_format;
   extern int            EGTBlimit;
   extern char           whisper_text[500];
   extern int            whisper_value;
   extern int            whisper_depth;
   extern int            last_mate_score;
   extern int            last_opponent_move;

   extern int            incheck_depth;
   extern int            onerep_depth;
   extern int            pushpp_depth;
   extern int            recap_depth;
   extern int            singular_depth;
   extern int            threat_depth;

   extern char           pgn_event[32];
   extern char           pgn_date[32];
   extern char           pgn_round[32];
   extern char           pgn_site[32];
   extern char           pgn_white[64];
   extern char           pgn_white_elo[32];
   extern char           pgn_black[64];
   extern char           pgn_black_elo[32];
   extern char           pgn_result[32];
   extern char           log_filename[64];
   extern char           history_filename[64];

   extern int            number_of_solutions;
   extern int            solutions[10];
   extern int            solution_type;
   extern int            default_draw_score;
   extern int            over;
   extern int            ics;
   extern int            auto232;
   extern int            auto232_delay;
   extern int            xboard;
   extern int            whisper;
   extern int            channel;
   extern char           channel_title[32];
   extern char           book_path[128];
   extern char           log_path[128];
   extern char           tb_path[128];
   extern char           cmd_buffer[512];
   extern char           *args[32];
   extern char           buffer[512];
   extern int            nargs;
   extern int            kibitz;
   extern int            move_number;
   extern int            wtm;
   extern int            crafty_is_white;
   extern int            iteration_depth;
   extern int            last_search_value;
   extern int            previous_search_value;
   extern int            search_failed_high;
   extern int            search_failed_low;
   extern int            largest_positional_score;
   extern int            root_alpha;
   extern int            root_beta;
   extern int            root_value;
   extern int            root_wtm;
   extern int            root_move;
   extern int            root_total_white_pieces;
   extern int            root_total_white_pawns;
   extern int            root_total_black_pieces;
   extern int            root_total_black_pawns;
   extern int            nodes_per_second;
   extern int            cpu_percent;

   extern int            tb_probes;
   extern int            tb_probes_successful;

   extern int            opening;
   extern int            middle_game;
   extern int            end_game;
   extern int            analyze_mode;
   extern int            annotate_mode;
   extern int            test_mode;
   extern int            analyze_move_read;
   extern signed char    resign;
   extern signed char    resign_counter;
   extern signed char    resign_count;
   extern signed char    draw_counter;
   extern signed char    draw_count;
   extern char           audible_alarm;
   extern char           hint[16];
   extern int            post;
   extern int            search_depth;
   extern int            search_move;
   extern int            easy_move;
   extern TIME_TYPE      time_type;
   extern int            time_limit;
   extern int            absolute_time_limit;
   extern int            search_time_limit;
   extern int            nodes_between_time_checks;
   extern int            next_time_check;

   extern int            time_abort;
   extern signed char    pondering;    
   extern signed char    thinking;     
   extern signed char    puzzling;     
   extern signed char    booking;      
   extern signed char    abort_search;
   extern int            ponder;
   extern int            ponder_move;
   extern int            made_predicted_move;
   extern int            force;
   extern int            ponder_moves[220];
   extern int            num_ponder_moves;
   extern char           initial_position[80];

   extern unsigned int   opponent_start_time, opponent_end_time;
   extern unsigned int   program_start_time, program_end_time;
   extern unsigned int   start_time, end_time;
   extern unsigned int   elapsed_start, elapsed_end;
   extern unsigned int   nodes_searched;
   extern unsigned int   evaluations;
   extern int            predicted;
   extern signed char    transposition_id;
   extern int            transposition_probes;
   extern int            transposition_hits;
   extern int            pawn_probes;
   extern int            pawn_hits;
   extern int            check_extensions_done;
   extern int            recapture_extensions_done;
   extern int            passed_pawn_extensions_done;
   extern int            one_reply_extensions_done;

   extern int            ansi;
   extern int            trace_level;
   extern int            display_options;
   extern int            burp;
   extern unsigned int   noise_level;

   extern int            book_move;
   extern int            moves_out_of_book;
   extern int            book_accept_mask;
   extern int            book_reject_mask;
   extern int            book_random;
   extern float          book_weight_freq;
   extern float          book_weight_wlratio;
   extern float          book_weight_eval;
   extern float          book_weight_learn;
   extern int            book_search_trigger;
   extern int            book_selection_width;
   extern int            show_book;
   extern int            learning;
   extern int            book_learn_eval[10 ];
   extern int            book_learn_depth[10 ];

   extern int            tc_moves;
   extern int            tc_time;
   extern int            tc_time_remaining;
   extern int            tc_time_remaining_opponent;
   extern int            tc_moves_remaining;
   extern int            tc_secondary_moves;
   extern int            tc_secondary_time;
   extern int            tc_increment;
   extern int            tc_sudden_death;
   extern int            tc_operator_time;
   extern int            tc_safety_margin;
   extern int            no_tricks;
   extern int            computer_opponent;
   extern int            usage_level;

   extern int            log_hash;
   extern int            log_pawn_hash;
   extern int            hash_table_size;
   extern int            pawn_hash_table_size;

   extern int            hash_maska;
   extern int            hash_maskb;
   extern unsigned int   pawn_hash_mask;
   extern HASH_ENTRY      *trans_ref_wa;
   extern HASH_ENTRY      *trans_ref_wb;
   extern HASH_ENTRY      *trans_ref_ba;
   extern HASH_ENTRY      *trans_ref_bb;
   extern PAWN_HASH_ENTRY *pawn_hash_table;

   extern int            hash_move[65 ];
   extern int            history_w[4096], history_b[4096];
   extern int            killer_move1[65 ];
   extern int            killer_move2[65 ];
   extern int            killer_count1[65 ];
   extern int            killer_count2[65 ];
   extern BITBOARD       replist_w[50+ 65 /2];
   extern BITBOARD       replist_b[50+ 65 /2];
   extern BITBOARD       *rephead_w;
   extern BITBOARD       *rephead_b;

   extern int            unblocked_pawns[9];
   extern int            p_values[15];
   extern int            current_move[65 ];
   extern int            *last[65 ];
   extern signed char    in_check[65 ];
   extern signed char    extended_reason[65 ];
   extern signed char    current_phase[65 ];
   extern int            move_list[5120];
   extern int            sort_value[256];
   extern signed char    searched_this_root_move[256];
   extern unsigned int   root_nodes[256];
   extern CHESS_PATH     pv[65 ];
   extern CHESS_PATH     last_pv;
   extern int            last_value;
   extern NEXT_MOVE      next_status[65 ];
   extern SEARCH_POSITION position[65 +2];
   extern BITBOARD       save_hash_key[65 +2];
   extern unsigned int   save_pawn_hash_key[65 +2];

   extern char           white_outpost[64];
   extern char           black_outpost[64];
   extern char           square_color[64];
   extern int            passed_pawn_value[8];
   extern int            supported_passer[8];
   extern int            reduced_material_passer[20];
   extern int            pawn_advance[8];
   extern int            outside_passed[128];
   extern int            pawn_value_w[64];
   extern int            pawn_value_b[64];
   extern int            knight_value_w[64];
   extern int            knight_value_b[64];
   extern int            bishop_value_w[64];
   extern int            bishop_value_b[64];
   extern int            rook_value_w[64];
   extern int            rook_value_b[64];
   extern int            queen_value_w[64];
   extern int            queen_value_b[64];
   extern int            king_value_w[64];
   extern int            king_value_b[64];
   extern char           king_defects_w[64];
   extern char           king_defects_b[64];

   extern int            b_n_mate_dark_squares[64];
   extern int            b_n_mate_light_squares[64];
   extern int            mate[64];

   extern char           push_extensions[64];

   extern signed char    directions[64][64];
   extern BITBOARD       w_pawn_attacks[64];
   extern BITBOARD       b_pawn_attacks[64];
   extern BITBOARD       knight_attacks[64];
   extern BITBOARD       bishop_attacks[64];
# 294 "data.h"

  extern BITBOARD       bishop_attacks_rl45[64][256];
  extern BITBOARD       bishop_attacks_rr45[64][256];
  extern int            bishop_mobility_rl45[64][256];
  extern int            bishop_mobility_rr45[64][256];
  extern int            bishop_shift_rl45[64];
  extern int            bishop_shift_rr45[64];

  extern BITBOARD       rook_attacks[64];

  extern BITBOARD       rook_attacks_r0[64][256];
  extern BITBOARD       rook_attacks_rl90[64][256];
  extern int            rook_mobility_r0[64][256];
  extern int            rook_mobility_rl90[64][256];


   extern CHESS_POSITION search;
   extern CHESS_POSITION display;

   extern BITBOARD       queen_attacks[64];
   extern BITBOARD       king_attacks[64];
   extern BITBOARD       king_attacks_1[64];
   extern BITBOARD       king_attacks_2[64];
   extern BITBOARD       obstructed[64][64];

   extern unsigned int   w_pawn_random32[64];
   extern unsigned int   b_pawn_random32[64];
   extern BITBOARD       w_pawn_random[64];
   extern BITBOARD       b_pawn_random[64];
   extern BITBOARD       w_knight_random[64];
   extern BITBOARD       b_knight_random[64];
   extern BITBOARD       w_bishop_random[64];
   extern BITBOARD       b_bishop_random[64];
   extern BITBOARD       w_rook_random[64];
   extern BITBOARD       b_rook_random[64];
   extern BITBOARD       w_queen_random[64];
   extern BITBOARD       b_queen_random[64];
   extern BITBOARD       w_king_random[64];
   extern BITBOARD       b_king_random[64];
   extern BITBOARD       enpassant_random[65];
   extern BITBOARD       castle_random_w[2];
   extern BITBOARD       castle_random_b[2];
   extern BITBOARD       wtm_random[2];
   extern BITBOARD       endgame_random_w;
   extern BITBOARD       endgame_random_b;
   extern BITBOARD       w_rooks_random;
   extern BITBOARD       b_rooks_random;

   extern BITBOARD       threat_flag;
   extern BITBOARD       clear_mask[65];
   extern BITBOARD       clear_mask_rl45[65];
   extern BITBOARD       clear_mask_rr45[65];
   extern BITBOARD       clear_mask_rl90[65];
   extern BITBOARD       set_mask[65];
   extern BITBOARD       set_mask_rl45[65];
   extern BITBOARD       set_mask_rr45[65];
   extern BITBOARD       set_mask_rl90[65];
   extern BITBOARD       file_mask[8];
   extern BITBOARD       rank_mask[8];
   extern BITBOARD       mask_not_rank8;
   extern BITBOARD       mask_not_rank1;
   extern BITBOARD       right_side_mask[8];
   extern BITBOARD       left_side_mask[8];
   extern BITBOARD       right_side_empty_mask[8];
   extern BITBOARD       left_side_empty_mask[8];
   extern BITBOARD       right_half_mask, left_half_mask;
   extern BITBOARD       mask_abs7_w, mask_abs7_b;
   extern BITBOARD       pawns_cramp_black;
   extern BITBOARD       pawns_cramp_white;
   extern BITBOARD       mask_advance_2_w;
   extern BITBOARD       mask_advance_2_b;
   extern BITBOARD       mask_left_edge;
   extern BITBOARD       mask_right_edge;
   extern BITBOARD       mask_corner_squares;
   extern BITBOARD       promote_mask_w;
   extern BITBOARD       promote_mask_b;
   extern BITBOARD       mask_G2G3;
   extern BITBOARD       mask_B2B3;
   extern BITBOARD       mask_G6G7;
   extern BITBOARD       mask_B6B7;
   extern BITBOARD       mask_F3H3;
   extern BITBOARD       mask_F6H6;
   extern BITBOARD       mask_A3C3;
   extern BITBOARD       mask_A6C6;
   extern BITBOARD       mask_A7H7;
   extern BITBOARD       mask_A2H2;
   extern BITBOARD       center;

   extern BITBOARD       stonewall_white;
   extern BITBOARD       stonewall_black;

   extern BITBOARD       mask_kr_trapped_w[3];
   extern BITBOARD       mask_qr_trapped_w[3];
   extern BITBOARD       mask_kr_trapped_b[3];
   extern BITBOARD       mask_qr_trapped_b[3];

   extern BITBOARD       good_bishop_kw;
   extern BITBOARD       good_bishop_qw;
   extern BITBOARD       good_bishop_kb;
   extern BITBOARD       good_bishop_qb;

   extern BITBOARD       light_squares;
   extern BITBOARD       dark_squares;
   extern BITBOARD       not_rook_pawns;

   extern BITBOARD       plus1dir[65];
   extern BITBOARD       plus7dir[65];
   extern BITBOARD       plus8dir[65];
   extern BITBOARD       plus9dir[65];
   extern BITBOARD       minus1dir[65];
   extern BITBOARD       minus7dir[65];
   extern BITBOARD       minus8dir[65];
   extern BITBOARD       minus9dir[65];

   extern BITBOARD       mask_eptest[64];

     extern BITBOARD       mask_1;
     extern BITBOARD       mask_2;
     extern BITBOARD       mask_3;
     extern BITBOARD       mask_4;
     extern BITBOARD       mask_8;
     extern BITBOARD       mask_16;
     extern BITBOARD       mask_32;
     extern BITBOARD       mask_72;
     extern BITBOARD       mask_80;
     extern BITBOARD       mask_85;
     extern BITBOARD       mask_96;
     extern BITBOARD       mask_107;
     extern BITBOARD       mask_108;
     extern BITBOARD       mask_112;
     extern BITBOARD       mask_118;
     extern BITBOARD       mask_120;
     extern BITBOARD       mask_121;
     extern BITBOARD       mask_127;

   extern BITBOARD       mask_clear_entry;


     extern unsigned char  first_ones[65536];
     extern unsigned char  last_ones[65536];

   extern unsigned char  first_ones_8bit[256];
   extern unsigned char  last_ones_8bit[256];
   extern unsigned char  connected_passed[256];

   extern BITBOARD       mask_kingside_attack_w1;
   extern BITBOARD       mask_kingside_attack_w2;
   extern BITBOARD       mask_kingside_attack_b1;
   extern BITBOARD       mask_kingside_attack_b2;
   extern BITBOARD       mask_queenside_attack_w1;
   extern BITBOARD       mask_queenside_attack_w2;
   extern BITBOARD       mask_queenside_attack_b1;
   extern BITBOARD       mask_queenside_attack_b2;

   extern BITBOARD       mask_pawn_protected_b[64];
   extern BITBOARD       mask_pawn_protected_w[64];
   extern BITBOARD       mask_pawn_isolated[64];
   extern BITBOARD       mask_pawn_passed_w[64];
   extern BITBOARD       mask_pawn_passed_b[64];
   extern BITBOARD       mask_promotion_threat_w[64];
   extern BITBOARD       mask_promotion_threat_b[64];
   extern BITBOARD       mask_pawn_connected[64];
   extern BITBOARD       mask_no_pawn_attacks_w[64];
   extern BITBOARD       mask_no_pawn_attacks_b[64];
   extern BITBOARD       mask_a1_corner;
   extern BITBOARD       mask_a8_corner;
   extern BITBOARD       mask_h1_corner;
   extern BITBOARD       mask_h8_corner;
   extern BITBOARD       white_minor_pieces;
   extern BITBOARD       black_minor_pieces;
   extern BITBOARD       white_center_pawns;
   extern BITBOARD       black_center_pawns;
   extern BITBOARD       white_pawn_race_wtm[64];
   extern BITBOARD       white_pawn_race_btm[64];
   extern BITBOARD       black_pawn_race_wtm[64];
   extern BITBOARD       black_pawn_race_btm[64];

   extern BITBOARD       mask_wk_4th, mask_wq_4th, mask_bk_4th, mask_bq_4th;
   extern BITBOARD       mask_wk_5th, mask_wq_5th, mask_bk_5th, mask_bq_5th;
   extern BOOK_POSITION  book_buffer[600 ];

# 6 "zzz.c" 2





 
 







































int Book(int wtm, int root_list_done) {
  static int book_moves[200];
  static BOOK_POSITION start_moves[20];
  static int selected[200];
  static int selected_order_won[200], selected_order_drawn[200],
         selected_order_lost[200];
  static int selected_status[200], book_development[200];
  static int bs_won[200], bs_drawn[200], bs_lost[200];
  static int bs_played[200];
  static int book_status[200], evaluations[200], bs_learn[200];
  static float bs_value[200];
  int m1_status, status, forced=0;
  float won, lost, tempr;
  int done, i, j, last_move, temp, which, minlv=999999, maxlv=-999999;
  int maxp=-999999, minev=999999, maxev=-999999;
  float minwl=999999.0,maxwl=-999999.0;
  int *mv, mp, value, np;
  int cluster, test;
  BITBOARD temp_hash_key, common;
  int key, nmoves, num_selected, st;
  int percent_played, total_played, total_moves, smoves;
  int distribution;
  int initial_development;
  char *whisper_p;

  static char ch[11] = {'0','1','2','3','4','5','6','7',
                        '8','9','A'};

 







  if (moves_out_of_book > 3) return(0);
 








  if (!root_list_done) RootMoveList(wtm);
  test= search.hash_key >>49;
  smoves=0;
  if (books_file) {
    fseek(books_file,test*sizeof(int),0 );
    fread(&key,sizeof(int),1,books_file);
    if (key > 0) {
      fseek(books_file,key,0 );
      fread(&cluster,sizeof(int),1,books_file);
      fread(book_buffer,sizeof(BOOK_POSITION),cluster,books_file);
      for (mv=last[0];mv<last[1];mv++) {
        common=And(search.hash_key ,mask_16);
        MakeMove(1,*mv,wtm);
        if (RepetitionCheck(2,(( wtm )^1) )) {
          UnMakeMove(1,*mv,wtm);
          return(0);
        }
        temp_hash_key=Xor(search.hash_key ,wtm_random[wtm]);
        temp_hash_key=Or(And(temp_hash_key,Compl(mask_16)),common);
        for (i=0;i<cluster;i++)
          if (!Xor(temp_hash_key,book_buffer[i].position)) {
            start_moves[smoves++]=book_buffer[i];
            break;
          }
        UnMakeMove(1,*mv,wtm);
      }
    }
  }
 









  test= search.hash_key >>49;
  if (book_file) {
    fseek(book_file,test*sizeof(int),0 );
    fread(&key,sizeof(int),1,book_file);
    if (key > 0) {
      fseek(book_file,key,0 );
      fread(&cluster,sizeof(int),1,book_file);
      fread(book_buffer,sizeof(BOOK_POSITION),cluster,book_file);
    }
    else cluster=0;
 










    for (i=0;i<smoves;i++) {
      for (j=0;j<cluster;j++)
        if (!Xor(book_buffer[j].position,start_moves[i].position)) {
          book_buffer[j].status=Or(book_buffer[j].status,
                              And(start_moves[i].status,mask_16));
          break;
        }
      if (j == cluster) book_buffer[cluster++]=start_moves[i];
    }
    if (!cluster) return(0);
 








    initial_development=(wtm) ? EvaluateDevelopment(1) : 
                               -EvaluateDevelopment(1);
    total_moves=0;
    nmoves=0;
    for (mv=last[0];mv<last[1];mv++) {
      common=And(search.hash_key ,mask_16);
      MakeMove(1,*mv,wtm);
      if (RepetitionCheck(2,(( wtm )^1) )) {
        UnMakeMove(1,*mv,wtm);
        return(0);
      }
      temp_hash_key=Xor(search.hash_key ,wtm_random[wtm]);
      temp_hash_key=Or(And(temp_hash_key,Compl(mask_16)),common);
      for (i=0;i<cluster;i++) {
        if (!Xor(temp_hash_key,book_buffer[i].position)) {
          status=Shiftr(book_buffer[i].status,48);
          book_status[nmoves]=status;
          if (wtm) {
            bs_won[nmoves]=Shiftr(book_buffer[i].status,32)&65535;
            bs_drawn[nmoves]=Shiftr(book_buffer[i].status,16)&65535;
            bs_lost[nmoves]=book_buffer[i].status&65535;
            bs_played[nmoves]=bs_won[nmoves]+bs_drawn[nmoves];
          }
          else {
            bs_lost[nmoves]=Shiftr(book_buffer[i].status,32)&65535;
            bs_drawn[nmoves]=Shiftr(book_buffer[i].status,16)&65535;
            bs_won[nmoves]=book_buffer[i].status&65535;
            bs_played[nmoves]=bs_lost[nmoves]+bs_drawn[nmoves];
          }
          bs_learn[nmoves]=(int) (book_buffer[i].learn*100.0);
          if (puzzling) bs_won[nmoves]+=1;
          current_move[1]=*mv;
          if (! ((( *mv )>>15)&7) ) 
            book_development[nmoves]=((wtm) ? EvaluateDevelopment(2) : 
                  -EvaluateDevelopment(2))-initial_development;
          else book_development[nmoves]=0;
          total_moves+=bs_won[nmoves];
          total_moves+=bs_drawn[nmoves];
          total_moves+=bs_lost[nmoves];
          evaluations[nmoves]=Evaluate(2,wtm,-999999,999999);
          evaluations[nmoves]-=(wtm) ? search.material_evaluation  : - search.material_evaluation ;
          book_moves[nmoves++]=*mv;
          break;
        }
      }
      UnMakeMove(1,*mv,wtm);
    }
    if (!nmoves) return(0);
 








    for (i=0;i<nmoves;i++) {
      minlv= ((( minlv ) < ( bs_learn[i] )) ? ( minlv ) : ( bs_learn[i] )) ;
      maxlv= ((( maxlv ) > ( bs_learn[i] )) ? ( maxlv ) : ( bs_learn[i] )) ;
      minev= ((( minev ) < ( evaluations[i] )) ? ( minev ) : ( evaluations[i] )) ;
      maxev= ((( maxev ) > ( evaluations[i] )) ? ( maxev ) : ( evaluations[i] )) ;
      minwl= ((( minwl ) < ( (float)bs_won[i]/
            ((float)((( bs_lost[i] ) > ( 1 )) ? ( bs_lost[i] ) : ( 1 )) ) )) ? ( minwl ) : ( (float)bs_won[i]/             ((float)((( bs_lost[i] ) > ( 1 )) ? ( bs_lost[i] ) : ( 1 )) ) )) ;
      maxwl= ((( maxwl ) > ( (float)bs_won[i]/
            ((float)((( bs_lost[i] ) > ( 1 )) ? ( bs_lost[i] ) : ( 1 )) ) )) ? ( maxwl ) : ( (float)bs_won[i]/             ((float)((( bs_lost[i] ) > ( 1 )) ? ( bs_lost[i] ) : ( 1 )) ) )) ;
      maxp= ((( maxp ) > ( bs_won[i]+bs_drawn[i]+bs_lost[i] )) ? ( maxp ) : ( bs_won[i]+bs_drawn[i]+bs_lost[i] )) ;
    }
    maxp++;
    for (i=0;i<nmoves;i++) {
      bs_value[i]=1;
      bs_value[i]+=(bs_won[i]+bs_drawn[i]+bs_lost[i])/
                   (float) maxp*1000.0*book_weight_freq;
      if (minwl < maxwl) {
        won=bs_won[i];
        lost= ((( bs_lost[i] ) > ( 1 )) ? ( bs_lost[i] ) : ( 1 )) ;
        bs_value[i]+=((float)bs_won[i]/ ((( (float)bs_lost[i] ) > ( 1 )) ? ( (float)bs_lost[i] ) : ( 1 )) -minwl)/
                        (float)(maxwl-minwl)*1000.0*book_weight_wlratio;
      }
      if (minlv < maxlv)
        bs_value[i]+=(bs_learn[i]-minlv)/
                            (float) (maxlv-minlv)*1000.0*book_weight_learn;
      if (minev < maxev)
        bs_value[i]+=(evaluations[i]-minev)/(float)(maxev-minev)*
                            1000.0*book_weight_eval;
    }
    total_played=total_moves;
 








    for (i=0;i<nmoves;i++) {
      if (bs_learn[i] <= -80  &&
          !(book_status[i] & 030)) book_status[i]|= 002 ;
      if (bs_won[i]==0 && 
          !(book_status[i] & 030)) book_status[i]|= 002 ;
      if (bs_learn[i] >= +100  &&
          !(book_status[i] & 003)) book_status[i]|= 010 ;
    }
 







    mp=0;
    for (i=0;i<nmoves;i++) mp= ((( mp ) > ( bs_played[i] )) ? ( mp ) : ( bs_played[i] )) ;
    for (i=0;i<nmoves;i++) {
      if (book_status[i] & 030) bs_played[i]+=mp;
      if (book_status[i] & 003) bs_played[i]-=mp;
    }
 







    if (nmoves) 
      do {
        done=1;
        for (i=0;i<nmoves-1;i++) {
          if (bs_value[i] < bs_value[i+1]) {
            tempr=bs_played[i];
            bs_played[i]=bs_played[i+1];
            bs_played[i+1]=tempr;
            tempr=bs_value[i];
            bs_value[i]=bs_value[i+1];
            bs_value[i+1]=tempr;
            temp=evaluations[i];
            evaluations[i]=evaluations[i+1];
            evaluations[i+1]=temp;
            temp=bs_learn[i];
            bs_learn[i]=bs_learn[i+1];
            bs_learn[i+1]=temp;
            temp=bs_won[i];
            bs_won[i]=bs_won[i+1];
            bs_won[i+1]=temp;
            temp=bs_drawn[i];
            bs_drawn[i]=bs_drawn[i+1];
            bs_drawn[i+1]=temp;
            temp=bs_lost[i];
            bs_lost[i]=bs_lost[i+1];
            bs_lost[i+1]=temp;
            temp=book_development[i];
            book_development[i]=book_development[i+1];
            book_development[i+1]=temp;
            temp=book_moves[i];
            book_moves[i]=book_moves[i+1];
            book_moves[i+1]=temp;
            temp=book_status[i];
            book_status[i]=book_status[i+1];
            book_status[i+1]=temp;
            done=0;
          }
        }
      } while (!done);
 







    if (show_book) {
      Print(128,"  move     win  draw  lose   %%  w/l   score    learn     sortv  P\n");
      for (i=0;i<nmoves;i++) {
        Print(128,"%6s", OutputMove(&book_moves[i],1,wtm));
        st=book_status[i];
        if (st) {
          if (st & 1) Print(128,"??");
          else if (st & 2) Print(128,"? ");
          else if (st & 4) Print(128,"= ");
          else if (st & 8) Print(128,"! ");
          else if (st & 16) Print(128,"!!");
          else {
            Print(128,"  ");
            st=st>>5;
            Print(128,"/");
            for (j=0;j<11;j++) {
              if (st & 1) Print(128,"%c",ch[j]);
              st=st>>1;
            }
          }
        }
        else Print(128,"  ");
        Print(128,"%6d%6d%6d",bs_won[i], bs_drawn[i],
                                 bs_lost[i]);
        Print(128," %3d",100*(bs_won[i]+bs_drawn[i]+
                               bs_lost[i])/ ((( total_moves ) > ( 1 )) ? ( total_moves ) : ( 1 )) );
        Print(128,"%5.1f ",((float) bs_won[i]/
                            ((( bs_lost[i] ) > ( 1 )) ? ( bs_lost[i] ) : ( 1 )) ));
        Print(128,"%s",DisplayEvaluation(evaluations[i]));
        Print(128,"%9.2f",(float)bs_learn[i]/100.0);
        Print(128," %9.1f",bs_value[i]);
        if (((book_status[i]&book_accept_mask) && !(book_status[i] & book_reject_mask)) || 
              (!(book_status[i] & book_reject_mask) && bs_won[i])) Print(128,"  Y");
        else Print(128,"  N");
        Print(128,"\n");
      }
    }
 







    num_selected=0;
    for (i=0;i<nmoves;i++)
      if (!(book_status[i] & 003)) {
        selected_status[num_selected]=book_status[i];
        selected_order_won[num_selected]=bs_won[i];
        selected_order_drawn[num_selected]=bs_drawn[i];
        selected_order_lost[num_selected]=bs_lost[i];
        selected[num_selected++]=book_moves[i];
      }
    for (i=0;i<num_selected;i++) {
      book_status[i]=selected_status[i];
      bs_won[i]=selected_order_won[i];
      bs_drawn[i]=selected_order_drawn[i];
      bs_lost[i]=selected_order_lost[i];
      book_moves[i]=selected[i];
    }
    nmoves=num_selected;
 








    if (!puzzling) do {
      whisper_text[0]='\0';
      if (!nmoves) break;
      sprintf(whisper_text,"book moves (");
      whisper_p=whisper_text+strlen(whisper_text);
      for (i=0;i<nmoves;i++) {
        sprintf(whisper_p,"%s %d%%",OutputMove(&book_moves[i],1,wtm),
                                    100*(bs_won[i]+bs_drawn[i]+bs_lost[i])
                                    / ((( total_played ) > ( 1 )) ? ( total_played ) : ( 1 )) );
        whisper_p=whisper_text+strlen(whisper_text);
        if (i < nmoves-1) {
          sprintf(whisper_p,", ");
          whisper_p=whisper_text+strlen(whisper_text);
        }
      }
      sprintf(whisper_p,")\n");
      Whisper(4,0,0,0,0,0,whisper_text);
    } while(0);
 













 


    num_selected=0;
    if (!num_selected && !puzzling)
      if (book_accept_mask & 16)
        for (i=0;i<nmoves;i++)
          if (book_status[i] & 16) {
            forced=1;
            selected_status[num_selected]=book_status[i];
            selected_order_won[num_selected]=bs_won[i];
            selected_order_drawn[num_selected]=bs_drawn[i];
            selected_order_lost[num_selected]=bs_lost[i];
            selected[num_selected++]=book_moves[i];
          }
 


    if (!num_selected && !puzzling)
      if (book_accept_mask & 8)
        for (i=0;i<nmoves;i++)
          if (book_status[i] & 8) {
            forced=1;
            selected_status[num_selected]=book_status[i];
            selected_order_won[num_selected]=bs_won[i];
            selected_order_drawn[num_selected]=bs_drawn[i];
            selected_order_lost[num_selected]=bs_lost[i];
            selected[num_selected++]=book_moves[i];
          }
 


    if (!num_selected && !puzzling)
      if (book_accept_mask & 4)
        for (i=0;i<nmoves;i++)
          if (book_status[i] & 4) {
            selected_status[num_selected]=book_status[i];
            selected_order_won[num_selected]=bs_won[i];
            selected_order_drawn[num_selected]=bs_drawn[i];
            selected_order_lost[num_selected]=bs_lost[i];
            selected[num_selected++]=book_moves[i];
          }
 


    if (!num_selected && !puzzling)
      for (i=0;i<nmoves;i++)
        if (book_status[i] & book_accept_mask) {
          selected_status[num_selected]=book_status[i];
          selected_order_won[num_selected]=bs_won[i];
          selected_order_drawn[num_selected]=bs_drawn[i];
          selected_order_lost[num_selected]=bs_lost[i];
          selected[num_selected++]=book_moves[i];
        }
 


    if (!num_selected)
      for (i=0;i<nmoves;i++) {
        selected_status[num_selected]=book_status[i];
        selected_order_won[num_selected]=bs_won[i];
        selected_order_drawn[num_selected]=bs_drawn[i];
        selected_order_lost[num_selected]=bs_lost[i];
        selected[num_selected++]=book_moves[i];
      }
    if (!num_selected) return(0);
 


    for (i=0;i<num_selected;i++) {
      book_status[i]=selected_status[i];
      book_moves[i]=selected[i];
      bs_won[i]=selected_order_won[i];
      bs_drawn[i]=selected_order_drawn[i];
      bs_lost[i]=selected_order_lost[i];
    }
    nmoves=num_selected;
    if (nmoves == 0) return(0);

    Print(128,"               book moves {");
    for (i=0;i<nmoves;i++) {
      Print(128,"%s", OutputMove(&book_moves[i],1,wtm));
      if (i < nmoves-1) Print(128,", ");
    }
    Print(128,"}\n");
    nmoves= ((( nmoves ) < ( book_selection_width )) ? ( nmoves ) : ( book_selection_width )) ;
    if (show_book) {
      Print(128,"               moves considered {");
      for (i=0;i<nmoves;i++) {
        Print(128,"%s", OutputMove(&book_moves[i],1,wtm));
        if (i < nmoves-1) Print(128,", ");
      }
      Print(128,"}\n");
    }
 








    if (nmoves) {
      np=bs_won[nmoves-1]+
         bs_drawn[nmoves-1]+bs_lost[nmoves-1];
      if (!puzzling && (!book_random ||
                       (mode==tournament_mode && np<book_search_trigger))) {
        if (!forced) {
          for (i=0;i<nmoves;i++) *(last[0]+i)=book_moves[i];
          last[1]=last[0]+nmoves;
          last_pv.path_iteration_depth=0;
          booking=1;
          value=Iterate(wtm,booking,1);
          booking=0;
          if (value < -50) {
            last_pv.path_iteration_depth=0;
            return(0);
          }
        }
        else {
          pv[1].path[1]=book_moves[0];
          pv[1].path_length=1;
        }
        return(1);
      }
    }
 










    else if (mode==tournament_mode && puzzling && !auto232) {
      RootMoveList(wtm);
      for (i=0;i<(last[1]-last[0]);i++)
        for (j=0;j<nmoves;j++)
          if (*(last[0]+i)==book_moves[j]) *(last[0]+i)=0;
      for (i=0,j=0;i<(last[1]-last[0]);i++)
        if (*(last[0]+i) != 0) *(last[0]+j++)=*(last[0]+i);
      last[1]=last[0]+j;
      Print(128,"               moves considered {only non-book moves}\n");
      nmoves=j;
      if (nmoves > 1) {
        last_pv.path_iteration_depth=0;
        booking=1;
        (void) Iterate(wtm,booking,1);
        booking=0;
      }
      else {
        pv[1].path[1]=book_moves[0];
        pv[1].path_length=1;
      }
      return(1);
    }
    last_move=nmoves;
 








    which=Random32();
    j=ReadClock(microseconds)/100 % 13;
    for (i=0;i<j;i++) which=Random32();
    total_moves=0;
    for (i=0;i<last_move;i++) total_moves+=bs_value[i];
    distribution=abs(which) % ((( total_moves ) > ( 1 )) ? ( total_moves ) : ( 1 )) ;
    for (which=0;which<last_move;which++) {
      distribution-=bs_value[which];
      if (distribution < 0) break;
    }
    which= ((( which ) < ( last_move-1 )) ? ( which ) : ( last_move-1 )) ;
    pv[1].path[1]=book_moves[which];
    percent_played=100*(bs_won[which]+bs_drawn[which]+
                        bs_lost[which])/ ((( total_played ) > ( 1 )) ? ( total_played ) : ( 1 )) ;
    total_played=bs_won[which]+bs_drawn[which];
    m1_status=book_status[which];
    pv[1].path_length=1;
    MakeMove(1,book_moves[which],wtm);
    UnMakeMove(1,book_moves[which],wtm);
    Print(128,"               book   0.0s    %3d%%   ", percent_played);
    Print(128," %s",OutputMove(&pv[1].path[1],1,wtm));
    st=m1_status & book_accept_mask & (~224);
    if (st) {
      if (st & 1) Print(128,"??");
      else if (st & 2) Print(128,"?");
      else if (st & 4) Print(128,"=");
      else if (st & 8) Print(128,"!");
      else if (st & 16) Print(128,"!!");
      else {
        st=st>>5;
        Print(128,"/");
        for (j=0;j<11;j++) {
          if (st & 1) Print(128,"%c",ch[j]);
          st=st>>1;
        }
      }
    }
    Print(128,"\n");
    return(1);
  }
  return(0);
}
-------------------------------------------------------------------------
|   Feith Systems  |   Voice: 1-215-646-8000  |  Email: john@feith.com  |
|    John Wehle    |     Fax: 1-215-540-5495  |                         |
-------------------------------------------------------------------------



Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]