diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..86072ca4470ff03814b0dace044f13e305ceb4f2 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.zst filter=lfs diff=lfs merge=lfs -text
*tfevents* filter=lfs diff=lfs merge=lfs -text
+stockfish-4-win/Windows/stockfish_4_32bit.exe filter=lfs diff=lfs merge=lfs -text
+stockfish-4-win/Windows/stockfish_4_x64_modern_sse42.exe filter=lfs diff=lfs merge=lfs -text
+stockfish-4-win/Windows/stockfish_4_x64_modern.exe filter=lfs diff=lfs merge=lfs -text
+stockfish-4-win/Windows/stockfish_4_x64.exe filter=lfs diff=lfs merge=lfs -text
diff --git a/stockfish-4-win/.DS_Store b/stockfish-4-win/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..11c5d585b1893b91d81ef2f3111591f675ac19aa
Binary files /dev/null and b/stockfish-4-win/.DS_Store differ
diff --git a/stockfish-4-win/Copying.txt b/stockfish-4-win/Copying.txt
new file mode 100644
index 0000000000000000000000000000000000000000..818433ecc0e094a4db1023c68b33f24344643ad8
--- /dev/null
+++ b/stockfish-4-win/Copying.txt
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ Copyright (C)
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+.
diff --git a/stockfish-4-win/Readme.md b/stockfish-4-win/Readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..5ea7a2c793ce1564293908ad811d764fba3eecf8
--- /dev/null
+++ b/stockfish-4-win/Readme.md
@@ -0,0 +1,70 @@
+### Overview
+
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
+not a complete chess program and requires some UCI-compatible GUI
+(e.g. XBoard with PolyGlot, eboard, Arena, Sigma Chess, Shredder, Chess
+Partner or Fritz) in order to be used comfortably. Read the
+documentation for your GUI of choice for information about how to use
+Stockfish with it.
+
+This version of Stockfish supports up to 64 CPUs. The engine defaults
+to one search thread it is therefore recommended to inspect the value of
+the *Threads* UCI parameter, and to make sure it equals the number of CPU
+cores on your computer.
+
+
+### Files
+
+This distribution of Stockfish consists of the following files:
+
+ * Readme.md, the file you are currently reading.
+
+ * Copying.txt, a text file containing the GNU General Public License.
+
+ * src, a subdirectory containing the full source code, including a Makefile
+ that can be used to compile Stockfish on Unix-like systems. For further
+ information about how to compile Stockfish yourself read section below.
+
+ * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
+ adapter.
+
+
+### Opening books
+
+This version of Stockfish has support for PolyGlot opening books. For
+information about how to create such books, consult the PolyGlot
+documentation. The book file can be selected by setting the *Book File*
+UCI parameter.
+
+
+### Compiling it yourself
+
+On Unix-like systems, it should be possible to compile Stockfish
+directly from the source code with the included Makefile.
+
+Stockfish has support for 32 or 64-bit CPUs, the hardware POPCNT
+instruction, big-endian machines such as Power PC, and other platforms.
+
+In general it is recommended to run `make help` to see a list of make
+targets with corresponding descriptions. When not using Makefile to
+compile (for instance with Microsoft MSVC) you need to manually
+set/unset some switches in the compiler command line; see file *types.h*
+for a quick reference.
+
+
+### Terms of use
+
+Stockfish is free, and distributed under the **GNU General Public License**
+(GPL). Essentially, this means that you are free to do almost exactly
+what you want with the program, including distributing it among your
+friends, making it available for download from your web site, selling
+it (either by itself or as part of some bigger software package), or
+using it as the starting point for a software project of your own.
+
+The only real limitation is that whenever you distribute Stockfish in
+some way, you must always include the full source code, or a pointer
+to where the source code can be found. If you make any changes to the
+source code, these changes must also be made available under the GPL.
+
+For full details, read the copy of the GPL found in the file named
+*Copying.txt*
diff --git a/stockfish-4-win/Windows/stockfish_4_32bit.exe b/stockfish-4-win/Windows/stockfish_4_32bit.exe
new file mode 100644
index 0000000000000000000000000000000000000000..00a8bf0e58b8af58619f475b9af4be0d21594000
--- /dev/null
+++ b/stockfish-4-win/Windows/stockfish_4_32bit.exe
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48d7df295a019b0e84310e8b0264153e1b6e14808996191212115282ee38b9a6
+size 860672
diff --git a/stockfish-4-win/Windows/stockfish_4_x64.exe b/stockfish-4-win/Windows/stockfish_4_x64.exe
new file mode 100644
index 0000000000000000000000000000000000000000..11e9c5d0573ea5d753a8bb8a75d4e5f029057cb2
--- /dev/null
+++ b/stockfish-4-win/Windows/stockfish_4_x64.exe
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41403082407022143f8b981d0e1b4e32f75101d7c7a9d440da9fbda9e3ae77bd
+size 1051648
diff --git a/stockfish-4-win/Windows/stockfish_4_x64_modern.exe b/stockfish-4-win/Windows/stockfish_4_x64_modern.exe
new file mode 100644
index 0000000000000000000000000000000000000000..c0d9ca0d450c81e1ca9b4c58cc3179da43768af6
--- /dev/null
+++ b/stockfish-4-win/Windows/stockfish_4_x64_modern.exe
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4a70a652171e2d55f3d0fcafe5bb1c88afd82645ad3b4cd03a589c71ebac85e
+size 1046528
diff --git a/stockfish-4-win/Windows/stockfish_4_x64_modern_sse42.exe b/stockfish-4-win/Windows/stockfish_4_x64_modern_sse42.exe
new file mode 100644
index 0000000000000000000000000000000000000000..63d66f1ec47df252e096b18aaeef7ff1b1e8da48
--- /dev/null
+++ b/stockfish-4-win/Windows/stockfish_4_x64_modern_sse42.exe
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3920c8b7e541c61e9eb4863b1599e47a4e4b01718835bcf8b79097632cd56de
+size 1046528
diff --git a/stockfish-4-win/logo.bmp b/stockfish-4-win/logo.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..a3c59a7022419ced13e52af5de517eb0f5bd95c0
Binary files /dev/null and b/stockfish-4-win/logo.bmp differ
diff --git a/stockfish-4-win/polyglot.ini b/stockfish-4-win/polyglot.ini
new file mode 100644
index 0000000000000000000000000000000000000000..26320f4d9ea5cabecb15156e64120c73f8fc8a70
--- /dev/null
+++ b/stockfish-4-win/polyglot.ini
@@ -0,0 +1,47 @@
+[PolyGlot]
+
+EngineDir = .
+EngineCommand = ./stockfish
+
+Book = false
+BookFile = book.bin
+
+Log = false
+LogFile = stockfish.log
+
+Resign = true
+ResignScore = 600
+
+[Engine]
+
+Write Debug Log = false
+Write Search Log = false
+Search Log Filename = SearchLog.txt
+Book File = book.bin
+Best Book Move = false
+Contempt Factor = 0
+Mobility (Midgame) = 100
+Mobility (Endgame) = 100
+Pawn Structure (Midgame) = 100
+Pawn Structure (Endgame) = 100
+Passed Pawns (Midgame) = 100
+Passed Pawns (Endgame) = 100
+Space = 100
+Aggressiveness = 100
+Cowardice = 100
+Min Split Depth = 0
+Max Threads per Split Point = 5
+Threads = 1
+Idle Threads Sleep = false
+Hash = 128
+Ponder = true
+OwnBook = false
+MultiPV = 1
+Skill Level = 20
+Emergency Move Horizon = 40
+Emergency Base Time = 200
+Emergency Move Time = 70
+Minimum Thinking Time = 20
+Slow Mover = 100
+UCI_Chess960 = false
+UCI_AnalyseMode = false
diff --git a/stockfish-4-win/src/Makefile b/stockfish-4-win/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..f8d65ccb32eddc33395199087984a3145b784aa0
--- /dev/null
+++ b/stockfish-4-win/src/Makefile
@@ -0,0 +1,565 @@
+# Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+# Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+# Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+#
+# Stockfish is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Stockfish is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see .
+
+
+### ==========================================================================
+### Section 1. General Configuration
+### ==========================================================================
+
+### Establish the operating system name
+UNAME = $(shell uname)
+
+### Executable name
+EXE = stockfish
+
+### Installation dir definitions
+PREFIX = /usr/local
+# Haiku has a non-standard filesystem layout
+ifeq ($(UNAME),Haiku)
+ PREFIX=/boot/common
+endif
+BINDIR = $(PREFIX)/bin
+
+### Built-in benchmark for pgo-builds and signature
+PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+SIGNBENCH = ./$(EXE) bench
+
+### Object files
+OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
+ material.o misc.o movegen.o movepick.o notation.o pawns.o position.o \
+ search.o thread.o timeman.o tt.o uci.o ucioption.o
+
+### ==========================================================================
+### Section 2. High-level Configuration
+### ==========================================================================
+#
+# flag --- Comp switch --- Description
+# ----------------------------------------------------------------------------
+#
+# debug = yes/no --- -DNDEBUG --- Enable/Disable debug mode
+# optimize = yes/no --- (-O3/-fast etc.) --- Enable/Disable optimizations
+# arch = (name) --- (-arch) --- Target architecture
+# os = (name) --- --- Target operating system
+# bits = 64/32 --- -DIS_64BIT --- 64-/32-bit operating system
+# prefetch = yes/no --- -DUSE_PREFETCH --- Use prefetch x86 asm-instruction
+# bsfq = yes/no --- -DUSE_BSFQ --- Use bsfq x86_64 asm-instruction (only
+# with GCC and ICC 64-bit)
+# popcnt = yes/no --- -DUSE_POPCNT --- Use popcnt x86_64 asm-instruction
+# sse = yes/no --- -msse --- Use Intel Streaming SIMD Extensions
+#
+# Note that Makefile is space sensitive, so when adding new architectures
+# or modifying existing flags, you have to make sure there are no extra spaces
+# at the end of the line for flag values.
+
+### 2.1. General
+debug = no
+optimize = yes
+
+### 2.2 Architecture specific
+
+# General-section
+ifeq ($(ARCH),general-64)
+ arch = any
+ os = any
+ bits = 64
+ prefetch = no
+ bsfq = no
+ popcnt = no
+ sse = no
+endif
+
+ifeq ($(ARCH),general-32)
+ arch = any
+ os = any
+ bits = 32
+ prefetch = no
+ bsfq = no
+ popcnt = no
+ sse = no
+endif
+
+# x86-section
+ifeq ($(ARCH),x86-64)
+ arch = x86_64
+ os = any
+ bits = 64
+ prefetch = yes
+ bsfq = yes
+ popcnt = no
+ sse = yes
+endif
+
+ifeq ($(ARCH),x86-64-modern)
+ arch = x86_64
+ os = any
+ bits = 64
+ prefetch = yes
+ bsfq = yes
+ popcnt = yes
+ sse = yes
+endif
+
+ifeq ($(ARCH),x86-32)
+ arch = i386
+ os = any
+ bits = 32
+ prefetch = yes
+ bsfq = no
+ popcnt = no
+ sse = yes
+endif
+
+ifeq ($(ARCH),x86-32-old)
+ arch = i386
+ os = any
+ bits = 32
+ prefetch = no
+ bsfq = no
+ popcnt = no
+ sse = no
+endif
+
+#arm section
+ifeq ($(ARCH),armv7)
+ arch = armv7
+ os = any
+ bits = 32
+ prefetch = yes
+ bsfq = yes
+ popcnt = no
+ sse = no
+endif
+
+# osx-section
+ifeq ($(ARCH),osx-ppc-64)
+ arch = ppc64
+ os = osx
+ bits = 64
+ prefetch = no
+ bsfq = no
+ popcnt = no
+ sse = no
+endif
+
+ifeq ($(ARCH),osx-ppc-32)
+ arch = ppc
+ os = osx
+ bits = 32
+ prefetch = no
+ bsfq = no
+ popcnt = no
+ sse = no
+endif
+
+ifeq ($(ARCH),osx-x86-64)
+ arch = x86_64
+ os = osx
+ bits = 64
+ prefetch = yes
+ bsfq = yes
+ popcnt = no
+ sse = yes
+endif
+
+ifeq ($(ARCH),osx-x86-32)
+ arch = i386
+ os = osx
+ bits = 32
+ prefetch = yes
+ bsfq = no
+ popcnt = no
+ sse = yes
+endif
+
+
+### ==========================================================================
+### Section 3. Low-level configuration
+### ==========================================================================
+
+### 3.1 Selecting compiler (default = gcc)
+ifeq ($(COMP),)
+ COMP=gcc
+endif
+
+ifeq ($(COMP),mingw)
+ comp=mingw
+ CXX=g++
+ profile_prepare = gcc-profile-prepare
+ profile_make = gcc-profile-make
+ profile_use = gcc-profile-use
+ profile_clean = gcc-profile-clean
+endif
+
+ifeq ($(COMP),gcc)
+ comp=gcc
+ CXX=g++
+ profile_prepare = gcc-profile-prepare
+ profile_make = gcc-profile-make
+ profile_use = gcc-profile-use
+ profile_clean = gcc-profile-clean
+endif
+
+ifeq ($(COMP),icc)
+ comp=icc
+ CXX=icpc
+ profile_prepare = icc-profile-prepare
+ profile_make = icc-profile-make
+ profile_use = icc-profile-use
+ profile_clean = icc-profile-clean
+endif
+
+ifeq ($(COMP),clang)
+ comp=clang
+ CXX=clang++
+ profile_prepare = gcc-profile-prepare
+ profile_make = gcc-profile-make
+ profile_use = gcc-profile-use
+ profile_clean = gcc-profile-clean
+endif
+
+### 3.2 General compiler settings
+CXXFLAGS = -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+
+ifeq ($(comp),gcc)
+ CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
+endif
+
+ifeq ($(comp),mingw)
+ CXXFLAGS += -Wextra -Wshadow
+endif
+
+ifeq ($(comp),icc)
+ CXXFLAGS += -wd383,981,1418,1419,1476,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+endif
+
+ifeq ($(comp),clang)
+ CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
+endif
+
+ifeq ($(os),osx)
+ CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.0
+endif
+
+### 3.3 General linker settings
+LDFLAGS = $(EXTRALDFLAGS)
+
+ifeq ($(comp),mingw)
+ LDFLAGS += -static-libstdc++ -static-libgcc
+endif
+
+### On mingw use Windows threads, otherwise POSIX
+ifneq ($(comp),mingw)
+ # Haiku has pthreads in its libroot, so only link it in on other platforms
+ ifneq ($(UNAME),Haiku)
+ LDFLAGS += -lpthread
+ endif
+endif
+
+ifeq ($(os),osx)
+ LDFLAGS += -arch $(arch) -mmacosx-version-min=10.0
+endif
+
+### 3.4 Debugging
+ifeq ($(debug),no)
+ CXXFLAGS += -DNDEBUG
+else
+ CXXFLAGS += -g
+endif
+
+### 3.5 Optimization
+ifeq ($(optimize),yes)
+
+ ifeq ($(comp),gcc)
+ CXXFLAGS += -O3
+
+ ifeq ($(os),osx)
+ ifeq ($(arch),i386)
+ CXXFLAGS += -mdynamic-no-pic
+ endif
+ ifeq ($(arch),x86_64)
+ CXXFLAGS += -mdynamic-no-pic
+ endif
+ endif
+
+ ifeq ($(arch),armv7)
+ CXXFLAGS += -fno-gcse
+ endif
+ endif
+
+ ifeq ($(comp),mingw)
+ CXXFLAGS += -O3
+ endif
+
+ ifeq ($(comp),icc)
+ ifeq ($(os),osx)
+ CXXFLAGS += -fast -mdynamic-no-pic
+ else
+ CXXFLAGS += -O3
+ endif
+ endif
+
+ ifeq ($(comp),clang)
+ ### -O4 requires a linker that supports LLVM's LTO
+ CXXFLAGS += -O3
+
+ ifeq ($(os),osx)
+ ifeq ($(arch),i386)
+ CXXFLAGS += -mdynamic-no-pic
+ endif
+ ifeq ($(arch),x86_64)
+ CXXFLAGS += -mdynamic-no-pic
+ endif
+ endif
+ endif
+endif
+
+### 3.6. Bits
+ifeq ($(bits),64)
+ CXXFLAGS += -DIS_64BIT
+endif
+
+### 3.7 prefetch
+ifeq ($(prefetch),yes)
+ ifeq ($(sse),yes)
+ CXXFLAGS += -msse
+ DEPENDFLAGS += -msse
+ endif
+else
+ CXXFLAGS += -DNO_PREFETCH
+endif
+
+### 3.8 bsfq
+ifeq ($(bsfq),yes)
+ CXXFLAGS += -DUSE_BSFQ
+endif
+
+### 3.9 popcnt
+ifeq ($(popcnt),yes)
+ CXXFLAGS += -msse3 -DUSE_POPCNT
+endif
+
+### 3.10 Link Time Optimization, it works since gcc 4.5 but not on mingw.
+### This is a mix of compile and link time options because the lto link phase
+### needs access to the optimization flags.
+ifeq ($(comp),gcc)
+ ifeq ($(optimize),yes)
+ ifeq ($(debug),no)
+ GCC_MAJOR := `$(CXX) -dumpversion | cut -f1 -d.`
+ GCC_MINOR := `$(CXX) -dumpversion | cut -f2 -d.`
+ ifeq (1,$(shell expr \( $(GCC_MAJOR) \> 4 \) \| \( $(GCC_MAJOR) \= 4 \& $(GCC_MINOR) \>= 5 \)))
+ CXXFLAGS += -flto
+ LDFLAGS += $(CXXFLAGS)
+ endif
+ endif
+ endif
+endif
+
+### ==========================================================================
+### Section 4. Public targets
+### ==========================================================================
+
+help:
+ @echo ""
+ @echo "To compile stockfish, type: "
+ @echo ""
+ @echo "make target ARCH=arch [COMP=comp]"
+ @echo ""
+ @echo "Supported targets:"
+ @echo ""
+ @echo "build > Standard build"
+ @echo "signature-build > Standard build with embedded signature"
+ @echo "profile-build > PGO build"
+ @echo "signature-profile-build > PGO build with embedded signature"
+ @echo "strip > Strip executable"
+ @echo "install > Install executable"
+ @echo "clean > Clean up"
+ @echo ""
+ @echo "Supported archs:"
+ @echo ""
+ @echo "x86-64 > x86 64-bit"
+ @echo "x86-64-modern > x86 64-bit with popcnt support"
+ @echo "x86-32 > x86 32-bit with SSE support"
+ @echo "x86-32-old > x86 32-bit fall back for old hardware"
+ @echo "osx-ppc-64 > PPC-Mac OS X 64 bit"
+ @echo "osx-ppc-32 > PPC-Mac OS X 32 bit"
+ @echo "osx-x86-64 > x86-Mac OS X 64 bit"
+ @echo "osx-x86-32 > x86-Mac OS X 32 bit"
+ @echo "armv7 > ARMv7 32 bit"
+ @echo "general-64 > unspecified 64-bit"
+ @echo "general-32 > unspecified 32-bit"
+ @echo ""
+ @echo "Supported compilers:"
+ @echo ""
+ @echo "gcc > Gnu compiler (default)"
+ @echo "mingw > Gnu compiler with MinGW under Windows"
+ @echo "clang > LLVM Clang compiler"
+ @echo "icc > Intel compiler"
+ @echo ""
+ @echo "Non-standard targets:"
+ @echo ""
+ @echo "make hpux > Compile for HP-UX. Compiler = aCC"
+ @echo ""
+ @echo "Examples. If you don't know what to do, you likely want to run: "
+ @echo ""
+ @echo "make build ARCH=x86-64 (This is for 64-bit systems)"
+ @echo "make build ARCH=x86-32 (This is for 32-bit systems)"
+ @echo ""
+
+.PHONY: build profile-build embed-signature
+build:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+profile-build:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+ @echo ""
+ @echo "Step 0/4. Preparing for profile build."
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
+ @echo ""
+ @echo "Step 1/4. Building executable for benchmark ..."
+ @touch *.cpp *.h
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
+ @echo ""
+ @echo "Step 2/4. Running benchmark for pgo-build ..."
+ @$(PGOBENCH) > /dev/null
+ @echo ""
+ @echo "Step 3/4. Building final executable ..."
+ @touch *.cpp
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
+ @echo ""
+ @echo "Step 4/4. Deleting profile data ..."
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
+
+embed-signature:
+ @echo "Running benchmark for getting the signature ..."
+ @$(SIGNBENCH) 2>&1 | sed -n 's/Nodes searched : \(.*\)/\/string Version\/s\/"\\(.*\\)"\/"sig-\1"\//p' > sign.txt
+ @sed -f sign.txt misc.cpp > misc2.cpp
+ @mv misc2.cpp misc.cpp
+ @rm sign.txt
+
+signature-build: build embed-signature
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+signature-profile-build: build embed-signature profile-build
+
+strip:
+ strip $(EXE)
+
+install:
+ -mkdir -p -m 755 $(BINDIR)
+ -cp $(EXE) $(BINDIR)
+ -strip $(BINDIR)/$(EXE)
+
+clean:
+ $(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
+
+default:
+ help
+
+### ==========================================================================
+### Section 5. Private targets
+### ==========================================================================
+
+all: $(EXE) .depend
+
+config-sanity:
+ @echo ""
+ @echo "Config:"
+ @echo "debug: '$(debug)'"
+ @echo "optimize: '$(optimize)'"
+ @echo "arch: '$(arch)'"
+ @echo "os: '$(os)'"
+ @echo "bits: '$(bits)'"
+ @echo "prefetch: '$(prefetch)'"
+ @echo "bsfq: '$(bsfq)'"
+ @echo "popcnt: '$(popcnt)'"
+ @echo "sse: '$(sse)'"
+ @echo ""
+ @echo "Flags:"
+ @echo "CXX: $(CXX)"
+ @echo "CXXFLAGS: $(CXXFLAGS)"
+ @echo "LDFLAGS: $(LDFLAGS)"
+ @echo ""
+ @echo "Testing config sanity. If this fails, try 'make help' ..."
+ @echo ""
+ @test "$(debug)" = "yes" || test "$(debug)" = "no"
+ @test "$(optimize)" = "yes" || test "$(optimize)" = "no"
+ @test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
+ test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7"
+ @test "$(os)" = "any" || test "$(os)" = "osx"
+ @test "$(bits)" = "32" || test "$(bits)" = "64"
+ @test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
+ @test "$(bsfq)" = "yes" || test "$(bsfq)" = "no"
+ @test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
+ @test "$(sse)" = "yes" || test "$(sse)" = "no"
+ @test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang"
+
+$(EXE): $(OBJS)
+ $(CXX) -o $@ $(OBJS) $(LDFLAGS)
+
+gcc-profile-prepare:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) gcc-profile-clean
+
+gcc-profile-make:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-fprofile-generate' \
+ EXTRALDFLAGS='-lgcov' \
+ all
+
+gcc-profile-use:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-fprofile-use' \
+ EXTRALDFLAGS='-lgcov' \
+ all
+
+gcc-profile-clean:
+ @rm -rf *.gcda *.gcno bench.txt
+
+icc-profile-prepare:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) icc-profile-clean
+ @mkdir profdir
+
+icc-profile-make:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \
+ all
+
+icc-profile-use:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
+ all
+
+icc-profile-clean:
+ @rm -rf profdir bench.txt
+
+.depend:
+ -@$(CXX) $(DEPENDFLAGS) -MM $(OBJS:.o=.cpp) > $@ 2> /dev/null
+
+-include .depend
+
+
+### ==========================================================================
+### Section 6. Non-standard targets
+### ==========================================================================
+
+hpux:
+ $(MAKE) \
+ CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -mt +O3 -DNDEBUG -DNO_PREFETCH' \
+ CXXFLAGS="" \
+ LDFLAGS="" \
+ all
+
diff --git a/stockfish-4-win/src/benchmark.cpp b/stockfish-4-win/src/benchmark.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f22ea6dada5d2ca7246039d45454c9e5e7e01a63
--- /dev/null
+++ b/stockfish-4-win/src/benchmark.cpp
@@ -0,0 +1,145 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+#include
+#include
+
+#include "misc.h"
+#include "position.h"
+#include "search.h"
+#include "thread.h"
+#include "tt.h"
+#include "ucioption.h"
+
+using namespace std;
+
+static const char* Defaults[] = {
+ "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+ "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10",
+ "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 11",
+ "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
+ "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14",
+ "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14",
+ "r3r1k1/2p2ppp/p1p1bn2/8/1q2P3/2NPQN2/PPP3PP/R4RK1 b - - 2 15",
+ "r1bbk1nr/pp3p1p/2n5/1N4p1/2Np1B2/8/PPP2PPP/2KR1B1R w kq - 0 13",
+ "r1bq1rk1/ppp1nppp/4n3/3p3Q/3P4/1BP1B3/PP1N2PP/R4RK1 w - - 1 16",
+ "4r1k1/r1q2ppp/ppp2n2/4P3/5Rb1/1N1BQ3/PPP3PP/R5K1 w - - 1 17",
+ "2rqkb1r/ppp2p2/2npb1p1/1N1Nn2p/2P1PP2/8/PP2B1PP/R1BQK2R b KQ - 0 11",
+ "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16",
+ "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
+ "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
+ "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
+ "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
+};
+
+
+/// benchmark() runs a simple benchmark by letting Stockfish analyze a set
+/// of positions for a given limit each. There are five parameters; the
+/// transposition table size, the number of search threads that should
+/// be used, the limit value spent for each position (optional, default is
+/// depth 12), an optional file name where to look for positions in fen
+/// format (defaults are the positions defined above) and the type of the
+/// limit value: depth (default), time in secs or number of nodes.
+
+void benchmark(const Position& current, istream& is) {
+
+ string token;
+ Search::LimitsType limits;
+ vector fens;
+
+ // Assign default values to missing arguments
+ string ttSize = (is >> token) ? token : "32";
+ string threads = (is >> token) ? token : "1";
+ string limit = (is >> token) ? token : "12";
+ string fenFile = (is >> token) ? token : "default";
+ string limitType = (is >> token) ? token : "depth";
+
+ Options["Hash"] = ttSize;
+ Options["Threads"] = threads;
+ TT.clear();
+
+ if (limitType == "time")
+ limits.movetime = 1000 * atoi(limit.c_str()); // movetime is in ms
+
+ else if (limitType == "nodes")
+ limits.nodes = atoi(limit.c_str());
+
+ else if (limitType == "mate")
+ limits.mate = atoi(limit.c_str());
+
+ else
+ limits.depth = atoi(limit.c_str());
+
+ if (fenFile == "default")
+ fens.assign(Defaults, Defaults + 16);
+
+ else if (fenFile == "current")
+ fens.push_back(current.fen());
+
+ else
+ {
+ string fen;
+ ifstream file(fenFile.c_str());
+
+ if (!file.is_open())
+ {
+ cerr << "Unable to open file " << fenFile << endl;
+ return;
+ }
+
+ while (getline(file, fen))
+ if (!fen.empty())
+ fens.push_back(fen);
+
+ file.close();
+ }
+
+ int64_t nodes = 0;
+ Search::StateStackPtr st;
+ Time::point elapsed = Time::now();
+
+ for (size_t i = 0; i < fens.size(); i++)
+ {
+ Position pos(fens[i], Options["UCI_Chess960"], Threads.main());
+
+ cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
+
+ if (limitType == "perft")
+ {
+ size_t cnt = Search::perft(pos, limits.depth * ONE_PLY);
+ cerr << "\nPerft " << limits.depth << " leaf nodes: " << cnt << endl;
+ nodes += cnt;
+ }
+ else
+ {
+ Threads.start_thinking(pos, limits, vector(), st);
+ Threads.wait_for_think_finished();
+ nodes += Search::RootPos.nodes_searched();
+ }
+ }
+
+ elapsed = Time::now() - elapsed + 1; // Assure positive to avoid a 'divide by zero'
+
+ cerr << "\n==========================="
+ << "\nTotal time (ms) : " << elapsed
+ << "\nNodes searched : " << nodes
+ << "\nNodes/second : " << 1000 * nodes / elapsed << endl;
+}
diff --git a/stockfish-4-win/src/bitbase.cpp b/stockfish-4-win/src/bitbase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..570a9771419099aec3bc929b469a1b0b598e61dd
--- /dev/null
+++ b/stockfish-4-win/src/bitbase.cpp
@@ -0,0 +1,175 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+
+#include "bitboard.h"
+#include "types.h"
+
+namespace {
+
+ // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
+ const unsigned IndexMax = 2*24*64*64; // stm * psq * wksq * bksq = 196608
+
+ // Each uint32_t stores results of 32 positions, one per bit
+ uint32_t KPKBitbase[IndexMax / 32];
+
+ // A KPK bitbase index is an integer in [0, IndexMax] range
+ //
+ // Information is mapped in a way that minimizes number of iterations:
+ //
+ // bit 0- 5: white king square (from SQ_A1 to SQ_H8)
+ // bit 6-11: black king square (from SQ_A1 to SQ_H8)
+ // bit 12: side to move (WHITE or BLACK)
+ // bit 13-14: white pawn file (from FILE_A to FILE_D)
+ // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
+ unsigned index(Color us, Square bksq, Square wksq, Square psq) {
+ return wksq + (bksq << 6) + (us << 12) + (file_of(psq) << 13) + ((RANK_7 - rank_of(psq)) << 15);
+ }
+
+ enum Result {
+ INVALID = 0,
+ UNKNOWN = 1,
+ DRAW = 2,
+ WIN = 4
+ };
+
+ inline Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
+
+ struct KPKPosition {
+
+ operator Result() const { return res; }
+ Result classify_leaf(unsigned idx);
+ Result classify(const std::vector& db)
+ { return us == WHITE ? classify(db) : classify(db); }
+
+ private:
+ template Result classify(const std::vector& db);
+
+ Color us;
+ Square bksq, wksq, psq;
+ Result res;
+ };
+
+} // namespace
+
+
+bool Bitbases::probe_kpk(Square wksq, Square wpsq, Square bksq, Color us) {
+
+ assert(file_of(wpsq) <= FILE_D);
+
+ unsigned idx = index(us, bksq, wksq, wpsq);
+ return KPKBitbase[idx / 32] & (1 << (idx & 0x1F));
+}
+
+
+void Bitbases::init_kpk() {
+
+ unsigned idx, repeat = 1;
+ std::vector db(IndexMax);
+
+ // Initialize db with known win / draw positions
+ for (idx = 0; idx < IndexMax; idx++)
+ db[idx].classify_leaf(idx);
+
+ // Iterate through the positions until no more of the unknown positions can be
+ // changed to either wins or draws (15 cycles needed).
+ while (repeat)
+ for (repeat = idx = 0; idx < IndexMax; idx++)
+ if (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN)
+ repeat = 1;
+
+ // Map 32 results into one KPKBitbase[] entry
+ for (idx = 0; idx < IndexMax; idx++)
+ if (db[idx] == WIN)
+ KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);
+}
+
+
+namespace {
+
+ Result KPKPosition::classify_leaf(unsigned idx) {
+
+ wksq = Square((idx >> 0) & 0x3F);
+ bksq = Square((idx >> 6) & 0x3F);
+ us = Color ((idx >> 12) & 0x01);
+ psq = File ((idx >> 13) & 0x03) | Rank(RANK_7 - (idx >> 15));
+
+ // Check if two pieces are on the same square or if a king can be captured
+ if ( wksq == psq || wksq == bksq || bksq == psq
+ || (StepAttacksBB[KING][wksq] & bksq)
+ || (us == WHITE && (StepAttacksBB[PAWN][psq] & bksq)))
+ return res = INVALID;
+
+ if (us == WHITE)
+ {
+ // Immediate win if pawn can be promoted without getting captured
+ if ( rank_of(psq) == RANK_7
+ && wksq != psq + DELTA_N
+ && ( square_distance(bksq, psq + DELTA_N) > 1
+ ||(StepAttacksBB[KING][wksq] & (psq + DELTA_N))))
+ return res = WIN;
+ }
+ // Immediate draw if is stalemate or king captures undefended pawn
+ else if ( !(StepAttacksBB[KING][bksq] & ~(StepAttacksBB[KING][wksq] | StepAttacksBB[PAWN][psq]))
+ || (StepAttacksBB[KING][bksq] & psq & ~StepAttacksBB[KING][wksq]))
+ return res = DRAW;
+
+ return res = UNKNOWN;
+ }
+
+ template
+ Result KPKPosition::classify(const std::vector& db) {
+
+ // White to Move: If one move leads to a position classified as WIN, the result
+ // of the current position is WIN. If all moves lead to positions classified
+ // as DRAW, the current position is classified DRAW otherwise the current
+ // position is classified as UNKNOWN.
+ //
+ // Black to Move: If one move leads to a position classified as DRAW, the result
+ // of the current position is DRAW. If all moves lead to positions classified
+ // as WIN, the position is classified WIN otherwise the current position is
+ // classified UNKNOWN.
+
+ const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+ Result r = INVALID;
+ Bitboard b = StepAttacksBB[KING][Us == WHITE ? wksq : bksq];
+
+ while (b)
+ r |= Us == WHITE ? db[index(Them, bksq, pop_lsb(&b), psq)]
+ : db[index(Them, pop_lsb(&b), wksq, psq)];
+
+ if (Us == WHITE && rank_of(psq) < RANK_7)
+ {
+ Square s = psq + DELTA_N;
+ r |= db[index(BLACK, bksq, wksq, s)]; // Single push
+
+ if (rank_of(s) == RANK_3 && s != wksq && s != bksq)
+ r |= db[index(BLACK, bksq, wksq, s + DELTA_N)]; // Double push
+ }
+
+ if (Us == WHITE)
+ return res = r & WIN ? WIN : r & UNKNOWN ? UNKNOWN : DRAW;
+ else
+ return res = r & DRAW ? DRAW : r & UNKNOWN ? UNKNOWN : WIN;
+ }
+
+} // namespace
diff --git a/stockfish-4-win/src/bitboard.cpp b/stockfish-4-win/src/bitboard.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9598aa706552f5f38da88c50bc7b734dd6b35919
--- /dev/null
+++ b/stockfish-4-win/src/bitboard.cpp
@@ -0,0 +1,339 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+#include
+
+#include "bitboard.h"
+#include "bitcount.h"
+#include "misc.h"
+#include "rkiss.h"
+
+CACHE_LINE_ALIGNMENT
+
+Bitboard RMasks[SQUARE_NB];
+Bitboard RMagics[SQUARE_NB];
+Bitboard* RAttacks[SQUARE_NB];
+unsigned RShifts[SQUARE_NB];
+
+Bitboard BMasks[SQUARE_NB];
+Bitboard BMagics[SQUARE_NB];
+Bitboard* BAttacks[SQUARE_NB];
+unsigned BShifts[SQUARE_NB];
+
+Bitboard SquareBB[SQUARE_NB];
+Bitboard FileBB[FILE_NB];
+Bitboard RankBB[RANK_NB];
+Bitboard AdjacentFilesBB[FILE_NB];
+Bitboard InFrontBB[COLOR_NB][RANK_NB];
+Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+Bitboard DistanceRingsBB[SQUARE_NB][8];
+Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
+Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+
+int SquareDistance[SQUARE_NB][SQUARE_NB];
+
+namespace {
+
+ // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
+ const uint64_t DeBruijn_64 = 0x3F79D71B4CB0A89ULL;
+ const uint32_t DeBruijn_32 = 0x783A9B23;
+
+ CACHE_LINE_ALIGNMENT
+
+ int MS1BTable[256];
+ Square BSFTable[SQUARE_NB];
+ Bitboard RTable[0x19000]; // Storage space for rook attacks
+ Bitboard BTable[0x1480]; // Storage space for bishop attacks
+
+ typedef unsigned (Fn)(Square, Bitboard);
+
+ void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
+ Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
+
+ FORCE_INLINE unsigned bsf_index(Bitboard b) {
+
+ // Matt Taylor's folding for 32 bit systems, extended to 64 bits by Kim Walisch
+ b ^= (b - 1);
+ return Is64Bit ? (b * DeBruijn_64) >> 58
+ : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn_32) >> 26;
+ }
+}
+
+/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
+/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
+
+#ifndef USE_BSFQ
+
+Square lsb(Bitboard b) { return BSFTable[bsf_index(b)]; }
+
+Square pop_lsb(Bitboard* b) {
+
+ Bitboard bb = *b;
+ *b = bb & (bb - 1);
+ return BSFTable[bsf_index(bb)];
+}
+
+Square msb(Bitboard b) {
+
+ unsigned b32;
+ int result = 0;
+
+ if (b > 0xFFFFFFFF)
+ {
+ b >>= 32;
+ result = 32;
+ }
+
+ b32 = unsigned(b);
+
+ if (b32 > 0xFFFF)
+ {
+ b32 >>= 16;
+ result += 16;
+ }
+
+ if (b32 > 0xFF)
+ {
+ b32 >>= 8;
+ result += 8;
+ }
+
+ return (Square)(result + MS1BTable[b32]);
+}
+
+#endif // ifndef USE_BSFQ
+
+
+/// Bitboards::print() prints a bitboard in an easily readable format to the
+/// standard output. This is sometimes useful for debugging.
+
+void Bitboards::print(Bitboard b) {
+
+ sync_cout;
+
+ for (Rank rank = RANK_8; rank >= RANK_1; rank--)
+ {
+ std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
+
+ for (File file = FILE_A; file <= FILE_H; file++)
+ std::cout << "| " << (b & (file | rank) ? "X " : " ");
+
+ std::cout << "|\n";
+ }
+ std::cout << "+---+---+---+---+---+---+---+---+" << sync_endl;
+}
+
+
+/// Bitboards::init() initializes various bitboard arrays. It is called during
+/// program initialization.
+
+void Bitboards::init() {
+
+ for (int k = 0, i = 0; i < 8; i++)
+ while (k < (2 << i))
+ MS1BTable[k++] = i;
+
+ for (int i = 0; i < 64; i++)
+ BSFTable[bsf_index(1ULL << i)] = Square(i);
+
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ SquareBB[s] = 1ULL << s;
+
+ FileBB[FILE_A] = FileABB;
+ RankBB[RANK_1] = Rank1BB;
+
+ for (int i = 1; i < 8; i++)
+ {
+ FileBB[i] = FileBB[i - 1] << 1;
+ RankBB[i] = RankBB[i - 1] << 8;
+ }
+
+ for (File f = FILE_A; f <= FILE_H; f++)
+ AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
+
+ for (Rank r = RANK_1; r < RANK_8; r++)
+ InFrontBB[WHITE][r] = ~(InFrontBB[BLACK][r + 1] = InFrontBB[BLACK][r] | RankBB[r]);
+
+ for (Color c = WHITE; c <= BLACK; c++)
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ {
+ ForwardBB[c][s] = InFrontBB[c][rank_of(s)] & FileBB[file_of(s)];
+ PawnAttackSpan[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
+ PassedPawnMask[c][s] = ForwardBB[c][s] | PawnAttackSpan[c][s];
+ }
+
+ for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
+ for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+ {
+ SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
+ if (s1 != s2)
+ DistanceRingsBB[s1][SquareDistance[s1][s2] - 1] |= s2;
+ }
+
+ int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
+ {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
+
+ for (Color c = WHITE; c <= BLACK; c++)
+ for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ for (int k = 0; steps[pt][k]; k++)
+ {
+ Square to = s + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
+
+ if (is_ok(to) && square_distance(s, to) < 3)
+ StepAttacksBB[make_piece(c, pt)][s] |= to;
+ }
+
+ Square RDeltas[] = { DELTA_N, DELTA_E, DELTA_S, DELTA_W };
+ Square BDeltas[] = { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW };
+
+ init_magics(RTable, RAttacks, RMagics, RMasks, RShifts, RDeltas, magic_index);
+ init_magics(BTable, BAttacks, BMagics, BMasks, BShifts, BDeltas, magic_index);
+
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ {
+ PseudoAttacks[QUEEN][s] = PseudoAttacks[BISHOP][s] = attacks_bb(s, 0);
+ PseudoAttacks[QUEEN][s] |= PseudoAttacks[ ROOK][s] = attacks_bb< ROOK>(s, 0);
+ }
+
+ for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
+ for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+ if (PseudoAttacks[QUEEN][s1] & s2)
+ {
+ Square delta = (s2 - s1) / square_distance(s1, s2);
+
+ for (Square s = s1 + delta; s != s2; s += delta)
+ BetweenBB[s1][s2] |= s;
+ }
+}
+
+
+namespace {
+
+ Bitboard sliding_attack(Square deltas[], Square sq, Bitboard occupied) {
+
+ Bitboard attack = 0;
+
+ for (int i = 0; i < 4; i++)
+ for (Square s = sq + deltas[i];
+ is_ok(s) && square_distance(s, s - deltas[i]) == 1;
+ s += deltas[i])
+ {
+ attack |= s;
+
+ if (occupied & s)
+ break;
+ }
+
+ return attack;
+ }
+
+
+ Bitboard pick_random(RKISS& rk, int booster) {
+
+ // Values s1 and s2 are used to rotate the candidate magic of a
+ // quantity known to be the optimal to quickly find the magics.
+ int s1 = booster & 63, s2 = (booster >> 6) & 63;
+
+ Bitboard m = rk.rand();
+ m = (m >> s1) | (m << (64 - s1));
+ m &= rk.rand();
+ m = (m >> s2) | (m << (64 - s2));
+ return m & rk.rand();
+ }
+
+
+ // init_magics() computes all rook and bishop attacks at startup. Magic
+ // bitboards are used to look up attacks of sliding pieces. As a reference see
+ // chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
+ // use the so called "fancy" approach.
+
+ void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
+ Bitboard masks[], unsigned shifts[], Square deltas[], Fn index) {
+
+ int MagicBoosters[][8] = { { 3191, 2184, 1310, 3618, 2091, 1308, 2452, 3996 },
+ { 1059, 3608, 605, 3234, 3326, 38, 2029, 3043 } };
+ RKISS rk;
+ Bitboard occupancy[4096], reference[4096], edges, b;
+ int i, size, booster;
+
+ // attacks[s] is a pointer to the beginning of the attacks table for square 's'
+ attacks[SQ_A1] = table;
+
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ {
+ // Board edges are not considered in the relevant occupancies
+ edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));
+
+ // Given a square 's', the mask is the bitboard of sliding attacks from
+ // 's' computed on an empty board. The index must be big enough to contain
+ // all the attacks for each possible subset of the mask and so is 2 power
+ // the number of 1s of the mask. Hence we deduce the size of the shift to
+ // apply to the 64 or 32 bits word to get the index.
+ masks[s] = sliding_attack(deltas, s, 0) & ~edges;
+ shifts[s] = (Is64Bit ? 64 : 32) - popcount(masks[s]);
+
+ // Use Carry-Rippler trick to enumerate all subsets of masks[s] and
+ // store the corresponding sliding attack bitboard in reference[].
+ b = size = 0;
+ do {
+ occupancy[size] = b;
+ reference[size++] = sliding_attack(deltas, s, b);
+ b = (b - masks[s]) & masks[s];
+ } while (b);
+
+ // Set the offset for the table of the next square. We have individual
+ // table sizes for each square with "Fancy Magic Bitboards".
+ if (s < SQ_H8)
+ attacks[s + 1] = attacks[s] + size;
+
+ booster = MagicBoosters[Is64Bit][rank_of(s)];
+
+ // Find a magic for square 's' picking up an (almost) random number
+ // until we find the one that passes the verification test.
+ do {
+ do magics[s] = pick_random(rk, booster);
+ while (popcount((magics[s] * masks[s]) >> 56) < 6);
+
+ std::memset(attacks[s], 0, size * sizeof(Bitboard));
+
+ // A good magic must map every possible occupancy to an index that
+ // looks up the correct sliding attack in the attacks[s] database.
+ // Note that we build up the database for square 's' as a side
+ // effect of verifying the magic.
+ for (i = 0; i < size; i++)
+ {
+ Bitboard& attack = attacks[s][index(s, occupancy[i])];
+
+ if (attack && attack != reference[i])
+ break;
+
+ assert(reference[i] != 0);
+
+ attack = reference[i];
+ }
+ } while (i != size);
+ }
+ }
+}
diff --git a/stockfish-4-win/src/bitboard.h b/stockfish-4-win/src/bitboard.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc3ed87b623dab6ae9debb5d89a48df9e3ee68ee
--- /dev/null
+++ b/stockfish-4-win/src/bitboard.h
@@ -0,0 +1,322 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifndef BITBOARD_H_INCLUDED
+#define BITBOARD_H_INCLUDED
+
+#include "types.h"
+
+namespace Bitboards {
+
+void init();
+void print(Bitboard b);
+
+}
+
+namespace Bitbases {
+
+void init_kpk();
+bool probe_kpk(Square wksq, Square wpsq, Square bksq, Color us);
+
+}
+
+const Bitboard FileABB = 0x0101010101010101ULL;
+const Bitboard FileBBB = FileABB << 1;
+const Bitboard FileCBB = FileABB << 2;
+const Bitboard FileDBB = FileABB << 3;
+const Bitboard FileEBB = FileABB << 4;
+const Bitboard FileFBB = FileABB << 5;
+const Bitboard FileGBB = FileABB << 6;
+const Bitboard FileHBB = FileABB << 7;
+
+const Bitboard Rank1BB = 0xFF;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
+
+CACHE_LINE_ALIGNMENT
+
+extern Bitboard RMasks[SQUARE_NB];
+extern Bitboard RMagics[SQUARE_NB];
+extern Bitboard* RAttacks[SQUARE_NB];
+extern unsigned RShifts[SQUARE_NB];
+
+extern Bitboard BMasks[SQUARE_NB];
+extern Bitboard BMagics[SQUARE_NB];
+extern Bitboard* BAttacks[SQUARE_NB];
+extern unsigned BShifts[SQUARE_NB];
+
+extern Bitboard SquareBB[SQUARE_NB];
+extern Bitboard FileBB[FILE_NB];
+extern Bitboard RankBB[RANK_NB];
+extern Bitboard AdjacentFilesBB[FILE_NB];
+extern Bitboard InFrontBB[COLOR_NB][RANK_NB];
+extern Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard DistanceRingsBB[SQUARE_NB][8];
+extern Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
+extern Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+extern Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+
+extern int SquareDistance[SQUARE_NB][SQUARE_NB];
+
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
+
+/// Overloads of bitwise operators between a Bitboard and a Square for testing
+/// whether a given bit is set in a bitboard, and for setting and clearing bits.
+
+inline Bitboard operator&(Bitboard b, Square s) {
+ return b & SquareBB[s];
+}
+
+inline Bitboard& operator|=(Bitboard& b, Square s) {
+ return b |= SquareBB[s];
+}
+
+inline Bitboard& operator^=(Bitboard& b, Square s) {
+ return b ^= SquareBB[s];
+}
+
+inline Bitboard operator|(Bitboard b, Square s) {
+ return b | SquareBB[s];
+}
+
+inline Bitboard operator^(Bitboard b, Square s) {
+ return b ^ SquareBB[s];
+}
+
+inline bool more_than_one(Bitboard b) {
+ return b & (b - 1);
+}
+
+inline int square_distance(Square s1, Square s2) {
+ return SquareDistance[s1][s2];
+}
+
+inline int file_distance(Square s1, Square s2) {
+ return abs(file_of(s1) - file_of(s2));
+}
+
+inline int rank_distance(Square s1, Square s2) {
+ return abs(rank_of(s1) - rank_of(s2));
+}
+
+
+/// shift_bb() moves bitboard one step along direction Delta. Mainly for pawns.
+
+template
+inline Bitboard shift_bb(Bitboard b) {
+
+ return Delta == DELTA_N ? b << 8 : Delta == DELTA_S ? b >> 8
+ : Delta == DELTA_NE ? (b & ~FileHBB) << 9 : Delta == DELTA_SE ? (b & ~FileHBB) >> 7
+ : Delta == DELTA_NW ? (b & ~FileABB) << 7 : Delta == DELTA_SW ? (b & ~FileABB) >> 9
+ : 0;
+}
+
+
+/// rank_bb() and file_bb() take a file or a square as input and return
+/// a bitboard representing all squares on the given file or rank.
+
+inline Bitboard rank_bb(Rank r) {
+ return RankBB[r];
+}
+
+inline Bitboard rank_bb(Square s) {
+ return RankBB[rank_of(s)];
+}
+
+inline Bitboard file_bb(File f) {
+ return FileBB[f];
+}
+
+inline Bitboard file_bb(Square s) {
+ return FileBB[file_of(s)];
+}
+
+
+/// adjacent_files_bb() takes a file as input and returns a bitboard representing
+/// all squares on the adjacent files.
+
+inline Bitboard adjacent_files_bb(File f) {
+ return AdjacentFilesBB[f];
+}
+
+
+/// in_front_bb() takes a color and a rank as input, and returns a bitboard
+/// representing all the squares on all ranks in front of the rank, from the
+/// given color's point of view. For instance, in_front_bb(BLACK, RANK_3) will
+/// give all squares on ranks 1 and 2.
+
+inline Bitboard in_front_bb(Color c, Rank r) {
+ return InFrontBB[c][r];
+}
+
+
+/// between_bb() returns a bitboard representing all squares between two squares.
+/// For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with the bits for
+/// square d5 and e6 set. If s1 and s2 are not on the same line, file or diagonal,
+/// 0 is returned.
+
+inline Bitboard between_bb(Square s1, Square s2) {
+ return BetweenBB[s1][s2];
+}
+
+
+/// forward_bb() takes a color and a square as input, and returns a bitboard
+/// representing all squares along the line in front of the square, from the
+/// point of view of the given color. Definition of the table is:
+/// ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
+
+inline Bitboard forward_bb(Color c, Square s) {
+ return ForwardBB[c][s];
+}
+
+
+/// pawn_attack_span() takes a color and a square as input, and returns a bitboard
+/// representing all squares that can be attacked by a pawn of the given color
+/// when it moves along its file starting from the given square. Definition is:
+/// PawnAttackSpan[c][s] = in_front_bb(c, s) & adjacent_files_bb(s);
+
+inline Bitboard pawn_attack_span(Color c, Square s) {
+ return PawnAttackSpan[c][s];
+}
+
+
+/// passed_pawn_mask() takes a color and a square as input, and returns a
+/// bitboard mask which can be used to test if a pawn of the given color on
+/// the given square is a passed pawn. Definition of the table is:
+/// PassedPawnMask[c][s] = pawn_attack_span(c, s) | forward_bb(c, s)
+
+inline Bitboard passed_pawn_mask(Color c, Square s) {
+ return PassedPawnMask[c][s];
+}
+
+
+/// squares_of_color() returns a bitboard representing all squares with the same
+/// color of the given square.
+
+inline Bitboard squares_of_color(Square s) {
+ return DarkSquares & s ? DarkSquares : ~DarkSquares;
+}
+
+
+/// squares_aligned() returns true if the squares s1, s2 and s3 are aligned
+/// either on a straight or on a diagonal line.
+
+inline bool squares_aligned(Square s1, Square s2, Square s3) {
+ return (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
+ & ( SquareBB[s1] | SquareBB[s2] | SquareBB[s3]);
+}
+
+
+/// Functions for computing sliding attack bitboards. Function attacks_bb() takes
+/// a square and a bitboard of occupied squares as input, and returns a bitboard
+/// representing all squares attacked by Pt (bishop or rook) on the given square.
+template
+FORCE_INLINE unsigned magic_index(Square s, Bitboard occ) {
+
+ Bitboard* const Masks = Pt == ROOK ? RMasks : BMasks;
+ Bitboard* const Magics = Pt == ROOK ? RMagics : BMagics;
+ unsigned* const Shifts = Pt == ROOK ? RShifts : BShifts;
+
+ if (Is64Bit)
+ return unsigned(((occ & Masks[s]) * Magics[s]) >> Shifts[s]);
+
+ unsigned lo = unsigned(occ) & unsigned(Masks[s]);
+ unsigned hi = unsigned(occ >> 32) & unsigned(Masks[s] >> 32);
+ return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
+}
+
+template
+inline Bitboard attacks_bb(Square s, Bitboard occ) {
+ return (Pt == ROOK ? RAttacks : BAttacks)[s][magic_index(s, occ)];
+}
+
+
+/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
+/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
+
+#ifdef USE_BSFQ
+
+# if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+
+FORCE_INLINE Square lsb(Bitboard b) {
+ unsigned long index;
+ _BitScanForward64(&index, b);
+ return (Square) index;
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+ unsigned long index;
+ _BitScanReverse64(&index, b);
+ return (Square) index;
+}
+
+# elif defined(__arm__)
+
+FORCE_INLINE int lsb32(uint32_t v) {
+ __asm__("rbit %0, %1" : "=r"(v) : "r"(v));
+ return __builtin_clz(v);
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+ return (Square) (63 - __builtin_clzll(b));
+}
+
+FORCE_INLINE Square lsb(Bitboard b) {
+ return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32)));
+}
+
+# else
+
+FORCE_INLINE Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen
+ Bitboard index;
+ __asm__("bsfq %1, %0": "=r"(index): "rm"(b) );
+ return (Square) index;
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+ Bitboard index;
+ __asm__("bsrq %1, %0": "=r"(index): "rm"(b) );
+ return (Square) index;
+}
+
+# endif
+
+FORCE_INLINE Square pop_lsb(Bitboard* b) {
+ const Square s = lsb(*b);
+ *b &= *b - 1;
+ return s;
+}
+
+#else // if defined(USE_BSFQ)
+
+extern Square msb(Bitboard b);
+extern Square lsb(Bitboard b);
+extern Square pop_lsb(Bitboard* b);
+
+#endif
+
+#endif // #ifndef BITBOARD_H_INCLUDED
diff --git a/stockfish-4-win/src/bitcount.h b/stockfish-4-win/src/bitcount.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad8df94ab078522066fdfa44da80c931fa732c88
--- /dev/null
+++ b/stockfish-4-win/src/bitcount.h
@@ -0,0 +1,105 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifndef BITCOUNT_H_INCLUDED
+#define BITCOUNT_H_INCLUDED
+
+#include
+#include "types.h"
+
+enum BitCountType {
+ CNT_64,
+ CNT_64_MAX15,
+ CNT_32,
+ CNT_32_MAX15,
+ CNT_HW_POPCNT
+};
+
+/// Determine at compile time the best popcount<> specialization according if
+/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count
+/// and if hardware popcnt instruction is available.
+const BitCountType Full = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64 : CNT_32;
+const BitCountType Max15 = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64_MAX15 : CNT_32_MAX15;
+
+
+/// popcount() counts the number of nonzero bits in a bitboard
+template inline int popcount(Bitboard);
+
+template<>
+inline int popcount(Bitboard b) {
+ b -= (b >> 1) & 0x5555555555555555ULL;
+ b = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+ b = ((b >> 4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+ return (b * 0x0101010101010101ULL) >> 56;
+}
+
+template<>
+inline int popcount(Bitboard b) {
+ b -= (b >> 1) & 0x5555555555555555ULL;
+ b = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+ return (b * 0x1111111111111111ULL) >> 60;
+}
+
+template<>
+inline int popcount(Bitboard b) {
+ unsigned w = unsigned(b >> 32), v = unsigned(b);
+ v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+ w -= (w >> 1) & 0x55555555;
+ v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+ w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+ v = ((v >> 4) + v + (w >> 4) + w) & 0x0F0F0F0F;
+ return (v * 0x01010101) >> 24;
+}
+
+template<>
+inline int popcount(Bitboard b) {
+ unsigned w = unsigned(b >> 32), v = unsigned(b);
+ v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+ w -= (w >> 1) & 0x55555555;
+ v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+ w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+ return ((v + w) * 0x11111111) >> 28;
+}
+
+template<>
+inline int popcount(Bitboard b) {
+
+#ifndef USE_POPCNT
+
+ assert(false);
+ return b != 0; // Avoid 'b not used' warning
+
+#elif defined(_MSC_VER) && defined(__INTEL_COMPILER)
+
+ return _mm_popcnt_u64(b);
+
+#elif defined(_MSC_VER)
+
+ return (int)__popcnt64(b);
+
+#else
+
+ __asm__("popcnt %1, %0" : "=r" (b) : "r" (b));
+ return b;
+
+#endif
+}
+
+#endif // #ifndef BITCOUNT_H_INCLUDED
diff --git a/stockfish-4-win/src/book.cpp b/stockfish-4-win/src/book.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..caf2b0663ec76987720231e29360c6d434238d27
--- /dev/null
+++ b/stockfish-4-win/src/book.cpp
@@ -0,0 +1,478 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+/*
+ The code in this file is based on the opening book code in PolyGlot
+ by Fabien Letouzey. PolyGlot is available under the GNU General
+ Public License, and can be downloaded from http://wbec-ridderkerk.nl
+*/
+
+#include
+#include
+#include
+
+#include "book.h"
+#include "misc.h"
+#include "movegen.h"
+
+using namespace std;
+
+namespace {
+
+ // A Polyglot book is a series of "entries" of 16 bytes. All integers are
+ // stored in big-endian format, with highest byte first (regardless of size).
+ // The entries are ordered according to the key in ascending order.
+ struct Entry {
+ uint64_t key;
+ uint16_t move;
+ uint16_t count;
+ uint32_t learn;
+ };
+
+ // Random numbers from PolyGlot, used to compute book hash keys
+ const union {
+ Key PolyGlotRandoms[781];
+ struct {
+ Key psq[12][64]; // [piece][square]
+ Key castle[4]; // [castle right]
+ Key enpassant[8]; // [file]
+ Key turn;
+ } Zobrist;
+ } PG = {{
+ 0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
+ 0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
+ 0x0FBBAD1F61042279ULL, 0xE83A908FF2FB60CAULL, 0x0D7E765D58755C10ULL,
+ 0x1A083822CEAFE02DULL, 0x9605D5F0E25EC3B0ULL, 0xD021FF5CD13A2ED5ULL,
+ 0x40BDF15D4A672E32ULL, 0x011355146FD56395ULL, 0x5DB4832046F3D9E5ULL,
+ 0x239F8B2D7FF719CCULL, 0x05D1A1AE85B49AA1ULL, 0x679F848F6E8FC971ULL,
+ 0x7449BBFF801FED0BULL, 0x7D11CDB1C3B7ADF0ULL, 0x82C7709E781EB7CCULL,
+ 0xF3218F1C9510786CULL, 0x331478F3AF51BBE6ULL, 0x4BB38DE5E7219443ULL,
+ 0xAA649C6EBCFD50FCULL, 0x8DBD98A352AFD40BULL, 0x87D2074B81D79217ULL,
+ 0x19F3C751D3E92AE1ULL, 0xB4AB30F062B19ABFULL, 0x7B0500AC42047AC4ULL,
+ 0xC9452CA81A09D85DULL, 0x24AA6C514DA27500ULL, 0x4C9F34427501B447ULL,
+ 0x14A68FD73C910841ULL, 0xA71B9B83461CBD93ULL, 0x03488B95B0F1850FULL,
+ 0x637B2B34FF93C040ULL, 0x09D1BC9A3DD90A94ULL, 0x3575668334A1DD3BULL,
+ 0x735E2B97A4C45A23ULL, 0x18727070F1BD400BULL, 0x1FCBACD259BF02E7ULL,
+ 0xD310A7C2CE9B6555ULL, 0xBF983FE0FE5D8244ULL, 0x9F74D14F7454A824ULL,
+ 0x51EBDC4AB9BA3035ULL, 0x5C82C505DB9AB0FAULL, 0xFCF7FE8A3430B241ULL,
+ 0x3253A729B9BA3DDEULL, 0x8C74C368081B3075ULL, 0xB9BC6C87167C33E7ULL,
+ 0x7EF48F2B83024E20ULL, 0x11D505D4C351BD7FULL, 0x6568FCA92C76A243ULL,
+ 0x4DE0B0F40F32A7B8ULL, 0x96D693460CC37E5DULL, 0x42E240CB63689F2FULL,
+ 0x6D2BDCDAE2919661ULL, 0x42880B0236E4D951ULL, 0x5F0F4A5898171BB6ULL,
+ 0x39F890F579F92F88ULL, 0x93C5B5F47356388BULL, 0x63DC359D8D231B78ULL,
+ 0xEC16CA8AEA98AD76ULL, 0x5355F900C2A82DC7ULL, 0x07FB9F855A997142ULL,
+ 0x5093417AA8A7ED5EULL, 0x7BCBC38DA25A7F3CULL, 0x19FC8A768CF4B6D4ULL,
+ 0x637A7780DECFC0D9ULL, 0x8249A47AEE0E41F7ULL, 0x79AD695501E7D1E8ULL,
+ 0x14ACBAF4777D5776ULL, 0xF145B6BECCDEA195ULL, 0xDABF2AC8201752FCULL,
+ 0x24C3C94DF9C8D3F6ULL, 0xBB6E2924F03912EAULL, 0x0CE26C0B95C980D9ULL,
+ 0xA49CD132BFBF7CC4ULL, 0xE99D662AF4243939ULL, 0x27E6AD7891165C3FULL,
+ 0x8535F040B9744FF1ULL, 0x54B3F4FA5F40D873ULL, 0x72B12C32127FED2BULL,
+ 0xEE954D3C7B411F47ULL, 0x9A85AC909A24EAA1ULL, 0x70AC4CD9F04F21F5ULL,
+ 0xF9B89D3E99A075C2ULL, 0x87B3E2B2B5C907B1ULL, 0xA366E5B8C54F48B8ULL,
+ 0xAE4A9346CC3F7CF2ULL, 0x1920C04D47267BBDULL, 0x87BF02C6B49E2AE9ULL,
+ 0x092237AC237F3859ULL, 0xFF07F64EF8ED14D0ULL, 0x8DE8DCA9F03CC54EULL,
+ 0x9C1633264DB49C89ULL, 0xB3F22C3D0B0B38EDULL, 0x390E5FB44D01144BULL,
+ 0x5BFEA5B4712768E9ULL, 0x1E1032911FA78984ULL, 0x9A74ACB964E78CB3ULL,
+ 0x4F80F7A035DAFB04ULL, 0x6304D09A0B3738C4ULL, 0x2171E64683023A08ULL,
+ 0x5B9B63EB9CEFF80CULL, 0x506AACF489889342ULL, 0x1881AFC9A3A701D6ULL,
+ 0x6503080440750644ULL, 0xDFD395339CDBF4A7ULL, 0xEF927DBCF00C20F2ULL,
+ 0x7B32F7D1E03680ECULL, 0xB9FD7620E7316243ULL, 0x05A7E8A57DB91B77ULL,
+ 0xB5889C6E15630A75ULL, 0x4A750A09CE9573F7ULL, 0xCF464CEC899A2F8AULL,
+ 0xF538639CE705B824ULL, 0x3C79A0FF5580EF7FULL, 0xEDE6C87F8477609DULL,
+ 0x799E81F05BC93F31ULL, 0x86536B8CF3428A8CULL, 0x97D7374C60087B73ULL,
+ 0xA246637CFF328532ULL, 0x043FCAE60CC0EBA0ULL, 0x920E449535DD359EULL,
+ 0x70EB093B15B290CCULL, 0x73A1921916591CBDULL, 0x56436C9FE1A1AA8DULL,
+ 0xEFAC4B70633B8F81ULL, 0xBB215798D45DF7AFULL, 0x45F20042F24F1768ULL,
+ 0x930F80F4E8EB7462ULL, 0xFF6712FFCFD75EA1ULL, 0xAE623FD67468AA70ULL,
+ 0xDD2C5BC84BC8D8FCULL, 0x7EED120D54CF2DD9ULL, 0x22FE545401165F1CULL,
+ 0xC91800E98FB99929ULL, 0x808BD68E6AC10365ULL, 0xDEC468145B7605F6ULL,
+ 0x1BEDE3A3AEF53302ULL, 0x43539603D6C55602ULL, 0xAA969B5C691CCB7AULL,
+ 0xA87832D392EFEE56ULL, 0x65942C7B3C7E11AEULL, 0xDED2D633CAD004F6ULL,
+ 0x21F08570F420E565ULL, 0xB415938D7DA94E3CULL, 0x91B859E59ECB6350ULL,
+ 0x10CFF333E0ED804AULL, 0x28AED140BE0BB7DDULL, 0xC5CC1D89724FA456ULL,
+ 0x5648F680F11A2741ULL, 0x2D255069F0B7DAB3ULL, 0x9BC5A38EF729ABD4ULL,
+ 0xEF2F054308F6A2BCULL, 0xAF2042F5CC5C2858ULL, 0x480412BAB7F5BE2AULL,
+ 0xAEF3AF4A563DFE43ULL, 0x19AFE59AE451497FULL, 0x52593803DFF1E840ULL,
+ 0xF4F076E65F2CE6F0ULL, 0x11379625747D5AF3ULL, 0xBCE5D2248682C115ULL,
+ 0x9DA4243DE836994FULL, 0x066F70B33FE09017ULL, 0x4DC4DE189B671A1CULL,
+ 0x51039AB7712457C3ULL, 0xC07A3F80C31FB4B4ULL, 0xB46EE9C5E64A6E7CULL,
+ 0xB3819A42ABE61C87ULL, 0x21A007933A522A20ULL, 0x2DF16F761598AA4FULL,
+ 0x763C4A1371B368FDULL, 0xF793C46702E086A0ULL, 0xD7288E012AEB8D31ULL,
+ 0xDE336A2A4BC1C44BULL, 0x0BF692B38D079F23ULL, 0x2C604A7A177326B3ULL,
+ 0x4850E73E03EB6064ULL, 0xCFC447F1E53C8E1BULL, 0xB05CA3F564268D99ULL,
+ 0x9AE182C8BC9474E8ULL, 0xA4FC4BD4FC5558CAULL, 0xE755178D58FC4E76ULL,
+ 0x69B97DB1A4C03DFEULL, 0xF9B5B7C4ACC67C96ULL, 0xFC6A82D64B8655FBULL,
+ 0x9C684CB6C4D24417ULL, 0x8EC97D2917456ED0ULL, 0x6703DF9D2924E97EULL,
+ 0xC547F57E42A7444EULL, 0x78E37644E7CAD29EULL, 0xFE9A44E9362F05FAULL,
+ 0x08BD35CC38336615ULL, 0x9315E5EB3A129ACEULL, 0x94061B871E04DF75ULL,
+ 0xDF1D9F9D784BA010ULL, 0x3BBA57B68871B59DULL, 0xD2B7ADEEDED1F73FULL,
+ 0xF7A255D83BC373F8ULL, 0xD7F4F2448C0CEB81ULL, 0xD95BE88CD210FFA7ULL,
+ 0x336F52F8FF4728E7ULL, 0xA74049DAC312AC71ULL, 0xA2F61BB6E437FDB5ULL,
+ 0x4F2A5CB07F6A35B3ULL, 0x87D380BDA5BF7859ULL, 0x16B9F7E06C453A21ULL,
+ 0x7BA2484C8A0FD54EULL, 0xF3A678CAD9A2E38CULL, 0x39B0BF7DDE437BA2ULL,
+ 0xFCAF55C1BF8A4424ULL, 0x18FCF680573FA594ULL, 0x4C0563B89F495AC3ULL,
+ 0x40E087931A00930DULL, 0x8CFFA9412EB642C1ULL, 0x68CA39053261169FULL,
+ 0x7A1EE967D27579E2ULL, 0x9D1D60E5076F5B6FULL, 0x3810E399B6F65BA2ULL,
+ 0x32095B6D4AB5F9B1ULL, 0x35CAB62109DD038AULL, 0xA90B24499FCFAFB1ULL,
+ 0x77A225A07CC2C6BDULL, 0x513E5E634C70E331ULL, 0x4361C0CA3F692F12ULL,
+ 0xD941ACA44B20A45BULL, 0x528F7C8602C5807BULL, 0x52AB92BEB9613989ULL,
+ 0x9D1DFA2EFC557F73ULL, 0x722FF175F572C348ULL, 0x1D1260A51107FE97ULL,
+ 0x7A249A57EC0C9BA2ULL, 0x04208FE9E8F7F2D6ULL, 0x5A110C6058B920A0ULL,
+ 0x0CD9A497658A5698ULL, 0x56FD23C8F9715A4CULL, 0x284C847B9D887AAEULL,
+ 0x04FEABFBBDB619CBULL, 0x742E1E651C60BA83ULL, 0x9A9632E65904AD3CULL,
+ 0x881B82A13B51B9E2ULL, 0x506E6744CD974924ULL, 0xB0183DB56FFC6A79ULL,
+ 0x0ED9B915C66ED37EULL, 0x5E11E86D5873D484ULL, 0xF678647E3519AC6EULL,
+ 0x1B85D488D0F20CC5ULL, 0xDAB9FE6525D89021ULL, 0x0D151D86ADB73615ULL,
+ 0xA865A54EDCC0F019ULL, 0x93C42566AEF98FFBULL, 0x99E7AFEABE000731ULL,
+ 0x48CBFF086DDF285AULL, 0x7F9B6AF1EBF78BAFULL, 0x58627E1A149BBA21ULL,
+ 0x2CD16E2ABD791E33ULL, 0xD363EFF5F0977996ULL, 0x0CE2A38C344A6EEDULL,
+ 0x1A804AADB9CFA741ULL, 0x907F30421D78C5DEULL, 0x501F65EDB3034D07ULL,
+ 0x37624AE5A48FA6E9ULL, 0x957BAF61700CFF4EULL, 0x3A6C27934E31188AULL,
+ 0xD49503536ABCA345ULL, 0x088E049589C432E0ULL, 0xF943AEE7FEBF21B8ULL,
+ 0x6C3B8E3E336139D3ULL, 0x364F6FFA464EE52EULL, 0xD60F6DCEDC314222ULL,
+ 0x56963B0DCA418FC0ULL, 0x16F50EDF91E513AFULL, 0xEF1955914B609F93ULL,
+ 0x565601C0364E3228ULL, 0xECB53939887E8175ULL, 0xBAC7A9A18531294BULL,
+ 0xB344C470397BBA52ULL, 0x65D34954DAF3CEBDULL, 0xB4B81B3FA97511E2ULL,
+ 0xB422061193D6F6A7ULL, 0x071582401C38434DULL, 0x7A13F18BBEDC4FF5ULL,
+ 0xBC4097B116C524D2ULL, 0x59B97885E2F2EA28ULL, 0x99170A5DC3115544ULL,
+ 0x6F423357E7C6A9F9ULL, 0x325928EE6E6F8794ULL, 0xD0E4366228B03343ULL,
+ 0x565C31F7DE89EA27ULL, 0x30F5611484119414ULL, 0xD873DB391292ED4FULL,
+ 0x7BD94E1D8E17DEBCULL, 0xC7D9F16864A76E94ULL, 0x947AE053EE56E63CULL,
+ 0xC8C93882F9475F5FULL, 0x3A9BF55BA91F81CAULL, 0xD9A11FBB3D9808E4ULL,
+ 0x0FD22063EDC29FCAULL, 0xB3F256D8ACA0B0B9ULL, 0xB03031A8B4516E84ULL,
+ 0x35DD37D5871448AFULL, 0xE9F6082B05542E4EULL, 0xEBFAFA33D7254B59ULL,
+ 0x9255ABB50D532280ULL, 0xB9AB4CE57F2D34F3ULL, 0x693501D628297551ULL,
+ 0xC62C58F97DD949BFULL, 0xCD454F8F19C5126AULL, 0xBBE83F4ECC2BDECBULL,
+ 0xDC842B7E2819E230ULL, 0xBA89142E007503B8ULL, 0xA3BC941D0A5061CBULL,
+ 0xE9F6760E32CD8021ULL, 0x09C7E552BC76492FULL, 0x852F54934DA55CC9ULL,
+ 0x8107FCCF064FCF56ULL, 0x098954D51FFF6580ULL, 0x23B70EDB1955C4BFULL,
+ 0xC330DE426430F69DULL, 0x4715ED43E8A45C0AULL, 0xA8D7E4DAB780A08DULL,
+ 0x0572B974F03CE0BBULL, 0xB57D2E985E1419C7ULL, 0xE8D9ECBE2CF3D73FULL,
+ 0x2FE4B17170E59750ULL, 0x11317BA87905E790ULL, 0x7FBF21EC8A1F45ECULL,
+ 0x1725CABFCB045B00ULL, 0x964E915CD5E2B207ULL, 0x3E2B8BCBF016D66DULL,
+ 0xBE7444E39328A0ACULL, 0xF85B2B4FBCDE44B7ULL, 0x49353FEA39BA63B1ULL,
+ 0x1DD01AAFCD53486AULL, 0x1FCA8A92FD719F85ULL, 0xFC7C95D827357AFAULL,
+ 0x18A6A990C8B35EBDULL, 0xCCCB7005C6B9C28DULL, 0x3BDBB92C43B17F26ULL,
+ 0xAA70B5B4F89695A2ULL, 0xE94C39A54A98307FULL, 0xB7A0B174CFF6F36EULL,
+ 0xD4DBA84729AF48ADULL, 0x2E18BC1AD9704A68ULL, 0x2DE0966DAF2F8B1CULL,
+ 0xB9C11D5B1E43A07EULL, 0x64972D68DEE33360ULL, 0x94628D38D0C20584ULL,
+ 0xDBC0D2B6AB90A559ULL, 0xD2733C4335C6A72FULL, 0x7E75D99D94A70F4DULL,
+ 0x6CED1983376FA72BULL, 0x97FCAACBF030BC24ULL, 0x7B77497B32503B12ULL,
+ 0x8547EDDFB81CCB94ULL, 0x79999CDFF70902CBULL, 0xCFFE1939438E9B24ULL,
+ 0x829626E3892D95D7ULL, 0x92FAE24291F2B3F1ULL, 0x63E22C147B9C3403ULL,
+ 0xC678B6D860284A1CULL, 0x5873888850659AE7ULL, 0x0981DCD296A8736DULL,
+ 0x9F65789A6509A440ULL, 0x9FF38FED72E9052FULL, 0xE479EE5B9930578CULL,
+ 0xE7F28ECD2D49EECDULL, 0x56C074A581EA17FEULL, 0x5544F7D774B14AEFULL,
+ 0x7B3F0195FC6F290FULL, 0x12153635B2C0CF57ULL, 0x7F5126DBBA5E0CA7ULL,
+ 0x7A76956C3EAFB413ULL, 0x3D5774A11D31AB39ULL, 0x8A1B083821F40CB4ULL,
+ 0x7B4A38E32537DF62ULL, 0x950113646D1D6E03ULL, 0x4DA8979A0041E8A9ULL,
+ 0x3BC36E078F7515D7ULL, 0x5D0A12F27AD310D1ULL, 0x7F9D1A2E1EBE1327ULL,
+ 0xDA3A361B1C5157B1ULL, 0xDCDD7D20903D0C25ULL, 0x36833336D068F707ULL,
+ 0xCE68341F79893389ULL, 0xAB9090168DD05F34ULL, 0x43954B3252DC25E5ULL,
+ 0xB438C2B67F98E5E9ULL, 0x10DCD78E3851A492ULL, 0xDBC27AB5447822BFULL,
+ 0x9B3CDB65F82CA382ULL, 0xB67B7896167B4C84ULL, 0xBFCED1B0048EAC50ULL,
+ 0xA9119B60369FFEBDULL, 0x1FFF7AC80904BF45ULL, 0xAC12FB171817EEE7ULL,
+ 0xAF08DA9177DDA93DULL, 0x1B0CAB936E65C744ULL, 0xB559EB1D04E5E932ULL,
+ 0xC37B45B3F8D6F2BAULL, 0xC3A9DC228CAAC9E9ULL, 0xF3B8B6675A6507FFULL,
+ 0x9FC477DE4ED681DAULL, 0x67378D8ECCEF96CBULL, 0x6DD856D94D259236ULL,
+ 0xA319CE15B0B4DB31ULL, 0x073973751F12DD5EULL, 0x8A8E849EB32781A5ULL,
+ 0xE1925C71285279F5ULL, 0x74C04BF1790C0EFEULL, 0x4DDA48153C94938AULL,
+ 0x9D266D6A1CC0542CULL, 0x7440FB816508C4FEULL, 0x13328503DF48229FULL,
+ 0xD6BF7BAEE43CAC40ULL, 0x4838D65F6EF6748FULL, 0x1E152328F3318DEAULL,
+ 0x8F8419A348F296BFULL, 0x72C8834A5957B511ULL, 0xD7A023A73260B45CULL,
+ 0x94EBC8ABCFB56DAEULL, 0x9FC10D0F989993E0ULL, 0xDE68A2355B93CAE6ULL,
+ 0xA44CFE79AE538BBEULL, 0x9D1D84FCCE371425ULL, 0x51D2B1AB2DDFB636ULL,
+ 0x2FD7E4B9E72CD38CULL, 0x65CA5B96B7552210ULL, 0xDD69A0D8AB3B546DULL,
+ 0x604D51B25FBF70E2ULL, 0x73AA8A564FB7AC9EULL, 0x1A8C1E992B941148ULL,
+ 0xAAC40A2703D9BEA0ULL, 0x764DBEAE7FA4F3A6ULL, 0x1E99B96E70A9BE8BULL,
+ 0x2C5E9DEB57EF4743ULL, 0x3A938FEE32D29981ULL, 0x26E6DB8FFDF5ADFEULL,
+ 0x469356C504EC9F9DULL, 0xC8763C5B08D1908CULL, 0x3F6C6AF859D80055ULL,
+ 0x7F7CC39420A3A545ULL, 0x9BFB227EBDF4C5CEULL, 0x89039D79D6FC5C5CULL,
+ 0x8FE88B57305E2AB6ULL, 0xA09E8C8C35AB96DEULL, 0xFA7E393983325753ULL,
+ 0xD6B6D0ECC617C699ULL, 0xDFEA21EA9E7557E3ULL, 0xB67C1FA481680AF8ULL,
+ 0xCA1E3785A9E724E5ULL, 0x1CFC8BED0D681639ULL, 0xD18D8549D140CAEAULL,
+ 0x4ED0FE7E9DC91335ULL, 0xE4DBF0634473F5D2ULL, 0x1761F93A44D5AEFEULL,
+ 0x53898E4C3910DA55ULL, 0x734DE8181F6EC39AULL, 0x2680B122BAA28D97ULL,
+ 0x298AF231C85BAFABULL, 0x7983EED3740847D5ULL, 0x66C1A2A1A60CD889ULL,
+ 0x9E17E49642A3E4C1ULL, 0xEDB454E7BADC0805ULL, 0x50B704CAB602C329ULL,
+ 0x4CC317FB9CDDD023ULL, 0x66B4835D9EAFEA22ULL, 0x219B97E26FFC81BDULL,
+ 0x261E4E4C0A333A9DULL, 0x1FE2CCA76517DB90ULL, 0xD7504DFA8816EDBBULL,
+ 0xB9571FA04DC089C8ULL, 0x1DDC0325259B27DEULL, 0xCF3F4688801EB9AAULL,
+ 0xF4F5D05C10CAB243ULL, 0x38B6525C21A42B0EULL, 0x36F60E2BA4FA6800ULL,
+ 0xEB3593803173E0CEULL, 0x9C4CD6257C5A3603ULL, 0xAF0C317D32ADAA8AULL,
+ 0x258E5A80C7204C4BULL, 0x8B889D624D44885DULL, 0xF4D14597E660F855ULL,
+ 0xD4347F66EC8941C3ULL, 0xE699ED85B0DFB40DULL, 0x2472F6207C2D0484ULL,
+ 0xC2A1E7B5B459AEB5ULL, 0xAB4F6451CC1D45ECULL, 0x63767572AE3D6174ULL,
+ 0xA59E0BD101731A28ULL, 0x116D0016CB948F09ULL, 0x2CF9C8CA052F6E9FULL,
+ 0x0B090A7560A968E3ULL, 0xABEEDDB2DDE06FF1ULL, 0x58EFC10B06A2068DULL,
+ 0xC6E57A78FBD986E0ULL, 0x2EAB8CA63CE802D7ULL, 0x14A195640116F336ULL,
+ 0x7C0828DD624EC390ULL, 0xD74BBE77E6116AC7ULL, 0x804456AF10F5FB53ULL,
+ 0xEBE9EA2ADF4321C7ULL, 0x03219A39EE587A30ULL, 0x49787FEF17AF9924ULL,
+ 0xA1E9300CD8520548ULL, 0x5B45E522E4B1B4EFULL, 0xB49C3B3995091A36ULL,
+ 0xD4490AD526F14431ULL, 0x12A8F216AF9418C2ULL, 0x001F837CC7350524ULL,
+ 0x1877B51E57A764D5ULL, 0xA2853B80F17F58EEULL, 0x993E1DE72D36D310ULL,
+ 0xB3598080CE64A656ULL, 0x252F59CF0D9F04BBULL, 0xD23C8E176D113600ULL,
+ 0x1BDA0492E7E4586EULL, 0x21E0BD5026C619BFULL, 0x3B097ADAF088F94EULL,
+ 0x8D14DEDB30BE846EULL, 0xF95CFFA23AF5F6F4ULL, 0x3871700761B3F743ULL,
+ 0xCA672B91E9E4FA16ULL, 0x64C8E531BFF53B55ULL, 0x241260ED4AD1E87DULL,
+ 0x106C09B972D2E822ULL, 0x7FBA195410E5CA30ULL, 0x7884D9BC6CB569D8ULL,
+ 0x0647DFEDCD894A29ULL, 0x63573FF03E224774ULL, 0x4FC8E9560F91B123ULL,
+ 0x1DB956E450275779ULL, 0xB8D91274B9E9D4FBULL, 0xA2EBEE47E2FBFCE1ULL,
+ 0xD9F1F30CCD97FB09ULL, 0xEFED53D75FD64E6BULL, 0x2E6D02C36017F67FULL,
+ 0xA9AA4D20DB084E9BULL, 0xB64BE8D8B25396C1ULL, 0x70CB6AF7C2D5BCF0ULL,
+ 0x98F076A4F7A2322EULL, 0xBF84470805E69B5FULL, 0x94C3251F06F90CF3ULL,
+ 0x3E003E616A6591E9ULL, 0xB925A6CD0421AFF3ULL, 0x61BDD1307C66E300ULL,
+ 0xBF8D5108E27E0D48ULL, 0x240AB57A8B888B20ULL, 0xFC87614BAF287E07ULL,
+ 0xEF02CDD06FFDB432ULL, 0xA1082C0466DF6C0AULL, 0x8215E577001332C8ULL,
+ 0xD39BB9C3A48DB6CFULL, 0x2738259634305C14ULL, 0x61CF4F94C97DF93DULL,
+ 0x1B6BACA2AE4E125BULL, 0x758F450C88572E0BULL, 0x959F587D507A8359ULL,
+ 0xB063E962E045F54DULL, 0x60E8ED72C0DFF5D1ULL, 0x7B64978555326F9FULL,
+ 0xFD080D236DA814BAULL, 0x8C90FD9B083F4558ULL, 0x106F72FE81E2C590ULL,
+ 0x7976033A39F7D952ULL, 0xA4EC0132764CA04BULL, 0x733EA705FAE4FA77ULL,
+ 0xB4D8F77BC3E56167ULL, 0x9E21F4F903B33FD9ULL, 0x9D765E419FB69F6DULL,
+ 0xD30C088BA61EA5EFULL, 0x5D94337FBFAF7F5BULL, 0x1A4E4822EB4D7A59ULL,
+ 0x6FFE73E81B637FB3ULL, 0xDDF957BC36D8B9CAULL, 0x64D0E29EEA8838B3ULL,
+ 0x08DD9BDFD96B9F63ULL, 0x087E79E5A57D1D13ULL, 0xE328E230E3E2B3FBULL,
+ 0x1C2559E30F0946BEULL, 0x720BF5F26F4D2EAAULL, 0xB0774D261CC609DBULL,
+ 0x443F64EC5A371195ULL, 0x4112CF68649A260EULL, 0xD813F2FAB7F5C5CAULL,
+ 0x660D3257380841EEULL, 0x59AC2C7873F910A3ULL, 0xE846963877671A17ULL,
+ 0x93B633ABFA3469F8ULL, 0xC0C0F5A60EF4CDCFULL, 0xCAF21ECD4377B28CULL,
+ 0x57277707199B8175ULL, 0x506C11B9D90E8B1DULL, 0xD83CC2687A19255FULL,
+ 0x4A29C6465A314CD1ULL, 0xED2DF21216235097ULL, 0xB5635C95FF7296E2ULL,
+ 0x22AF003AB672E811ULL, 0x52E762596BF68235ULL, 0x9AEBA33AC6ECC6B0ULL,
+ 0x944F6DE09134DFB6ULL, 0x6C47BEC883A7DE39ULL, 0x6AD047C430A12104ULL,
+ 0xA5B1CFDBA0AB4067ULL, 0x7C45D833AFF07862ULL, 0x5092EF950A16DA0BULL,
+ 0x9338E69C052B8E7BULL, 0x455A4B4CFE30E3F5ULL, 0x6B02E63195AD0CF8ULL,
+ 0x6B17B224BAD6BF27ULL, 0xD1E0CCD25BB9C169ULL, 0xDE0C89A556B9AE70ULL,
+ 0x50065E535A213CF6ULL, 0x9C1169FA2777B874ULL, 0x78EDEFD694AF1EEDULL,
+ 0x6DC93D9526A50E68ULL, 0xEE97F453F06791EDULL, 0x32AB0EDB696703D3ULL,
+ 0x3A6853C7E70757A7ULL, 0x31865CED6120F37DULL, 0x67FEF95D92607890ULL,
+ 0x1F2B1D1F15F6DC9CULL, 0xB69E38A8965C6B65ULL, 0xAA9119FF184CCCF4ULL,
+ 0xF43C732873F24C13ULL, 0xFB4A3D794A9A80D2ULL, 0x3550C2321FD6109CULL,
+ 0x371F77E76BB8417EULL, 0x6BFA9AAE5EC05779ULL, 0xCD04F3FF001A4778ULL,
+ 0xE3273522064480CAULL, 0x9F91508BFFCFC14AULL, 0x049A7F41061A9E60ULL,
+ 0xFCB6BE43A9F2FE9BULL, 0x08DE8A1C7797DA9BULL, 0x8F9887E6078735A1ULL,
+ 0xB5B4071DBFC73A66ULL, 0x230E343DFBA08D33ULL, 0x43ED7F5A0FAE657DULL,
+ 0x3A88A0FBBCB05C63ULL, 0x21874B8B4D2DBC4FULL, 0x1BDEA12E35F6A8C9ULL,
+ 0x53C065C6C8E63528ULL, 0xE34A1D250E7A8D6BULL, 0xD6B04D3B7651DD7EULL,
+ 0x5E90277E7CB39E2DULL, 0x2C046F22062DC67DULL, 0xB10BB459132D0A26ULL,
+ 0x3FA9DDFB67E2F199ULL, 0x0E09B88E1914F7AFULL, 0x10E8B35AF3EEAB37ULL,
+ 0x9EEDECA8E272B933ULL, 0xD4C718BC4AE8AE5FULL, 0x81536D601170FC20ULL,
+ 0x91B534F885818A06ULL, 0xEC8177F83F900978ULL, 0x190E714FADA5156EULL,
+ 0xB592BF39B0364963ULL, 0x89C350C893AE7DC1ULL, 0xAC042E70F8B383F2ULL,
+ 0xB49B52E587A1EE60ULL, 0xFB152FE3FF26DA89ULL, 0x3E666E6F69AE2C15ULL,
+ 0x3B544EBE544C19F9ULL, 0xE805A1E290CF2456ULL, 0x24B33C9D7ED25117ULL,
+ 0xE74733427B72F0C1ULL, 0x0A804D18B7097475ULL, 0x57E3306D881EDB4FULL,
+ 0x4AE7D6A36EB5DBCBULL, 0x2D8D5432157064C8ULL, 0xD1E649DE1E7F268BULL,
+ 0x8A328A1CEDFE552CULL, 0x07A3AEC79624C7DAULL, 0x84547DDC3E203C94ULL,
+ 0x990A98FD5071D263ULL, 0x1A4FF12616EEFC89ULL, 0xF6F7FD1431714200ULL,
+ 0x30C05B1BA332F41CULL, 0x8D2636B81555A786ULL, 0x46C9FEB55D120902ULL,
+ 0xCCEC0A73B49C9921ULL, 0x4E9D2827355FC492ULL, 0x19EBB029435DCB0FULL,
+ 0x4659D2B743848A2CULL, 0x963EF2C96B33BE31ULL, 0x74F85198B05A2E7DULL,
+ 0x5A0F544DD2B1FB18ULL, 0x03727073C2E134B1ULL, 0xC7F6AA2DE59AEA61ULL,
+ 0x352787BAA0D7C22FULL, 0x9853EAB63B5E0B35ULL, 0xABBDCDD7ED5C0860ULL,
+ 0xCF05DAF5AC8D77B0ULL, 0x49CAD48CEBF4A71EULL, 0x7A4C10EC2158C4A6ULL,
+ 0xD9E92AA246BF719EULL, 0x13AE978D09FE5557ULL, 0x730499AF921549FFULL,
+ 0x4E4B705B92903BA4ULL, 0xFF577222C14F0A3AULL, 0x55B6344CF97AAFAEULL,
+ 0xB862225B055B6960ULL, 0xCAC09AFBDDD2CDB4ULL, 0xDAF8E9829FE96B5FULL,
+ 0xB5FDFC5D3132C498ULL, 0x310CB380DB6F7503ULL, 0xE87FBB46217A360EULL,
+ 0x2102AE466EBB1148ULL, 0xF8549E1A3AA5E00DULL, 0x07A69AFDCC42261AULL,
+ 0xC4C118BFE78FEAAEULL, 0xF9F4892ED96BD438ULL, 0x1AF3DBE25D8F45DAULL,
+ 0xF5B4B0B0D2DEEEB4ULL, 0x962ACEEFA82E1C84ULL, 0x046E3ECAAF453CE9ULL,
+ 0xF05D129681949A4CULL, 0x964781CE734B3C84ULL, 0x9C2ED44081CE5FBDULL,
+ 0x522E23F3925E319EULL, 0x177E00F9FC32F791ULL, 0x2BC60A63A6F3B3F2ULL,
+ 0x222BBFAE61725606ULL, 0x486289DDCC3D6780ULL, 0x7DC7785B8EFDFC80ULL,
+ 0x8AF38731C02BA980ULL, 0x1FAB64EA29A2DDF7ULL, 0xE4D9429322CD065AULL,
+ 0x9DA058C67844F20CULL, 0x24C0E332B70019B0ULL, 0x233003B5A6CFE6ADULL,
+ 0xD586BD01C5C217F6ULL, 0x5E5637885F29BC2BULL, 0x7EBA726D8C94094BULL,
+ 0x0A56A5F0BFE39272ULL, 0xD79476A84EE20D06ULL, 0x9E4C1269BAA4BF37ULL,
+ 0x17EFEE45B0DEE640ULL, 0x1D95B0A5FCF90BC6ULL, 0x93CBE0B699C2585DULL,
+ 0x65FA4F227A2B6D79ULL, 0xD5F9E858292504D5ULL, 0xC2B5A03F71471A6FULL,
+ 0x59300222B4561E00ULL, 0xCE2F8642CA0712DCULL, 0x7CA9723FBB2E8988ULL,
+ 0x2785338347F2BA08ULL, 0xC61BB3A141E50E8CULL, 0x150F361DAB9DEC26ULL,
+ 0x9F6A419D382595F4ULL, 0x64A53DC924FE7AC9ULL, 0x142DE49FFF7A7C3DULL,
+ 0x0C335248857FA9E7ULL, 0x0A9C32D5EAE45305ULL, 0xE6C42178C4BBB92EULL,
+ 0x71F1CE2490D20B07ULL, 0xF1BCC3D275AFE51AULL, 0xE728E8C83C334074ULL,
+ 0x96FBF83A12884624ULL, 0x81A1549FD6573DA5ULL, 0x5FA7867CAF35E149ULL,
+ 0x56986E2EF3ED091BULL, 0x917F1DD5F8886C61ULL, 0xD20D8C88C8FFE65FULL,
+ 0x31D71DCE64B2C310ULL, 0xF165B587DF898190ULL, 0xA57E6339DD2CF3A0ULL,
+ 0x1EF6E6DBB1961EC9ULL, 0x70CC73D90BC26E24ULL, 0xE21A6B35DF0C3AD7ULL,
+ 0x003A93D8B2806962ULL, 0x1C99DED33CB890A1ULL, 0xCF3145DE0ADD4289ULL,
+ 0xD0E4427A5514FB72ULL, 0x77C621CC9FB3A483ULL, 0x67A34DAC4356550BULL,
+ 0xF8D626AAAF278509ULL
+ }};
+
+ // polyglot_key() returns the PolyGlot hash key of the given position
+ Key polyglot_key(const Position& pos) {
+
+ Key key = 0;
+ Bitboard b = pos.pieces();
+
+ while (b)
+ {
+ Square s = pop_lsb(&b);
+ Piece p = pos.piece_on(s);
+
+ // PolyGlot pieces are: BP = 0, WP = 1, BN = 2, ... BK = 10, WK = 11
+ key ^= PG.Zobrist.psq[2 * (type_of(p) - 1) + (color_of(p) == WHITE)][s];
+ }
+
+ b = pos.can_castle(ALL_CASTLES);
+
+ while (b)
+ key ^= PG.Zobrist.castle[pop_lsb(&b)];
+
+ if (pos.ep_square() != SQ_NONE)
+ key ^= PG.Zobrist.enpassant[file_of(pos.ep_square())];
+
+ if (pos.side_to_move() == WHITE)
+ key ^= PG.Zobrist.turn;
+
+ return key;
+ }
+
+} // namespace
+
+PolyglotBook::PolyglotBook() : rkiss(Time::now() % 10000) {}
+
+PolyglotBook::~PolyglotBook() { if (is_open()) close(); }
+
+
+/// operator>>() reads sizeof(T) chars from the file's binary byte stream and
+/// converts them in a number of type T. A Polyglot book stores numbers in
+/// big-endian format.
+
+template PolyglotBook& PolyglotBook::operator>>(T& n) {
+
+ n = 0;
+ for (size_t i = 0; i < sizeof(T); i++)
+ n = T((n << 8) + ifstream::get());
+
+ return *this;
+}
+
+template<> PolyglotBook& PolyglotBook::operator>>(Entry& e) {
+ return *this >> e.key >> e.move >> e.count >> e.learn;
+}
+
+
+/// open() tries to open a book file with the given name after closing any
+/// exsisting one.
+
+bool PolyglotBook::open(const char* fName) {
+
+ if (is_open()) // Cannot close an already closed file
+ close();
+
+ ifstream::open(fName, ifstream::in | ifstream::binary);
+
+ fileName = is_open() ? fName : "";
+ ifstream::clear(); // Reset any error flag to allow retry ifstream::open()
+ return !fileName.empty();
+}
+
+
+/// probe() tries to find a book move for the given position. If no move is
+/// found returns MOVE_NONE. If pickBest is true returns always the highest
+/// rated move, otherwise randomly chooses one, based on the move score.
+
+Move PolyglotBook::probe(const Position& pos, const string& fName, bool pickBest) {
+
+ if (fileName != fName && !open(fName.c_str()))
+ return MOVE_NONE;
+
+ Entry e;
+ uint16_t best = 0;
+ unsigned sum = 0;
+ Move move = MOVE_NONE;
+ Key key = polyglot_key(pos);
+
+ seekg(find_first(key) * sizeof(Entry), ios_base::beg);
+
+ while (*this >> e, e.key == key && good())
+ {
+ best = max(best, e.count);
+ sum += e.count;
+
+ // Choose book move according to its score. If a move has a very
+ // high score it has higher probability to be choosen than a move
+ // with lower score. Note that first entry is always chosen.
+ if ( (sum && rkiss.rand() % sum < e.count)
+ || (pickBest && e.count == best))
+ move = Move(e.move);
+ }
+
+ if (!move)
+ return MOVE_NONE;
+
+ // A PolyGlot book move is encoded as follows:
+ //
+ // bit 0- 5: destination square (from 0 to 63)
+ // bit 6-11: origin square (from 0 to 63)
+ // bit 12-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
+ //
+ // Castling moves follow "king captures rook" representation. So in case book
+ // move is a promotion we have to convert to our representation, in all the
+ // other cases we can directly compare with a Move after having masked out
+ // the special Move's flags (bit 14-15) that are not supported by PolyGlot.
+ int pt = (move >> 12) & 7;
+ if (pt)
+ move = make(from_sq(move), to_sq(move), PieceType(pt + 1));
+
+ // Add 'special move' flags and verify it is legal
+ for (MoveList it(pos); *it; ++it)
+ if (move == (*it ^ type_of(*it)))
+ return *it;
+
+ return MOVE_NONE;
+}
+
+
+/// find_first() takes a book key as input, and does a binary search through
+/// the book file for the given key. Returns the index of the leftmost book
+/// entry with the same key as the input.
+
+size_t PolyglotBook::find_first(Key key) {
+
+ seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size
+
+ size_t low = 0, mid, high = (size_t)tellg() / sizeof(Entry) - 1;
+ Entry e;
+
+ assert(low <= high);
+
+ while (low < high && good())
+ {
+ mid = (low + high) / 2;
+
+ assert(mid >= low && mid < high);
+
+ seekg(mid * sizeof(Entry), ios_base::beg);
+ *this >> e;
+
+ if (key <= e.key)
+ high = mid;
+ else
+ low = mid + 1;
+ }
+
+ assert(low == high);
+
+ return low;
+}
diff --git a/stockfish-4-win/src/book.h b/stockfish-4-win/src/book.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ce74f471fddddfdef74b710e6de15153ac89d93
--- /dev/null
+++ b/stockfish-4-win/src/book.h
@@ -0,0 +1,45 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifndef BOOK_H_INCLUDED
+#define BOOK_H_INCLUDED
+
+#include
+#include
+
+#include "position.h"
+#include "rkiss.h"
+
+class PolyglotBook : private std::ifstream {
+public:
+ PolyglotBook();
+ ~PolyglotBook();
+ Move probe(const Position& pos, const std::string& fName, bool pickBest);
+
+private:
+ template PolyglotBook& operator>>(T& n);
+
+ bool open(const char* fName);
+ size_t find_first(Key key);
+
+ RKISS rkiss;
+ std::string fileName;
+};
+
+#endif // #ifndef BOOK_H_INCLUDED
diff --git a/stockfish-4-win/src/endgame.cpp b/stockfish-4-win/src/endgame.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cc98de90d4f40f71f900c04c1bbc71bd2322ec11
--- /dev/null
+++ b/stockfish-4-win/src/endgame.cpp
@@ -0,0 +1,964 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+
+#include "bitboard.h"
+#include "bitcount.h"
+#include "endgame.h"
+#include "movegen.h"
+
+using std::string;
+
+namespace {
+
+ // Table used to drive the defending king towards the edge of the board
+ // in KX vs K and KQ vs KR endgames.
+ const int MateTable[SQUARE_NB] = {
+ 100, 90, 80, 70, 70, 80, 90, 100,
+ 90, 70, 60, 50, 50, 60, 70, 90,
+ 80, 60, 40, 30, 30, 40, 60, 80,
+ 70, 50, 30, 20, 20, 30, 50, 70,
+ 70, 50, 30, 20, 20, 30, 50, 70,
+ 80, 60, 40, 30, 30, 40, 60, 80,
+ 90, 70, 60, 50, 50, 60, 70, 90,
+ 100, 90, 80, 70, 70, 80, 90, 100,
+ };
+
+ // Table used to drive the defending king towards a corner square of the
+ // right color in KBN vs K endgames.
+ const int KBNKMateTable[SQUARE_NB] = {
+ 200, 190, 180, 170, 160, 150, 140, 130,
+ 190, 180, 170, 160, 150, 140, 130, 140,
+ 180, 170, 155, 140, 140, 125, 140, 150,
+ 170, 160, 140, 120, 110, 140, 150, 160,
+ 160, 150, 140, 110, 120, 140, 160, 170,
+ 150, 140, 125, 140, 140, 155, 170, 180,
+ 140, 130, 140, 150, 160, 170, 180, 190,
+ 130, 140, 150, 160, 170, 180, 190, 200
+ };
+
+ // The attacking side is given a descending bonus based on distance between
+ // the two kings in basic endgames.
+ const int DistanceBonus[8] = { 0, 0, 100, 80, 60, 40, 20, 10 };
+
+ // Get the material key of a Position out of the given endgame key code
+ // like "KBPKN". The trick here is to first forge an ad-hoc fen string
+ // and then let a Position object to do the work for us. Note that the
+ // fen string could correspond to an illegal position.
+ Key key(const string& code, Color c) {
+
+ assert(code.length() > 0 && code.length() < 8);
+ assert(code[0] == 'K');
+
+ string sides[] = { code.substr(code.find('K', 1)), // Weaker
+ code.substr(0, code.find('K', 1)) }; // Stronger
+
+ std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
+
+ string fen = sides[0] + char('0' + int(8 - code.length()))
+ + sides[1] + "/8/8/8/8/8/8/8 w - - 0 10";
+
+ return Position(fen, false, NULL).material_key();
+ }
+
+ template
+ void delete_endgame(const typename M::value_type& p) { delete p.second; }
+
+} // namespace
+
+
+/// Endgames members definitions
+
+Endgames::Endgames() {
+
+ add("KK");
+ add("KPK");
+ add("KBK");
+ add("KNK");
+ add("KNNK");
+ add("KBNK");
+ add("KRKP");
+ add("KRKB");
+ add("KRKN");
+ add("KQKP");
+ add("KQKR");
+ add("KBBKN");
+
+ add("KNPK");
+ add("KNPKB");
+ add("KRPKR");
+ add("KBPKB");
+ add("KBPKN");
+ add("KBPPKB");
+ add("KRPPKRP");
+}
+
+Endgames::~Endgames() {
+
+ for_each(m1.begin(), m1.end(), delete_endgame);
+ for_each(m2.begin(), m2.end(), delete_endgame);
+}
+
+template
+void Endgames::add(const string& code) {
+
+ map((Endgame*)0)[key(code, WHITE)] = new Endgame(WHITE);
+ map((Endgame*)0)[key(code, BLACK)] = new Endgame(BLACK);
+}
+
+
+/// Mate with KX vs K. This function is used to evaluate positions with
+/// King and plenty of material vs a lone king. It simply gives the
+/// attacking side a bonus for driving the defending king towards the edge
+/// of the board, and for keeping the distance between the two kings small.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
+ assert(!pos.count(weakerSide));
+ assert(!pos.checkers()); // Eval is never called when in check
+
+ // Stalemate detection with lone king
+ if (pos.side_to_move() == weakerSide && !MoveList(pos).size())
+ return VALUE_DRAW;
+
+ Square winnerKSq = pos.king_square(strongerSide);
+ Square loserKSq = pos.king_square(weakerSide);
+
+ Value result = pos.non_pawn_material(strongerSide)
+ + pos.count(strongerSide) * PawnValueEg
+ + MateTable[loserKSq]
+ + DistanceBonus[square_distance(winnerKSq, loserKSq)];
+
+ if ( pos.count(strongerSide)
+ || pos.count(strongerSide)
+ || pos.bishop_pair(strongerSide))
+ result += VALUE_KNOWN_WIN;
+
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
+/// defending king towards a corner square of the right color.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == KnightValueMg + BishopValueMg);
+ assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count< PAWN>(strongerSide) == 0);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+
+ Square winnerKSq = pos.king_square(strongerSide);
+ Square loserKSq = pos.king_square(weakerSide);
+ Square bishopSq = pos.list(strongerSide)[0];
+
+ // kbnk_mate_table() tries to drive toward corners A1 or H8,
+ // if we have a bishop that cannot reach the above squares we
+ // mirror the kings so to drive enemy toward corners A8 or H1.
+ if (opposite_colors(bishopSq, SQ_A1))
+ {
+ winnerKSq = mirror(winnerKSq);
+ loserKSq = mirror(loserKSq);
+ }
+
+ Value result = VALUE_KNOWN_WIN
+ + DistanceBonus[square_distance(winnerKSq, loserKSq)]
+ + KBNKMateTable[loserKSq];
+
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KP vs K. This endgame is evaluated with the help of a bitbase.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
+ assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count(weakerSide ) == 0);
+
+ Square wksq, bksq, wpsq;
+ Color us;
+
+ if (strongerSide == WHITE)
+ {
+ wksq = pos.king_square(WHITE);
+ bksq = pos.king_square(BLACK);
+ wpsq = pos.list(WHITE)[0];
+ us = pos.side_to_move();
+ }
+ else
+ {
+ wksq = ~pos.king_square(BLACK);
+ bksq = ~pos.king_square(WHITE);
+ wpsq = ~pos.list(BLACK)[0];
+ us = ~pos.side_to_move();
+ }
+
+ if (file_of(wpsq) >= FILE_E)
+ {
+ wksq = mirror(wksq);
+ bksq = mirror(bksq);
+ wpsq = mirror(wpsq);
+ }
+
+ if (!Bitbases::probe_kpk(wksq, wpsq, bksq, us))
+ return VALUE_DRAW;
+
+ Value result = VALUE_KNOWN_WIN + PawnValueEg + Value(rank_of(wpsq));
+
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KP. This is a somewhat tricky endgame to evaluate precisely without
+/// a bitbase. The function below returns drawish scores when the pawn is
+/// far advanced with support of the king, while the attacking king is far
+/// away.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == RookValueMg);
+ assert(pos.non_pawn_material(weakerSide) == 0);
+ assert(pos.count(strongerSide) == 0);
+ assert(pos.count(weakerSide ) == 1);
+
+ Square wksq, wrsq, bksq, bpsq;
+ int tempo = (pos.side_to_move() == strongerSide);
+
+ wksq = pos.king_square(strongerSide);
+ bksq = pos.king_square(weakerSide);
+ wrsq = pos.list(strongerSide)[0];
+ bpsq = pos.list(weakerSide)[0];
+
+ if (strongerSide == BLACK)
+ {
+ wksq = ~wksq;
+ wrsq = ~wrsq;
+ bksq = ~bksq;
+ bpsq = ~bpsq;
+ }
+
+ Square queeningSq = file_of(bpsq) | RANK_1;
+ Value result;
+
+ // If the stronger side's king is in front of the pawn, it's a win
+ if (wksq < bpsq && file_of(wksq) == file_of(bpsq))
+ result = RookValueEg - Value(square_distance(wksq, bpsq));
+
+ // If the weaker side's king is too far from the pawn and the rook,
+ // it's a win
+ else if ( square_distance(bksq, bpsq) - (tempo ^ 1) >= 3
+ && square_distance(bksq, wrsq) >= 3)
+ result = RookValueEg - Value(square_distance(wksq, bpsq));
+
+ // If the pawn is far advanced and supported by the defending king,
+ // the position is drawish
+ else if ( rank_of(bksq) <= RANK_3
+ && square_distance(bksq, bpsq) == 1
+ && rank_of(wksq) >= RANK_4
+ && square_distance(wksq, bpsq) - tempo > 2)
+ result = Value(80 - square_distance(wksq, bpsq) * 8);
+
+ else
+ result = Value(200)
+ - Value(square_distance(wksq, bpsq + DELTA_S) * 8)
+ + Value(square_distance(bksq, bpsq + DELTA_S) * 8)
+ + Value(square_distance(bpsq, queeningSq) * 8);
+
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KB. This is very simple, and always returns drawish scores. The
+/// score is slightly bigger when the defending king is close to the edge.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == RookValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == BishopValueMg);
+ assert(pos.count(weakerSide ) == 1);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+ assert(pos.count< PAWN>(strongerSide) == 0);
+
+ Value result = Value(MateTable[pos.king_square(weakerSide)]);
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KN. The attacking side has slightly better winning chances than
+/// in KR vs KB, particularly if the king and the knight are far apart.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == RookValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == KnightValueMg);
+ assert(pos.count(weakerSide ) == 1);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+ assert(pos.count< PAWN>(strongerSide) == 0);
+
+ const int penalty[8] = { 0, 10, 14, 20, 30, 42, 58, 80 };
+
+ Square bksq = pos.king_square(weakerSide);
+ Square bnsq = pos.list(weakerSide)[0];
+ Value result = Value(MateTable[bksq] + penalty[square_distance(bksq, bnsq)]);
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KQ vs KP. In general, a win for the stronger side, however, there are a few
+/// important exceptions. Pawn on 7th rank, A,C,F or H file, with king next can
+/// be a draw, so we scale down to distance between kings only.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == QueenValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == VALUE_ZERO);
+ assert(pos.count(strongerSide) == 0);
+ assert(pos.count(weakerSide ) == 1);
+
+ Square winnerKSq = pos.king_square(strongerSide);
+ Square loserKSq = pos.king_square(weakerSide);
+ Square pawnSq = pos.list(weakerSide)[0];
+
+ Value result = QueenValueEg
+ - PawnValueEg
+ + DistanceBonus[square_distance(winnerKSq, loserKSq)];
+
+ if ( square_distance(loserKSq, pawnSq) == 1
+ && relative_rank(weakerSide, pawnSq) == RANK_7)
+ {
+ File f = file_of(pawnSq);
+
+ if (f == FILE_A || f == FILE_C || f == FILE_F || f == FILE_H)
+ result = Value(DistanceBonus[square_distance(winnerKSq, loserKSq)]);
+ }
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KQ vs KR. This is almost identical to KX vs K: We give the attacking
+/// king a bonus for having the kings close together, and for forcing the
+/// defending king towards the edge. If we also take care to avoid null move
+/// for the defending side in the search, this is usually sufficient to be
+/// able to win KQ vs KR.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == QueenValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == RookValueMg);
+ assert(pos.count(strongerSide) == 0);
+ assert(pos.count(weakerSide ) == 0);
+
+ Square winnerKSq = pos.king_square(strongerSide);
+ Square loserKSq = pos.king_square(weakerSide);
+
+ Value result = QueenValueEg
+ - RookValueEg
+ + MateTable[loserKSq]
+ + DistanceBonus[square_distance(winnerKSq, loserKSq)];
+
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == 2 * BishopValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == KnightValueMg);
+ assert(pos.count(strongerSide) == 2);
+ assert(pos.count(weakerSide ) == 1);
+ assert(!pos.pieces(PAWN));
+
+ Value result = BishopValueEg;
+ Square wksq = pos.king_square(strongerSide);
+ Square bksq = pos.king_square(weakerSide);
+ Square nsq = pos.list(weakerSide)[0];
+
+ // Bonus for attacking king close to defending king
+ result += Value(DistanceBonus[square_distance(wksq, bksq)]);
+
+ // Bonus for driving the defending king and knight apart
+ result += Value(square_distance(bksq, nsq) * 32);
+
+ // Bonus for restricting the knight's mobility
+ result += Value((8 - popcount(pos.attacks_from(nsq))) * 8);
+
+ return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Some cases of trivial draws
+template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; }
+
+
+/// K, bishop and one or more pawns vs K. It checks for draws with rook pawns and
+/// a bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_DRAW
+/// is returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
+/// will be used.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count< PAWN>(strongerSide) >= 1);
+
+ // No assertions about the material of weakerSide, because we want draws to
+ // be detected even when the weaker side has some pawns.
+
+ Bitboard pawns = pos.pieces(strongerSide, PAWN);
+ File pawnFile = file_of(pos.list(strongerSide)[0]);
+
+ // All pawns are on a single rook file ?
+ if ( (pawnFile == FILE_A || pawnFile == FILE_H)
+ && !(pawns & ~file_bb(pawnFile)))
+ {
+ Square bishopSq = pos.list(strongerSide)[0];
+ Square queeningSq = relative_square(strongerSide, pawnFile | RANK_8);
+ Square kingSq = pos.king_square(weakerSide);
+
+ if ( opposite_colors(queeningSq, bishopSq)
+ && abs(file_of(kingSq) - pawnFile) <= 1)
+ {
+ // The bishop has the wrong color, and the defending king is on the
+ // file of the pawn(s) or the adjacent file. Find the rank of the
+ // frontmost pawn.
+ Rank rank;
+ if (strongerSide == WHITE)
+ {
+ for (rank = RANK_7; !(rank_bb(rank) & pawns); rank--) {}
+ assert(rank >= RANK_2 && rank <= RANK_7);
+ }
+ else
+ {
+ for (rank = RANK_2; !(rank_bb(rank) & pawns); rank++) {}
+ rank = Rank(rank ^ 7); // HACK to get the relative rank
+ assert(rank >= RANK_2 && rank <= RANK_7);
+ }
+ // If the defending king has distance 1 to the promotion square or
+ // is placed somewhere in front of the pawn, it's a draw.
+ if ( square_distance(kingSq, queeningSq) <= 1
+ || relative_rank(strongerSide, kingSq) >= rank)
+ return SCALE_FACTOR_DRAW;
+ }
+ }
+
+ // All pawns on same B or G file? Then potential draw
+ if ( (pawnFile == FILE_B || pawnFile == FILE_G)
+ && !(pos.pieces(PAWN) & ~file_bb(pawnFile))
+ && pos.non_pawn_material(weakerSide) == 0
+ && pos.count(weakerSide) >= 1)
+ {
+ // Get weaker pawn closest to opponent's queening square
+ Bitboard wkPawns = pos.pieces(weakerSide, PAWN);
+ Square weakerPawnSq = strongerSide == WHITE ? msb(wkPawns) : lsb(wkPawns);
+
+ Square strongerKingSq = pos.king_square(strongerSide);
+ Square weakerKingSq = pos.king_square(weakerSide);
+ Square bishopSq = pos.list(strongerSide)[0];
+
+ // Draw if weaker pawn is on rank 7, bishop can't attack the pawn, and
+ // weaker king can stop opposing opponent's king from penetrating.
+ if ( relative_rank(strongerSide, weakerPawnSq) == RANK_7
+ && opposite_colors(bishopSq, weakerPawnSq)
+ && square_distance(weakerPawnSq, weakerKingSq) <= square_distance(weakerPawnSq, strongerKingSq))
+ return SCALE_FACTOR_DRAW;
+ }
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K and queen vs K, rook and one or more pawns. It tests for fortress draws with
+/// a rook on the third rank defended by a pawn.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == QueenValueMg);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count< PAWN>(strongerSide) == 0);
+ assert(pos.count< ROOK>(weakerSide ) == 1);
+ assert(pos.count< PAWN>(weakerSide ) >= 1);
+
+ Square kingSq = pos.king_square(weakerSide);
+ if ( relative_rank(weakerSide, kingSq) <= RANK_2
+ && relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4
+ && (pos.pieces(weakerSide, ROOK) & rank_bb(relative_rank(weakerSide, RANK_3)))
+ && (pos.pieces(weakerSide, PAWN) & rank_bb(relative_rank(weakerSide, RANK_2)))
+ && (pos.attacks_from(kingSq) & pos.pieces(weakerSide, PAWN)))
+ {
+ Square rsq = pos.list(weakerSide)[0];
+ if (pos.attacks_from(rsq, strongerSide) & pos.pieces(weakerSide, PAWN))
+ return SCALE_FACTOR_DRAW;
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K, rook and one pawn vs K and a rook. This function knows a handful of the
+/// most important classes of drawn positions, but is far from perfect. It would
+/// probably be a good idea to add more knowledge in the future.
+///
+/// It would also be nice to rewrite the actual code for this function,
+/// which is mostly copied from Glaurung 1.x, and not very pretty.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == RookValueMg);
+ assert(pos.non_pawn_material(weakerSide) == RookValueMg);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count(weakerSide ) == 0);
+
+ Square wksq = pos.king_square(strongerSide);
+ Square bksq = pos.king_square(weakerSide);
+ Square wrsq = pos.list(strongerSide)[0];
+ Square wpsq = pos.list(strongerSide)[0];
+ Square brsq = pos.list(weakerSide)[0];
+
+ // Orient the board in such a way that the stronger side is white, and the
+ // pawn is on the left half of the board.
+ if (strongerSide == BLACK)
+ {
+ wksq = ~wksq;
+ wrsq = ~wrsq;
+ wpsq = ~wpsq;
+ bksq = ~bksq;
+ brsq = ~brsq;
+ }
+ if (file_of(wpsq) > FILE_D)
+ {
+ wksq = mirror(wksq);
+ wrsq = mirror(wrsq);
+ wpsq = mirror(wpsq);
+ bksq = mirror(bksq);
+ brsq = mirror(brsq);
+ }
+
+ File f = file_of(wpsq);
+ Rank r = rank_of(wpsq);
+ Square queeningSq = f | RANK_8;
+ int tempo = (pos.side_to_move() == strongerSide);
+
+ // If the pawn is not too far advanced and the defending king defends the
+ // queening square, use the third-rank defence.
+ if ( r <= RANK_5
+ && square_distance(bksq, queeningSq) <= 1
+ && wksq <= SQ_H5
+ && (rank_of(brsq) == RANK_6 || (r <= RANK_3 && rank_of(wrsq) != RANK_6)))
+ return SCALE_FACTOR_DRAW;
+
+ // The defending side saves a draw by checking from behind in case the pawn
+ // has advanced to the 6th rank with the king behind.
+ if ( r == RANK_6
+ && square_distance(bksq, queeningSq) <= 1
+ && rank_of(wksq) + tempo <= RANK_6
+ && (rank_of(brsq) == RANK_1 || (!tempo && abs(file_of(brsq) - f) >= 3)))
+ return SCALE_FACTOR_DRAW;
+
+ if ( r >= RANK_6
+ && bksq == queeningSq
+ && rank_of(brsq) == RANK_1
+ && (!tempo || square_distance(wksq, wpsq) >= 2))
+ return SCALE_FACTOR_DRAW;
+
+ // White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7
+ // and the black rook is behind the pawn.
+ if ( wpsq == SQ_A7
+ && wrsq == SQ_A8
+ && (bksq == SQ_H7 || bksq == SQ_G7)
+ && file_of(brsq) == FILE_A
+ && (rank_of(brsq) <= RANK_3 || file_of(wksq) >= FILE_D || rank_of(wksq) <= RANK_5))
+ return SCALE_FACTOR_DRAW;
+
+ // If the defending king blocks the pawn and the attacking king is too far
+ // away, it's a draw.
+ if ( r <= RANK_5
+ && bksq == wpsq + DELTA_N
+ && square_distance(wksq, wpsq) - tempo >= 2
+ && square_distance(wksq, brsq) - tempo >= 2)
+ return SCALE_FACTOR_DRAW;
+
+ // Pawn on the 7th rank supported by the rook from behind usually wins if the
+ // attacking king is closer to the queening square than the defending king,
+ // and the defending king cannot gain tempi by threatening the attacking rook.
+ if ( r == RANK_7
+ && f != FILE_A
+ && file_of(wrsq) == f
+ && wrsq != queeningSq
+ && (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo)
+ && (square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo))
+ return ScaleFactor(SCALE_FACTOR_MAX - 2 * square_distance(wksq, queeningSq));
+
+ // Similar to the above, but with the pawn further back
+ if ( f != FILE_A
+ && file_of(wrsq) == f
+ && wrsq < wpsq
+ && (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo)
+ && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wpsq + DELTA_N) - 2 + tempo)
+ && ( square_distance(bksq, wrsq) + tempo >= 3
+ || ( square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo
+ && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wrsq) + tempo))))
+ return ScaleFactor( SCALE_FACTOR_MAX
+ - 8 * square_distance(wpsq, queeningSq)
+ - 2 * square_distance(wksq, queeningSq));
+
+ // If the pawn is not far advanced, and the defending king is somewhere in
+ // the pawn's path, it's probably a draw.
+ if (r <= RANK_4 && bksq > wpsq)
+ {
+ if (file_of(bksq) == file_of(wpsq))
+ return ScaleFactor(10);
+ if ( abs(file_of(bksq) - file_of(wpsq)) == 1
+ && square_distance(wksq, bksq) > 2)
+ return ScaleFactor(24 - 2 * square_distance(wksq, bksq));
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K, rook and two pawns vs K, rook and one pawn. There is only a single
+/// pattern: If the stronger side has no passed pawns and the defending king
+/// is actively placed, the position is drawish.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == RookValueMg);
+ assert(pos.non_pawn_material(weakerSide) == RookValueMg);
+ assert(pos.count(strongerSide) == 2);
+ assert(pos.count(weakerSide ) == 1);
+
+ Square wpsq1 = pos.list(strongerSide)[0];
+ Square wpsq2 = pos.list(strongerSide)[1];
+ Square bksq = pos.king_square(weakerSide);
+
+ // Does the stronger side have a passed pawn?
+ if ( pos.pawn_is_passed(strongerSide, wpsq1)
+ || pos.pawn_is_passed(strongerSide, wpsq2))
+ return SCALE_FACTOR_NONE;
+
+ Rank r = std::max(relative_rank(strongerSide, wpsq1), relative_rank(strongerSide, wpsq2));
+
+ if ( file_distance(bksq, wpsq1) <= 1
+ && file_distance(bksq, wpsq2) <= 1
+ && relative_rank(strongerSide, bksq) > r)
+ {
+ switch (r) {
+ case RANK_2: return ScaleFactor(10);
+ case RANK_3: return ScaleFactor(10);
+ case RANK_4: return ScaleFactor(15);
+ case RANK_5: return ScaleFactor(20);
+ case RANK_6: return ScaleFactor(40);
+ default: assert(false);
+ }
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K and two or more pawns vs K. There is just a single rule here: If all pawns
+/// are on the same rook file and are blocked by the defending king, it's a draw.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
+ assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
+ assert(pos.count(strongerSide) >= 2);
+ assert(pos.count(weakerSide ) == 0);
+
+ Square ksq = pos.king_square(weakerSide);
+ Bitboard pawns = pos.pieces(strongerSide, PAWN);
+
+ // Are all pawns on the 'a' file?
+ if (!(pawns & ~FileABB))
+ {
+ // Does the defending king block the pawns?
+ if ( square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1
+ || ( file_of(ksq) == FILE_A
+ && !(in_front_bb(strongerSide, rank_of(ksq)) & pawns)))
+ return SCALE_FACTOR_DRAW;
+ }
+ // Are all pawns on the 'h' file?
+ else if (!(pawns & ~FileHBB))
+ {
+ // Does the defending king block the pawns?
+ if ( square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1
+ || ( file_of(ksq) == FILE_H
+ && !(in_front_bb(strongerSide, rank_of(ksq)) & pawns)))
+ return SCALE_FACTOR_DRAW;
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K, bishop and a pawn vs K and a bishop. There are two rules: If the defending
+/// king is somewhere along the path of the pawn, and the square of the king is
+/// not of the same color as the stronger side's bishop, it's a draw. If the two
+/// bishops have opposite color, it's almost always a draw.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == BishopValueMg);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count(weakerSide ) == 1);
+ assert(pos.count< PAWN>(strongerSide) == 1);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+
+ Square pawnSq = pos.list(strongerSide)[0];
+ Square strongerBishopSq = pos.list(strongerSide)[0];
+ Square weakerBishopSq = pos.list(weakerSide)[0];
+ Square weakerKingSq = pos.king_square(weakerSide);
+
+ // Case 1: Defending king blocks the pawn, and cannot be driven away
+ if ( file_of(weakerKingSq) == file_of(pawnSq)
+ && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
+ && ( opposite_colors(weakerKingSq, strongerBishopSq)
+ || relative_rank(strongerSide, weakerKingSq) <= RANK_6))
+ return SCALE_FACTOR_DRAW;
+
+ // Case 2: Opposite colored bishops
+ if (opposite_colors(strongerBishopSq, weakerBishopSq))
+ {
+ // We assume that the position is drawn in the following three situations:
+ //
+ // a. The pawn is on rank 5 or further back.
+ // b. The defending king is somewhere in the pawn's path.
+ // c. The defending bishop attacks some square along the pawn's path,
+ // and is at least three squares away from the pawn.
+ //
+ // These rules are probably not perfect, but in practice they work
+ // reasonably well.
+
+ if (relative_rank(strongerSide, pawnSq) <= RANK_5)
+ return SCALE_FACTOR_DRAW;
+ else
+ {
+ Bitboard path = forward_bb(strongerSide, pawnSq);
+
+ if (path & pos.pieces(weakerSide, KING))
+ return SCALE_FACTOR_DRAW;
+
+ if ( (pos.attacks_from(weakerBishopSq) & path)
+ && square_distance(weakerBishopSq, pawnSq) >= 3)
+ return SCALE_FACTOR_DRAW;
+ }
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K, bishop and two pawns vs K and bishop. It detects a few basic draws with
+/// opposite-colored bishops.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == BishopValueMg);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count(weakerSide ) == 1);
+ assert(pos.count< PAWN>(strongerSide) == 2);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+
+ Square wbsq = pos.list(strongerSide)[0];
+ Square bbsq = pos.list(weakerSide)[0];
+
+ if (!opposite_colors(wbsq, bbsq))
+ return SCALE_FACTOR_NONE;
+
+ Square ksq = pos.king_square(weakerSide);
+ Square psq1 = pos.list(strongerSide)[0];
+ Square psq2 = pos.list(strongerSide)[1];
+ Rank r1 = rank_of(psq1);
+ Rank r2 = rank_of(psq2);
+ Square blockSq1, blockSq2;
+
+ if (relative_rank(strongerSide, psq1) > relative_rank(strongerSide, psq2))
+ {
+ blockSq1 = psq1 + pawn_push(strongerSide);
+ blockSq2 = file_of(psq2) | rank_of(psq1);
+ }
+ else
+ {
+ blockSq1 = psq2 + pawn_push(strongerSide);
+ blockSq2 = file_of(psq1) | rank_of(psq2);
+ }
+
+ switch (file_distance(psq1, psq2))
+ {
+ case 0:
+ // Both pawns are on the same file. Easy draw if defender firmly controls
+ // some square in the frontmost pawn's path.
+ if ( file_of(ksq) == file_of(blockSq1)
+ && relative_rank(strongerSide, ksq) >= relative_rank(strongerSide, blockSq1)
+ && opposite_colors(ksq, wbsq))
+ return SCALE_FACTOR_DRAW;
+ else
+ return SCALE_FACTOR_NONE;
+
+ case 1:
+ // Pawns on adjacent files. Draw if defender firmly controls the square
+ // in front of the frontmost pawn's path, and the square diagonally behind
+ // this square on the file of the other pawn.
+ if ( ksq == blockSq1
+ && opposite_colors(ksq, wbsq)
+ && ( bbsq == blockSq2
+ || (pos.attacks_from(blockSq2) & pos.pieces(weakerSide, BISHOP))
+ || abs(r1 - r2) >= 2))
+ return SCALE_FACTOR_DRAW;
+
+ else if ( ksq == blockSq2
+ && opposite_colors(ksq, wbsq)
+ && ( bbsq == blockSq1
+ || (pos.attacks_from(blockSq1) & pos.pieces(weakerSide, BISHOP))))
+ return SCALE_FACTOR_DRAW;
+ else
+ return SCALE_FACTOR_NONE;
+
+ default:
+ // The pawns are not on the same file or adjacent files. No scaling.
+ return SCALE_FACTOR_NONE;
+ }
+}
+
+
+/// K, bisop and a pawn vs K and knight. There is a single rule: If the defending
+/// king is somewhere along the path of the pawn, and the square of the king is
+/// not of the same color as the stronger side's bishop, it's a draw.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == KnightValueMg);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count(weakerSide ) == 1);
+ assert(pos.count< PAWN>(strongerSide) == 1);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+
+ Square pawnSq = pos.list(strongerSide)[0];
+ Square strongerBishopSq = pos.list(strongerSide)[0];
+ Square weakerKingSq = pos.king_square(weakerSide);
+
+ if ( file_of(weakerKingSq) == file_of(pawnSq)
+ && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
+ && ( opposite_colors(weakerKingSq, strongerBishopSq)
+ || relative_rank(strongerSide, weakerKingSq) <= RANK_6))
+ return SCALE_FACTOR_DRAW;
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K, knight and a pawn vs K. There is a single rule: If the pawn is a rook pawn
+/// on the 7th rank and the defending king prevents the pawn from advancing, the
+/// position is drawn.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == KnightValueMg);
+ assert(pos.non_pawn_material(weakerSide ) == VALUE_ZERO);
+ assert(pos.count(strongerSide) == 1);
+ assert(pos.count< PAWN>(strongerSide) == 1);
+ assert(pos.count< PAWN>(weakerSide ) == 0);
+
+ Square pawnSq = pos.list(strongerSide)[0];
+ Square weakerKingSq = pos.king_square(weakerSide);
+
+ if ( pawnSq == relative_square(strongerSide, SQ_A7)
+ && square_distance(weakerKingSq, relative_square(strongerSide, SQ_A8)) <= 1)
+ return SCALE_FACTOR_DRAW;
+
+ if ( pawnSq == relative_square(strongerSide, SQ_H7)
+ && square_distance(weakerKingSq, relative_square(strongerSide, SQ_H8)) <= 1)
+ return SCALE_FACTOR_DRAW;
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K, knight and a pawn vs K and bishop. If knight can block bishop from taking
+/// pawn, it's a win. Otherwise, drawn.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ Square pawnSq = pos.list(strongerSide)[0];
+ Square bishopSq = pos.list(weakerSide)[0];
+ Square weakerKingSq = pos.king_square(weakerSide);
+
+ // King needs to get close to promoting pawn to prevent knight from blocking.
+ // Rules for this are very tricky, so just approximate.
+ if (forward_bb(strongerSide, pawnSq) & pos.attacks_from(bishopSq))
+ return ScaleFactor(square_distance(weakerKingSq, pawnSq));
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K and a pawn vs K and a pawn. This is done by removing the weakest side's
+/// pawn and probing the KP vs K bitbase: If the weakest side has a draw without
+/// the pawn, she probably has at least a draw with the pawn as well. The exception
+/// is when the stronger side's pawn is far advanced and not on a rook file; in
+/// this case it is often possible to win (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1).
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
+ assert(pos.non_pawn_material(weakerSide ) == VALUE_ZERO);
+ assert(pos.count(WHITE) == 1);
+ assert(pos.count(BLACK) == 1);
+
+ Square wksq = pos.king_square(strongerSide);
+ Square bksq = pos.king_square(weakerSide);
+ Square wpsq = pos.list(strongerSide)[0];
+ Color us = pos.side_to_move();
+
+ if (strongerSide == BLACK)
+ {
+ wksq = ~wksq;
+ bksq = ~bksq;
+ wpsq = ~wpsq;
+ us = ~us;
+ }
+
+ if (file_of(wpsq) >= FILE_E)
+ {
+ wksq = mirror(wksq);
+ bksq = mirror(bksq);
+ wpsq = mirror(wpsq);
+ }
+
+ // If the pawn has advanced to the fifth rank or further, and is not a
+ // rook pawn, it's too dangerous to assume that it's at least a draw.
+ if ( rank_of(wpsq) >= RANK_5
+ && file_of(wpsq) != FILE_A)
+ return SCALE_FACTOR_NONE;
+
+ // Probe the KPK bitbase with the weakest side's pawn removed. If it's a draw,
+ // it's probably at least a draw even with the pawn.
+ return Bitbases::probe_kpk(wksq, wpsq, bksq, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
+}
diff --git a/stockfish-4-win/src/endgame.h b/stockfish-4-win/src/endgame.h
new file mode 100644
index 0000000000000000000000000000000000000000..5529eae108429e35fba55f9a1c7ec362c68c3789
--- /dev/null
+++ b/stockfish-4-win/src/endgame.h
@@ -0,0 +1,125 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifndef ENDGAME_H_INCLUDED
+#define ENDGAME_H_INCLUDED
+
+#include