diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index cc8e8398..b64d416c 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -21,7 +21,7 @@ jobs:
           - os: windows-latest
             build_command: make build ARCH=x64 COMP=gcc OS=windows
           - os: macos-latest
-            build_command: make build ARCH=x64-modern COMP=gcc OS=osx
+            build_command: make build ARCH=arm COMP=gcc OS=osx
 
     steps:
     - uses: actions/checkout@v2
diff --git a/.gitignore b/.gitignore
index 001704be..fb9fa71c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+<<<<<<< HEAD
+<<<<<<< HEAD
 bin/
 data/
 doc/
@@ -5,3 +7,38 @@ doc/
 *.7z
 
 .DS_Store
+=======
+*.o
+*.s
+*.exe
+*~
+pgopti*
+*.dyn
+all.gc*
+generate_flip.*
+generate_count_flip.*
+bcnttest.*
+*.utf8.c
+bin/
+doc/
+<<<<<<< HEAD
+>>>>>>> dd6b636 (Bcc32 friendly and minor improvement on Flip_32.)
+=======
+problem/
+>>>>>>> 48873fa (calc opponent_feature once in eval_open)
+=======
+*.o
+*.s
+*.exe
+*~
+pgopti*
+*.dyn
+all.gc*
+generate_flip.*
+generate_count_flip.*
+bcnttest.*
+*.utf8.c
+bin/
+doc/
+problem/
+>>>>>>> 3e1ed4f (fix cr/lf in repository to lf)
diff --git a/README.md b/README.md
index def41a7a..22b96b04 100644
--- a/README.md
+++ b/README.md
@@ -51,3 +51,111 @@ cd src
 doxygen
 open ../doc/html/index.html
 ```
+=======
+# edax-reversi-AVX
+Automatically exported from code.google.com/p/okuharaandroid-edax-reversi
+
+=======
+# edax-reversi-AVX
+Automatically exported from code.google.com/p/okuharaandroid-edax-reversi
+
+Edax is a strong othello program. Its main features are:
+
+    fast bitboard based & multithreaded engine.
+    accurate midgame-evaluation function.
+    opening book learning capability.
+    text based rich interface.
+    multi-protocol support to connect to graphical interfaces or play on Internet (GGS).
+    multi-OS support to run under MS-Windows, Linux and Mac OS X.
+
+>>>>>>> 81dec96 (Kindergarten last flip for arm32; MSVC arm Windows build (not tested))
+This is SSE/AVX optimized version of Edax 4.4.0. Functionally equivalent to the parent project, provided no bugs are introduced.
+
+Thanks to AVX2, x64-modern build solves fforum-40-59.obf 60% faster than official edax-4.4 on Haswell, and runs level 30 autoplay 80% faster.
+
+See http://www.amy.hi-ho.ne.jp/okuhara/bitboard.htm and http://www.amy.hi-ho.ne.jp/okuhara/edaxopt.htm for optimization details in Japanese.
+
+## 1. Mobility (board_sse.c, board_mmx.c)
+
+### 1.1 new SSE2 version of get_moves
+Diagonals are SIMD'd using vertical mirroring by bswap.
+
+    Athlon -get_moves_sse
+    problem\fforum-20-39.obf: 111349635 nodes in 0:07.998 (13922185 nodes/s).
+    mobility: 81.10 < 81.28 +/- 0.17 < 82.03
+    Athlon +get_moves_sse
+    problem\fforum-20-39.obf: 111349635 nodes in 0:07.889 (14114544 nodes/s).
+    mobility: 71.08 < 71.72 +/- 0.34 < 73.53
+    Core2 -get_moves_sse
+    problem/fforum-20-39.obf: 111349635 nodes in 0:10.180 (10938078 nodes/s).
+    mobility: 78.06 < 78.18 +/- 0.08 < 78.41
+    Core2 +get_moves_sse
+    problem/fforum-20-39.obf: 111349635 nodes in 0:09.978 (11159514 nodes/s).
+    mobility: 60.84 < 61.19 +/- 0.13 < 61.47
+
+### 1.2 can_move
+Now calls SIMD'd get_moves for x86/x64 build.
+
+## 2. Stability (board.c, board_sse.c, board_mmx.c)
+
+### 2.1 get_full_lines_h, get_full_lines_v
+get_full_lines for horizontal and vertical are simplified. The latter is compiled into rotation instrunction.
+
+### 2.2 rearranged loop
+The last while loop is rearranged not to call bit_count in case stable == 0.
+
+### 2.3 new SSE2 version with bswap and pcmpeqb
+    Athlon -get_stability_sse
+    stability: 90.10 < 90.28 +/- 0.24 < 91.20
+    Athlon +get_stability_sse
+    stability: 81.59 < 81.93 +/- 0.73 < 86.25
+    Core2 -get_stability_sse
+    stability: 79.24 < 79.39 +/- 0.15 < 79.93
+    Core2 +get_stability_sse
+    stability: 71.80 < 71.85 +/- 0.06 < 72.07
+
+### 2.4 get_corner_stability
+Kindergarten version eliminates bit_count call.
+
+### 2.5 find_edge_stable
+Loop optimization and flip using carry propagation. One time execution but affect total solving time.
+
+## 3. eval.c (4.4.5)
+Eval feature calculation using SSE2 / AVX2 (now in eval_sse.c) improves midgame by 15-30% and endgame by 8-12%.
+Restoring eval from backup instead of rewinding.
+eval_open (one time execution) is also optimized.
+
+## 4. hash.c
+I think hash->data.move[0] on line 677 should be hash->data.move[1].
+
+## 5. board_symetry, board_unique (board.c, board_sse.c)
+SSE optimization and mirroring reduction. (Not used in solving game)
+
+## 6. endgame_sse.c (4.4.7)
+Keep more variables in SSE registers.  SSE optimized count_last_flip.  Parity sort by shuffle.
+
+## 7. board_get_hash_code (4.5.0)
+Changed to use CRC32c.  This enables hardware acceleration on modern build.
+
+## 8. AVX2 versions (x64-modern build only)
+In many cases AVX2 version is simplest, thanks to variable shift instructions (although they are 3 micro-op instructions).
+
+Benchmarks are on Core i5-4260U (Haswell) 1.4GHz (TB 2.7GHz) single thread.
+
+    4.4.0 original x64-modern clang
+    problem/fforum-20-39.obf: 111349635 nodes in 0:05.726 (19446321 nodes/s).
+    +optimizations 1-5 above, no-avx2
+    problem/fforum-20-39.obf: 111349635 nodes in 0:05.342 (20844185 nodes/s).
+    +get_moves (board_sse.c)
+    problem/fforum-20-39.obf: 111349635 nodes in 0:05.142 (21654927 nodes/s).
+    +flip_avx.c
+    problem/fforum-20-39.obf: 111349635 nodes in 0:04.946 (22513068 nodes/s).
+    +count_last_flip_sse.c
+    problem/fforum-20-39.obf: 111349635 nodes in 0:04.906 (22696624 nodes/s).
+
+## 9. makefile
+gcc-old, x86 build should be -m32, not -m64. Some flags and defines added for optimization.
+<<<<<<< HEAD
+>>>>>>> b9d48c1 (Create README.md)
+=======
+>>>>>>> 81dec96 (Kindergarten last flip for arm32; MSVC arm Windows build (not tested))
diff --git a/src/Android.mk b/src/Android.mk
new file mode 100644
index 00000000..4a54afdc
--- /dev/null
+++ b/src/Android.mk
@@ -0,0 +1,8 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := aEdax # should be renamed to lib..aEdax..so afterwords
+LOCAL_CFLAGS += -DUNICODE
+LOCAL_SRC_FILES := all.c board_sse.c.neon eval_sse.c.neon flip_neon_bitscan.c.neon android/cpu-features.c
+LOCAL_ARM_NEON := false
+# cmd-strip :=
+include $(BUILD_EXECUTABLE)
diff --git a/src/Application.mk b/src/Application.mk
new file mode 100644
index 00000000..6a59b5f1
--- /dev/null
+++ b/src/Application.mk
@@ -0,0 +1,3 @@
+APP_ABI := armeabi-v7a arm64-v8a x86 x86_64
+APP_PLATFORM := android-14
+APP_BUILD_SCRIPT := Android.mk
diff --git a/src/Doxyfile b/src/Doxyfile
index 8a539572..db85cfe5 100644
--- a/src/Doxyfile
+++ b/src/Doxyfile
@@ -687,7 +687,7 @@ RECURSIVE              = NO
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                =
+EXCLUDE                = _*.c
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
@@ -1599,7 +1599,7 @@ HIDE_UNDOC_RELATIONS   = YES
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section
 # have no effect if this option is set to NO (the default)
 
-HAVE_DOT               = YES
+HAVE_DOT               = NO
 
 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
 # allowed to run in parallel. When set to 0 (the default) doxygen will
@@ -1688,7 +1688,7 @@ INCLUDED_BY_GRAPH      = YES
 # the time of a run. So in most cases it will be better to enable call graphs
 # for selected functions only using the \callgraph command.
 
-CALL_GRAPH             = YES
+CALL_GRAPH             = NO
 
 # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
 # doxygen will generate a caller dependency graph for every global function
@@ -1696,7 +1696,7 @@ CALL_GRAPH             = YES
 # the time of a run. So in most cases it will be better to enable caller
 # graphs for selected functions only using the \callergraph command.
 
-CALLER_GRAPH           = YES
+CALLER_GRAPH           = NO
 
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
 # will generate a graphical hierarchy of all classes instead of a textual one.
diff --git a/src/Makefile b/src/Makefile
index 87974154..4f6f51c3 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,9 +1,9 @@
 #
 # makefile to Compile Edax
 #
-# Copyright 1998 - 2012
+# Copyright 1998 - 2024
 # Richard Delorme
-# Version 4.3
+# Version 4.5
 #
 
 # Default settings
@@ -38,51 +38,89 @@ endif
 
 # gcc 4.x (x >= 7)
 ifeq ($(COMP),gcc)
-	CFLAGS = -std=c99 -pedantic -W -Wall -Wextra -pipe -D_GNU_SOURCE=1
+	CFLAGS = -std=c99 -pedantic -W -Wall -Wextra -pipe -D_GNU_SOURCE=1 -DUNICODE
 	PGO_GEN = -fprofile-generate
 	PGO_USE = -fprofile-correction -fprofile-use
-	
+
 	ifeq ($(BUILD),optimize)
-		CFLAGS += -Ofast -fwhole-program -flto -DNDEBUG
+		CFLAGS += -Ofast -fwhole-program -DNDEBUG
+		LTOFLAG = -flto
 	else
-		CFLAGS += -O0 -g -DDEBUG
+		CFLAGS += -O1 -g -DDEBUG
 	endif
 
 	ifeq ($(ARCH),x64-modern)
-		CFLAGS += -m64 -march=native -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -m64 -march=core-avx2 -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
+	endif
+	ifeq ($(ARCH),x64-avx512)
+		CFLAGS += -m64 -march=skylake-avx512 -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
+	endif
+	ifeq ($(ARCH),x64-popcnt)
+		CFLAGS += -m64 -mpopcnt -mtune=generic -DUSE_GAS_X64 -DPOPCOUNT
+	endif
+	ifeq ($(ARCH),x64-k10)
+		CFLAGS += -m64 -march=amdfam10 -DUSE_GAS_X64 -DPOPCOUNT -DMOVE_GENERATOR=MOVE_GENERATOR_BITSCAN
 	endif
 	ifeq ($(ARCH),x32-modern)
-		CFLAGS += -mx32 -march=native -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -mx32 -march=core-avx2 -DUSE_GAS_X64 -DPOPCOUNT
 	endif
 	ifeq ($(ARCH),x64)
-		CFLAGS += -m64 -mtune=generic -DUSE_GAS_X64 
+		CFLAGS += -m64 -mtune=generic -DUSE_GAS_X64
 	endif
 	ifeq ($(ARCH),x32)
-		CFLAGS += -mx32 -march=native -DUSE_GAS_X64
+		CFLAGS += -mx32 -mtune=generic -DUSE_GAS_X64
+	endif
+	ifeq ($(ARCH),x86-sse)
+		CFLAGS += -m32 -march=pentium-m -mfpmath=sse -DUSE_GAS_X86 -DUSE_GAS_MMX -DhasSSE2
+		ifeq ($(BUILD),optimize)
+			CFLAGS += -fomit-frame-pointer
+		endif
 	endif
 	ifeq ($(ARCH),x86)
-		CFLAGS += -m32 -mtune=generic -DUSE_GAS_X86
+		CFLAGS += -m32 -march=i386 -mtune=generic -DUSE_GAS_X86 -DUSE_GAS_MMX
 		ifeq ($(BUILD),optimize)
 			CFLAGS += -fomit-frame-pointer
 		endif
 	endif
-	ifeq ($(ARCH),ARM)
+	ifeq ($(ARCH),arm)
 		ifeq ($(BUILD),optimize)
-			CFLAGS += -fomit-frame-pointer -DUSE_GCC_ARM
+			CFLAGS += -fomit-frame-pointer
 		endif
 	endif
-	ifeq ($(ARCH),ARMv7)
+	ifeq ($(ARCH),armv7)
+		CFLAGS += -march=armv7-a
 		ifeq ($(BUILD),optimize)
-			CFLAGS += -fomit-frame-pointer -march=armv7-a -mfpu=neon -DUSE_GCC_ARM
+			CFLAGS += -fomit-frame-pointer
+		endif
+	endif
+	ifeq ($(ARCH),arm-neon)
+		CFLAGS += -march=armv7-a+simd -mfloat-abi=softfp
+		ifeq ($(BUILD),optimize)
+			CFLAGS += -fomit-frame-pointer
+		endif
+	endif
+	ifeq ($(ARCH),arm-sve)
+		CFLAGS += -march=armv8.2-a+sve
+		ifeq ($(BUILD),optimize)
+			CFLAGS += -fomit-frame-pointer
 		endif
 	endif
 
 	ifeq ($(OS),osx)
 		CFLAGS += -mmacosx-version-min=10.4
+		ifeq ($(ARCH),x86)
+			CFLAGS += -msse2 -DhasSSE2
+		endif
+		ifeq ($(ARCH),arm)
+			CFLAGS += -march=armv8.3-a
+		endif
+	endif
+	ifeq ($(OS),android)
+		CFLAGS += -DANDROID=1
 	endif
 	ifeq ($(OS),windows)
-		CFLAGS += -D__USE_MINGW_ANSI_STDIO -DWINVER=0x501
-		ifeq ($(ARCH),x86)
+		CFLAGS += -D__USE_MINGW_ANSI_STDIO -DWINVER=0x0501
+		ifneq (,$(findstring x86,$(ARCH)))
 			CFLAGS += -DUSE_PTHREAD
 		endif
 	endif
@@ -90,8 +128,9 @@ ifeq ($(COMP),gcc)
 endif
 
 ifeq ($(COMP),gcc-old)
-	CFLAGS = -std=c99 -pedantic -W -Wall -Wextra -pipe -D_GNU_SOURCE=1
-	
+	CC = gcc
+	CFLAGS = -std=c99 -pedantic -W -Wall -Wextra -pipe -D_GNU_SOURCE=1 -DUNICODE
+
 	ifeq ($(BUILD),optimize)
 		CFLAGS += -O3 -fwhole-program -DNDEBUG
 	else
@@ -99,30 +138,33 @@ ifeq ($(COMP),gcc-old)
 	endif
 
 	ifeq ($(ARCH),x64-modern)
-		CFLAGS += -m64 -march=native -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -m64 -march=native -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
 	endif
 	ifeq ($(ARCH),x64)
 		CFLAGS += -m64 -mtune=generic -DUSE_GAS_X64 
 	endif
 	ifeq ($(ARCH),x86)
-		CFLAGS += -m64 -mtune=generic -DUSE_GAS_X86
+		CFLAGS += -m32 -mtune=generic -DUSE_GAS_X86 -DUSE_GAS_MMX
 		ifeq ($(BUILD),optimize)
 			CFLAGS += -fomit-frame-pointer
 		endif
 	endif
-	ifeq ($(ARCH),ARM)
+	ifeq ($(ARCH),arm)
 		ifeq ($(BUILD),optimize)
 			CFLAGS += -fomit-frame-pointer -DUSE_GCC_ARM
 		endif
 	endif
-	ifeq ($(ARCH),ARMv7)
+	ifeq ($(ARCH),armv7)
 		ifeq ($(BUILD),optimize)
 			CFLAGS += -fomit-frame-pointer -march=armv7-a -mfpu=neon -DUSE_GCC_ARM
 		endif
 	endif
 
 	ifeq ($(OS),osx)
-		CFLAGS += -mmacosx-version-min=10.4
+		CFLAGS += -mmacosx-version-min=10.4 -mdynamic-no-pic
+		ifeq ($(ARCH),x86)
+			CFLAGS += -msse2 -DhasSSE2
+		endif
 	endif
 	ifeq ($(OS),android)
 		CFLAGS += -DANDROID=1
@@ -138,24 +180,25 @@ endif
 
 # g++
 ifeq ($(COMP),g++)
-	CFLAGS = -x c++ -std=c++11 -pedantic -W -Wall -Wextra -pipe -D_GNU_SOURCE=1
+	CFLAGS = -x c++ -std=c++11 -pedantic -W -Wall -Wextra -pipe -D_GNU_SOURCE=1 -DUNICODE
 	PGO_GEN = -fprofile-generate
 	PGO_USE = -fprofile-correction -fprofile-use
 
 	ifeq ($(BUILD),optimize)
-		CFLAGS += -Ofast -fwhole-program -flto -DNDEBUG
+		CFLAGS += -Ofast -fwhole-program -DNDEBUG
+		LTOFLAG = -flto
 	else
 		CFLAGS += -O0 -g -DDEBUG
 	endif
 
 	ifeq ($(ARCH),x64-modern)
-		CFLAGS += -m64 -march=native -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -m64 -march=native -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
 	endif
 	ifeq ($(ARCH),x64)
 		CFLAGS += -m64 -mtune=generic -DUSE_GAS_X64 
 	endif
 	ifeq ($(ARCH),x86)
-		CFLAGS += -m32 -mtune=generic -DUSE_GAS_X86
+		CFLAGS += -m32 -mtune=generic -DUSE_GAS_X86 -DUSE_GAS_MMX
 		ifeq ($(BUILD),optimize)
 			CFLAGS += -fomit-frame-pointer
 		endif
@@ -163,6 +206,9 @@ ifeq ($(COMP),g++)
 
 	ifeq ($(OS),osx)
 		CFLAGS += -mmacosx-version-min=10.4 -mdynamic-no-pic
+		ifeq ($(ARCH),x86)
+			CFLAGS += -msse2 -DhasSSE2
+		endif
 	endif
 	ifeq ($(OS),windows)
 		CFLAGS += -D__USE_MINGW_ANSI_STDIO -DWINVER=0x501
@@ -175,7 +221,7 @@ endif
 
 #icc
 ifeq ($(COMP),icc)
-	CFLAGS = -std=c99 -Wall -Wcheck -wd2259 -wd913 -D_GNU_SOURCE=1
+	CFLAGS = -std=c99 -Wall -Wcheck -wd2259 -D_GNU_SOURCE=1 -DUNICODE -Qoption,cpp,--unicode_source_kind,"UTF-8"
 	PGO_GEN = -prof_gen
 	PGO_USE = -prof_use -wd11505
 
@@ -186,13 +232,16 @@ ifeq ($(COMP),icc)
 	endif
 
 	ifeq ($(ARCH),x64-modern)
-		CFLAGS += -m64 -xHOST -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -m64 -march=core-avx2 -DUSE_GAS_X64 -DPOPCOUNT
+	endif
+	ifeq ($(ARCH),x64-avx512)
+		CFLAGS += -m64 -march=skylake-avx512 -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
 	endif
 	ifeq ($(ARCH),x64)
-		CFLAGS += -m64 -xHost -DUSE_GAS_X64 
+		CFLAGS += -m64 -DUSE_GAS_X64
 	endif
 	ifeq ($(ARCH),x32-modern)
-		CFLAGS += -m64 -xHost -ipo -auto-ilp32 -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -m64 -ipo -auto-ilp32 -DUSE_GAS_X64 -DPOPCOUNT
 	endif
 	ifeq ($(ARCH),x86)
 		CFLAGS += -m32 -DUSE_GAS_X86
@@ -201,7 +250,7 @@ endif
 
 #pcc
 ifeq ($(COMP),pcc)
-	CFLAGS = - -D_GNU_SOURCE=1
+	CFLAGS = - -D_GNU_SOURCE=1 -DUNICODE
 
 	ifeq ($(BUILD),optimize)
 		CFLAGS += -O4 -DNDEBUG
@@ -210,7 +259,7 @@ ifeq ($(COMP),pcc)
 	endif
 
 	ifeq ($(ARCH),x64-modern)
-		CFLAGS += -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
 	endif
 	ifeq ($(ARCH),x64)
 		CFLAGS += -DUSE_GAS_X64
@@ -222,29 +271,39 @@ endif
 
 #clang
 ifeq ($(COMP),clang)
-	CFLAGS = -std=c99 -pedantic -W -Wall -D_GNU_SOURCE=1 -Wno-invalid-source-encoding
+	CFLAGS = -std=c99 -pedantic -W -Wall -D_GNU_SOURCE=1 -DUNICODE
 	PGO_GEN = -fprofile-instr-generate
 	PGO_USE = -fprofile-instr-use=edax.profdata
 	PGO = llvm-profdata merge -output=edax.profdata $(BIN)/*.profraw
 
 	ifeq ($(BUILD),optimize)
-		CFLAGS += -O3 -flto -ffast-math -fomit-frame-pointer -DNDEBUG -fuse-ld=gold
+		CFLAGS += -O3 -ffast-math -fomit-frame-pointer -DNDEBUG
+		LTOFLAG = -flto
 	else
 		CFLAGS += -O0 -g -DDEBUG
 	endif
 
 	ifeq ($(ARCH),x64-modern)
-		CFLAGS += -m64 -march=native -DUSE_GAS_X64 -DPOPCOUNT
+		CFLAGS += -m64 -march=core-avx2 -DUSE_GAS_X64 -DPOPCOUNT -DLASTFLIP_HIGHCUT
+	endif
+	ifeq ($(ARCH),x64-avx512)
+		CFLAGS += -m64 -march=skylake-avx512 -DUSE_GAS_X64 -DPOPCOUNT
 	endif
 	ifeq ($(ARCH),x64)
 		CFLAGS += -m64 -DUSE_GAS_X64 
 	endif
 	ifeq ($(ARCH),x86)
-		CFLAGS += -m32 -DUSE_GAS_X86
+		CFLAGS += -m32 -DUSE_GAS_X86 -DUSE_GAS_MMX
 	endif
 
 	ifeq ($(OS),osx)
 		CFLAGS += -mmacosx-version-min=10.4 -mdynamic-no-pic
+		ifeq ($(ARCH),x86)
+			CFLAGS += -msse2 -DhasSSE2
+		endif
+		ifeq ($(ARCH),arm)
+			CFLAGS += -march=armv8.3-a
+		endif
 	endif
 endif
 
@@ -259,25 +318,16 @@ endif
 ifeq ($(OS),windows)
 	EXE = wEdax-$(ARCH).exe
 	LIBS += -lws2_32
-	ifeq ($(ARCH),x86)
-		LIBS += -lpthread
+	ifneq (,$(findstring x86,$(ARCH)))
+		LIBS += -Bstatic -Wl,-Bstatic,-lpthread
 	endif
 endif
 ifeq ($(OS),osx)
-	EXE = mEdax
+	EXE = mEdax-$(ARCH)
 	LIBS += -lpthread
 endif
 
-ifeq ($(ARCH),x64)
-	CFLAGS += -DHAS_CPU_64
-endif
-ifeq ($(ARCH),x64-modern)
-	CFLAGS += -DHAS_CPU_64
-endif
-ifeq ($(ARCH),x32)
-	CFLAGS += -DHAS_CPU_64
-endif
-ifeq ($(ARCH),x32-modern)
+ifneq (,$(findstring x64,$(ARCH))$(findstring x32,$(ARCH)))
 	CFLAGS += -DHAS_CPU_64
 endif
 
@@ -308,8 +358,8 @@ help:
 	@echo " x32-modern   x32 with popcount"
 	@echo " x32          x32"
 	@echo " x86          x86"
-	@echo " ARM          ARM v5 & up"
-	@echo " ARMv7        ARM v7-a"
+	@echo " arm          arm v5 & up"
+	@echo " armv7        arm v7-a"
 	@echo ""
 	@echo "Compilers:"
 	@echo "   gcc        GNU C compiler version >= 4.6"
@@ -328,50 +378,59 @@ help:
 
 build:
 	@echo "building edax..."
-	$(CC) $(CFLAGS) all.c -o $(BIN)/$(EXE) $(LIBS)
+	$(CC) $(CFLAGS) $(LTOFLAG) all.c -s -o $(BIN)/$(EXE) $(LIBS)
+
+source:
+	$(CC) $(CFLAGS) -S all.c
 
 pgo-build:
 	@echo "building edax with pgo..."
 	$(MAKE) clean
-	$(CC) $(CFLAGS) $(PGO_GEN) all.c -o $(BIN)/$(EXE) $(LIBS)
+	$(CC) $(CFLAGS) $(LTOFLAG) $(PGO_GEN) all.c -o $(BIN)/$(EXE) $(LIBS)
 	cd $(BIN); echo -e 'count games 10\ncount positions 9\n' | ./$(EXE) 
-	cd $(BIN); ./$(EXE) -l 60 -solve problem/fforum-20-39.obf
+	cd $(BIN); ./$(EXE) -l 60 -solve ../problem/fforum-20-39.obf
 	cd $(BIN); ./$(EXE) -l 18 -auto-store on -auto-start on -repeat 2 -auto-quit on -mode 2 -book-file book.pgo
 	rm -f ../bin/book.pgo ../bin/book.pgo.store
 	$(PGO)	
-	$(CC) $(CFLAGS) $(PGO_USE) all.c -s -o $(BIN)/$(EXE) $(LIBS)
+	$(CC) $(CFLAGS) $(LTOFLAG) $(PGO_USE) all.c -s -o $(BIN)/$(EXE) $(LIBS)
 
 pgo-rebuild:
 	@echo "rebuilding edax with pgo..."
-	$(CC) $(CFLAGS) $(PGO_USE) all.c -s -o $(BIN)/$(EXE) $(LIBS)
+	$(CC) $(CFLAGS) $(LTOFLAG) $(PGO_USE) all.c -s -o $(BIN)/$(EXE) $(LIBS)
 
 prof:
 	@echo "rebuilding edax for profiling..."
-	$(CC) $(CFLAGS) all.c -g -inline-level=0 -o $(BIN)/$(EXE) $(LIBS) -lprofiler
+	$(CC) $(CFLAGS) $(LTOFLAG) all.c -pg -o $(BIN)/$(EXE) $(LIBS) # -inline-level=0 -lprofiler
 
 debug:
-	make ARCH=$(ARCH) COMP=$(COMP) OS=$(OS) BUILD=debug build
+	make ARCH=$(ARCH) COMP=$(COMP) OS=$(OS) BUILD=debug prof
 
 release:
 	$(MAKE) pgo-build ARCH=x64 OS=linux COMP=gcc 
 	$(MAKE) build ARCH=x64 OS=windows COMP=gcc CC='x86_64-w64-mingw32-gcc'
 	$(MAKE) build ARCH=x86 OS=windows COMP=gcc CC='i686-w64-mingw32-gcc'
-	$(MAKE) build ARCH=ARMv7 OS=android COMP=gcc-old CC='arm-linux-androideabi-gcc'
+	$(MAKE) build ARCH=armv7 OS=android COMP=gcc CC='arm-linux-androideabi-gcc --sysroot=$SYSROOT'
 	$(MAKE) clean
 	$(MAKE) build ARCH=x64 OS=osx COMP=gcc-old CC=i686-apple-darwin10-gcc
 
 android:
-	$(MAKE) build ARCH=ARMv7 OS=android COMP=gcc-old CC='arm-linux-androideabi-gcc'
+	ndk-build NDK_PROJECT_PATH=. NDK_APPLICATION_MK=./Application.mk # NDK_DEBUG=1
+
+macuniversal:
+	$(MAKE) build ARCH=x86 OS=osx COMP=clang
+	$(MAKE) build ARCH=x64 OS=osx COMP=clang
+	lipo -create -arch i686 ../bin/mEdax-x86 -arch x86_64 ../bin/mEdax-x64 -arch arm64 ../bin/mEdax-arm -output ../bin/mEdax
+	rm -f ../bin/mEdax-x86 ../bin/mEdax-x64
 
 clean:
 	rm -f pgopti* *.dyn all.gc* *~ *.o generate_flip generate_count_flip *.prof*
 
 noip:
-	$(CC) -g $(CFLAGS) $(SRC) -o $(BIN)/$(EXE) $(LIBS)
+	$(CC) -g $(CFLAGS) $(LTOFLAG) $(SRC) -o $(BIN)/$(EXE) $(LIBS)
 
 code:
-	$(CC) $(CFLAGS) generate_flip.c -o generate_flip
-	$(CC) $(CFLAGS) generate_count_flip.c -o generate_count_flip
+	$(CC) $(CFLAGS) $(LTOFLAG) generate_flip.c -o generate_flip
+	$(CC) $(CFLAGS) $(LTOFLAG) generate_count_flip.c -o generate_count_flip
 	generate_flip
 	generate_count_flip
 
diff --git a/src/NMakefile b/src/NMakefile
index 73a9ab40..ba1a68ef 100644
--- a/src/NMakefile
+++ b/src/NMakefile
@@ -4,35 +4,112 @@
 # Compilation options for Microsoft Visual C++ & nmake.
 #
 # If you have a CPU supporting popcount (Intel Nehalem (i7) or AMD Barcelona or greater),
-# add /D "POPCOUNT" to the compiler option set.
+# add /D POPCOUNT to the compiler option set.
 #
 
-# Microsoft Visual C++ 2008 or better for Windows (7 or Vista) 64bits.
-W64_VC_FLAGS = /I"..\include" /O2 /GL /fp:fast /favor:INTEL64 /arch:AVX\
-               /D "NDEBUG" /D "inline=__inline" /D "__func__=__FUNCTION__" /D "USE_MSVC_X64" /D "POPCOUNT"\
-               /MT
+# Microsoft Visual C++ 2008 or better for Windows (7 or Vista).
+# VC_FLAGS = /source-charset:.1252 /execution-charset:.1252\
+VC_FLAGS = /D UNICODE /utf-8 /D _CRT_SECURE_NO_DEPRECATE /I"..\include" /O2 /fp:fast /GS- /D NDEBUG /MT
 
-# Microsoft Visual C++ 2008 of better for Windows (7 or Vista or xp) 32bits.
-W32_VC_FLAGS = /I"..\include" /O2 /GL /fp:fast\
-               /D "NDEBUG" /D "inline=__inline" /D "__func__=__FUNCTION__"  /D "USE_MASM_X86"\
-               /MT /L ws2_32
+vc-w64-modern:
+	cl $(VC_FLAGS) /GL /D HAS_CPU_64 /arch:AVX2 /D POPCOUNT /D LASTFLIP_HIGHCUT all.c ws2_32.lib /Fe..\bin\wEdax-w64-modern.exe /link /VERSION:4.5
 
-win-vc-x64:
-	cl $(W64_VC_FLAGS) all.c ws2_32.lib /Fe..\bin\wEdax-w64.exe /link /machine:x64 /VERSION:4.4
+vc-w64-avx512:
+	cl $(VC_FLAGS) /GL /D HAS_CPU_64 /arch:AVX512 /D POPCOUNT /D LASTFLIP_HIGHCUT all.c ws2_32.lib /Fe..\bin\wEdax-w64-avx512.exe /link /VERSION:4.5
+#	cl $(VC_FLAGS) /GL /D HAS_CPU_64 /arch:AVX2 /D __AVX512VL__ /D POPCOUNT /D LASTFLIP_HIGHCUT all.c ws2_32.lib /Fe..\bin\wEdax-w64-avx512.exe /link /VERSION:4.5
 
-win-vc-x86:
-	cl $(W32_VC_FLAGS) all.c /Fe..\bin\wEdax-w32.exe
+vc-w64-popcnt:
+	cl $(VC_FLAGS) /GL /D HAS_CPU_64 /D POPCOUNT all.c ws2_32.lib /Fe..\bin\wEdax-w64-popcnt.exe /link /VERSION:4.5
 
-win-vc-pgo-x64:
+vc-w64-k10:
+	cl $(VC_FLAGS) /GL /D HAS_CPU_64 /D POPCOUNT /D __LZCNT__ /D MOVE_GENERATOR=MOVE_GENERATOR_BITSCAN /favor:AMD64 all.c ws2_32.lib /Fe..\bin\wEdax-w64-k10.exe /link /VERSION:4.5
+
+vc-w64:
+	cl $(VC_FLAGS) /GL /D HAS_CPU_64 all.c ws2_32.lib /Fe..\bin\wEdax-w64.exe /link /VERSION:4.5
+
+vc-w32-modern:
+	cl $(VC_FLAGS) /GL /D hasSSE2 /arch:AVX2 /D POPCOUNT all.c ws2_32.lib /Fe..\bin\wEdax-w32-modern.exe
+
+vc-w32-sse:
+	cl $(VC_FLAGS) /GL /D hasSSE2 all.c ws2_32.lib /Fe..\bin\wEdax-w32-sse.exe
+
+vc-w32-mmx:
+	cl $(VC_FLAGS) /GL /arch:IA32 /D hasMMX all.c ws2_32.lib /Fe..\bin\wEdax-w32-mmx.exe
+
+vc-w32:
+	cl $(VC_FLAGS) /GL /arch:IA32 all.c ws2_32.lib /Fe..\bin\wEdax-w32.exe
+
+vc-a64:
+#	vcvarsamd64_arm64.bat
+	cl $(VC_FLAGS) /GL /D HAS_CPU_64 all.c ws2_32.lib /Fe..\bin\wEdax-a64.exe /link /VERSION:4.5
+
+vc-a32:
+#	vcvarsamd64_arm.bat
+	cl $(VC_FLAGS) /GL all.c ws2_32.lib /Fe..\bin\wEdax-a32.exe
+
+icc-w64-modern:
+	icl $(VC_FLAGS) /GL /D HAS_CPU_64 /arch:AVX2 /D POPCOUNT /D LASTFLIP_HIGHCUT all.c ws2_32.lib /Fe..\bin\wEdax-w64-modern.exe /link /VERSION:4.5
+
+icc-w64-avx512:
+	icl $(VC_FLAGS) /GL /D HAS_CPU_64 /arch:CORE-AVX512 /D POPCOUNT /D LASTFLIP_HIGHCUT all.c ws2_32.lib /Fe..\bin\wEdax-w64-avx512.exe /link /VERSION:4.5
+
+icc-w64:
+	icl $(VC_FLAGS) /GL /D HAS_CPU_64 all.c ws2_32.lib /Fe..\bin\wEdax-w64.exe /link /VERSION:4.5
+
+icc-w32:
+	icl $(VC_FLAGS) /GL /arch:IA32 all.c ws2_32.lib /Fe..\bin\wEdax-w32.exe
+
+clang-w64-modern:
+	clang-cl $(VC_FLAGS) /D HAS_CPU_64 /arch:AVX2 /D POPCOUNT all.c ws2_32.lib /Fe..\bin\wEdax-w64-modern.exe /link /VERSION:4.5
+
+clang-w64:
+	clang-cl $(VC_FLAGS) /D HAS_CPU_64 all.c ws2_32.lib /Fe..\bin\wEdax-w64.exe /link /VERSION:4.5
+
+clang-w32:
+	clang-cl $(VC_FLAGS) /arch:IA32 all.c ws2_32.lib /Fe..\bin\wEdax-w32.exe
+
+vc-pgo-w64-modern:
 	set VCPROFILE_PATH=..\src
-	cl $(W64_VC_FLAGS) all.c ws2_32.lib /Fe..\bin\wEdax-x64.exe /link /ltcg:pgi /machine:x64 /VERSION:4.4
+	cl $(VC_FLAGS) /GL /arch:AVX2 /D POPCOUNT /D LASTFLIP_HIGHCUT all.c ws2_32.lib /Fe..\bin\wEdax-w64-modern.exe /link /ltcg:pgi /VERSION:4.5
+	cd ..\bin
+	wEdax-w64-modern -l 60 -solve ..\problem\fforum-20-39.obf
+	wEdax-w64-modern -l 18 -auto-store on -auto-start on -repeat 2 -auto-quit on -mode 2 -book-file book.pgo
+	del book.pgo book.pgo.store
+	cd ..\src
+	link all.obj  ws2_32.lib /out:..\bin\wEdax-w64-modern.exe /ltcg:pgo /VERSION:4.5
+	del *.pgc ..\bin\*.pgd
+
+vc-pgo-w64-k10:
+	set VCPROFILE_PATH=..\src
+	cl $(VC_FLAGS) /GL /D POPCOUNT /D __LZCNT__ /D MOVE_GENERATOR=MOVE_GENERATOR_BITSCAN all.c ws2_32.lib /Fe..\bin\wEdax-w64-k10.exe /link /ltcg:pgi /VERSION:4.5
+	cd ..\bin
+	wEdax-w64-k10 -l 60 -solve ..\problem\fforum-20-39.obf
+	wEdax-w64-k10 -l 18 -auto-store on -auto-start on -repeat 2 -auto-quit on -mode 2 -book-file book.pgo
+	del book.pgo book.pgo.store
+	cd ..\src
+	link all.obj  ws2_32.lib /out:..\bin\wEdax-w64-k10.exe /ltcg:pgo /VERSION:4.5
+	del *.pgc ..\bin\*.pgd
+
+vc-pgo-w64:
+	set VCPROFILE_PATH=..\src
+	cl $(VC_FLAGS) /GL all.c ws2_32.lib /Fe..\bin\wEdax-w64.exe /link /ltcg:pgi /VERSION:4.5
+	cd ..\bin
+	wEdax-w64 -l 60 -solve ..\problem\fforum-20-39.obf
+	wEdax-w64 -l 18 -auto-store on -auto-start on -repeat 2 -auto-quit on -mode 2 -book-file book.pgo
+	del book.pgo book.pgo.store
+	cd ..\src
+	link all.obj  ws2_32.lib /out:..\bin\wEdax-w64.exe /ltcg:pgo /VERSION:4.5
+	del *.pgc ..\bin\*.pgd
+
+icc-pgo-w64-modern:
+	icl $(VC_FLAGS) /arch:AVX2 /D POPCOUNT /D LASTFLIP_HIGHCUT /Qprof-gen all.c ws2_32.lib /Fe..\bin\wEdax-w64-modern.exe /link /VERSION:4.5
 	cd ..\bin
-	wEdax-x64.exe -l 60 -solve problem\fforum-20-39.obf
-	wEdax-x64.exe -l 21 -auto-store on -auto-start on -repeat 2 -auto-quit on -mode 2 -book-file book.pgo
+	wEdax-w64-modern -l 60 -solve ..\problem\fforum-20-39.obf
+	wEdax-w64-modern -l 18 -auto-store on -auto-start on -repeat 2 -auto-quit on -mode 2 -book-file book.pgo
+	del book.pgo book.pgo.store
 	cd ..\src
-	link all.obj  ws2_32.lib /out:..\bin\wEdax-x64.exe /ltcg:pgo /machine:x64 /VERSION:4.4
+	icl $(VC_FLAGS) /GL /arch:AVX2 /D POPCOUNT /D LASTFLIP_HIGHCUT /Qprof-use /Qip all.c ws2_32.lib /Fe..\bin\wEdax-w64-modern.exe /link /VERSION:4.5
 
-	 
 clean:
 	del -f pgopti* *.dyn all.gc* *~ *.p* *.obj
 
diff --git a/src/base.c b/src/base.c
index 29a295e9..aef0f865 100644
--- a/src/base.c
+++ b/src/base.c
@@ -3,7 +3,7 @@
  *
  * Header file for game base management.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -131,7 +131,7 @@ static void wthor_players_init(WthorBase *base)
 static void wthor_players_load(WthorBase *base, const char *file)
 {
 	FILE *f;
-	WthorHeader header[1];
+	WthorHeader header;
 	int i, r;
 
 	r = base->n_players = 0;
@@ -143,9 +143,9 @@ static void wthor_players_load(WthorBase *base, const char *file)
 		return;
 	}
 
-	if (wthor_header_read(header, f)) {;
+	if (wthor_header_read(&header, f)) {;
 
-		base->n_players = header->n;
+		base->n_players = header.n;
 
 		base->player = (char (*)[20]) malloc(base->n_players * sizeof (*base->player));
 		if (base->player) {
@@ -174,19 +174,19 @@ static void wthor_players_load(WthorBase *base, const char *file)
 static void wthor_players_save(WthorBase *base, const char *file)
 {
 	FILE *f;
-	WthorHeader header[1];
+	WthorHeader header;
 	int i, r;
 
 	r = 0;
 
-	wthor_header_set(header, 0, base->n_players, 0);
+	wthor_header_set(&header, 0, base->n_players, 0);
 
 	if ((f = fopen(file, "wb")) == NULL) {
 		warn("Cannot open Wthor players' file %s\n", file);
 		return;
 	}
 
-	if (wthor_header_write(header, f)) {
+	if (wthor_header_write(&header, f)) {
 
 		for (i = 0; i < base->n_players; ++i) {
 			r += fwrite(base->player[i], 20, 1, f);
@@ -216,16 +216,15 @@ int wthor_player_get(WthorBase *base, const char *name)
 	assert(base->player != NULL && base->n_players > 0);
 
 	for (i = 0; i < base->n_players; ++i) {
-	    if (strcmp(name, base->player[i]) == 0) return i;            
+		if (strcmp(name, base->player[i]) == 0) return i;
 	}
 	
 	n = base->n_players + 1;
 	player = (char (*)[20]) realloc(base->player, n * sizeof (*base->player));
 	if (player) {
-	    base->player = player;
-	    base->n_players = n; 
-	    strncpy(base->player[i], name, 20); // used on purpose, as strncpy fills with '\0' the field name
-		base->player[i][19] = '\0'; // force null terminated string
+		base->player = player;
+		base->n_players = n;
+		sprintf(base->player[i], "%-.19s", name); // force null terminated string
 	} else {
 		warn("Cannot allocate Wthor players' array\n");
 		i = 0;
@@ -243,7 +242,7 @@ int wthor_player_get(WthorBase *base, const char *name)
 static void wthor_tournaments_load(WthorBase *base, const char *file)
 {
 	FILE *f;
-	WthorHeader header[1];
+	WthorHeader header;
 	int i, r;
 
 	r = 0;
@@ -254,8 +253,8 @@ static void wthor_tournaments_load(WthorBase *base, const char *file)
 		return;
 	}
 
-	if (wthor_header_read(header, f)) {
-		base->n_tournaments = header->n;
+	if (wthor_header_read(&header, f)) {
+		base->n_tournaments = header.n;
 
 		base->tournament = (char (*)[26]) malloc(base->n_tournaments * sizeof (*base->tournament));
 		if (base->tournament) {
@@ -285,7 +284,7 @@ static void wthor_tournaments_load(WthorBase *base, const char *file)
 static void wthor_tournaments_save(WthorBase *base, const char *file)
 {
 	FILE *f;
-	WthorHeader header[1];
+	WthorHeader header;
 	int i, r;
 
 	r = 0;
@@ -294,8 +293,8 @@ static void wthor_tournaments_save(WthorBase *base, const char *file)
 		warn("Cannot open Wthor tournaments' file %s\n", file);
 		return;
 	}
-	wthor_header_set(header, 0, base->n_tournaments, 0);
-	if (wthor_header_write(header, f)) {
+	wthor_header_set(&header, 0, base->n_tournaments, 0);
+	if (wthor_header_write(&header, f)) {
 		for (i = r = 0; i < base->n_tournaments; ++i) {
 			r += fwrite(base->tournament[i], 26, 1, f);
 		}
@@ -344,8 +343,8 @@ bool wthor_load(WthorBase *base, const char *file)
 	wthor_players_load(base, path);
 
 	if ((f = fopen(file, "rb")) != NULL) {
-		if (wthor_header_read(base->header, f) && base->header->board_size == 8) {
-			base->n_games = base->header->n_games;
+		if (wthor_header_read(&base->header, f) && base->header.board_size == 8) {
+			base->n_games = base->header.n_games;
 
 			base->game = (WthorGame*) malloc(base->n_games * sizeof (WthorGame));
 			if (base->game) {
@@ -394,8 +393,8 @@ bool wthor_save(WthorBase *base, const char *file)
 	wthor_players_save(base, path);
 
 	if ((f = fopen(file, "wb")) != NULL) {
-		wthor_header_set(base->header, base->n_games, 0, 0);
-		r = wthor_header_write(base->header, f);
+		wthor_header_set(&base->header, base->n_games, 0, 0);
+		r = wthor_header_write(&base->header, f);
 		if (base->game) {
 			r += (fwrite(base->game, sizeof (WthorGame), base->n_games, f) == (unsigned) base->n_games);
 		}
@@ -445,20 +444,20 @@ bool base_to_wthor(const Base *base, WthorBase *wthor)
  */
 void wthor_print_game(WthorBase *base, int i, FILE *f)
 {
-	Game game[1];
+	Game game;
 
 	if (0 <= i && i < base->n_games) {
 
 		fprintf(f, "Game #%d: %s: %4d - %s vs. %s: ",
 			i, base->tournament[base->game[i].tournament],
-			base->header->game_year,
+			base->header.game_year,
 			base->player[base->game[i].black],
 			base->player[base->game[i].white]);
 
-		wthor_to_game(base->game + i, game);
-		game_export_text(game, f);
+		wthor_to_game(base->game + i, &game);
+		game_export_text(&game, f);
 
-		fprintf(f, "Theoric score %d empties : %+02d, ", base->header->depth, base->game[i].theoric_score);
+		fprintf(f, "Theoric score %d empties : %+02d, ", base->header.depth, base->game[i].theoric_score);
 		fprintf(f, "Score final : %+02d (as black disc count.)\n", base->game[i].score);
 	}
 }
@@ -474,7 +473,7 @@ void wthor_print_game(WthorBase *base, int i, FILE *f)
 static void wthorgame_get_board(WthorGame *game, const int n_empties, Board *board, int *player)
 {
 	int i;
-	Move move[1];
+	Move move;
 	char s_move[4];
 
 	*player = BLACK; board_init(board);
@@ -482,11 +481,11 @@ static void wthorgame_get_board(WthorGame *game, const int n_empties, Board *boa
 		if (board_is_pass(board)) {
 			board_pass(board); *player ^= 1;
 		}
-		board_get_move(board, move_from_wthor(game->x[i]), move);
-		if (board_check_move(board, move)) {
-			board_update(board, move); *player ^= 1;
+		board_get_move_flip(board, move_from_wthor(game->x[i]), &move);
+		if (board_check_move(board, &move)) {
+			board_update(board, &move); *player ^= 1;
 		} else {
-			warn("Illegal move %s\n", move_to_string(move->x, *player, s_move));
+			warn("Illegal move %s\n", move_to_string(move.x, *player, s_move));
 			break;
 		}
 	}
@@ -501,10 +500,10 @@ static void wthorgame_get_board(WthorGame *game, const int n_empties, Board *boa
  */
 int pv_check(const Board *init_board, Line *pv, Search *search)
 {
-	Game game[1];
+	Game game;
 
-	line_to_game(init_board, pv, game);
-	return game_analyze(game, search, board_count_empties(init_board), false);
+	line_to_game(init_board, pv, &game);
+	return game_analyze(&game, search, board_count_empties(init_board), false);
 }
 
 /**
@@ -515,9 +514,9 @@ int pv_check(const Board *init_board, Line *pv, Search *search)
  */
 void wthor_test(const char *file, Search *search)
 {
-	WthorBase base[1];
+	WthorBase base;
 	WthorGame *wthor;
-	Board board[1];
+	Board board;
 	int player;
 	int score;
 	int n_empties;
@@ -526,7 +525,7 @@ void wthor_test(const char *file, Search *search)
 	long long t;
 	int n_err;
 
-	if (wthor_load(base, file)) {
+	if (wthor_load(&base, file)) {
 
 		if (search->options.verbosity == 1) {
 			if (search->options.header) puts(search->options.header);
@@ -538,11 +537,11 @@ void wthor_test(const char *file, Search *search)
 		t = 0;
 
 		foreach_wthorgame(wthor, base) {
-			wthorgame_get_board(wthor, base->header->depth, board, &player);
-			n_empties = board_count_empties(board);
-			if (n_empties != base->header->depth && !board_is_game_over(board)) {
+			wthorgame_get_board(wthor, base.header.depth, &board, &player);
+			n_empties = board_count_empties(&board);
+			if (n_empties != base.header.depth && !board_is_game_over(&board)) {
 				warn("Incomplete or Illegal game: %d empties\n", n_empties);
-				wthor_print_game(base, wthor - base->game, stderr);
+				wthor_print_game(&base, wthor - base.game, stderr);
 				continue;
 			}
 
@@ -550,33 +549,33 @@ void wthor_test(const char *file, Search *search)
 			else score = 2 * wthor->theoric_score - 64;
 			if (abs(score) > 64) {
 				warn("Impossible theoric score:\n");
-				wthor_print_game(base, wthor - base->game, stderr);
+				wthor_print_game(&base, wthor - base.game, stderr);
 				continue;
 			}
 
 			search_cleanup(search);
-			search_set_board(search, board, player);
-			search_set_level(search, 60, base->header->depth);
+			search_set_board(search, &board, player);
+			search_set_level(search, 60, base.header.depth);
 			search_run(search);
 			if (search->options.verbosity) putchar('\n');
 			n_nodes += search->result->n_nodes;
 			t += search->result->time;
 			if (score != search->result->score) {
 				warn("Wrong theoric score: %+d (Wthor) instead of %+d (Edax)\n", score, search->result->score);
-				wthor_print_game(base, wthor - base->game, stderr);
+				wthor_print_game(&base, wthor - base.game, stderr);
 				++n_failure;
 				assert(false); // stop here when debug is on
 			}
 
 			if (options.pv_check) {
 				Line pv;
-				line_copy(&pv, search->result->pv, 0);
-				n_err = pv_check(board, &pv, search);
+				line_copy(&pv, &search->result->pv, 0);
+				n_err = pv_check(&board, &pv, search);
 				if (n_err) {
 					char s[80];
 					warn("Wrong pv:\n");
-					board_print(board, player, stderr);
-					fprintf(stderr, "setboard %s\nplay ", board_to_string(board, player, s));
+					board_print(&board, player, stderr);
+					fprintf(stderr, "setboard %s\nplay ", board_to_string(&board, player, s));
 					line_print(&pv, 200, " ", stderr);
 					putc('\n', stderr); putc('\n', stderr);
 					assert(false); // stop here when debug is on
@@ -584,7 +583,7 @@ void wthor_test(const char *file, Search *search)
 			}
 
 			if (search->options.verbosity == 0) {
-				printf("%s  game: %4d, error: %2d ; ", file, (int)(wthor - base->game) + 1, n_failure);
+				printf("%s  game: %4d, error: %2d ; ", file, (int)(wthor - base.game) + 1, n_failure);
 				printf("%lld n, ", n_nodes); time_print(t, false, stdout); putchar('\r');
 				fflush(stdout);
 			}
@@ -594,7 +593,7 @@ void wthor_test(const char *file, Search *search)
 		}
 		putchar('\n');
 
-		wthor_free(base);
+		wthor_free(&base);
 	}
 	return;
 }
@@ -610,18 +609,18 @@ void wthor_test(const char *file, Search *search)
  */
 void wthor_eval(const char *file, Search *search, unsigned long long histogram[129][65])
 {
-	WthorBase base[1];
+	WthorBase base;
 	WthorGame *wthor;
-	Board board[1];
+	Board board;
 	int player;
 	int score;
 	int n_empties;
 
-	if (wthor_load(base, file)) {
+	if (wthor_load(&base, file)) {
 		foreach_wthorgame(wthor, base) {
-			wthorgame_get_board(wthor, base->header->depth, board, &player);
-			n_empties = board_count_empties(board);
-			if (n_empties != base->header->depth && !board_is_game_over(board)) {
+			wthorgame_get_board(wthor, base.header.depth, &board, &player);
+			n_empties = board_count_empties(&board);
+			if (n_empties != base.header.depth && !board_is_game_over(&board)) {
 				continue;
 			}
 
@@ -632,12 +631,12 @@ void wthor_eval(const char *file, Search *search, unsigned long long histogram[1
 			}
 
 			search_cleanup(search);
-			search_set_board(search, board, player);
-			search_set_level(search, options.level, base->header->depth);
+			search_set_board(search, &board, player);
+			search_set_level(search, options.level, base.header.depth);
 			search_run(search);
 			++histogram[search->result->score + 64][(score + 64) / 2];
 		}
-		wthor_free(base);
+		wthor_free(&base);
 	}
 	return;
 }
@@ -650,17 +649,17 @@ void wthor_eval(const char *file, Search *search, unsigned long long histogram[1
  */
 void wthor_edaxify(const char *file)
 {
-	WthorBase base[1];
+	WthorBase base;
 	WthorGame *wthor;
 
-	if (wthor_load(base, file)) {
+	if (wthor_load(&base, file)) {
 		foreach_wthorgame(wthor, base) {
 			wthor->black = 1368; // "Edax (delorme)"
 			wthor->white = 1368; // "Edax (delorme)"
 			wthor->tournament = 157; // "Etudes"
 		}
-		wthor_save(base, file);
-		wthor_free(base);
+		wthor_save(&base, file);
+		wthor_free(&base);
 	}
 }
 
@@ -740,11 +739,11 @@ void base_unique(Base *base)
 bool base_load(Base *base, const char *file)
 {
 	void (*load)(Game*, FILE*) = game_import_text;
-	Game game[1];
+	Game game;
 	FILE *f;
 	char ext[8];
 	int l;
-	WthorHeader header[1];
+	WthorHeader header;
 
 	l = strlen(file); strcpy(ext, file + l - 4); string_to_lowercase(ext);
 	if (strcmp(ext, ".txt") == 0) load = game_import_text;
@@ -766,11 +765,11 @@ bool base_load(Base *base, const char *file)
 	}
 
 	info("loading games...");
-	if (load == game_import_wthor) wthor_header_read(header, f);
+	if (load == game_import_wthor) wthor_header_read(&header, f);
 	for (;;) {
-		load(game, f);
+		load(&game, f);
 		if (ferror(f) || feof(f)) break;
-		base_append(base, game);
+		base_append(base, &game);
 	}
 	info("done (%d games loaded)\n", base->n_games);
 
@@ -841,15 +840,15 @@ void base_save(const Base *base, const char *file)
 void base_to_problem(Base *base, const int n_empties, const char *problem)
 {
 	int i;
-	Board board[1];
+	Board board;
 	char s[80];
 	FILE *f;
 
 	f = fopen(problem, "w");
 
 	for (i = 0; i < base->n_games; ++i) {
-		if (game_get_board(base->game + i, 60 - n_empties, board)) {
-			board_to_string(board, n_empties & 1, s);
+		if (game_get_board(base->game + i, 60 - n_empties, &board)) {
+			board_to_string(&board, n_empties & 1, s);
 			fprintf(f, "%s\n", s);
 		}
 	}
@@ -867,14 +866,14 @@ void base_to_problem(Base *base, const int n_empties, const char *problem)
 void base_to_FEN(Base *base, const int n_empties, const char *problem)
 {
 	int i;
-	Board board[1];
+	Board board;
 	FILE *f;
 
 	f = fopen(problem, "w");
 
 	for (i = 0; i < base->n_games; ++i) {
-		if (game_get_board(base->game + i, 60 - n_empties, board)) {
-			board_print_FEN(board, n_empties & 1, f);
+		if (game_get_board(base->game + i, 60 - n_empties, &board)) {
+			board_print_FEN(&board, n_empties & 1, f);
 			putc('\n', f);
 		}
 	}
@@ -943,8 +942,8 @@ void base_complete(Base *base, Search *search)
 void base_compare(const char *file_1, const char *file_2)
 {
 	Base base_1[1], base_2[2];
-	PositionHash hash[1];
-	Board board[1];
+	PositionHash hash;
+	Board board;
 	int i, j;
 	long long n_1, n_2, n_2_only;
 
@@ -955,13 +954,13 @@ void base_compare(const char *file_1, const char *file_2)
 	n_2_only = 0;
 
 	base_load(base_1, file_1);
-	positionhash_init(hash, options.hash_table_size);
+	positionhash_init(&hash, options.hash_table_size);
 	for (i = 0; i < base_1->n_games; ++i) {
 		Game *game = base_1->game + i;
-		*board = *game->initial_board;
+		board = game->initial_board;
 		for (j = 0; j < 60 && game->move[j] != NOMOVE; ++j) {
-			if (!game_update_board(board, game->move[j])) break; // BAD MOVE -> end of game
-			if (positionhash_append(hash, board)) {
+			if (!game_update_board(&board, game->move[j])) break; // BAD MOVE -> end of game
+			if (positionhash_append(&hash, &board)) {
 				++n_1;
 			}
 		}
@@ -971,30 +970,30 @@ void base_compare(const char *file_1, const char *file_2)
 	base_load(base_2, file_2);
 	for (i = 0; i < base_2->n_games; ++i) {
 		Game *game = base_2->game + i;
-		*board = *game->initial_board;
+		board = game->initial_board;
 		for (j = 0; j < 60 && game->move[j] != NOMOVE; ++j) {
-			if (!game_update_board(board, game->move[j])) break; // BAD MOVE -> end of game
-			if (positionhash_append(hash, board)) {
+			if (!game_update_board(&board, game->move[j])) break; // BAD MOVE -> end of game
+			if (positionhash_append(&hash, &board)) {
 				++n_2_only;
 			}
 		}
 	}
 
-	positionhash_delete(hash);
-	positionhash_init(hash, options.hash_table_size);
+	positionhash_delete(&hash);
+	positionhash_init(&hash, options.hash_table_size);
 	for (i = 0; i < base_2->n_games; ++i) {
 		Game *game = base_2->game + i;
-		*board = *game->initial_board;
+		board = game->initial_board;
 		for (j = 0; j < 60 && game->move[j] != NOMOVE; ++j) {
-			if (!game_update_board(board, game->move[j])) break; // BAD MOVE -> end of game
-			if (positionhash_append(hash, board)) {
+			if (!game_update_board(&board, game->move[j])) break; // BAD MOVE -> end of game
+			if (positionhash_append(&hash, &board)) {
 				++n_2;
 			}
 		}
 	}
 	base_free(base_2);
 
-	positionhash_delete(hash);
+	positionhash_delete(&hash);
 
 	printf("%s : %lld positions - %lld original positions\n", file_1, n_1, n_1 - (n_2- n_2_only));
 	printf("%s : %lld positions - %lld original positions\n", file_2, n_2, n_2_only);
diff --git a/src/base.h b/src/base.h
index 15ce13f7..0c019b84 100644
--- a/src/base.h
+++ b/src/base.h
@@ -36,7 +36,7 @@ typedef struct WthorHeader {
 } WthorHeader;
 
 typedef struct WthorBase {
-	WthorHeader header[1];     /** Header */
+	WthorHeader header;        /** Header */
 	char (*tournament)[26];    /** tournaments */
 	int n_tournaments;         /** tournament number */
 	char (*player)[20];        /** players */
@@ -60,7 +60,7 @@ void wthor_eval(const char*, struct Search*, unsigned long long histogram[129][6
 void wthor_edaxify(const char*);
 
 #define foreach_wthorgame(wgame, wbase) \
-	for ((wgame) = (wbase)->game ; (wgame) < (wbase)->game + (wbase)->header->n_games; ++(wgame))
+	for ((wgame) = (wbase).game ; (wgame) < (wbase).game + (wbase).header.n_games; ++(wgame))
 
 void base_init(Base*);
 void base_free(Base*);
diff --git a/src/bench.c b/src/bench.c
index 073ab174..7b6fad96 100644
--- a/src/bench.c
+++ b/src/bench.c
@@ -1,9 +1,9 @@
 /**
  * @file bench.c
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "bit.h"
@@ -20,7 +20,7 @@
  *
  * @return a CPU clock tick.
  */
-static unsigned long long click()
+static unsigned long long click(void)
 {
 #if defined(USE_GAS_X64)
 
@@ -34,7 +34,7 @@ static unsigned long long click()
 	__asm__ volatile (
 		"rdtsc" : "=A" (a));
 	return a;
-#elif defined(_WIN32)
+#elif defined(_WIN32) && (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64))
 	return __rdtsc();
 #else
 	return cpu_clock();
@@ -44,25 +44,29 @@ static unsigned long long click()
 /*
  * @brief Move generator performance test.
  */
-static void bench_move_generator()
+static void bench_move_generator(void)
 {
 	const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
 	char m[4];
 	Board board;
 	Move move;
 	int i, x;
+	volatile int v;
 	const int N_WARMUP = 1000;
 	const int N_REPEAT = 1000000;
 	unsigned long long c, overhead;
 	double t, t_mean, t_var, t_min, t_max;
 
+	v = 0;
 	c = -click();
 	for (i = 0; i < N_WARMUP; ++i) {
+		v += i;
 	}
 	c += click();
 
 	c = -click();
 	for (i = 0; i < N_REPEAT; ++i) {
+		v += i;
 	}
 	c += click();
 	overhead = c;
@@ -78,13 +82,13 @@ static void bench_move_generator()
 		
 		c = -click();
 		for (i = 0; i < N_WARMUP; ++i) {
-			board_get_move(&board, x, &move);
+			v += board_get_move_flip(&board, x, &move);
 		}
 		c += click();
 
 		c = -click();
 		for (i = 0; i < N_REPEAT; ++i) {
-			board_get_move(&board, x, &move);
+			v += board_get_move_flip(&board, x, &move);
 		}
 		c += click();
 
@@ -94,37 +98,42 @@ static void bench_move_generator()
 		if (t < t_min) t_min = t;
 		if (t > t_max) t_max = t;
 
-		if (options.verbosity >= 2) printf("board_get_move: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
+		if (options.verbosity >= 2) printf("board_get_move_flip: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
 
 	}
 
 	t_mean /= x;
 	t_var = t_var / x - (t_mean * t_mean);
-	
-	printf("board_get_move:  %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
+
+	printf("board_get_move_flip:  %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
 }
 
 /*
  * @brief Last Move performance test.
  */
-static void bench_count_last_flip()
+static void bench_count_last_flip(void)
 {
 	const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
 	char m[4];
 	Board board;
 	int i, x;
+	volatile int v;
 	const int N_WARMUP = 1000;
 	const int N_REPEAT = 1000000;
 	unsigned long long c, overhead;
 	double t, t_mean, t_var, t_min, t_max;
 
+	v = 0;
+
 	c = -click();
 	for (i = 0; i < N_WARMUP; ++i) {
+		v += i;
 	}
 	c += click();
 
 	c = -click();
 	for (i = 0; i < N_REPEAT; ++i) {
+		v += i;
 	}
 	c += click();
 	overhead = c;
@@ -136,17 +145,17 @@ static void bench_count_last_flip()
 	for (x = A1; x < PASS; ++x) {
 		board_set(&board, b);
 		board.player &= ~x_to_bit(x);
-		board.opponent &= ~x_to_bit(x);
-		
+		// board.opponent &= ~x_to_bit(x);
+
 		c = -click();
 		for (i = 0; i < N_WARMUP; ++i) {
-			count_last_flip(x, board.player);
+			v += last_flip(x, board.player & ~i);
 		}
 		c += click();
 
 		c = -click();
 		for (i = 0; i < N_REPEAT; ++i) {
-			count_last_flip(x, board.player);
+			v += last_flip(x, board.player& ~i);
 		}
 		c += click();
 
@@ -162,32 +171,37 @@ static void bench_count_last_flip()
 
 	t_mean /= x;
 	t_var = t_var / x - (t_mean * t_mean);
-	
+
 	printf("count_last_flip:  %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
 }
 
 /*
  * @brief Scoring performance test.
  */
-static void bench_board_score_1()
+static void bench_board_score_1(void)
 {
 	const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
 	char m[4];
 	Board board;
 	int i, x;
+	volatile int v;
 	const int N_WARMUP = 1000;
 	const int N_REPEAT = 1000000;
 	unsigned long long c, overhead;
 	double t, t_mean, t_var, t_min, t_max;
 
+	board_set(&board, b);
+	v = 0;
 
 	c = -click();
 	for (i = 0; i < N_WARMUP; ++i) {
+		v += i;
 	}
 	c += click();
 
 	c = -click();
 	for (i = 0; i < N_REPEAT; ++i) {
+		v += i;
 	}
 	c += click();
 	overhead = c;
@@ -200,16 +214,16 @@ static void bench_board_score_1()
 		board_set(&board, b);
 		board.player &= ~x_to_bit(x);
 		board.opponent &= ~x_to_bit(x);
-		
+
 		c = -click();
 		for (i = 0; i < N_WARMUP; ++i) {
-			board_score_1(&board, SCORE_MAX, x);
+			v += board_score_1(board.player, SCORE_MAX - 1, x);
 		}
 		c += click();
 
 		c = -click();
 		for (i = 0; i < N_REPEAT; ++i) {
-			board_score_1(&board, SCORE_MAX, x);
+			v += board_score_1(board.player, SCORE_MAX - 1, x);
 		}
 		c += click();
 
@@ -225,38 +239,41 @@ static void bench_board_score_1()
 
 	t_mean /= x;
 	t_var = t_var / x - (t_mean * t_mean);
-	
+
 	printf("board_score_1:  %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
 }
 
 /*
  * @brief Mobility performance test.
  */
-static void bench_mobility()
+static void bench_mobility(void)
 {
 	const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
 	char m[4];
 	Board board;
-	int i, x, v;
+	int i, x;
+	volatile int v;
 	const int N_WARMUP = 1000;
 	const int N_REPEAT = 1000000;
 	unsigned long long c, overhead;
 	double t, t_mean, t_var, t_min, t_max;
 
 	board_set(&board, b);
-
-	x = A1;
+	v = 0;
 	c = -click();
 	for (i = 0; i < N_WARMUP; ++i) {
-		board.player &= ~x_to_bit(x);
-		board.opponent &= ~x_to_bit(x);
+		board.player &= ~i;
+		board.opponent &= ~i;
+		v += i;
 	}
 	c += click();
 
+	board_set(&board, b);
 	c = -click();
 	for (i = 0; i < N_REPEAT; ++i) {
-		board.player &= ~x_to_bit(x);
-		board.opponent &= ~x_to_bit(x);
+		board.player &= ~i;
+		board.opponent &= ~i;
+		v += i;
 	}
 	c += click();
 	overhead = 0;
@@ -267,21 +284,22 @@ static void bench_mobility()
 
 	for (x = A1; x < PASS; ++x) {
 		board_set(&board, b);
-		
+
 		v = 0;
 		c = -click();
 		for (i = 0; i < N_WARMUP; ++i) {
-			board.player &= ~x_to_bit(x);
-			board.opponent &= ~x_to_bit(x);
+			board.player &= ~i;
+			board.opponent &= ~i;
 			v += get_mobility(board.player, board.opponent);
 			v -= get_mobility(board.opponent, board.player);
 		}
 		c += click();
 
+		board_set(&board, b);
 		c = -click();
 		for (i = 0; i < N_REPEAT; ++i) {
-			board.player &= ~x_to_bit(x);
-			board.opponent &= ~x_to_bit(x);
+			board.player &= ~i;
+			board.opponent &= ~i;
 			v += get_mobility(board.player, board.opponent);
 			v -= get_mobility(board.opponent, board.player);
 		}
@@ -299,26 +317,28 @@ static void bench_mobility()
 
 	t_mean /= x;
 	t_var = t_var / x - (t_mean * t_mean);
-	
+
 	printf("mobility:  %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
 }
 
 /*
  * @brief Stability performance test.
  */
-static void bench_stability()
+static void bench_stability(void)
 {
 	const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
 	char m[4];
 	Board board;
-	int i, x, v;
+	int i, x;
+	volatile int v;
 	const int N_WARMUP = 1000;
 	const int N_REPEAT = 1000000;
 	unsigned long long c, overhead;
 	double t, t_mean, t_var, t_min, t_max;
 
 	board_init(&board);
-	
+
+	v = 0;
 	x = A1;
 	c = -click();
 	for (i = 0; i < N_WARMUP; ++i) {
@@ -327,6 +347,7 @@ static void bench_stability()
 	}
 	c += click();
 
+	board_set(&board, b);
 	c = -click();
 	for (i = 0; i < N_REPEAT; ++i) {
 		board.player &= ~x_to_bit(x);
@@ -341,7 +362,7 @@ static void bench_stability()
 
 	for (x = A1; x < PASS; ++x) {
 		board_set(&board, b);
-		
+
 		v = 0;
 		c = -click();
 		for (i = 0; i < N_WARMUP; ++i) {
@@ -351,6 +372,7 @@ static void bench_stability()
 		}
 		c += click();
 
+		board_set(&board, b);
 		c = -click();
 		for (i = 0; i < N_REPEAT; ++i) {
 			board.player &= ~x_to_bit(x);
diff --git a/src/bit.c b/src/bit.c
index 32f6e243..de9f903e 100644
--- a/src/bit.c
+++ b/src/bit.c
@@ -6,53 +6,42 @@
  * a macro needs to be defined to chose between different flavors of the
  * algorithm.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "bit.h"
 #include "util.h"
 
+/** Table for a 32-bits-at-a-time software CRC-32C calculation.
+ * This tablehas built into it the pre and post bit inversion of the CRC. */
+#ifndef crc32c_u64
+static unsigned int crc32c_table[4][256];
+#endif
+
 /** coordinate to bit table converter */
-const unsigned long long X_TO_BIT[] = {
-	0x0000000000000001ULL, 0x0000000000000002ULL, 0x0000000000000004ULL, 0x0000000000000008ULL,
-	0x0000000000000010ULL, 0x0000000000000020ULL, 0x0000000000000040ULL, 0x0000000000000080ULL,
-	0x0000000000000100ULL, 0x0000000000000200ULL, 0x0000000000000400ULL, 0x0000000000000800ULL,
-	0x0000000000001000ULL, 0x0000000000002000ULL, 0x0000000000004000ULL, 0x0000000000008000ULL,
-	0x0000000000010000ULL, 0x0000000000020000ULL, 0x0000000000040000ULL, 0x0000000000080000ULL,
-	0x0000000000100000ULL, 0x0000000000200000ULL, 0x0000000000400000ULL, 0x0000000000800000ULL,
-	0x0000000001000000ULL, 0x0000000002000000ULL, 0x0000000004000000ULL, 0x0000000008000000ULL,
-	0x0000000010000000ULL, 0x0000000020000000ULL, 0x0000000040000000ULL, 0x0000000080000000ULL,
-	0x0000000100000000ULL, 0x0000000200000000ULL, 0x0000000400000000ULL, 0x0000000800000000ULL,
-	0x0000001000000000ULL, 0x0000002000000000ULL, 0x0000004000000000ULL, 0x0000008000000000ULL,
-	0x0000010000000000ULL, 0x0000020000000000ULL, 0x0000040000000000ULL, 0x0000080000000000ULL,
-	0x0000100000000000ULL, 0x0000200000000000ULL, 0x0000400000000000ULL, 0x0000800000000000ULL,
-	0x0001000000000000ULL, 0x0002000000000000ULL, 0x0004000000000000ULL, 0x0008000000000000ULL,
-	0x0010000000000000ULL, 0x0020000000000000ULL, 0x0040000000000000ULL, 0x0080000000000000ULL,
-	0x0100000000000000ULL, 0x0200000000000000ULL, 0x0400000000000000ULL, 0x0800000000000000ULL,
-	0x1000000000000000ULL, 0x2000000000000000ULL, 0x4000000000000000ULL, 0x8000000000000000ULL,
-	0, 0 // <- hack for passing move & nomove
-};
+unsigned long long X_TO_BIT[66];
 
-/** Conversion array: neighbour bits */
+/** Conversion array: flippable neighbour bits */
+// https://eukaryote.hateblo.jp/entry/2020/04/26/031246
 const unsigned long long NEIGHBOUR[] = {
-	0x0000000000000302ULL, 0x0000000000000705ULL, 0x0000000000000e0aULL, 0x0000000000001c14ULL,
-	0x0000000000003828ULL, 0x0000000000007050ULL, 0x000000000000e0a0ULL, 0x000000000000c040ULL,
-	0x0000000000030203ULL, 0x0000000000070507ULL, 0x00000000000e0a0eULL, 0x00000000001c141cULL,
-	0x0000000000382838ULL, 0x0000000000705070ULL, 0x0000000000e0a0e0ULL, 0x0000000000c040c0ULL,
-	0x0000000003020300ULL, 0x0000000007050700ULL, 0x000000000e0a0e00ULL, 0x000000001c141c00ULL,
-	0x0000000038283800ULL, 0x0000000070507000ULL, 0x00000000e0a0e000ULL, 0x00000000c040c000ULL,
-	0x0000000302030000ULL, 0x0000000705070000ULL, 0x0000000e0a0e0000ULL, 0x0000001c141c0000ULL,
-	0x0000003828380000ULL, 0x0000007050700000ULL, 0x000000e0a0e00000ULL, 0x000000c040c00000ULL,
-	0x0000030203000000ULL, 0x0000070507000000ULL, 0x00000e0a0e000000ULL, 0x00001c141c000000ULL,
-	0x0000382838000000ULL, 0x0000705070000000ULL, 0x0000e0a0e0000000ULL, 0x0000c040c0000000ULL,
-	0x0003020300000000ULL, 0x0007050700000000ULL, 0x000e0a0e00000000ULL, 0x001c141c00000000ULL,
-	0x0038283800000000ULL, 0x0070507000000000ULL, 0x00e0a0e000000000ULL, 0x00c040c000000000ULL,
-	0x0302030000000000ULL, 0x0705070000000000ULL, 0x0e0a0e0000000000ULL, 0x1c141c0000000000ULL,
-	0x3828380000000000ULL, 0x7050700000000000ULL, 0xe0a0e00000000000ULL, 0xc040c00000000000ULL,
-	0x0203000000000000ULL, 0x0507000000000000ULL, 0x0a0e000000000000ULL, 0x141c000000000000ULL,
-	0x2838000000000000ULL, 0x5070000000000000ULL, 0xa0e0000000000000ULL, 0x40c0000000000000ULL,
+	0x0000000000000302ULL, 0x0000000000000604ULL, 0x0000000000000e0aULL, 0x0000000000001c14ULL,
+	0x0000000000003828ULL, 0x0000000000007050ULL, 0x0000000000006020ULL, 0x000000000000c040ULL,
+	0x0000000000030200ULL, 0x0000000000060400ULL, 0x00000000000e0a00ULL, 0x00000000001c1400ULL,
+	0x0000000000382800ULL, 0x0000000000705000ULL, 0x0000000000602000ULL, 0x0000000000c04000ULL,
+	0x0000000003020300ULL, 0x0000000006040600ULL, 0x000000000e0a0e00ULL, 0x000000001c141c00ULL,
+	0x0000000038283800ULL, 0x0000000070507000ULL, 0x0000000060206000ULL, 0x00000000c040c000ULL,
+	0x0000000302030000ULL, 0x0000000604060000ULL, 0x0000000e0a0e0000ULL, 0x0000001c141c0000ULL,
+	0x0000003828380000ULL, 0x0000007050700000ULL, 0x0000006020600000ULL, 0x000000c040c00000ULL,
+	0x0000030203000000ULL, 0x0000060406000000ULL, 0x00000e0a0e000000ULL, 0x00001c141c000000ULL,
+	0x0000382838000000ULL, 0x0000705070000000ULL, 0x0000602060000000ULL, 0x0000c040c0000000ULL,
+	0x0003020300000000ULL, 0x0006040600000000ULL, 0x000e0a0e00000000ULL, 0x001c141c00000000ULL,
+	0x0038283800000000ULL, 0x0070507000000000ULL, 0x0060206000000000ULL, 0x00c040c000000000ULL,
+	0x0002030000000000ULL, 0x0004060000000000ULL, 0x000a0e0000000000ULL, 0x00141c0000000000ULL,
+	0x0028380000000000ULL, 0x0050700000000000ULL, 0x0020600000000000ULL, 0x0040c00000000000ULL,
+	0x0203000000000000ULL, 0x0406000000000000ULL, 0x0a0e000000000000ULL, 0x141c000000000000ULL,
+	0x2838000000000000ULL, 0x5070000000000000ULL, 0x2060000000000000ULL, 0x40c0000000000000ULL,
 	0, 0 // <- hack for passing move & nomove
 };
 
@@ -69,95 +58,146 @@ const unsigned long long NEIGHBOUR[] = {
  * @param b 64-bit integer to count bits of.
  * @return the number of bits set.
  */
+
+#ifndef POPCOUNT
+  #if 0
 int bit_count(unsigned long long b)
 {
-#if defined(POPCOUNT)
-
-	#if defined(USE_GAS_X64)
-		__asm__("popcntq %1,%0" :"=r" (b) :"rm" (b));
-		return (int) b;
-	#elif defined(USE_MSVC_X64)
-		return __popcnt64(b);
-	#elif defined(USE_GCC_X64)
-		return __builtin_popcountll(b);
-	#endif
-
-// MMX does not help much here :-(
-#elif defined (USE_GAS_MMX)
- 
-	const unsigned long long M55 = 0x5555555555555555ULL;
-	const unsigned long long M33 = 0x3333333333333333ULL;
-	const unsigned long long M0F = 0x0F0F0F0F0F0F0F0FULL;
-	int count;
-
-	__asm__ volatile(
- 		"movq  %1, %%mm1\n\t"
-		"pxor  %%mm2, %%mm2\n\t"
-
-		"movq  %%mm1, %%mm0\n\t"
-		"psrlq $1, %%mm1\n\t"
-		"pand  %2, %%mm1\n\t"
-		"psubd %%mm1, %%mm0\n\t"
-
-		"movq  %%mm0, %%mm1\n\t"
-		"psrlq $2, %%mm0\n\t"
-		"pand  %3, %%mm1\n\t"
-		"pand  %3, %%mm0\n\t"
-		"paddd %%mm1, %%mm0\n\t"
-
-		"movq  %%mm0, %%mm1\n\t"
-		"psrlq $4, %%mm0\n\t"
-		"paddd %%mm1, %%mm0\n\t"
-		"pand  %4, %%mm0\n\t"
-
-		"psadbw %%mm2, %%mm0\n\t"
-		"movd	%%mm0, %0\n\t"
-		"emms\n\t"
-		: "=a" (count) : "m" (b), "m" (M55), "m" (M33), "m" (M0F));
-
-	return count;
+	int	c;
 
-#else
+	b  = b - ((b >> 1) & 0x5555555555555555ULL);
+	b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+    #ifdef HAS_CPU_64
+	b = (b + (b >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+	c = (b * 0x0101010101010101ULL) >> 56;
+    #else
+	c = (b >> 32) + b;
+	c = (c & 0x0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F);
+	c = (c * 0x01010101) >> 24;
+    #endif
+	return c;
+}
 
-	register unsigned long long c = b
-		- ((b >> 1) & 0x7777777777777777ULL)
-		- ((b >> 2) & 0x3333333333333333ULL)
-		- ((b >> 3) & 0x1111111111111111ULL);
-	c = ((c + (c >> 4)) & 0x0F0F0F0F0F0F0F0FULL) * 0x0101010101010101ULL;
+  #else
+// https://github.com/official-stockfish/Stockfish/pull/620/files
+// 2% faster than SWAR bit_count for 32 & 64 non-POPCOUNT build
+unsigned char PopCnt16[1 << 16];
 
-	return  (int)(c >> 56);
+static int bit_count_32_SWAR(unsigned int b)
+{
+	b = b - ((b >> 1) & 0x55555555);
+	b = ((b >> 2) & 0x333333333) + (b & 0x33333333);
+	b = ((b >> 4) + b) & 0x0F0F0F0F;
+	return (b * 0x01010101) >> 24;
+}
+  #endif
+#endif
 
+/**
+ * @brief initialize PopCnt16 table and check MMX/SSE availability.
+ */
+void bit_init(void)
+{
+	unsigned int	n;
+	unsigned long long	ll;
+#ifndef crc32c_u64
+	unsigned int	k, crc;
+
+	// http://stackoverflow.com/a/17646775/1821055
+	// https://github.com/baruch/crcbench
+	// Generate byte-wise table.
+	for (n = 0; n < 256; n++) {
+		crc = ~n;
+		for (k = 0; k < 8; k++)
+			crc = (crc >> 1) ^ (-(int)(crc & 1) & 0x82f63b78);
+		crc32c_table[0][n] = ~crc;
+	}
+	// Use byte-wise table to generate word-wise table.
+	for (n = 0; n < 256; n++) {
+		crc = ~crc32c_table[0][n];
+		for (k = 1; k < 4; k++) {
+			crc = crc32c_table[0][crc & 0xff] ^ (crc >> 8);
+			crc32c_table[k][n] = ~crc;
+		}
+	}
 #endif
-}
 
+	ll = 1;
+	for (n = 0; n < 66; ++n) {	// X_TO_BIT[64] = X_TO_BIT[65] = 0 for passing move & nomove
+		X_TO_BIT[n] = ll;
+		ll <<= 1;
+	}
+
+#ifndef POPCOUNT
+	for (n = 0; n < (1 << 16); ++n)
+		PopCnt16[n] = bit_count_32_SWAR(n);
+#endif
+
+#if (defined(USE_GAS_MMX) || defined(USE_MSVC_X86)) && !defined(hasSSE2)
+	init_mmx();
+#endif
+#if defined(ANDROID) && !defined(__ARM_NEON) && !defined(hasSSE2)
+	init_neon();
+#endif
+}
 
 /**
  * @brief count the number of discs, counting the corners twice.
  *
  * This is a variation of the above algorithm to count the mobility and favour
  * the corners. This function is useful for move sorting.
+ * (SSE/Neon version caliculates 2 elements in parallel.)
  *
  * @param v 64-bit integer to count bits of.
  * @return the number of bit set, counting the corners twice.
  */
-int bit_weighted_count(const unsigned long long v)
+#if !defined(__AVX2__) && defined(hasSSE2) && !defined(POPCOUNT)
+__m128i bit_weighted_count_sse(unsigned long long Q0, unsigned long long Q1)
 {
-#if defined(POPCOUNT)
-
-	return bit_count(v) + bit_count(v & 0x8100000000000081ULL);
-
-#else
+	static const V2DI mask15 = {{ 0x1555555555555515, 0x1555555555555515 }};
+	static const V2DI mask01 = {{ 0x0100000000000001, 0x0100000000000001 }};
+	static const V2DI mask33 = {{ 0x3333333333333333, 0x3333333333333333 }};
+	static const V2DI mask0F = {{ 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F }};
+
+	__m128i v = _mm_set_epi64x(Q1, Q0);
+	v = _mm_add_epi64(_mm_sub_epi64(v, _mm_and_si128(_mm_srli_epi64(v, 1), mask15.v2)), _mm_and_si128(v, mask01.v2));
+	v = _mm_add_epi64(_mm_and_si128(v, mask33.v2), _mm_and_si128(_mm_srli_epi64(v, 2), mask33.v2));
+	v = _mm_and_si128(_mm_add_epi64(v, _mm_srli_epi64(v, 4)), mask0F.v2);
+	return _mm_sad_epu8(v, _mm_setzero_si128());
+}
 
-	register unsigned long long b;
-	b  = v - ((v >> 1) & 0x1555555555555515ULL) + (v & 0x0100000000000001ULL);
-	b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-	b  = ((b >> 4) + b) & 0x0f0f0f0f0f0f0f0fULL;
-	b *= 0x0101010101010101ULL;
+#elif defined(__ARM_NEON)
+uint64x2_t bit_weighted_count_neon(unsigned long long Q0, unsigned long long Q1)
+{
+	uint64x2_t v = vcombine_u64(vcreate_u64(Q0), vcreate_u64(Q1));
+	return vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(vaddq_u8(vcntq_u8(vreinterpretq_u8_u64(v)),
+		vcntq_u8(vreinterpretq_u8_u64(vandq_u64(v, vdupq_n_u64(0x8100000000000081))))))));
+}
 
-	return  (int)(b >> 56);
+#elif 0	// SWAR, for record
+int bit_weighted_count(unsigned long long v)
+{
+	int	c;
+
+	v  = v - ((v >> 1) & 0x1555555555555515) + (v & 0x0100000000000001);
+	v  = ((v >> 2) & 0x3333333333333333) + (v & 0x3333333333333333);
+	c = (v >> 32) + v;
+	c = (c & 0x0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F);
+	c = (c * 0x01010101) >> 24;
+	return c;
+}
 
-#endif
+#else
+int bit_weighted_count(unsigned long long v)
+{
+  	unsigned int AH18 = ((v >> 56) | (v << 8)) & 0x8181;	// ror 56
+  #ifdef POPCOUNT
+	return bit_count(v) + bit_count_32(AH18);
+  #else
+  	return bit_count(v) + PopCnt16[AH18];
+  #endif
 }
+#endif
 
 /**
  *
@@ -168,60 +208,71 @@ int bit_weighted_count(const unsigned long long v)
  * magic numbers is provided.
  *
  * @param b 64-bit integer.
- * @return the index of the first bit set.
+ * @return the index of the first bit set. (undefined if b = 0)
  */
-int first_bit(unsigned long long b)
+#if !defined(first_bit_32) && !defined(HAS_CPU_64)
+int first_bit_32(unsigned int b)
 {
-#if defined(USE_GAS_X64)
+  #if defined(_MSC_VER)
+	unsigned long index;
+	_BitScanForward(&index, b);
+	return (int) index;
 
-	__asm__("bsfq %1,%0" : "=r" (b) : "rm" (b));
+  #elif defined(USE_GAS_X64) || defined(USE_GAS_X86)
+	__asm__("rep; bsf	%1, %0" : "=r" (b) : "rm" (b));	// tzcnt on BMI CPUs, bsf otherwise
 	return (int) b;
 
-#elif defined(USE_GAS_X86)
+  #elif defined(USE_MSVC_X86)
+	__asm {
+		bsf	eax, word ptr b
+	}
+
+  #elif defined(USE_GCC_ARM)
+	return  __builtin_clz(b & -b) ^ 31;
+
+  #else
+	static const unsigned char magic[32] = {
+		0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
+		31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
+	};
 
-  int x1, x2;
-	__asm__ ("bsf %0,%0\n"
-	         "jnz 1f\n"
-	         "bsf %1,%0\n"
-	         "jz 1f\n"
-	         "addl $32,%0\n"
-		     "1:": "=&q" (x1), "=&q" (x2):"1" ((int) (b >> 32)), "0" ((int) b));
-	return x1;
+	return magic[((b & (-b)) * 0x077CB531U) >> 27];
+  #endif
+}
+#endif // first_bit_32
 
-#elif defined(USE_MSVC_X64)
+#ifndef first_bit
+int first_bit(unsigned long long b)
+{
+  #if defined(USE_GAS_X64)
+	__asm__("rep; bsfq	%1, %0" : "=r" (b) : "rm" (b));	// tzcntq on BMI CPUs
+	return (int) b;
 
+  #elif defined(USE_GAS_X86)
+	int 	x;
+	__asm__ ("bsf	%2, %0\n\t"	// (ZF differs from tzcnt)
+		"jnz	1f\n\t"
+		"bsf	%1, %0\n\t"
+		"addl	$32, %0\n"
+	"1:" : "=&q" (x) : "g" ((int) (b >> 32)), "g" ((int) b));
+	return x;
+
+  #elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
 	unsigned long index;
 	_BitScanForward64(&index, b);
 	return (int) index;
 
-#elif defined(USE_GCC_X64)
-
-	return __builtin_ctzll(b);
-
-#elif defined(USE_MASM_X86)
+  #elif defined(USE_MSVC_X86)
 	__asm {
-		xor eax, eax
-		bsf edx, dword ptr b
-		jnz l1
-		bsf edx, dword ptr b+4
-		mov eax, 32
-		jnz l1
-		mov edx, -32
-	l1:	add eax, edx
+		bsf	eax, dword ptr b
+		jnz	l1
+		bsf	eax, dword ptr b+4
+		add	eax, 32
+	l1:
 	}
 
-#elif defined(USE_GCC_ARM)
-	const unsigned int lb = (unsigned int)b;
-	if (lb) {
-		return  __builtin_clz(lb & -lb) ^ 31;
-	} else {
-		const unsigned int hb = b >> 32;
-		return 32 + (__builtin_clz(hb & -hb) ^ 31);
-	}
-
-#else
-
-	const int magic[64] = {
+  #elif defined(HAS_CPU_64)
+	static const unsigned char magic[64] = {
 		63, 0, 58, 1, 59, 47, 53, 2,
 		60, 39, 48, 27, 54, 33, 42, 3,
 		61, 51, 37, 40, 49, 18, 28, 20,
@@ -234,23 +285,34 @@ int first_bit(unsigned long long b)
 
 	return magic[((b & (-b)) * 0x07EDD5E59A4E28C2ULL) >> 58];
 
-#endif
+  #else
+	const unsigned int lb = (unsigned int) b;
+	if (lb) {
+		return first_bit_32(lb);
+	} else {
+		return 32 + first_bit_32(b >> 32);
+	}
+  #endif
 }
+#endif // first_bit
 
+#if 0
 /**
  * @brief Search the next bit set.
  *
  * In practice, clear the first bit set and search the next one.
  *
  * @param b 64-bit integer.
-  * @return the index of the next bit set.
+ * @return the index of the next bit set.
  */
 int next_bit(unsigned long long *b)
 {
 	*b &= *b - 1;
 	return first_bit(*b);
 }
+#endif
 
+#ifndef last_bit
 /**
  * @brief Search the last bit set (same as log2()).
  *
@@ -263,33 +325,25 @@ int next_bit(unsigned long long *b)
  */
 int last_bit(unsigned long long b)
 {
-#if defined(USE_GAS_X64)
-
-	__asm__("bsrq %1,%0" :"=r" (b) :"rm" (b));
+  #if defined(USE_GAS_X64)
+	__asm__("bsrq	%1, %0" :"=r" (b) :"rm" (b));
 	return b;
 
-#elif defined(USE_MSVC_X64)
-
+  #elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
 	unsigned long index;
 	_BitScanReverse64(&index, b);
 	return (int) index;
 
-#elif defined(USE_GCC_X64)
-
-	return 63 - __builtin_clzll(b);
-	
-#elif defined(USE_GAS_X86)
+  #elif defined(USE_GAS_X86)
+	int	x;
+	__asm__ ("bsr	%1, %0\n\t"
+		"leal	32(%0), %0\n\t"
+		"jnz	1f\n\t"
+		"bsr	%2, %0\n\t"
+        "1:" : "=&q" (x) : "g" ((int) (b >> 32)), "g" ((int) b));
+	return x;
 
-  int x1, x2;
-	__asm__ ("bsr %1,%0\n"
-	         "jnz 1f\n"
-	         "bsr %0,%0\n"
-	         "subl $32,%0\n"
-             "1: addl $32,%0\n" : "=&q" (x1), "=&q" (x2) : "1" ((int) (b >> 32)), "0" ((int) b));
-  return x1;
-
-	
-#elif defined(USE_GCC_ARM)
+  #elif 0 // defined(USE_GCC_ARM)
 	const unsigned int hb = b >> 32;
 	if (hb) {
 		return 63 - __builtin_clz(hb);
@@ -297,31 +351,26 @@ int last_bit(unsigned long long b)
 		return 31 - __builtin_clz((int) b);
 	}
 
-
-#elif defined(USE_MASM_X86)
+  #elif defined(USE_MSVC_X86)
 	__asm {
-		xor eax, eax
-		bsr edx, dword ptr b+4
-		jnz l1
-		bsr edx, dword ptr b
-		mov eax, 32
-		jnz l1
-		mov edx, -32
-	l1:	add eax, edx
+		bsr	eax, dword ptr b+4
+		lea	eax, [eax+32]
+		jnz	l1
+		bsr	eax, dword ptr b
+	l1:
 	}
 
-	
-#else
-
-	const int magic[64] = {
-		63, 0, 58, 1, 59, 47, 53, 2,
-		60, 39, 48, 27, 54, 33, 42, 3,
-		61, 51, 37, 40, 49, 18, 28, 20,
-		55, 30, 34, 11, 43, 14, 22, 4,
-		62, 57, 46, 52, 38, 26, 32, 41,
-		50, 36, 17, 19, 29, 10, 13, 21,
-		56, 45, 25, 31, 35, 16, 9, 12,
-		44, 24, 15, 8, 23, 7, 6, 5
+  #elif defined(HAS_CPU_64)
+	// https://www.chessprogramming.org/BitScan#De_Bruijn_Multiplication_2
+	static const unsigned char magic[64] = {
+		 0, 47,  1, 56, 48, 27,  2, 60,
+		57, 49, 41, 37, 28, 16,  3, 61,
+		54, 58, 35, 52, 50, 42, 21, 44,
+		38, 32, 29, 23, 17, 11,  4, 62,
+		46, 55, 26, 59, 40, 36, 15, 53,
+		34, 51, 20, 43, 31, 22, 10, 45,
+		25, 39, 14, 33, 19, 30,  9, 24,
+		13, 18,  8, 12,  7,  6,  5, 63
 	};
 
 	b |= b >> 1;
@@ -330,30 +379,36 @@ int last_bit(unsigned long long b)
 	b |= b >> 8;
 	b |= b >> 16;
 	b |= b >> 32;
-	b = (b >> 1) + 1;
-
-	return magic[(b * 0x07EDD5E59A4E28C2ULL) >> 58];
 
-#endif
+	return magic[(b * 0x03f79d71b4cb0a89) >> 58];
+
+  #else
+	static const unsigned char clz_table_4bit[16] = { 4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
+	int	n = 63;
+	unsigned int	x;
+
+	x = b >> 32;
+	if (x == 0) { n = 31; x = (unsigned int) b; }
+	if ((x & 0xFFFF0000) == 0) { n -= 16; x <<= 16; }
+	if ((x & 0xFF000000) == 0) { n -=  8; x <<=  8; }
+	if ((x & 0xF0000000) == 0) { n -=  4; x <<=  4; }
+	n -= clz_table_4bit[x >> (32 - 4)];
+	return n;
+  #endif
 }
+#endif // last_bit
 
+#ifndef bswap_int
 /**
- * @brief Transpose the unsigned long long (symetry % A1-H8 diagonal).
- * @param b An unsigned long long
- * @return The transposed unsigned long long.
+ * @brief Mirror the unsigned int (little <-> big endian).
+ * @param i An unsigned int.
+ * @return The mirrored int.
  */
-unsigned long long transpose(unsigned long long b)
+unsigned int bswap_int(unsigned int i)
 {
-	unsigned long long t;
-
-	t = (b ^ (b >> 7)) & 0x00aa00aa00aa00aaULL;
-	b = b ^ t ^ (t << 7);
-	t = (b ^ (b >> 14)) & 0x0000cccc0000ccccULL;
-	b = b ^ t ^ (t << 14);
-	t = (b ^ (b >> 28)) & 0x00000000f0f0f0f0ULL;
-	b = b ^ t ^ (t << 28);
-
-	return b;
+	i = ((i >>  8) & 0x00FF00FFU) | ((i & 0x00FF00FFU) <<  8);
+	i = (i >> 16) | (i << 16);
+	return i;
 }
 
 /**
@@ -363,47 +418,101 @@ unsigned long long transpose(unsigned long long b)
  */
 unsigned long long vertical_mirror(unsigned long long b)
 {
-	b = ((b >>  8) & 0x00FF00FF00FF00FFULL) | ((b <<  8) & 0xFF00FF00FF00FF00ULL);
-	b = ((b >> 16) & 0x0000FFFF0000FFFFULL) | ((b << 16) & 0xFFFF0000FFFF0000ULL);
-	b = ((b >> 32) & 0x00000000FFFFFFFFULL) | ((b << 32) & 0xFFFFFFFF00000000ULL);
-	return b;
+	return bswap_int((unsigned int)(b >> 32)) | ((unsigned long long) bswap_int((unsigned int) b) << 32);
 }
+#endif // bswap_int
 
 /**
  * @brief Mirror the unsigned long long (exchange the line 1 - 8, 2 - 7, 3 - 6 & 4 - 5).
  * @param b An unsigned long long.
  * @return The mirrored unsigned long long.
  */
+unsigned int horizontal_mirror_32(unsigned int b)
+{
+#ifdef __ARM_ACLE
+	return __rev(__rbit(b));
+#else
+	b = ((b >> 1) & 0x55555555U) +  2 * (b & 0x55555555U);
+	b = ((b >> 2) & 0x33333333U) +  4 * (b & 0x33333333U);
+	b = ((b >> 4) & 0x0F0F0F0FU) + 16 * (b & 0x0F0F0F0FU);
+	return b;
+#endif
+}
+
 unsigned long long horizontal_mirror(unsigned long long b)
 {
-  b = ((b >> 1) & 0x5555555555555555ULL) | ((b << 1) & 0xAAAAAAAAAAAAAAAAULL);
-  b = ((b >> 2) & 0x3333333333333333ULL) | ((b << 2) & 0xCCCCCCCCCCCCCCCCULL);
-  b = ((b >> 4) & 0x0F0F0F0F0F0F0F0FULL) | ((b << 4) & 0xF0F0F0F0F0F0F0F0ULL);
+#if defined(HAS_CPU_64) && !defined(__ARM_ACLE)
+	b = ((b >> 1) & 0x5555555555555555ULL) | ((b & 0x5555555555555555ULL) << 1);
+	b = ((b >> 2) & 0x3333333333333333ULL) | ((b & 0x3333333333333333ULL) << 2);
+	b = ((b >> 4) & 0x0F0F0F0F0F0F0F0FULL) | ((b & 0x0F0F0F0F0F0F0F0FULL) << 4);
+	return b;
+#else
+	return ((unsigned long long) horizontal_mirror_32(b >> 32) << 32)
+		| horizontal_mirror_32((unsigned int) b);
+#endif
+}
 
-  return b;
+/**
+ * @brief Transpose the unsigned long long (symetry % A1-H8 diagonal, or swap axes).
+ * @param b An unsigned long long
+ * @return The transposed unsigned long long.
+ */
+#ifdef __AVX2__
+unsigned long long transpose(unsigned long long b)
+{
+	__m256i	v = _mm256_sllv_epi64(_mm256_broadcastq_epi64(_mm_cvtsi64_si128(b)), _mm256_set_epi64x(0, 1, 2, 3));
+	return ((unsigned long long) _mm256_movemask_epi8(v) << 32)
+		| (unsigned int) _mm256_movemask_epi8(_mm256_slli_epi64(v, 4));
 }
 
+#else
+unsigned long long transpose(unsigned long long b)
+{
+	unsigned long long t;
+
+	t = (b ^ (b >> 7)) & 0x00aa00aa00aa00aaULL;
+	b = b ^ t ^ (t << 7);
+	t = (b ^ (b >> 14)) & 0x0000cccc0000ccccULL;
+	b = b ^ t ^ (t << 14);
+	t = (b ^ (b >> 28)) & 0x00000000f0f0f0f0ULL;
+	b = b ^ t ^ (t << 28);
+
+	return b;
+}
+#endif // __AVX2__
+
+#ifndef crc32c_u64
 /**
- * @brief Swap bytes of a short (little <-> big endian).
- * @param s An unsigned short.
- * @return The mirrored short.
+ * @brief Caliculate crc32c checksum for 8 bytes data
+ * @param crc Initial crc from previous data.
+ * @param data Data to accumulate.
+ * @return Resulting crc.
  */
-unsigned short bswap_short(unsigned short s)
+unsigned int crc32c_u64(unsigned int crc, unsigned long long data)
 {
-	return (unsigned short) ((s >> 8) & 0x00FF) | ((s <<  8) & 0xFF00);
+	crc ^= (unsigned int) data;
+	crc =	crc32c_table[3][crc & 0xff] ^
+		crc32c_table[2][(crc >> 8) & 0xff] ^
+		crc32c_table[1][(crc >> 16) & 0xff] ^
+		crc32c_table[0][crc >> 24];
+	crc ^= (unsigned int) (data >> 32);
+	return	crc32c_table[3][crc & 0xff] ^
+		crc32c_table[2][(crc >> 8) & 0xff] ^
+		crc32c_table[1][(crc >> 16) & 0xff] ^
+		crc32c_table[0][crc >> 24];
 }
 
 /**
- * @brief Mirror the unsigned int (little <-> big endian).
- * @param i An unsigned int.
- * @return The mirrored int.
+ * @brief Caliculate crc32c checksum for a byte
+ * @param crc Initial crc from previous data.
+ * @param data Data to accumulate.
+ * @return Resulting crc.
  */
-unsigned int bswap_int(unsigned int i)
+unsigned int crc32c_u8(unsigned int crc, unsigned int data)
 {
-	i = ((i >>  8) & 0x00FF00FFU) | ((i <<  8) & 0xFF00FF00U);
-	i = ((i >> 16) & 0x0000FFFFU) | ((i << 16) & 0xFFFF0000U);
-	return i;
+	return	crc32c_table[0][(crc ^ data) & 0xff] ^ (crc >> 8);
 }
+#endif
 
 /**
  * @brief Get a random set bit index.
@@ -432,27 +541,22 @@ int get_rand_bit(unsigned long long b, Random *r)
  * @param b The unsigned long long.
  * @param f Output stream.
  */
-void bitboard_write(const unsigned long long b, FILE *f)
+void bitboard_write(unsigned long long b, FILE *f)
 {
-	int i, j, x;
-	const char *color = ".X";
+	int i, j;
+	static const char color[2] = ".X";
 
 	fputs("  A B C D E F G H\n", f);
 	for (i = 0; i < 8; ++i) {
 		fputc(i + '1', f);
 		fputc(' ', f);
 		for (j = 0; j < 8; ++j) {
-			x = i * 8 + j;
-			fputc(color[((b >> (unsigned)x) & 1)], f);
+			fputc(color[b & 1], f);
 			fputc(' ', f);
+			b >>= 1;
 		}
 		fputc(i + '1', f);
 		fputc('\n', f);
 	}
 	fputs("  A B C D E F G H\n", f);
 }
-
-
-
-
-
diff --git a/src/bit.h b/src/bit.h
index e850ae1b..c08243ea 100644
--- a/src/bit.h
+++ b/src/bit.h
@@ -3,40 +3,229 @@
  *
  * Bitwise operations header file.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_BIT_H
 #define EDAX_BIT_H
 
 #include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <stdbool.h>
+
+#include "bit_intrinsics.h"
 
 struct Random;
 
 /* declaration */
-int bit_count(unsigned long long);
-int bit_weighted_count(const unsigned long long);
-int first_bit(unsigned long long);
-int next_bit(unsigned long long*);
-int last_bit(unsigned long long);
-void bitboard_write(const unsigned long long, FILE*);
+void bit_init(void);
+// int next_bit(unsigned long long*);
+void bitboard_write(unsigned long long, FILE*);
 unsigned long long transpose(unsigned long long);
-unsigned long long vertical_mirror(unsigned long long);
+unsigned int horizontal_mirror_32(unsigned int b);
 unsigned long long horizontal_mirror(unsigned long long);
-unsigned int bswap_int(unsigned int);
-unsigned short bswap_short(unsigned short);
 int get_rand_bit(unsigned long long, struct Random*);
 
-/** Loop over each bit set. */
-#define foreach_bit(i, b) for (i = first_bit(b); b; i = next_bit(&b))
+#if !defined(__AVX2__) && defined(hasSSE2) && !defined(POPCOUNT)
+	__m128i bit_weighted_count_sse(unsigned long long, unsigned long long);
+#elif defined (__ARM_NEON)
+	uint64x2_t bit_weighted_count_neon(unsigned long long, unsigned long long);
+#else
+	int bit_weighted_count(unsigned long long);
+#endif
+
+extern unsigned long long X_TO_BIT[];
+extern const unsigned long long NEIGHBOUR[];
 
-extern const unsigned long long X_TO_BIT[];
 /** Return a bitboard with bit x set. */
-#define x_to_bit(x) X_TO_BIT[x]
+// https://eukaryote.hateblo.jp/entry/2020/04/12/054905
+#ifdef HAS_CPU_64 // 1% slower on Sandy Bridge
+	#define x_to_bit(x) (1ULL << (x))
+#else
+	#define x_to_bit(x) X_TO_BIT[x]
+#endif
+
+/** Loop over each bit set. */
+#if defined(tzcnt_u64)
+	#define	first_bit(x)	tzcnt_u64(x)
+	#define	last_bit(x)	(63 - lzcnt_u64(x))
+#elif ((defined(__GNUC__) && (__GNUC__ >= 4)) || __has_builtin(__builtin_ctzll)) && !defined(__INTEL_COMPILER)
+	#define	first_bit(x)	__builtin_ctzll(x)
+	#define	last_bit(x)	(63 - __builtin_clzll(x))
+#else
+	int first_bit(unsigned long long);
+	int last_bit(unsigned long long);
+#endif
+
+#if defined(HAS_CPU_64) || !defined(__STDC_HOSTED__)	// __STDC_HOSTED__ (C99) to declare var in for statement
+	#define foreach_bit(i, b)	for (i = first_bit(b); b; i = first_bit(b &= (b - 1)))
+#else
+  #ifdef tzcnt_u32
+	#define	first_bit_32(x)	tzcnt_u32(x)
+  #else
+	int first_bit_32(unsigned int);
+  #endif
+	#define foreach_bit(i, b)	(void) i; for (unsigned int _j = 0; _j < sizeof(b) * CHAR_BIT; _j += sizeof(int) * CHAR_BIT) \
+		for (int _r = (b >> _j), i = first_bit_32(_r) + _j; _r; i = first_bit_32(_r &= (_r - 1)) + _j)
+#endif
+
+// popcount
+#ifdef __ARM_NEON
+  #ifdef HAS_CPU_64
+	#define bit_count(x)	vaddv_u8(vcnt_u8(vcreate_u8(x)))
+	#define bit_count_32(x)	vaddv_u8(vcnt_u8(vcreate_u8((unsigned int) x)))
+  #else
+	#define bit_count(x)	vget_lane_u32(vreinterpret_u32_u64(vpaddl_u32(vpaddl_u16(vpaddl_u8(vcnt_u8(vcreate_u8(x)))))), 0)
+	#define bit_count_32(x)	vget_lane_u32(vpaddl_u16(vpaddl_u8(vcnt_u8(vcreate_u8(x)))), 0)
+  #endif
+
+#elif defined(POPCOUNT)
+  /*
+  #if defined (USE_GAS_X64)
+	static inline int bit_count (unsigned long long x) {
+		long long	y;
+		__asm__ ( "popcntq %1,%0" : "=r" (y) : "rm" (x));
+		return y;
+	}
+  #elif defined (USE_GAS_X86)
+	static inline int bit_count (unsigned long long x) {
+		unsigned int	y0, y1;
+		__asm__ ( "popcntl %2,%0\n\t"
+			"popcntl %3,%1"
+			: "=&r" (y0), "=&r" (y1)
+			: "rm" ((unsigned int) x), "rm" ((unsigned int) (x >> 32)));
+		return y0 + y1;
+	}
+  */
+  #ifdef _MSC_VER
+    #if defined(_M_ARM) || defined(_M_ARM64)
+	#define bit_count(x)	_CountOneBits64(x)
+	#define bit_count_32(x)	_CountOneBits(x)
+    #elif defined(_M_X64)
+	#define bit_count(x)	((int) __popcnt64(x))
+	#define bit_count_32(x)	__popcnt(x)
+    #else
+	#define bit_count(x)	(__popcnt((unsigned int) (x)) + __popcnt((unsigned int) ((x) >> 32)))
+	#define bit_count_32(x)	__popcnt(x)
+    #endif
+  #else
+	#define bit_count(x)	__builtin_popcountll(x)
+	#define bit_count_32(x)	__builtin_popcount(x)
+  #endif
+	#define bit_count_si64(x)	bit_count(_mm_cvtsi128_si64(x))
+
+#else
+	extern unsigned char PopCnt16[1 << 16];
+	static inline int bit_count(unsigned long long b) {
+		union { unsigned long long bb; unsigned short u[4]; } v = { b };
+		return (unsigned char)(PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]]);
+	}
+	static inline int bit_count_32(unsigned int b) {
+		union { unsigned int bb; unsigned short u[2]; } v = { b };
+		return (unsigned char)(PopCnt16[v.u[0]] + PopCnt16[v.u[1]]);
+	}
+	#define bit_count_si64(x)	((unsigned char)(PopCnt16[_mm_extract_epi16((x), 0)] + PopCnt16[_mm_extract_epi16((x), 1)] + PopCnt16[_mm_extract_epi16((x), 2)] + PopCnt16[_mm_extract_epi16((x), 3)]))
+#endif
+
+#if defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+  #ifndef hasSSE2
+	extern bool	hasSSE2;
+  #endif
+  #ifndef hasMMX
+	extern bool	hasMMX;
+  #endif
+#endif
+
+#if defined(ANDROID) && ((defined(__arm__) && !defined(__ARM_NEON)) || (defined(__i386__) && !defined(hasSSE2)))
+extern bool	hasSSE2;
+#endif
+
+/** Board : board representation */
+typedef struct Board {
+	unsigned long long player, opponent;     /**< bitboard representation */
+} Board;
+
+typedef union {
+	unsigned long long	ull[2];
+	Board	board;	// for vboard optimization in search
+  #ifdef __ARM_NEON
+	uint64x2_t	v2;
+  #elif defined(hasSSE2) || defined(USE_MSVC_X86)
+	__m128i	v2;
+	__m128d	d2;	// used in flip_carry_sse_32.c
+  #endif
+}
+#if defined(__GNUC__) && !defined(hasSSE2)
+__attribute__ ((aligned (16)))
+#endif
+V2DI;
+
+typedef union {
+	unsigned long long	ull[4];
+  #ifdef __AVX2__
+	__m256i	v4;
+  #endif
+  #ifdef hasSSE2
+	__m128i	v2[2];
+  #endif
+  #ifdef USE_MSVC_X86
+	__m64	v1[4];
+  #endif
+} V4DI;
+
+typedef union {
+	unsigned long long	ull[8];
+  #ifdef __AVX512VL__
+	__m512i	v8;
+  #endif
+  #ifdef __AVX2__
+	__m256i	v4[2];
+  #endif
+} V8DI;
+
+/* Define function attributes directive when available */
+
+#if (defined(_MSC_VER) || defined(__clang__)) && defined(hasSSE2)
+	#define	vectorcall	__vectorcall
+#elif defined(__GNUC__) && defined(__i386__)
+	#define	vectorcall	__attribute__((sseregparm))
+#elif 0 // defined(__GNUC__)	// erroreous result on pgo-build
+	#define	vectorcall	__attribute__((sysv_abi))
+#else
+	#define	vectorcall
+#endif
+
+// X64 compatibility sims for X86
+#if !defined(HAS_CPU_64) && (defined(hasSSE2) || defined(USE_MSVC_X86))
+	// static inline __m128i _mm_cvtsi64_si128(const unsigned long long x) {
+	//	return _mm_unpacklo_epi32(_mm_cvtsi32_si128(x), _mm_cvtsi32_si128(x >> 32));
+	// }
+		// better code but requires lvalue
+	#define	_mm_cvtsi64_si128(x)	_mm_loadl_epi64((__m128i *) &(x))
+	static inline unsigned long long vectorcall _mm_cvtsi128_si64(__m128i x) {
+		return *(unsigned long long *) &x;
+	}
+	static inline unsigned long long vectorcall _mm_extract_epi64(__m128i x, int i) {
+		return ((unsigned long long *) &x)[i];
+	}
 
-//#define x_to_bit(x) (1ULL << (x)) // 1% slower on Sandy Bridge
+  #if defined(_MSC_VER) && _MSC_VER<1900
+	static inline __m128i _mm_set_epi64x(unsigned long long b, unsigned long long a) {
+		return _mm_unpacklo_epi64(_mm_cvtsi64_si128(b), _mm_cvtsi64_si128(a));
+	}
+	static inline __m128i _mm_set1_epi64x(unsigned long long x) {
+		__m128i t = _mm_cvtsi64_si128(x);
+		return _mm_unpacklo_epi64(t, t);
+	}
+  #endif
+#endif // !HAS_CPU_64
 
+#if __clang_major__ == 3	// undefined reference to `llvm.x86.avx.storeu.dq.256'
+	#define	_mm_storeu_si128(a,b)	*(__m128i *)(a) = (b)
+	#define	_mm256_storeu_si256(a,b)	*(__m256i *)(a) = (b)
 #endif
 
+#endif // EDAX_BIT_H
diff --git a/src/bit_intrinsics.h b/src/bit_intrinsics.h
new file mode 100644
index 00000000..3ddd4834
--- /dev/null
+++ b/src/bit_intrinsics.h
@@ -0,0 +1,221 @@
+/**
+ * @file bit_intrinsics.h
+ *
+ * CPU dependent bit operation intrinsics.
+ *
+ * @date 2020 - 2024
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#ifndef EDAX_BIT_INTRINSICS_H
+#define EDAX_BIT_INTRINSICS_H
+
+#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64)
+	#define	HAS_CPU_64	1
+#endif
+
+#if defined(__SSE2__) || defined(__AVX__) || defined(_M_X64)
+	#define hasSSE2	1
+#endif
+
+#ifdef hasSSE2
+	#define	hasMMX	1
+#endif
+
+#if defined(ANDROID) && defined(__arm__)
+  #if __ANDROID_API__ < 21
+	#define	DISPATCH_NEON	1
+  #else
+	#define	__ARM_NEON	1
+  #endif
+#elif defined(__ARM_NEON__) || defined(__aarch64__) || defined(_M_ARM) || defined(_M_ARM64)
+	#define	__ARM_NEON	1
+#endif
+#ifdef __ARM_NEON
+	#include "arm_neon.h"
+#endif
+
+#ifdef _MSC_VER
+	#include <intrin.h>
+  #ifdef _M_IX86
+	#define	USE_MSVC_X86	1
+  #endif
+#elif defined(hasSSE2)
+	#include <x86intrin.h>
+#endif
+
+#ifndef __has_builtin  // Compatibility with non-clang compilers.
+	#define __has_builtin(x) 0
+#endif
+
+// mirror byte
+#if defined(_M_ARM) // || (defined(_M_ARM64) && _MSC_VER >= 1922)	// https://developercommunity.visualstudio.com/t/ARM64-still-missing-RBIT-intrinsics/10547420
+	#define mirror_byte(b)	(_arm_rbit(b) >> 24)
+#elif defined(__ARM_ACLE)
+	#include <arm_acle.h>
+	#define mirror_byte(b)	(__rbit(b) >> 24)
+#elif defined(HAS_CPU_64)
+	// http://graphics.stanford.edu/~seander/bithacks.html
+	#define mirror_byte(b)	(unsigned char)((((b) * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32)
+#else
+	static inline unsigned char mirror_byte(unsigned int b) { return ((((b * 0x200802) & 0x4422110) + ((b << 7) & 0x880)) * 0x01010101 >> 24); }
+#endif
+
+// rotl8
+#if __has_builtin(__builtin_rotateleft8)
+	#define rotl8(x,y)	__builtin_rotateleft8((x),(y))
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) && (defined(__x86_64__) || defined(__i386__))
+	#define rotl8(x,y)	__builtin_ia32_rolqi((x),(y))
+#elif defined(_MSC_VER)
+	#define	rotl8(x,y)	_rotl8((x),(y))
+#else	// may not compile into 8-bit rotate
+	#define	rotl8(x,y)	((unsigned char)(((x)<<(y))|((unsigned char)(x)>>(8-(y)))))
+#endif
+
+// bswap
+#ifdef _MSC_VER
+	#define	bswap_short(x)	_byteswap_ushort(x)
+	#define	bswap_int(x)	_byteswap_ulong(x)
+	#define	vertical_mirror(x)	_byteswap_uint64(x)
+#else
+  #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) || __has_builtin(__builtin_bswap16)
+	#define	bswap_short(x)	__builtin_bswap16(x)
+  #else
+	#define bswap_short(x)	(((unsigned short) (x) >> 8) | ((unsigned short) (x) << 8))
+  #endif
+  #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) || __has_builtin(__builtin_bswap64)
+	#define	bswap_int(x)	__builtin_bswap32(x)
+	#define	vertical_mirror(x)	__builtin_bswap64(x)
+  #else
+	unsigned int bswap_int(unsigned int);
+	unsigned long long vertical_mirror(unsigned long long);
+  #endif
+#endif
+
+// lzcnt / tzcnt (0 allowed)
+
+#ifdef USE_GAS_X86
+#ifdef __LZCNT__
+static inline int _lzcnt_u64(unsigned long long x) {
+	int	y;
+	__asm__ (
+		"lzcntl	%1, %0\n\t"
+		"lzcntl	%2, %2\n\t"
+		"leal	(%0, %2), %0\n\t"
+		"cmovnc	%2, %0"
+	: "=&r" (y) : "0" ((unsigned int) x), "r" ((unsigned int) (x >> 32)) );
+	return y;
+}
+#endif
+#ifdef __BMI__
+static inline int _tzcnt_u64(unsigned long long x) {
+	int	y;
+	__asm__ (
+		"tzcntl	%1, %0\n\t"
+		"tzcntl	%2, %2\n\t"
+		"leal	(%0, %2), %0\n\t"
+		"cmovnc	%2, %0"
+	: "=&r" (y) : "0" ((unsigned int) (x >> 32)), "r" ((unsigned int) x) );
+	return y;
+}
+#endif
+#elif defined(USE_MSVC_X86) && (defined(__AVX2__) || defined(__LZCNT__))
+static inline int _lzcnt_u64(unsigned long long x) {
+	__asm {
+		lzcnt	eax, dword ptr x
+		lzcnt	edx, dword ptr x+4
+		lea	eax, [eax+edx]
+		cmovnc	eax, edx
+	}
+}
+
+static inline int _tzcnt_u64(unsigned long long x) {
+	__asm {
+		tzcnt	eax, dword ptr x+4
+		tzcnt	edx, dword ptr x
+		lea	eax, [eax+edx]
+		cmovnc	eax, edx
+	}
+}
+#endif
+
+#if defined(__AVX2__) || defined(__LZCNT__)
+	#define	lzcnt_u32(x)	_lzcnt_u32(x)
+	#define	lzcnt_u64(x)	_lzcnt_u64(x)
+
+#elif defined(_M_ARM) || defined(_M_ARM64)
+	#define lzcnt_u32(x)	_CountLeadingZeros(x)
+	#define lzcnt_u64(x)	_CountLeadingZeros64(x)
+
+#elif defined(_MSC_VER)
+	static inline int lzcnt_u32(unsigned int n) {
+		unsigned long i;
+		if (!_BitScanReverse(&i, n))
+			i = 32 ^ 31;
+		return i ^ 31;
+	}
+  #ifdef _M_X64
+	static inline int lzcnt_u64(unsigned long long n) {
+		unsigned long i;
+		if (!_BitScanReverse64(&i, n))
+			i = 64 ^ 63;
+		return i ^ 63;
+	}
+  #else
+	static inline int lzcnt_u64(unsigned long long n) {
+		unsigned long i;
+		if (_BitScanReverse(&i, n >> 32))
+			return i ^ 31;
+		if (!_BitScanReverse(&i, (unsigned int) n))
+			i = 64 ^ 63;
+		return i ^ 63;
+	}
+  #endif
+
+#elif defined(__ARM_FEATURE_CLZ)
+  #if __ARM_ACLE >= 110
+	#define	lzcnt_u32(x)	__clz(x)
+	#define	lzcnt_u64(x)	__clzll(x)
+  #else // strictly-incorrect patch
+	#define	lzcnt_u32(x)	__builtin_clz(x)
+	#define	lzcnt_u64(x)	__builtin_clzll(x)
+  #endif
+
+#else
+	static inline int lzcnt_u32(unsigned long x) { return (x ? __builtin_clz(x) : 32); }
+	static inline int lzcnt_u64(unsigned long x) { return (x ? __builtin_clzll(x) : 64); }
+#endif
+
+#if defined(__BMI__) || defined(__AVX2__)
+	#define	tzcnt_u32(x)	_tzcnt_u32(x)
+	#define	tzcnt_u64(x)	_tzcnt_u64(x)
+
+#elif defined(__ARM_FEATURE_CLZ)
+  #ifdef _M_ARM
+	#define	tzcnt_u32(x)	_arm_clz(_arm_rbit(x))
+  #elif __has_builtin(__rbit) // (__ARM_ARCH >= 6 && __ARM_ISA_THUMB >= 2) || __ARM_ARCH >= 7	// not for gcc
+	#define	tzcnt_u32(x)	__clz(__rbit(x))
+  #endif
+#endif
+
+#if defined(__SSE4_2__) || defined(__AVX__)
+  #ifdef HAS_CPU_64
+	#define	crc32c_u64(crc,d)	_mm_crc32_u64((crc),(d))
+  #else
+	#define	crc32c_u64(crc,d)	_mm_crc32_u32(_mm_crc32_u32((crc),(d)),((d)>>32))
+  #endif
+	#define	crc32c_u8(crc,d)	_mm_crc32_u8((crc),(d))
+
+#elif defined(__ARM_FEATURE_CRC32)
+	#include "arm_acle.h"
+	#define	crc32c_u64(crc,d)	__crc32cd((crc),(d))
+	#define crc32c_u8(crc,d)	__crc32cb((crc),(d))
+
+#else
+	unsigned int crc32c_u64(unsigned int crc, unsigned long long data);
+	unsigned int crc32c_u8(unsigned int crc, unsigned int data);
+#endif
+
+#endif // EDAX_BIT_INTRINSICS_H
diff --git a/src/board.c b/src/board.c
index 4ffaf446..e4f31fb9 100644
--- a/src/board.c
+++ b/src/board.c
@@ -11,9 +11,10 @@
  * some board properties. Most of the functions are optimized to be as fast as
  * possible, while remaining readable.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2024
  * @author Richard Delorme
- * @version 4.4
+ * @author Toshihiko Okuhara
+ * @version 4.5
  */
 
 #include "board.h"
@@ -21,7 +22,6 @@
 #include "bit.h"
 #include "hash.h"
 #include "move.h"
-#include "settings.h"
 #include "util.h"
 
 #include <ctype.h>
@@ -30,102 +30,49 @@
 
 
 #if MOVE_GENERATOR == MOVE_GENERATOR_CARRY
-	#ifdef HAS_CPU_64
-		#include "flip_carry_64.c"
-		#include "count_last_flip_carry_64.c"
-	#else 
-		#include "flip_carry_32.c"
-		#include "count_last_flip_carry_32.c"
-	#endif
+	#include "flip_carry_64.c"
 #elif MOVE_GENERATOR == MOVE_GENERATOR_SSE
 	#include "flip_sse.c"
-	#include "count_last_flip_kindergarten.c"
 #elif MOVE_GENERATOR == MOVE_GENERATOR_BITSCAN
+  #ifdef __ARM_NEON
+	#define	flip_neon	flip
+	#include "flip_neon_bitscan.c"
+  #else
 	#include "flip_bitscan.c"
-	#include "count_last_flip_bitscan.c"
+  #endif
 #elif MOVE_GENERATOR == MOVE_GENERATOR_ROXANE
 	#include "flip_roxane.c"
-	#include "count_last_flip_kindergarten.c"
+#elif MOVE_GENERATOR == MOVE_GENERATOR_32
+	#include "flip_carry_sse_32.c"
+#elif MOVE_GENERATOR == MOVE_GENERATOR_SSE_BSWAP
+	#include "flip_sse_bswap.c"
+#elif MOVE_GENERATOR == MOVE_GENERATOR_AVX
+	#include "flip_avx_ppfill.c"
+#elif MOVE_GENERATOR == MOVE_GENERATOR_AVX512
+	#include "flip_avx512cd.c"
+#elif MOVE_GENERATOR == MOVE_GENERATOR_NEON
+  #ifdef __aarch64__
+	#include "flip_neon_rbit.c"
+  #else
+	#include "flip_neon_lzcnt.c"
+  #endif
+#elif MOVE_GENERATOR == MOVE_GENERATOR_SVE
+	#include "flip_sve_lzcnt.c"
 #else // MOVE_GENERATOR == MOVE_GENERATOR_KINDERGARTEN
 	#include "flip_kindergarten.c"
-	#include "count_last_flip_kindergarten.c"
 #endif
 
 
 /** edge stability global data */
-static unsigned char edge_stability[256][256];
-
-/** conversion from an 8-bit line to the A1-A8 line */
-static const unsigned long long A1_A8[256] = {
-	0x0000000000000000ULL, 0x0000000000000001ULL, 0x0000000000000100ULL, 0x0000000000000101ULL, 0x0000000000010000ULL, 0x0000000000010001ULL, 0x0000000000010100ULL, 0x0000000000010101ULL,
-	0x0000000001000000ULL, 0x0000000001000001ULL, 0x0000000001000100ULL, 0x0000000001000101ULL, 0x0000000001010000ULL, 0x0000000001010001ULL, 0x0000000001010100ULL, 0x0000000001010101ULL,
-	0x0000000100000000ULL, 0x0000000100000001ULL, 0x0000000100000100ULL, 0x0000000100000101ULL, 0x0000000100010000ULL, 0x0000000100010001ULL, 0x0000000100010100ULL, 0x0000000100010101ULL,
-	0x0000000101000000ULL, 0x0000000101000001ULL, 0x0000000101000100ULL, 0x0000000101000101ULL, 0x0000000101010000ULL, 0x0000000101010001ULL, 0x0000000101010100ULL, 0x0000000101010101ULL,
-	0x0000010000000000ULL, 0x0000010000000001ULL, 0x0000010000000100ULL, 0x0000010000000101ULL, 0x0000010000010000ULL, 0x0000010000010001ULL, 0x0000010000010100ULL, 0x0000010000010101ULL,
-	0x0000010001000000ULL, 0x0000010001000001ULL, 0x0000010001000100ULL, 0x0000010001000101ULL, 0x0000010001010000ULL, 0x0000010001010001ULL, 0x0000010001010100ULL, 0x0000010001010101ULL,
-	0x0000010100000000ULL, 0x0000010100000001ULL, 0x0000010100000100ULL, 0x0000010100000101ULL, 0x0000010100010000ULL, 0x0000010100010001ULL, 0x0000010100010100ULL, 0x0000010100010101ULL,
-	0x0000010101000000ULL, 0x0000010101000001ULL, 0x0000010101000100ULL, 0x0000010101000101ULL, 0x0000010101010000ULL, 0x0000010101010001ULL, 0x0000010101010100ULL, 0x0000010101010101ULL,
-	0x0001000000000000ULL, 0x0001000000000001ULL, 0x0001000000000100ULL, 0x0001000000000101ULL, 0x0001000000010000ULL, 0x0001000000010001ULL, 0x0001000000010100ULL, 0x0001000000010101ULL,
-	0x0001000001000000ULL, 0x0001000001000001ULL, 0x0001000001000100ULL, 0x0001000001000101ULL, 0x0001000001010000ULL, 0x0001000001010001ULL, 0x0001000001010100ULL, 0x0001000001010101ULL,
-	0x0001000100000000ULL, 0x0001000100000001ULL, 0x0001000100000100ULL, 0x0001000100000101ULL, 0x0001000100010000ULL, 0x0001000100010001ULL, 0x0001000100010100ULL, 0x0001000100010101ULL,
-	0x0001000101000000ULL, 0x0001000101000001ULL, 0x0001000101000100ULL, 0x0001000101000101ULL, 0x0001000101010000ULL, 0x0001000101010001ULL, 0x0001000101010100ULL, 0x0001000101010101ULL,
-	0x0001010000000000ULL, 0x0001010000000001ULL, 0x0001010000000100ULL, 0x0001010000000101ULL, 0x0001010000010000ULL, 0x0001010000010001ULL, 0x0001010000010100ULL, 0x0001010000010101ULL,
-	0x0001010001000000ULL, 0x0001010001000001ULL, 0x0001010001000100ULL, 0x0001010001000101ULL, 0x0001010001010000ULL, 0x0001010001010001ULL, 0x0001010001010100ULL, 0x0001010001010101ULL,
-	0x0001010100000000ULL, 0x0001010100000001ULL, 0x0001010100000100ULL, 0x0001010100000101ULL, 0x0001010100010000ULL, 0x0001010100010001ULL, 0x0001010100010100ULL, 0x0001010100010101ULL,
-	0x0001010101000000ULL, 0x0001010101000001ULL, 0x0001010101000100ULL, 0x0001010101000101ULL, 0x0001010101010000ULL, 0x0001010101010001ULL, 0x0001010101010100ULL, 0x0001010101010101ULL,
-	0x0100000000000000ULL, 0x0100000000000001ULL, 0x0100000000000100ULL, 0x0100000000000101ULL, 0x0100000000010000ULL, 0x0100000000010001ULL, 0x0100000000010100ULL, 0x0100000000010101ULL,
-	0x0100000001000000ULL, 0x0100000001000001ULL, 0x0100000001000100ULL, 0x0100000001000101ULL, 0x0100000001010000ULL, 0x0100000001010001ULL, 0x0100000001010100ULL, 0x0100000001010101ULL,
-	0x0100000100000000ULL, 0x0100000100000001ULL, 0x0100000100000100ULL, 0x0100000100000101ULL, 0x0100000100010000ULL, 0x0100000100010001ULL, 0x0100000100010100ULL, 0x0100000100010101ULL,
-	0x0100000101000000ULL, 0x0100000101000001ULL, 0x0100000101000100ULL, 0x0100000101000101ULL, 0x0100000101010000ULL, 0x0100000101010001ULL, 0x0100000101010100ULL, 0x0100000101010101ULL,
-	0x0100010000000000ULL, 0x0100010000000001ULL, 0x0100010000000100ULL, 0x0100010000000101ULL, 0x0100010000010000ULL, 0x0100010000010001ULL, 0x0100010000010100ULL, 0x0100010000010101ULL,
-	0x0100010001000000ULL, 0x0100010001000001ULL, 0x0100010001000100ULL, 0x0100010001000101ULL, 0x0100010001010000ULL, 0x0100010001010001ULL, 0x0100010001010100ULL, 0x0100010001010101ULL,
-	0x0100010100000000ULL, 0x0100010100000001ULL, 0x0100010100000100ULL, 0x0100010100000101ULL, 0x0100010100010000ULL, 0x0100010100010001ULL, 0x0100010100010100ULL, 0x0100010100010101ULL,
-	0x0100010101000000ULL, 0x0100010101000001ULL, 0x0100010101000100ULL, 0x0100010101000101ULL, 0x0100010101010000ULL, 0x0100010101010001ULL, 0x0100010101010100ULL, 0x0100010101010101ULL,
-	0x0101000000000000ULL, 0x0101000000000001ULL, 0x0101000000000100ULL, 0x0101000000000101ULL, 0x0101000000010000ULL, 0x0101000000010001ULL, 0x0101000000010100ULL, 0x0101000000010101ULL,
-	0x0101000001000000ULL, 0x0101000001000001ULL, 0x0101000001000100ULL, 0x0101000001000101ULL, 0x0101000001010000ULL, 0x0101000001010001ULL, 0x0101000001010100ULL, 0x0101000001010101ULL,
-	0x0101000100000000ULL, 0x0101000100000001ULL, 0x0101000100000100ULL, 0x0101000100000101ULL, 0x0101000100010000ULL, 0x0101000100010001ULL, 0x0101000100010100ULL, 0x0101000100010101ULL,
-	0x0101000101000000ULL, 0x0101000101000001ULL, 0x0101000101000100ULL, 0x0101000101000101ULL, 0x0101000101010000ULL, 0x0101000101010001ULL, 0x0101000101010100ULL, 0x0101000101010101ULL,
-	0x0101010000000000ULL, 0x0101010000000001ULL, 0x0101010000000100ULL, 0x0101010000000101ULL, 0x0101010000010000ULL, 0x0101010000010001ULL, 0x0101010000010100ULL, 0x0101010000010101ULL,
-	0x0101010001000000ULL, 0x0101010001000001ULL, 0x0101010001000100ULL, 0x0101010001000101ULL, 0x0101010001010000ULL, 0x0101010001010001ULL, 0x0101010001010100ULL, 0x0101010001010101ULL,
-	0x0101010100000000ULL, 0x0101010100000001ULL, 0x0101010100000100ULL, 0x0101010100000101ULL, 0x0101010100010000ULL, 0x0101010100010001ULL, 0x0101010100010100ULL, 0x0101010100010101ULL,
-	0x0101010101000000ULL, 0x0101010101000001ULL, 0x0101010101000100ULL, 0x0101010101000101ULL, 0x0101010101010000ULL, 0x0101010101010001ULL, 0x0101010101010100ULL, 0x0101010101010101ULL,
-};
-
-/** conversion from an 8-bit line to the H1-H8 line */
-static const unsigned long long H1_H8[256] = {
-	0x0000000000000000ULL, 0x0000000000000080ULL, 0x0000000000008000ULL, 0x0000000000008080ULL, 0x0000000000800000ULL, 0x0000000000800080ULL, 0x0000000000808000ULL, 0x0000000000808080ULL,
-	0x0000000080000000ULL, 0x0000000080000080ULL, 0x0000000080008000ULL, 0x0000000080008080ULL, 0x0000000080800000ULL, 0x0000000080800080ULL, 0x0000000080808000ULL, 0x0000000080808080ULL,
-	0x0000008000000000ULL, 0x0000008000000080ULL, 0x0000008000008000ULL, 0x0000008000008080ULL, 0x0000008000800000ULL, 0x0000008000800080ULL, 0x0000008000808000ULL, 0x0000008000808080ULL,
-	0x0000008080000000ULL, 0x0000008080000080ULL, 0x0000008080008000ULL, 0x0000008080008080ULL, 0x0000008080800000ULL, 0x0000008080800080ULL, 0x0000008080808000ULL, 0x0000008080808080ULL,
-	0x0000800000000000ULL, 0x0000800000000080ULL, 0x0000800000008000ULL, 0x0000800000008080ULL, 0x0000800000800000ULL, 0x0000800000800080ULL, 0x0000800000808000ULL, 0x0000800000808080ULL,
-	0x0000800080000000ULL, 0x0000800080000080ULL, 0x0000800080008000ULL, 0x0000800080008080ULL, 0x0000800080800000ULL, 0x0000800080800080ULL, 0x0000800080808000ULL, 0x0000800080808080ULL,
-	0x0000808000000000ULL, 0x0000808000000080ULL, 0x0000808000008000ULL, 0x0000808000008080ULL, 0x0000808000800000ULL, 0x0000808000800080ULL, 0x0000808000808000ULL, 0x0000808000808080ULL,
-	0x0000808080000000ULL, 0x0000808080000080ULL, 0x0000808080008000ULL, 0x0000808080008080ULL, 0x0000808080800000ULL, 0x0000808080800080ULL, 0x0000808080808000ULL, 0x0000808080808080ULL,
-	0x0080000000000000ULL, 0x0080000000000080ULL, 0x0080000000008000ULL, 0x0080000000008080ULL, 0x0080000000800000ULL, 0x0080000000800080ULL, 0x0080000000808000ULL, 0x0080000000808080ULL,
-	0x0080000080000000ULL, 0x0080000080000080ULL, 0x0080000080008000ULL, 0x0080000080008080ULL, 0x0080000080800000ULL, 0x0080000080800080ULL, 0x0080000080808000ULL, 0x0080000080808080ULL,
-	0x0080008000000000ULL, 0x0080008000000080ULL, 0x0080008000008000ULL, 0x0080008000008080ULL, 0x0080008000800000ULL, 0x0080008000800080ULL, 0x0080008000808000ULL, 0x0080008000808080ULL,
-	0x0080008080000000ULL, 0x0080008080000080ULL, 0x0080008080008000ULL, 0x0080008080008080ULL, 0x0080008080800000ULL, 0x0080008080800080ULL, 0x0080008080808000ULL, 0x0080008080808080ULL,
-	0x0080800000000000ULL, 0x0080800000000080ULL, 0x0080800000008000ULL, 0x0080800000008080ULL, 0x0080800000800000ULL, 0x0080800000800080ULL, 0x0080800000808000ULL, 0x0080800000808080ULL,
-	0x0080800080000000ULL, 0x0080800080000080ULL, 0x0080800080008000ULL, 0x0080800080008080ULL, 0x0080800080800000ULL, 0x0080800080800080ULL, 0x0080800080808000ULL, 0x0080800080808080ULL,
-	0x0080808000000000ULL, 0x0080808000000080ULL, 0x0080808000008000ULL, 0x0080808000008080ULL, 0x0080808000800000ULL, 0x0080808000800080ULL, 0x0080808000808000ULL, 0x0080808000808080ULL,
-	0x0080808080000000ULL, 0x0080808080000080ULL, 0x0080808080008000ULL, 0x0080808080008080ULL, 0x0080808080800000ULL, 0x0080808080800080ULL, 0x0080808080808000ULL, 0x0080808080808080ULL,
-	0x8000000000000000ULL, 0x8000000000000080ULL, 0x8000000000008000ULL, 0x8000000000008080ULL, 0x8000000000800000ULL, 0x8000000000800080ULL, 0x8000000000808000ULL, 0x8000000000808080ULL,
-	0x8000000080000000ULL, 0x8000000080000080ULL, 0x8000000080008000ULL, 0x8000000080008080ULL, 0x8000000080800000ULL, 0x8000000080800080ULL, 0x8000000080808000ULL, 0x8000000080808080ULL,
-	0x8000008000000000ULL, 0x8000008000000080ULL, 0x8000008000008000ULL, 0x8000008000008080ULL, 0x8000008000800000ULL, 0x8000008000800080ULL, 0x8000008000808000ULL, 0x8000008000808080ULL,
-	0x8000008080000000ULL, 0x8000008080000080ULL, 0x8000008080008000ULL, 0x8000008080008080ULL, 0x8000008080800000ULL, 0x8000008080800080ULL, 0x8000008080808000ULL, 0x8000008080808080ULL,
-	0x8000800000000000ULL, 0x8000800000000080ULL, 0x8000800000008000ULL, 0x8000800000008080ULL, 0x8000800000800000ULL, 0x8000800000800080ULL, 0x8000800000808000ULL, 0x8000800000808080ULL,
-	0x8000800080000000ULL, 0x8000800080000080ULL, 0x8000800080008000ULL, 0x8000800080008080ULL, 0x8000800080800000ULL, 0x8000800080800080ULL, 0x8000800080808000ULL, 0x8000800080808080ULL,
-	0x8000808000000000ULL, 0x8000808000000080ULL, 0x8000808000008000ULL, 0x8000808000008080ULL, 0x8000808000800000ULL, 0x8000808000800080ULL, 0x8000808000808000ULL, 0x8000808000808080ULL,
-	0x8000808080000000ULL, 0x8000808080000080ULL, 0x8000808080008000ULL, 0x8000808080008080ULL, 0x8000808080800000ULL, 0x8000808080800080ULL, 0x8000808080808000ULL, 0x8000808080808080ULL,
-	0x8080000000000000ULL, 0x8080000000000080ULL, 0x8080000000008000ULL, 0x8080000000008080ULL, 0x8080000000800000ULL, 0x8080000000800080ULL, 0x8080000000808000ULL, 0x8080000000808080ULL,
-	0x8080000080000000ULL, 0x8080000080000080ULL, 0x8080000080008000ULL, 0x8080000080008080ULL, 0x8080000080800000ULL, 0x8080000080800080ULL, 0x8080000080808000ULL, 0x8080000080808080ULL,
-	0x8080008000000000ULL, 0x8080008000000080ULL, 0x8080008000008000ULL, 0x8080008000008080ULL, 0x8080008000800000ULL, 0x8080008000800080ULL, 0x8080008000808000ULL, 0x8080008000808080ULL,
-	0x8080008080000000ULL, 0x8080008080000080ULL, 0x8080008080008000ULL, 0x8080008080008080ULL, 0x8080008080800000ULL, 0x8080008080800080ULL, 0x8080008080808000ULL, 0x8080008080808080ULL,
-	0x8080800000000000ULL, 0x8080800000000080ULL, 0x8080800000008000ULL, 0x8080800000008080ULL, 0x8080800000800000ULL, 0x8080800000800080ULL, 0x8080800000808000ULL, 0x8080800000808080ULL,
-	0x8080800080000000ULL, 0x8080800080000080ULL, 0x8080800080008000ULL, 0x8080800080008080ULL, 0x8080800080800000ULL, 0x8080800080800080ULL, 0x8080800080808000ULL, 0x8080800080808080ULL,
-	0x8080808000000000ULL, 0x8080808000000080ULL, 0x8080808000008000ULL, 0x8080808000008080ULL, 0x8080808000800000ULL, 0x8080808000800080ULL, 0x8080808000808000ULL, 0x8080808000808080ULL,
-	0x8080808080000000ULL, 0x8080808080000080ULL, 0x8080808080008000ULL, 0x8080808080008080ULL, 0x8080808080800000ULL, 0x8080808080800080ULL, 0x8080808080808000ULL, 0x8080808080808080ULL,
-};
+unsigned char edge_stability[256 * 256];
+
+#if (defined(USE_GAS_MMX) || defined(USE_MSVC_X86)) && !defined(hasSSE2)
+	#include "board_mmx.c"
+#endif
+#if (defined(USE_GAS_MMX) || defined(USE_MSVC_X86) || defined(hasSSE2) || defined(__ARM_NEON)) && !defined(ANDROID)
+	#include "board_sse.c"
+#endif
+
 
 /**
  * @brief Swap players.
@@ -151,36 +98,35 @@ void board_swap_players(Board *board)
  * @param string string describing the board
  * @return turn's color.
  */
-int board_set(Board *board, const char *string)
+int board_set(Board *board, const char *s)
 {
 	int i;
-	const char *s = string;
+	unsigned long long b = 1;
 
 	board->player = board->opponent = 0;
-	for (i = A1; i <= H8; ++i) {
-		if (*s == '\0') break;
+	for (i = A1; (i <= H8) && (*s != '\0'); ++s) {
 		switch (tolower(*s)) {
 		case 'b':
 		case 'x':
 		case '*':
-			board->player |= x_to_bit(i);
+			board->player |= b;
 			break;
 		case 'o':
 		case 'w':
-			board->opponent |= x_to_bit(i);
+			board->opponent |= b;
 			break;
 		case '-':
 		case '.':
 			break;
 		default:
-			i--;
-			break;
+			continue;
 		}
-		++s;
+		++i;
+		b <<= 1;
 	}
 	board_check(board);
 
-	for (;*s != '\0'; ++s) {
+	for (; *s != '\0'; ++s) {
 		switch (tolower(*s)) {
 		case 'b':
 		case 'x':
@@ -229,7 +175,7 @@ int board_from_FEN(Board *board, const char *string)
 			board->opponent |= x_to_bit(i);
 			++i;
 		} else {
-			return EMPTY;	
+			return EMPTY;
 		}
 	}
 
@@ -251,8 +197,8 @@ int board_from_FEN(Board *board, const char *string)
  */
 void board_init(Board *board)
 {
-	board->player   = 0x0000000810000000ULL; // BLACK
-	board->opponent = 0x0000001008000000ULL; // WHITE
+	board->player   = 0x0000000810000000; // BLACK
+	board->opponent = 0x0000001008000000; // WHITE
 }
 
 /**
@@ -272,7 +218,7 @@ void board_check(const Board *board)
 	}
 
 	// empty center ?
-	if (((board->player|board->opponent) & 0x0000001818000000ULL) != 0x0000001818000000ULL) {
+	if (~(board->player|board->opponent) & 0x0000001818000000) {
 		error("Empty center?\n");
 		board_print(board, BLACK, stderr);
 	}
@@ -286,27 +232,13 @@ void board_check(const Board *board)
  *
  * @param b1 first board
  * @param b2 second board
- * @return -1, 0, 1
- */
-int board_compare(const Board *b1, const Board *b2)
-{
-	if (b1->player > b2->player) return 1;
-	else if (b1->player < b2->player) return -1;
-	else if (b1->opponent > b2->opponent) return 1;
-	else if (b1->opponent < b2->opponent) return -1;
-	else return 0;
-}
-
-/**
- * @brief Compare two board for equality
- *
- * @param b1 first board
- * @param b2 second board
- * @return true if both board are equal
+ * @return true if b1 is lesser than b2
  */
-bool board_equal(const Board *b1, const Board *b2)
+bool board_lesser(const Board *b1, const Board *b2)
 {
-	return (b1->player == b2->player && b1->opponent == b2->opponent);
+	if (b1->player != b2->player)
+		return (b1->player < b2->player);
+	else	return (b1->opponent < b2->opponent);
 }
 
 /**
@@ -316,30 +248,40 @@ bool board_equal(const Board *b1, const Board *b2)
  * @param s symetry
  * @param sym symetric output board
  */
-void board_symetry(const Board *board, const int s, Board *sym)
+#if !defined(hasSSE2) && !defined(__ARM_NEON)	// SSE version in board_sse.c
+void board_horizontal_mirror(const Board *board, Board *sym)
 {
-	register unsigned long long player = board->player;
-	register unsigned long long opponent = board->opponent;
+	sym->player = horizontal_mirror(board->player);
+	sym->opponent = horizontal_mirror(board->opponent);
+}
 
-	if (s & 1) {
-		player = horizontal_mirror(player);
-		opponent = horizontal_mirror(opponent);
-	}
-	if (s & 2) {
-		player = vertical_mirror(player);
-		opponent = vertical_mirror(opponent);
-	}
-	if (s & 4) {
-		player = transpose(player);
-		opponent = transpose(opponent);
-	}
+void board_vertical_mirror(const Board *board, Board *sym)
+{
+	sym->player = vertical_mirror(board->player);
+	sym->opponent = vertical_mirror(board->opponent);
+}
 
-	sym->player = player;
-	sym->opponent = opponent;
+void board_transpose(const Board *board, Board *sym)
+{
+	sym->player = transpose(board->player);
+	sym->opponent = transpose(board->opponent);
+}
+
+void board_symetry(const Board *board, const int s, Board *sym)
+{
+	*sym = *board;
+	if (s & 1)
+		board_horizontal_mirror(sym, sym);
+	if (s & 2)
+		board_vertical_mirror(sym, sym);
+	if (s & 4)
+		board_transpose(sym, sym);
 
 	board_check(sym);
 }
+#endif
 
+#ifndef __AVX2__	// AVX2 version in board_sse.c
 /**
  * @brief unique board
  *
@@ -350,16 +292,22 @@ void board_symetry(const Board *board, const int s, Board *sym)
  */
 int board_unique(const Board *board, Board *unique)
 {
-	Board sym;
+	Board sym[8];
 	int i, s = 0;
 
-	assert(board != unique);
+	board_horizontal_mirror(board, &sym[1]);
+	board_vertical_mirror(board, &sym[2]);
+	board_vertical_mirror(&sym[1], &sym[3]);
+	board_transpose(board, &sym[4]);
+	board_vertical_mirror(&sym[4], &sym[5]);	// v-h reverted
+	board_horizontal_mirror(&sym[4], &sym[6]);
+	board_vertical_mirror(&sym[6], &sym[7]);
 
 	*unique = *board;
 	for (i = 1; i < 8; ++i) {
-		board_symetry(board, i, &sym);
-		if (board_compare(&sym, unique) < 0) {
-			*unique = sym;
+		// board_symetry(board, i, &sym);	// moved to before loop to minimize symetry ops
+		if (board_lesser(&sym[i], unique)) {
+			*unique = sym[i];
 			s = i;
 		}
 	}
@@ -367,6 +315,7 @@ int board_unique(const Board *board, Board *unique)
 	board_check(unique);
 	return s;
 }
+#endif
 
 /** 
  * @brief Get a random board by playing random moves.
@@ -377,22 +326,22 @@ int board_unique(const Board *board, Board *unique)
  */
 void board_rand(Board *board, int n_ply, Random *r)
 {
-	Move move[1];
+	Move move;
 	unsigned long long moves;
 	int ply;
 
 	board_init(board);
 	for (ply = 0; ply < n_ply; ply++) {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 		if (!moves) {
 			board_pass(board);
-			moves = get_moves(board->player, board->opponent);
+			moves = board_get_moves(board);
 			if (!moves) {
 				break;
 			}
 		}
-		board_get_move(board, get_rand_bit(moves, r), move);
-		board_update(board, move);
+		board_get_move_flip(board, get_rand_bit(moves, r), &move);
+		board_update(board, &move);
 	}
 }
 
@@ -407,10 +356,10 @@ void board_rand(Board *board, int n_ply, Random *r)
  * @param move  a Move structure remembering the modification.
  * @return      the flipped discs.
  */
-unsigned long long board_get_move(const Board *board, const int x, Move *move)
+unsigned long long board_get_move_flip(const Board *board, const int x, Move *move)
 {
-	move->flipped = flip[x](board->player, board->opponent);
 	move->x = x;
+	move->flipped = board_flip(board, x);
 	return move->flipped;
 }
 
@@ -424,8 +373,8 @@ unsigned long long board_get_move(const Board *board, const int x, Move *move)
 bool board_check_move(const Board *board, Move *move)
 {
 	if (move->x == PASS) return !can_move(board->player, board->opponent);
-	else if ((x_to_bit(move->x) & ~(board->player|board->opponent)) == 0) return false;
-	else if (move->flipped != flip[move->x](board->player, board->opponent)) return false;
+	else if (x_to_bit(move->x) & (board->player | board->opponent)) return false;
+	else if (move->flipped != board_flip(board, move->x)) return false;
 	else return true;
 }
 
@@ -436,14 +385,28 @@ bool board_check_move(const Board *board, Move *move)
  * according to the 'move' description.
  *
  * @param board the board to modify
- * @param move  A Move structure describing the modification.
+ * @param move  A Move structure describing the modification (may be PASS).
  */
 void board_update(Board *board, const Move *move)
 {
-	board->player ^= (move->flipped | x_to_bit(move->x));
-	board->opponent ^= move->flipped;
-	board_swap_players(board);
+#if defined(hasSSE2) && (defined(HAS_CPU_64) || !defined(__3dNOW__))	// 3DNow CPU has fast emms, and possibly slow SSE
+	__m128i	OP = _mm_loadu_si128((__m128i *) board);
+	OP = _mm_xor_si128(OP, _mm_or_si128(_mm_set1_epi64x(move->flipped), _mm_loadl_epi64((__m128i *) &X_TO_BIT[move->x])));
+	_mm_storeu_si128((__m128i *) board, _mm_shuffle_epi32(OP, 0x4e));
+
+#elif defined(hasMMX)
+	__m64	F = *(__m64 *) &move->flipped;
+	__m64	P = _m_pxor(*(__m64 *) &board->player, _m_por(F, *(__m64 *) &X_TO_BIT[move->x]));
+	__m64	O = _m_pxor(*(__m64 *) &board->opponent, F);
+	*(__m64 *) &board->player = O;
+	*(__m64 *) &board->opponent = P;
+	_mm_empty();
 
+#else
+	unsigned long long O = board->opponent;
+	board->opponent = board->player ^ (move->flipped | X_TO_BIT[move->x]);
+	board->player = O ^ move->flipped;
+#endif
 	board_check(board);
 }
 
@@ -458,10 +421,24 @@ void board_update(Board *board, const Move *move)
  */
 void board_restore(Board *board, const Move *move)
 {
-	board_swap_players(board);
-	board->player ^= (move->flipped | x_to_bit(move->x));
-	board->opponent ^= move->flipped;
+#if defined(hasSSE2) && (defined(HAS_CPU_64) || !defined(__3dNOW__))
+	__m128i	OP = _mm_shuffle_epi32(_mm_loadu_si128((__m128i *) board), 0x4e);
+	OP = _mm_xor_si128(OP, _mm_or_si128(_mm_set1_epi64x(move->flipped), _mm_loadl_epi64((__m128i *) &X_TO_BIT[move->x])));
+	_mm_storeu_si128((__m128i *) board, OP);
+
+#elif defined(hasMMX)
+	__m64	F = *(__m64 *) &move->flipped;
+	__m64	P = *(__m64 *) &board->opponent;
+	__m64	O = *(__m64 *) &board->player;
+	*(__m64 *) &board->player = _m_pxor(P, _m_por(F, *(__m64 *) &X_TO_BIT[move->x]));
+	*(__m64 *) &board->opponent = _m_pxor(O, F);
+	_mm_empty();
 
+#else
+	unsigned long long P = board->player;
+	board->player = board->opponent ^ (move->flipped | X_TO_BIT[move->x]);
+	board->opponent = P ^ move->flipped;
+#endif
 	board_check(board);
 }
 
@@ -475,48 +452,32 @@ void board_restore(Board *board, const Move *move)
 void board_pass(Board *board)
 {
 	board_swap_players(board);
+
 	board_check(board);
 }
 
+#if (MOVE_GENERATOR != MOVE_GENERATOR_AVX) && (MOVE_GENERATOR != MOVE_GENERATOR_AVX512) && (MOVE_GENERATOR != MOVE_GENERATOR_SSE) && (MOVE_GENERATOR != MOVE_GENERATOR_NEON)	// SSE version in board_sse.c
 /**
  * @brief Compute a board resulting of a move played on a previous board.
  *
  * @param board board to play the move on.
- * @param x move to play.
+ * @param x move to play (may be PASS).
  * @param next resulting board.
  * @return flipped discs.
  */
 unsigned long long board_next(const Board *board, const int x, Board *next)
 {
-	const unsigned long long flipped = flip[x](board->player, board->opponent);
+	const unsigned long long flipped = board_flip(board, x);
 	const unsigned long long player = board->opponent ^ flipped;
 
-	next->opponent = board->player ^ (flipped | x_to_bit(x));
+	next->opponent = board->player ^ (flipped | X_TO_BIT[x]);
 	next->player = player;
 
 	return flipped;
 }
+#endif
 
-/**
- * @brief Compute a board resulting of an opponent move played on a previous board.
- *
- * Compute the board after passing and playing a move.
- *
- * @param board board to play the move on.
- * @param x opponent move to play.
- * @param next resulting board.
- * @return flipped discs.
- */
-unsigned long long board_pass_next(const Board *board, const int x, Board *next)
-{
-	const unsigned long long flipped = flip[x](board->opponent, board->player);
-
-	next->opponent = board->opponent ^ (flipped | x_to_bit(x));
-	next->player = board->player ^ flipped;
-
-	return flipped;
-}
-
+#if !defined(hasSSE2) && !defined(__ARM_NEON)	// SSE version in board_sse.c
 /**
  * @brief Get a part of the moves.
  *
@@ -531,44 +492,50 @@ unsigned long long board_pass_next(const Board *board, const int x, Board *next)
  * @return some legal moves in a 64-bit unsigned integer.
  */
 static inline unsigned long long get_some_moves(const unsigned long long P, const unsigned long long mask, const int dir)
+// x86 build will use helper for long long shift unless inlined
 {
 
-#if PARALLEL_PREFIX & 1
+#if KOGGE_STONE & 1
+	// kogge-stone algorithm
+ 	// 6 << + 6 >> + 12 & + 7 |
+	// + better instruction independency
+	unsigned long long flip_l, flip_r;
+	unsigned long long mask_l, mask_r;
+	int d;
+
+	flip_l = flip_r = P;
+	mask_l = mask_r = mask;
+	d = dir;
+
+	flip_l |= mask_l & (flip_l << d);   flip_r |= mask_r & (flip_r >> d);
+	mask_l &= (mask_l << d);            mask_r &= (mask_r >> d);
+	d <<= 1;
+	flip_l |= mask_l & (flip_l << d);   flip_r |= mask_r & (flip_r >> d);
+	mask_l &= (mask_l << d);            mask_r &= (mask_r >> d);
+	d <<= 1;
+	flip_l |= mask_l & (flip_l << d);   flip_r |= mask_r & (flip_r >> d);
+
+	return ((flip_l & mask) << dir) | ((flip_r & mask) >> dir);
+
+#elif PARALLEL_PREFIX & 1
 	// 1-stage Parallel Prefix (intermediate between kogge stone & sequential) 
 	// 6 << + 6 >> + 7 | + 10 &
-	register unsigned long long flip_l, flip_r;
-	register unsigned long long mask_l, mask_r;
+	unsigned long long flip_l, flip_r;
+	unsigned long long mask_l, mask_r;
 	const int dir2 = dir + dir;
 
 	flip_l  = mask & (P << dir);          flip_r  = mask & (P >> dir);
 	flip_l |= mask & (flip_l << dir);     flip_r |= mask & (flip_r >> dir);
-	mask_l  = mask & (mask << dir);       mask_r  = mask & (mask >> dir);
+	mask_l  = mask & (mask << dir);       mask_r  = mask_l >> dir;
 	flip_l |= mask_l & (flip_l << dir2);  flip_r |= mask_r & (flip_r >> dir2);
 	flip_l |= mask_l & (flip_l << dir2);  flip_r |= mask_r & (flip_r >> dir2);
 
 	return (flip_l << dir) | (flip_r >> dir);
 
-#elif KOGGE_STONE & 1
-	// kogge-stone algorithm
- 	// 6 << + 6 >> + 12 & + 7 |
-	// + better instruction independency
-	register unsigned long long flip_l, flip_r;
-	register unsigned long long mask_l, mask_r;
-	const int dir2 = dir << 1;
-	const int dir4 = dir << 2;
-
-	flip_l  = P | (mask & (P << dir));    flip_r  = P | (mask & (P >> dir));
-	mask_l  = mask & (mask << dir);       mask_r  = mask & (mask >> dir);
-	flip_l |= mask_l & (flip_l << dir2);  flip_r |= mask_r & (flip_r >> dir2);
-	mask_l &= (mask_l << dir2);           mask_r &= (mask_r >> dir2);
-	flip_l |= mask_l & (flip_l << dir4);  flip_r |= mask_r & (flip_r >> dir4);
-
-	return ((flip_l & mask) << dir) | ((flip_r & mask) >> dir);
-	
 #else
  	// sequential algorithm
  	// 7 << + 7 >> + 6 & + 12 |
-	register unsigned long long flip;
+	unsigned long long flip;
 
 	flip = (((P << dir) | (P >> dir)) & mask);
 	flip |= (((flip << dir) | (flip >> dir)) & mask);
@@ -592,152 +559,26 @@ static inline unsigned long long get_some_moves(const unsigned long long P, cons
  */
 unsigned long long get_moves(const unsigned long long P, const unsigned long long O)
 {
-#if defined(USE_GAS_MMX)
- 			/* mm7: P, mm6: O */
-	const unsigned long long mask_7e = 0x7e7e7e7e7e7e7e7eULL;
-
-  __asm__ volatile(
-	"movl	%3, %%esi\n\t"		"movq	%1, %%mm7\n\t"
-	"movl	%4, %%edi\n\t"		"movq	%2, %%mm6\n\t"
-			/* shift=+1 */			/* shift=+8 */
-	"movl	%%esi, %%eax\n\t"	"movq	%%mm7, %%mm0\n\t"
-	"movq	%5, %%mm5\n\t"
-	"shrl	$1, %%eax\n\t"		"psrlq	$8, %%mm0\n\t"
-	"andl	$2122219134, %%edi\n\t"	"pand	%%mm6, %%mm5\n\t"
-	"andl	%%edi, %%eax\n\t"	"pand	%%mm6, %%mm0\n\t"	/* 0 m7&o6 m6&o5 .. m1&o0 */
-	"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
-	"shrl	$1, %%eax\n\t"		"psrlq	$8, %%mm0\n\t"
-	"movl	%%edi, %%ecx\n\t"	"movq	%%mm6, %%mm3\n\t"
-	"andl	%%edi, %%eax\n\t"	"pand	%%mm6, %%mm0\n\t"	/* 0 0 m7&o6&o5 .. m2&o1&o0 */
-	"shrl	$1, %%ecx\n\t"		"psrlq	$8, %%mm3\n\t"
-	"orl	%%edx, %%eax\n\t"	"por	%%mm1, %%mm0\n\t"	/* 0 m7&o6 (m6&o5)|(m7&o6&o5) .. (m1&o0) */
-	"andl	%%edi, %%ecx\n\t"	"pand	%%mm6, %%mm3\n\t"	/* 0 o7&o6 o6&o5 o5&o4 o4&o3 .. */
-	"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm4\n\t"
-	"shrl	$2, %%eax\n\t"		"psrlq	$16, %%mm0\n\t"
-	"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"	/* 0 0 0 m7&o6&o5&o4 (m6&o5&o4&o3)|(m7&o6&o5&o4&o3) .. */
-	"orl	%%eax, %%edx\n\t"	"por	%%mm0, %%mm4\n\t"
-	"shrl	$2, %%eax\n\t"		"psrlq	$16, %%mm0\n\t"
-	"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"	/* 0 0 0 0 0 m7&o6&..&o2 (m6&o5&..&o1)|(m7&o6&..&o1) .. */
-	"orl	%%edx, %%eax\n\t"	"por	%%mm0, %%mm4\n\t"
-	"shrl	$1, %%eax\n\t"		"psrlq	$8, %%mm4\n\t"		/* result of +8 */
-	/* shift=-1 */				/* shift=-8 */
-	"movq	%%mm7, %%mm0\n\t"
-	"addl	%%esi, %%esi\n\t"	"psllq	$8, %%mm0\n\t"
-	"andl	%%edi, %%esi\n\t"	"pand	%%mm6, %%mm0\n\t"
-	"movl	%%esi, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
-	"addl	%%esi, %%esi\n\t"	"psllq	$8, %%mm0\n\t"
-	"andl	%%edi, %%esi\n\t"	"pand	%%mm6, %%mm0\n\t"
-	"orl	%%esi, %%edx\n\t"	"por	%%mm1, %%mm0\n\t"
-	"addl	%%ecx, %%ecx\n\t"	"psllq	$8, %%mm3\n\t"
-	"movq	%%mm0, %%mm1\n\t"
-	"leal	(,%%edx,4), %%esi\n\t"	"psllq	$16, %%mm0\n\t"
-	"andl	%%ecx, %%esi\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"orl	%%esi, %%edx\n\t"	"por	%%mm0, %%mm1\n\t"
-	"shll	$2, %%esi\n\t"		"psllq	$16, %%mm0\n\t"
-	"andl	%%ecx, %%esi\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"orl	%%edx, %%esi\n\t"	"por	%%mm1, %%mm0\n\t"
-	"addl	%%esi, %%esi\n\t"	"psllq	$8, %%mm0\n\t"
-	"orl	%%eax, %%esi\n\t"	"por	%%mm0, %%mm4\n\t"
-	/* Serialize */				/* shift=+7 */
-	"movq	%%mm7, %%mm0\n\t"
-	"movd	%%esi, %%mm1\n\t"
-	"psrlq	$7, %%mm0\n\t"
-	"psllq	$32, %%mm1\n\t"
-	"pand	%%mm5, %%mm0\n\t"
-	"por	%%mm1, %%mm4\n\t"
-	"movq	%%mm0, %%mm1\n\t"
-	"psrlq	$7, %%mm0\n\t"
-	"pand	%%mm5, %%mm0\n\t"
-	"movq	%%mm5, %%mm3\n\t"
-	"por	%%mm1, %%mm0\n\t"
-	"psrlq	$7, %%mm3\n\t"
-	"movq	%%mm0, %%mm1\n\t"
-	"pand	%%mm5, %%mm3\n\t"
-	"psrlq	$14, %%mm0\n\t"
-	"pand	%%mm3, %%mm0\n\t"
-	"movl	%1, %%esi\n\t"		"por	%%mm0, %%mm1\n\t"
-	"movl	%2, %%edi\n\t"		"psrlq	$14, %%mm0\n\t"
-	"andl	$2122219134, %%edi\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"movl	%%edi, %%ecx\n\t"	"por	%%mm1, %%mm0\n\t"
-	"shrl	$1, %%ecx\n\t"		"psrlq	$7, %%mm0\n\t"
-	"andl	%%edi, %%ecx\n\t"	"por	%%mm0, %%mm4\n\t"
-			/* shift=+1 */			/* shift=-7 */
-	"movl	%%esi, %%eax\n\t"	"movq	%%mm7, %%mm0\n\t"
-	"shrl	$1, %%eax\n\t"		"psllq	$7, %%mm0\n\t"
-	"andl	%%edi, %%eax\n\t"	"pand	%%mm5, %%mm0\n\t"
-	"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
-	"shrl	$1, %%eax\n\t"		"psllq	$7, %%mm0\n\t"
-	"andl	%%edi, %%eax\n\t"	"pand	%%mm5, %%mm0\n\t"
-	"orl	%%edx, %%eax\n\t"	"por	%%mm1, %%mm0\n\t"
-					"psllq	$7, %%mm3\n\t"
-	"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
-	"shrl	$2, %%eax\n\t"		"psllq	$14, %%mm0\n\t"
-	"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"orl	%%eax, %%edx\n\t"	"por	%%mm0, %%mm1\n\t"
-	"shrl	$2, %%eax\n\t"		"psllq	$14, %%mm0\n\t"
-	"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"orl	%%edx, %%eax\n\t"	"por	%%mm1, %%mm0\n\t"
-	"shrl	$1, %%eax\n\t"		"psllq	$7, %%mm0\n\t"
-	"por	%%mm0, %%mm4\n\t"
-	/* shift=-1 */			/* shift=+9 */
-	"movq	%%mm7, %%mm0\n\t"
-	"addl	%%esi, %%esi\n\t"	"psrlq	$9, %%mm0\n\t"
-	"andl	%%edi, %%esi\n\t"	"pand	%%mm5, %%mm0\n\t"
-	"movl	%%esi, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
-	"addl	%%esi, %%esi\n\t"	"psrlq	$9, %%mm0\n\t"
-	"andl	%%edi, %%esi\n\t"	"pand	%%mm5, %%mm0\n\t"
-	"movq	%%mm5, %%mm3\n\t"
-	"orl	%%esi, %%edx\n\t"	"por	%%mm1, %%mm0\n\t"
-	"psrlq	$9, %%mm3\n\t"
-	"movq	%%mm0, %%mm1\n\t"
-	"addl	%%ecx, %%ecx\n\t"	"pand	%%mm5, %%mm3\n\t"
-	"leal	(,%%edx,4), %%esi\n\t"	"psrlq	$18, %%mm0\n\t"
-	"andl	%%ecx, %%esi\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"orl	%%esi, %%edx\n\t"	"por	%%mm0, %%mm1\n\t"
-	"shll	$2, %%esi\n\t"		"psrlq	$18, %%mm0\n\t"
-	"andl	%%ecx, %%esi\n\t"	"pand	%%mm3, %%mm0\n\t"
-	"orl	%%edx, %%esi\n\t"	"por	%%mm1, %%mm0\n\t"
-	"addl	%%esi, %%esi\n\t"	"psrlq	$9, %%mm0\n\t"
-	"orl	%%eax, %%esi\n\t"	"por	%%mm0, %%mm4\n\t"
-	/* Serialize */			/* shift=-9 */
-	"movq	%%mm7, %%mm0\n\t"
-	"movd	%%esi, %%mm1\n\t"
-	"psllq	$9, %%mm0\n\t"
-	"por	%%mm1, %%mm4\n\t"
-	"pand	%%mm5, %%mm0\n\t"
-	"movq	%%mm0, %%mm1\n\t"
-	"psllq	$9, %%mm0\n\t"
-	"pand	%%mm5, %%mm0\n\t"
-	"por	%%mm1, %%mm0\n\t"
-	"psllq	$9, %%mm3\n\t"
-	"movq	%%mm0, %%mm1\n\t"
-	"psllq	$18, %%mm0\n\t"
-	"pand	%%mm3, %%mm0\n\t"
-	"por	%%mm0, %%mm1\n\t"
-	"psllq	$18, %%mm0\n\t"
-	"pand	%%mm3, %%mm0\n\t"
-	"por	%%mm1, %%mm0\n\t"
-	"psllq	$9, %%mm0\n\t"
-	"por	%%mm0, %%mm4\n\t"
-	/* mm4 is the pseudo-feasible moves at this point. */
-	/* Let mm7 be the feasible moves, i.e., mm4 restricted to empty squares. */
-	"por	%%mm6, %%mm7\n\t"
-	"pandn	%%mm4, %%mm7\n\t"
-	"movq	%%mm7, %0\n\t"
-	"emms"		/* Reset the FP/MMX unit. */
-    : "=g" (moves) : "m" (P), "m" (O), "g" (P >> 32), "g" (O >> 32), "m" (mask_7e) : "eax", "edx", "ecx", "esi", "edi" );
+	unsigned long long moves, OM;
 
-#else
-	const unsigned long long mask = O & 0x7E7E7E7E7E7E7E7Eull;
+	#if defined(USE_GAS_MMX) || defined(USE_MSVC_X86) || defined(DISPATCH_NEON)
+	if (hasSSE2)
+		return get_moves_sse(P, O);
+	#endif
+	#if defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+	if (hasMMX)
+		return get_moves_mmx(P, O);
+	#endif
 
-	return (get_some_moves(P, mask, 1) // horizontal
+	OM = O & 0x7e7e7e7e7e7e7e7e;
+	moves = ( get_some_moves(P, OM, 1) // horizontal
 		| get_some_moves(P, O, 8)   // vertical
-		| get_some_moves(P, mask, 7)   // diagonals
-		| get_some_moves(P, mask, 9))
-		& ~(P|O); // mask with empties
+		| get_some_moves(P, OM, 7)   // diagonals
+		| get_some_moves(P, OM, 9));
 
-#endif
+	return moves & ~(P|O);	// mask with empties
 }
+#endif // hasSSE2/__ARM_NEON
 
 /**
  * @brief Get legal moves on a 6x6 board.
@@ -750,13 +591,9 @@ unsigned long long get_moves(const unsigned long long P, const unsigned long lon
  */
 unsigned long long get_moves_6x6(const unsigned long long P, const unsigned long long O)
 {
-	const unsigned long long E = (~(P|O) & 0x007E7E7E7E7E7E00ull); // empties
-
-	return ((get_some_moves(P, O & 0x003C3C3C3C3C3C00ull, 1) // horizontal
-		| get_some_moves(P, O & 0x00007E7E7E7E0000ull, 8)   // vertical
-		| get_some_moves(P, O & 0x00003C3C3C3C0000ull, 7)   // diagonals
-		| get_some_moves(P, O & 0x00003C3C3C3C0000ull, 9))
-		& E); // mask with empties
+	unsigned long long PM = P & 0x007E7E7E7E7E7E00;
+	unsigned long long OM = O & 0x007E7E7E7E7E7E00;
+	return get_moves(PM, OM) & 0x007E7E7E7E7E7E00;
 }
 
 /**
@@ -768,12 +605,18 @@ unsigned long long get_moves_6x6(const unsigned long long P, const unsigned long
  */
 bool can_move(const unsigned long long P, const unsigned long long O)
 {
+#if defined(hasMMX) || defined(__ARM_NEON)
+	return get_moves(P, O) != 0;
+
+#else
 	const unsigned long long E = ~(P|O); // empties
+	const unsigned long long OM = O & 0x7E7E7E7E7E7E7E7E;
 
-	return (get_some_moves(P, O & 0x007E7E7E7E7E7E00ull, 7) & E)  // diagonals
-		|| (get_some_moves(P, O & 0x007E7E7E7E7E7E00ull, 9) & E)
-		|| (get_some_moves(P, O & 0x7E7E7E7E7E7E7E7Eull, 1) & E)  // horizontal
-		|| (get_some_moves(P, O & 0x00FFFFFFFFFFFF00ull, 8) & E); // vertical
+	return (get_some_moves(P, OM, 7) & E)  // diagonals
+		|| (get_some_moves(P, OM, 9) & E)
+		|| (get_some_moves(P, OM, 1) & E)  // horizontal
+		|| (get_some_moves(P, O, 8) & E); // vertical
+#endif
 }
 
 /**
@@ -785,12 +628,7 @@ bool can_move(const unsigned long long P, const unsigned long long O)
  */
 bool can_move_6x6(const unsigned long long P, const unsigned long long O)
 {
-	const unsigned long long E = (~(P|O) & 0x007E7E7E7E7E7E00ull); // empties
-
-	return (get_some_moves(P, O & 0x00003C3C3C3C0000ull, 7) & E)  // diagonals
-		|| (get_some_moves(P, O & 0x00003C3C3C3C0000ull, 9) & E)
-		|| (get_some_moves(P, O & 0x003C3C3C3C3C3C00ull, 1) & E)  // horizontal
-		|| (get_some_moves(P, O & 0x00007E7E7E7E0000ull, 8) & E); // vertical
+	return get_moves_6x6(P, O) != 0;
 }
 
 /**
@@ -807,21 +645,17 @@ int get_mobility(const unsigned long long P, const unsigned long long O)
 	return bit_count(get_moves(P, O));
 }
 
-int get_weighted_mobility(const unsigned long long P, const unsigned long long O)
-{
-	return bit_weighted_count(get_moves(P, O));
-}
-
+#ifndef __AVX2__	// AVX2 version in board_sse.c
 /**
  * @brief Get some potential moves.
  *
- * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
  * @param dir flipping direction.
  * @return some potential moves in a 64-bit unsigned integer.
  */
-static inline unsigned long long get_some_potential_moves(const unsigned long long P, const int dir)
+static inline unsigned long long get_some_potential_moves(const unsigned long long O, const int dir)
 {
-	return (P << dir | P >> dir);
+	return (O << dir | O >> dir);
 }
 
 /**
@@ -833,28 +667,15 @@ static inline unsigned long long get_some_potential_moves(const unsigned long lo
  * @param O bitboard with opponent's discs.
  * @return all potential moves in a 64-bit unsigned integer.
  */
-static unsigned long long get_potential_moves(const unsigned long long P, const unsigned long long O)
+unsigned long long get_potential_moves(const unsigned long long P, const unsigned long long O)
 {
-	return (get_some_potential_moves(O & 0x7E7E7E7E7E7E7E7Eull, 1) // horizontal
-		| get_some_potential_moves(O & 0x00FFFFFFFFFFFF00ull, 8)   // vertical
-		| get_some_potential_moves(O & 0x007E7E7E7E7E7E00ull, 7)   // diagonals
-		| get_some_potential_moves(O & 0x007E7E7E7E7E7E00ull, 9))
+	return (get_some_potential_moves(O & 0x7E7E7E7E7E7E7E7E, 1) // horizontal
+		| get_some_potential_moves(O & 0x00FFFFFFFFFFFF00, 8)   // vertical
+		| get_some_potential_moves(O & 0x007E7E7E7E7E7E00, 7)   // diagonals
+		| get_some_potential_moves(O & 0x007E7E7E7E7E7E00, 9))
 		& ~(P|O); // mask with empties
 }
-
-/**
- * @brief Get potential mobility.
- *
- * Count the list of empty squares in contact of a player square.
- *
- * @param P bitboard with player's discs.
- * @param O bitboard with opponent's discs.
- * @return a count of potential moves.
- */
-int get_potential_mobility(const unsigned long long P, const unsigned long long O)
-{
-	return bit_weighted_count(get_potential_moves(P, O));
-}
+#endif // AVX2
 
 /**
  * @brief search stable edge patterns.
@@ -867,53 +688,53 @@ int get_potential_mobility(const unsigned long long P, const unsigned long long
  */
 static int find_edge_stable(const int old_P, const int old_O, int stable)
 {
-	register int P, O, x, y;
+	int P, O, O2, X, F;
 	const int E = ~(old_P | old_O); // empties
 
 	stable &= old_P; // mask stable squares with remaining player squares.
 	if (!stable || E == 0) return stable;
 
-	for (x = 0; x < 8; ++x) {
-		if (E & x_to_bit(x)) { //is x an empty square ?
+	for (X = 0x01; X <= 0x80; X <<= 1) {
+		if (E & X) { // is x an empty square ?
 			O = old_O;
-			P = old_P | x_to_bit(x); // player plays on it
-			if (x > 1) { // flip left discs
-				for (y = x - 1; y > 0 && (O & x_to_bit(y)); --y) ;
-				if (P & x_to_bit(y)) {
-					for (y = x - 1; y > 0 && (O & x_to_bit(y)); --y) {
-						O ^= x_to_bit(y); P ^= x_to_bit(y);
-					}
-				}
-			}
-			if (x < 6) { // flip right discs
-				for (y = x + 1; y < 8 && (O & x_to_bit(y)); ++y) ;
-				if (P & x_to_bit(y)) {
-					for (y = x + 1; y < 8 && (O & x_to_bit(y)); ++y) {
-						O ^= x_to_bit(y); P ^= x_to_bit(y);
-					}
-				}
+			P = old_P | X; // player plays on it
+			if (X > 0x02) { // flip left discs (using parallel prefix)
+				F  = O & (X >> 1);
+				F |= O & (F >> 1);
+				O2 = O & (O >> 1);
+				F |= O2 & (F >> 2);
+				F |= O2 & (F >> 2);
+				F &= -(P & (F >> 1));
+				O ^= F;
+				P ^= F;
 			}
+			// if (X < 0x40) { // flip right discs (using carry propagation)
+				F = (O + X + X) & P;
+				F -= (X + X) & -(int)(F != 0);
+				O ^= F;
+				P ^= F;
+			// }
 			stable = find_edge_stable(P, O, stable); // next move
 			if (!stable) return stable;
 
 			P = old_P;
-			O = old_O | x_to_bit(x); // opponent plays on it
-			if (x > 1) {
-				for (y = x - 1; y > 0 && (P & x_to_bit(y)); --y) ;
-				if (O & x_to_bit(y)) {
-					for (y = x - 1; y > 0 && (P & x_to_bit(y)); --y) {
-						O ^= x_to_bit(y); P ^= x_to_bit(y);
-					}
-				}
-			}
-			if (x < 6) {
-				for (y = x + 1; y < 8 && (P & x_to_bit(y)); ++y) ;
-				if (O & x_to_bit(y)) {
-					for (y = x + 1; y < 8 && (P & x_to_bit(y)); ++y) {
-						O ^= x_to_bit(y); P ^= x_to_bit(y);
-					}
-				}
+			O = old_O | X; // opponent plays on it
+			if (X > 0x02) { // flip left discs (using parallel prefix)
+				F  = P & (X >> 1);
+				F |= P & (F >> 1);
+				O2 = P & (P >> 1);
+				F |= O2 & (F >> 2);
+				F |= O2 & (F >> 2);
+				F &= -(O & (F >> 1));
+				O ^= F;
+				P ^= F;
 			}
+			// if (X < 0x40) { // flip right discs (using carry propagation)
+	 			F = (P + X + X) & O;
+				F -= (X + X) & -(int)(F != 0);
+				O ^= F;
+				P ^= F;
+			// }
 			stable = find_edge_stable(P, O, stable); // next move
 			if (!stable) return stable;
 		}
@@ -923,109 +744,145 @@ static int find_edge_stable(const int old_P, const int old_O, int stable)
 }
 
 /**
- * @brief Initialize the edge stability tables.
+ * @brief Initialize the edge stability table.
  */
 void edge_stability_init(void)
 {
-	int P, O;
+	int P, O, PO, rPO;
+	// long long t = cpu_clock();
 
-	for (P = 0; P < 256; ++P)
-	for (O = 0; O < 256; ++O) {
+	for (PO = 0; PO < 256 * 256; ++PO) {
+		P = PO >> 8;
+		O = PO & 0xFF;
 		if (P & O) { // illegal positions
-			edge_stability[P][O] = 0;
+			edge_stability[PO] = 0;
 		} else {
-			edge_stability[P][O] = find_edge_stable(P, O, P);
+			rPO = horizontal_mirror_32(PO);
+			if (PO > rPO)
+				edge_stability[PO] = mirror_byte(edge_stability[rPO]);
+			else
+				edge_stability[PO] = find_edge_stable(P, O, P);
 		}
 	}
+	// printf("edge_stability_init: %d\n", (int)(cpu_clock() - t));
 }
 
+#ifdef HAS_CPU_64
+#define	packA1A8(X)	((((X) & 0x0101010101010101) * 0x0102040810204080) >> 56)
+#define	packH1H8(X)	((((X) & 0x8080808080808080) * 0x0002040810204081) >> 56)
+#else
+#define	packA1A8(X)	(((((unsigned int)(X) & 0x01010101) + (((unsigned int)((X) >> 32) & 0x01010101) << 4)) * 0x01020408) >> 24)
+#define	packH1H8(X)	(((((unsigned int)((X) >> 32) & 0x80808080) + (((unsigned int)(X) & 0x80808080) >> 4)) * 0x00204081) >> 24)
+#endif
+
+#if !defined(hasSSE2) && !defined(__ARM_NEON)
 /**
- * @brief Get full lines.
+ * @brief Get stable edge.
+ *
+ * Compute the exact stable edges from precomputed tables.
+ *
+ * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
+ * @return a bitboard with (some of) player's stable discs.
  *
- * @param line all discs on a line.
- * @param dir tested direction
- * @return a bitboard with full lines along the tested direction.
  */
-static inline unsigned long long get_full_lines(const unsigned long long line, const int dir)
-{
-#if KOGGE_STONE & 2
-
-	// kogge-stone algorithm
- 	// 5 << + 5 >> + 7 & + 10 |
-	// + better instruction independency
-	register unsigned long long full_l, full_r, edge_l, edge_r;
-	const  unsigned long long edge = 0xff818181818181ffULL;
-	const int dir2 = dir << 1;
-	const int dir4 = dir << 2;
+unsigned long long get_stable_edge(const unsigned long long P, const unsigned long long O)
+{	// compute the exact stable edges (from precomputed tables)
+	return edge_stability[((unsigned int) P & 0xff) * 256 + ((unsigned int) O & 0xff)]
+	    |  (unsigned long long) edge_stability[(unsigned int) (P >> 56) * 256 + (unsigned int) (O >> 56)] << 56
+	    |  unpackA2A7(edge_stability[packA1A8(P) * 256 + packA1A8(O)])
+	    |  unpackH2H7(edge_stability[packH1H8(P) * 256 + packH1H8(O)]);
+}
 
-	full_l = line & (edge | (line >> dir)); full_r  = line & (edge | (line << dir));
-	edge_l = edge | (edge >> dir);        edge_r  = edge | (edge << dir);
-	full_l &= edge_l | (full_l >> dir2);  full_r &= edge_r | (full_r << dir2);
-	edge_l |= edge_l >> dir2;             edge_r |= edge_r << dir2;
-	full_l &= edge_l | (full_l >> dir4);  full_r &= edge_r | (full_r << dir4);
+/**
+ * @brief Estimate the stability of edges.
+ *
+ * Count the number (in fact a lower estimate) of stable discs on the edges.
+ *
+ * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
+ * @return the number of stable discs on the edges.
+ */
+int get_edge_stability(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int packedstable = edge_stability[((unsigned int) P & 0xff) * 256 + ((unsigned int) O & 0xff)]
+	  | edge_stability[(unsigned int) (P >> 56) * 256 + (unsigned int) (O >> 56)] << 8
+	  | edge_stability[packA1A8(P) * 256 + packA1A8(O)] << 16
+	  | edge_stability[packH1H8(P) * 256 + packH1H8(O)] << 24;
+	return bit_count_32(packedstable & 0xffff7e7e);
+}
+#endif
 
-	return full_r & full_l;
+/**
+ * @brief Get full lines.
+ *
+ * @param disc all discs on the board.
+ * @param full all 1 if full line, otherwise all 0.
+ */
 
-#elif PARALLEL_PREFIX & 2
+#if !defined(__ARM_NEON) && !defined(hasSSE2) && !defined(hasMMX)
+  #ifdef HAS_CPU_64
 
-	// 1-stage Parallel Prefix (intermediate between kogge stone & sequential) 
-	// 5 << + 5 >> + 7 & + 10 |
-	register unsigned long long full_l, full_r;
-	register unsigned long long edge_l, edge_r;
-	const  unsigned long long edge = 0xff818181818181ffULL;
-	const int dir2 = dir + dir;
+static unsigned long long get_full_lines_h(unsigned long long full)
+{
+	full &= full >> 1;
+	full &= full >> 2;
+	full &= full >> 4;
+	return (full & 0x0101010101010101) * 0xff;
+}
 
-	full_l  = edge | (line << dir);       full_r  = edge | (line >> dir);
-	full_l &= edge | (full_l << dir);     full_r &= edge | (full_r >> dir);
-	edge_l  = edge | (edge << dir);       edge_r  = edge | (edge >> dir);
-	full_l &= edge_l | (full_l << dir2);  full_r &= edge_r | (full_r >> dir2);
-	full_l &= edge_l | (full_l << dir2);  full_r &= edge_r | (full_r >> dir2);
+static unsigned long long get_full_lines_v(unsigned long long full)
+{
+	full &= (full >> 8) | (full << 56);	// ror 8
+	full &= (full >> 16) | (full << 48);	// ror 16
+	full &= (full >> 32) | (full << 32);	// ror 32
+	return full;
+}
 
-	return full_l & full_r;
+  #else
 
-#else
+static unsigned int get_full_lines_h_32(unsigned int full)
+{
+	full &= full >> 1;
+	full &= full >> 2;
+	full &= full >> 4;
+	return (full & 0x01010101) * 0xff;
+}
 
-	// sequential algorithm
- 	// 6 << + 6 >> + 12 & + 5 |
-	register unsigned long long full;
-	const unsigned long long edge = line & 0xff818181818181ffULL;
+static unsigned long long get_full_lines_h(unsigned long long full)
+{
+	return ((unsigned long long) get_full_lines_h_32(full >> 32) << 32) | get_full_lines_h_32(full);
+}
 
-	full = (line & (((line >> dir) & (line << dir)) | edge));
-	full &= (((full >> dir) & (full << dir)) | edge);
-	full &= (((full >> dir) & (full << dir)) | edge);
-	full &= (((full >> dir) & (full << dir)) | edge);
-	full &= (((full >> dir) & (full << dir)) | edge);
+static unsigned long long get_full_lines_v(unsigned long long full)
+{
+	unsigned int	t = (unsigned int) full & (unsigned int)(full >> 32);
+	t &= (t >> 16) | (t << 16);	// ror 16
+	t &= (t >> 8) | (t << 24);	// ror 8
+	return t | ((unsigned long long) t << 32);
+}
 
-	return ((full >> dir) & (full << dir));
+  #endif
 
-#endif
-}
+void get_full_lines(const unsigned long long disc, unsigned long long full[4])
+{
+	unsigned long long l7, l9, r7, r9;	// full lines
 
+	full[0] = get_full_lines_h(disc);
+	full[1] = get_full_lines_v(disc);
 
-#ifdef __X86_64__
-#define	packA1A8(X)	((((X) & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56)
-#define	packH1H8(X)	((((X) & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56)
-#else
-#define	packA1A8(X)	(((((unsigned int)(X) & 0x01010101u) + (((unsigned int)((X) >> 32) & 0x01010101u) << 4)) * 0x01020408u) >> 24)
-#define	packH1H8(X)	(((((unsigned int)((X) >> 32) & 0x80808080u) + (((unsigned int)(X) & 0x80808080u) >> 4)) * 0x00204081u) >> 24)
-#endif
+	l7 = r7 = disc;
+	l7 &= 0xff01010101010101 | (l7 >> 7);	r7 &= 0x80808080808080ff | (r7 << 7);
+	l7 &= 0xffff030303030303 | (l7 >> 14);	r7 &= 0xc0c0c0c0c0c0ffff | (r7 << 14);
+	l7 &= 0xffffffff0f0f0f0f | (l7 >> 28);	r7 &= 0xf0f0f0f0ffffffff | (r7 << 28);
+	full[3] = l7 & r7;
 
-/**
- * @brief Get stable edge.
- *
- * @param P bitboard with player's discs.
- * @param O bitboard with opponent's discs.
- * @return a bitboard with (some of) player's stable discs.
- *
- */
-static inline unsigned long long get_stable_edge(const unsigned long long P, const unsigned long long O)
-{
-	// compute the exact stable edges (from precomputed tables)
-	return edge_stability[P & 0xff][O & 0xff]
-	    |  ((unsigned long long)edge_stability[P >> 56][O >> 56]) << 56
-	    |  A1_A8[edge_stability[packA1A8(P)][packA1A8(O)]]
-	    |  H1_H8[edge_stability[packH1H8(P)][packH1H8(O)]];
+	l9 = r9 = disc;
+	l9 &= 0xff80808080808080 | (l9 >> 9);	r9 &= 0x01010101010101ff | (r9 << 9);
+	l9 &= 0xffffc0c0c0c0c0c0 | (l9 >> 18);	r9 &= 0x030303030303ffff | (r9 << 18);
+	full[2] = l9 & r9 & (0x0f0f0f0ff0f0f0f0 | (l9 >> 36) | (r9 << 36));
 }
+#endif // __ARM_NEON/hasSSE2/hasMMX
 
 /**
  * @brief Estimate the stability.
@@ -1036,49 +893,72 @@ static inline unsigned long long get_stable_edge(const unsigned long long P, con
  * @param O bitboard with opponent's discs.
  * @return the number of stable discs.
  */
-int get_stability(const unsigned long long P, const unsigned long long O)
+#ifndef __AVX2__	// AVX2 version in board_sse.c
+  #if !(defined(hasMMX) && !defined(hasSSE2))	// MMX version of get_stability in board_mmx.c
+    #if !(defined(hasSSE2) && !defined(HAS_CPU_64))	// 32bit SSE version in board_sse.c
+// compute the other stable discs (ie discs touching another stable disc in each flipping direction).
+int get_spreaded_stability(unsigned long long stable, unsigned long long P_central, unsigned long long full[4])
 {
-	const unsigned long long disc = (P | O);
-	const unsigned long long central_mask = (P & 0x007e7e7e7e7e7e00ULL);
-	const unsigned long long full_h = get_full_lines(disc, 1);
-	const unsigned long long full_v = get_full_lines(disc, 8);
-	const unsigned long long full_d7 = get_full_lines(disc, 7);
-	const unsigned long long full_d9 = get_full_lines(disc, 9);
-	register unsigned long long stable_h, stable_v, stable_d7, stable_d9, stable, new_stable;
-
-	// compute the exact stable edges (from precomputed tables)
-	new_stable = get_stable_edge(P, O);
-
-	// add full lines
-	new_stable |= (full_h & full_v & full_d7 & full_d9 & central_mask);
-
-	// now compute the other stable discs (ie discs touching another stable disc in each flipping direction).
-	stable = 0;
-	while (new_stable & ~stable) {
-		stable |= new_stable;
-		stable_h = ((stable >> 1) | (stable << 1) | full_h);
-		stable_v = ((stable >> 8) | (stable << 8) | full_v);
-		stable_d7 = ((stable >> 7) | (stable << 7) | full_d7);
-		stable_d9 = ((stable >> 9) | (stable << 9) | full_d9);
-		new_stable = (stable_h & stable_v & stable_d7 & stable_d9 & central_mask);
-	}
+	unsigned long long stable_h, stable_v, stable_d7, stable_d9, old_stable;
+
+	if (stable == 0)	// (2%)
+		return 0;
+
+	do {
+		old_stable = stable;
+		stable_h = ((stable >> 1) | (stable << 1) | full[0]);
+		stable_v = ((stable >> 8) | (stable << 8) | full[1]);
+		stable_d9 = ((stable >> 9) | (stable << 9) | full[2]);
+		stable_d7 = ((stable >> 7) | (stable << 7) | full[3]);
+		stable |= (stable_h & stable_v & stable_d9 & stable_d7 & P_central);
+	} while (stable != old_stable);	// (44%)
 
 	return bit_count(stable);
 }
+    #endif
+
+// returns stability count only
+int get_stability(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long stable = get_stable_edge(P, O);	// compute the exact stable edges
+	unsigned long long P_central = P & 0x007e7e7e7e7e7e00;
+	unsigned long long full[4];
+
+	get_full_lines(P | O, full);	// add full lines
+	stable |= (P_central & full[0] & full[1] & full[2] & full[3]);
+
+	return get_spreaded_stability(stable, P_central, full);	// compute the other stable discs
+}
+
+// returns all full in full[4] in addition to stability count
+int get_stability_fulls(const unsigned long long P, const unsigned long long O, unsigned long long full[5])
+{
+	unsigned long long stable = get_stable_edge(P, O);	// compute the exact stable edges
+	unsigned long long P_central = P & 0x007e7e7e7e7e7e00;
+
+	get_full_lines(P | O, full);	// add full lines
+	full[4] = full[0] & full[1] & full[2] & full[3];
+	stable |= (P_central & full[4]);
+
+	return get_spreaded_stability(stable, P_central, full);	// compute the other stable discs
+}
+  #endif
 
 /**
- * @brief Estimate the stability of edges.
+ * @brief Get intersection of full lines.
  *
- * Count the number (in fact a lower estimate) of stable discs on the edges.
+ * Get intersection of full lines.
  *
- * @param P bitboard with player's discs.
- * @param O bitboard with opponent's discs.
- * @return the number of stable discs on the edges.
+ * @param disc bitboard with occupied discs.
+ * @return the intersection of full lines.
  */
-int get_edge_stability(const unsigned long long P, const unsigned long long O)
+unsigned long long get_all_full_lines(const unsigned long long disc)
 {
-	return bit_count(get_stable_edge(P, O));
+	unsigned long long full[4];
+	get_full_lines(disc, full);
+	return full[0] & full[1] & full[2] & full[3];
 }
+#endif // __AVX2__
 
 /**
  * @brief Estimate corner stability.
@@ -1093,8 +973,40 @@ int get_edge_stability(const unsigned long long P, const unsigned long long O)
  */
 int get_corner_stability(const unsigned long long P)
 {
-	const unsigned long long stable = ((((0x0100000000000001ULL & P) << 1) | ((0x8000000000000080ULL & P) >> 1) | ((0x0000000000000081ULL & P) << 8) | ((0x8100000000000000ULL & P) >> 8) | 0x8100000000000081ULL) & P);
-	return bit_count(stable);
+#ifdef POPCOUNT
+	// stable = (((0x0100000000000001 & P) << 1) | ((0x8000000000000080 & P) >> 1) | ((0x0000000000000081 & P) << 8) | ((0x8100000000000000 & P) >> 8) | 0x8100000000000081) & P;
+  	unsigned int P2187 = (P >> 48) | (P << 16);	// ror 48
+	unsigned int stable = 0x00818100 & P2187;
+	stable |= ((((stable * 5) >> 1) & 0x00424200) | (stable << 8) | (stable >> 8)) & P2187;	// 1-8 alias does not matter since corner is stable anyway
+	return bit_count_32(stable);
+
+#else	// kindergarten
+	static const char n_stable_h2a2h1g1b1a1[64] = {
+		0, 1, 0, 2, 0, 1, 0, 2, 1, 2, 1, 3, 2, 3, 2, 4,
+		0, 2, 0, 3, 0, 2, 0, 3, 1, 3, 1, 4, 2, 4, 2, 5,
+		0, 1, 0, 2, 0, 1, 0, 2, 2, 3, 2, 4, 3, 4, 3, 5,
+		0, 2, 0, 3, 0, 2, 0, 3, 2, 4, 2, 5, 3, 5, 3, 6
+	};
+
+  #if 0 // defined(__BMI2__) && !defined(__bdver4__) && !defined(__znver1__) && !defined(__znver2__)	// BMI2 CPU has POPCOUNT
+	int cnt = n_stable_h2a2h1g1b1a1[_pext_u32((unsigned int) vertical_mirror(P), 0x000081c3)]
+		+ n_stable_h2a2h1g1b1a1[_pext_u32((unsigned int) P, 0x000081c3)];
+
+  #else
+	static const char n_stable_h8g8b8a8h7a7[64] = {
+		0, 0, 0, 0, 1, 2, 1, 2, 0, 0, 0, 0, 2, 3, 2, 3,
+		0, 0, 0, 0, 1, 2, 1, 2, 0, 0, 0, 0, 2, 3, 2, 3,
+		1, 1, 2, 2, 2, 3, 3, 4, 1, 1, 2, 2, 3, 4, 4, 5,
+		2, 2, 3, 3, 3, 4, 4, 5, 2, 2, 3, 3, 4, 5, 5, 6
+	};
+
+	int cnt = n_stable_h8g8b8a8h7a7[(((unsigned int) (P >> 32) & 0xc3810000) * 0x00000411) >> 26]
+		+ n_stable_h2a2h1g1b1a1[(((unsigned int) P & 0x000081c3) * 0x04410000) >> 26];
+  #endif
+	// assert(cnt == bit_count((((0x0100000000000001 & P) << 1) | ((0x8000000000000080 & P) >> 1) | ((0x0000000000000081 & P) << 8) | ((0x8100000000000000 & P) >> 8) | 0x8100000000000081) & P));
+	return cnt;
+
+#endif
 }
 
 /**
@@ -1105,27 +1017,8 @@ int get_corner_stability(const unsigned long long P)
  */
 unsigned long long board_get_hash_code(const Board *board)
 {
-	unsigned long long h1, h2;
-	const unsigned char *p = (const unsigned char*)board;
-
-	h1  = hash_rank[0][p[0]];
-	h2  = hash_rank[1][p[1]];
-	h1 ^= hash_rank[2][p[2]];
-	h2 ^= hash_rank[3][p[3]];
-	h1 ^= hash_rank[4][p[4]];
-	h2 ^= hash_rank[5][p[5]];
-	h1 ^= hash_rank[6][p[6]];
-	h2 ^= hash_rank[7][p[7]];
-	h1 ^= hash_rank[8][p[8]];
-	h2 ^= hash_rank[9][p[9]];
-	h1 ^= hash_rank[10][p[10]];
-	h2 ^= hash_rank[11][p[11]];
-	h1 ^= hash_rank[12][p[12]];
-	h2 ^= hash_rank[13][p[13]];
-	h1 ^= hash_rank[14][p[14]];
-	h2 ^= hash_rank[15][p[15]];
-
-	return h1 ^ h2;
+	unsigned long long crc = crc32c_u64(0, board->player);
+	return (crc << 32) | crc32c_u64(crc, board->opponent);
 }
 
 /**
@@ -1139,7 +1032,8 @@ unsigned long long board_get_hash_code(const Board *board)
  */
 int board_get_square_color(const Board *board, const int x)
 {
-	return 2 - 2 * ((board->player >> x) & 1) - ((board->opponent >> x) & 1);
+	unsigned long long b = x_to_bit(x);
+	return (int) ((board->player & b) == 0) * 2 - (int) ((board->opponent & b) != 0);
 }
 
 /**
@@ -1151,7 +1045,7 @@ int board_get_square_color(const Board *board, const int x)
  */
 bool board_is_occupied(const Board *board, const int x)
 {
-	return (board->player | board->opponent) & x_to_bit(x);
+	return ((board->player | board->opponent) & x_to_bit(x)) != 0;	// omitting != 0 causes bogus code on MSVC19 /GL
 }
 
 /**
@@ -1162,8 +1056,8 @@ bool board_is_occupied(const Board *board, const int x)
  */
 bool board_is_pass(const Board *board)
 {
-	return can_move(board->player, board->opponent) == false &&
-		can_move(board->opponent, board->player) == true;
+	return !can_move(board->player, board->opponent) &&
+		can_move(board->opponent, board->player);
 }
 
 /**
@@ -1174,8 +1068,8 @@ bool board_is_pass(const Board *board)
  */
 bool board_is_game_over(const Board *board)
 {
-	return can_move(board->player, board->opponent) == false &&
-		can_move(board->opponent, board->player) == false;
+	return !can_move(board->player, board->opponent) &&
+		!can_move(board->opponent, board->player);
 }
 
 
@@ -1201,31 +1095,42 @@ int board_count_empties(const Board *board)
  */
 void board_print(const Board *board, const int player, FILE *f)
 {
-	int i, j, square, x;
-	const char *color = "?*O-." + 1;
-	unsigned long long moves = get_moves(board->player, board->opponent);
+	int i, j, square;
+	unsigned long long bk, wh;
+	const char color[5] = "?*O-.";
+	unsigned long long moves = board_get_moves(board);
+
+	if (player == BLACK) {
+		bk = board->player;
+		wh = board->opponent;
+	} else {
+		bk = board->opponent;
+		wh = board->player;
+	}
 
 	fputs("  A B C D E F G H\n", f);
 	for (i = 0; i < 8; ++i) {
 		fputc(i + '1', f);
 		fputc(' ', f);
 		for (j = 0; j < 8; ++j) {
-			x = i * 8 + j;
-			if (player == BLACK) square = 2 - ((board->opponent >> x) & 1) - 2 * ((board->player >> x) & 1);
-			else square = 2 - ((board->player >> x) & 1) - 2 * ((board->opponent >> x) & 1);
-			if (square == EMPTY && (moves & x_to_bit(x))) ++square;
-			fputc(color[square], f);
+			square = 2 - (wh & 1) - 2 * (bk & 1);
+			if ((square == EMPTY) && (moves & 1))
+				square = EMPTY + 1;
+			fputc(color[square + 1], f);
 			fputc(' ', f);
+			bk >>= 1;
+			wh >>= 1;
+			moves >>= 1;
 		}
 		fputc(i + '1', f);
 		if (i == 1)
-			fprintf(f, " %c to move", color[player]);
+			fprintf(f, " %c to move", color[player + 1]);
 		else if (i == 3)
 			fprintf(f, " %c: discs = %2d    moves = %2d",
-				color[player], bit_count(board->player), get_mobility(board->player, board->opponent));
+				color[player + 1], bit_count(board->player), get_mobility(board->player, board->opponent));
 		else if (i == 4)
 			fprintf(f, " %c: discs = %2d    moves = %2d",
-				color[!player], bit_count(board->opponent), get_mobility(board->opponent, board->player));
+				color[2 - player], bit_count(board->opponent), get_mobility(board->opponent, board->player));
 		else if (i == 5)
 			fprintf(f, "  empties = %2d      ply = %2d",
 				64 - bit_count(board->opponent|board->player), bit_count(board->opponent|board->player) - 3);
@@ -1244,12 +1149,22 @@ void board_print(const Board *board, const int player, FILE *f)
 char* board_to_string(const Board *board, const int player, char *s)
 {
 	int square, x;
-	const char *color = "XO-?";
+	unsigned long long bk, wh;
+	static const char color[4] = "XO-?";
+
+	if (player == BLACK) {
+		bk = board->player;
+		wh = board->opponent;
+	} else {
+		bk = board->opponent;
+		wh = board->player;
+	}
 
 	for (x = 0; x < 64; ++x) {
-		if (player == BLACK) square = 2 - ((board->opponent >> x) & 1) - 2 * ((board->player >> x) & 1);
-		else square = 2 - ((board->player >> x) & 1) - 2 * ((board->opponent >> x) & 1);
+		square = 2 - (wh & 1) - 2 * (bk & 1);
 		s[x] = color[square];
+		bk >>= 1;
+		wh >>= 1;
 	}
 	s[64] = ' ';
 	s[65] = color[player];
@@ -1284,45 +1199,48 @@ void board_print_FEN(const Board *board, const int player, FILE *f)
 char* board_to_FEN(const Board *board, const int player, char *string)
 {
 	int square, x, r, c;
-	const char *piece = "pP-?";
-	const char *color = "bw";
+	unsigned long long bk, wh;
+	static const char piece[4] = "pP-?";
+	static const char color[2] = "bw";
 	int n_empties = 0;
 	char *s = string;
 	static char local_string[128];
 
 	if (s == NULL) s = string = local_string;
 
-	for (r = 7; r >= 0; --r)
-	for (c = 0; c < 8; ++c) {
-		if (c == 0 && r < 7) {
-			if (n_empties) {
-				*s++ = n_empties + '0';
-				n_empties = 0;
-			}
-			*s++ = '/';
-		}
-		x = 8 * r + c;
-		if (player == BLACK) square = 2 - ((board->opponent >> x) & 1) - 2 * ((board->player >> x) & 1);
-		else square = 2 - ((board->player >> x) & 1) - 2 * ((board->opponent >> x) & 1);
+	if (player == BLACK) {
+		bk = board->player;
+		wh = board->opponent;
+	} else {
+		bk = board->opponent;
+		wh = board->player;
+	}
 
-		if (square == EMPTY) {
-			++n_empties;
-		} else {
-			if (n_empties) {
-				*s++ = n_empties + '0';
-				n_empties = 0;
+	for (r = 7; r >= 0; --r) {
+		for (c = 0; c < 8; ++c) {
+			x = 8 * r + c;
+			square = 2 - ((wh >> x) & 1) - 2 * ((bk >> x) & 1);
+
+			if (square == EMPTY) {
+				++n_empties;
+			} else {
+				if (n_empties) {
+					*s++ = n_empties + '0';
+					n_empties = 0;
+				}
+				*s++ = piece[square];
 			}
-			*s++ = piece[square];
 		}
-	}
-	if (n_empties) {
-		*s++ = n_empties + '0';
-		n_empties = 0;
+		if (n_empties) {
+			*s++ = n_empties + '0';
+			n_empties = 0;
+		}
+		if (r > 0)
+			*s++ = '/';
 	}
 	*s++ = ' ';
 	*s++ = color[player];
-	*s++ = ' '; *s++ = '-'; *s++ = ' '; *s++ = '-'; 
-	*s++ = ' '; *s++ = '0'; *s++ = ' '; *s++ = '1'; *s = '\0';
+	strcpy(s, " - - 0 1");
 
 	return string;
 }
diff --git a/src/board.h b/src/board.h
index cf55e6a3..2da07dbb 100644
--- a/src/board.h
+++ b/src/board.h
@@ -3,23 +3,22 @@
  *
  * Board management header file.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2024
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_BOARD_H
 #define EDAX_BOARD_H
 
 #include "const.h"
+#include "settings.h"
+#include "bit.h"
 
 #include <stdio.h>
 #include <stdbool.h>
 
-/** Board : board representation */
-typedef struct Board {
-	unsigned long long player, opponent;     /**< bitboard representation */
-} Board;
+// struct Board: moved to bit.h
 
 struct Move;
 struct Random;
@@ -28,22 +27,49 @@ struct Random;
 void board_init(Board*);
 int board_set(Board*, const char*);
 int board_from_FEN(Board*, const char*);
-int board_compare(const Board*, const Board*);
-bool board_equal(const Board*, const Board*);
+bool board_lesser(const Board*, const Board*);
+void board_horizontal_mirror(const Board *, Board *);
+void board_vertical_mirror(const Board *, Board *);
+void board_transpose(const Board *, Board *);
 void board_symetry(const Board*, const int, Board*);
 int board_unique(const Board*, Board*);
 void board_check(const Board*);
 void board_rand(Board*, int, struct Random*);
 
+// Compare two board for equality
+#define	board_equal(b1,b2)	((b1)->player == (b2)->player && (b1)->opponent == (b2)->opponent)
+
 int board_count_last_flips(const Board*, const int);
-unsigned long long board_get_move(const Board*, const int, struct Move*);
+unsigned long long board_get_move_flip(const Board*, const int, struct Move*);
 bool board_check_move(const Board*, struct Move*);
 void board_swap_players(Board*);
 void board_update(Board*, const struct Move*);
 void board_restore(Board*, const struct Move*);
 void board_pass(Board*);
-unsigned long long board_next(const Board*, const int, Board*);
-unsigned long long board_pass_next(const Board*, const int, Board*);
+
+bool can_move(const unsigned long long, const unsigned long long);
+unsigned long long get_moves_6x6(const unsigned long long, const unsigned long long);
+bool can_move_6x6(const unsigned long long, const unsigned long long);
+int get_mobility(const unsigned long long, const unsigned long long);
+#ifdef __AVX2__
+	__m128i vectorcall get_moves_and_potential(__m256i, __m256i);
+#else
+	unsigned long long get_potential_moves(const unsigned long long, const unsigned long long);
+#endif
+
+void edge_stability_init(void);
+unsigned long long get_stable_edge(const unsigned long long, const unsigned long long);
+#ifndef __AVX2__	// public for android dispatch
+	void get_full_lines(const unsigned long long, unsigned long long [4]);
+  #if !(defined(hasMMX) && !defined(hasSSE2))
+	int get_spreaded_stability(unsigned long long, unsigned long long, unsigned long long [4]);
+  #endif
+#endif
+unsigned long long get_all_full_lines(const unsigned long long);
+int get_stability(const unsigned long long, const unsigned long long);
+int get_stability_fulls(const unsigned long long, const unsigned long long, unsigned long long [5]);
+int get_edge_stability(const unsigned long long, const unsigned long long);
+int get_corner_stability(const unsigned long long);
 unsigned long long board_get_hash_code(const Board*);
 int board_get_square_color(const Board*, const int);
 bool board_is_occupied(const Board*, const int);
@@ -54,20 +80,119 @@ char* board_to_FEN(const Board*, const int, char*);
 bool board_is_pass(const Board*);
 bool board_is_game_over(const Board*);
 int board_count_empties(const Board *board);
+#if defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+	void init_mmx (void);
+	unsigned long long get_moves_mmx(const unsigned long long, const unsigned long long);
+	unsigned long long get_moves_sse(const unsigned long long, const unsigned long long);
 
-int count_last_flip(const int, const unsigned long long);
-extern unsigned long long (*flip[BOARD_SIZE + 2])(const unsigned long long, const unsigned long long);
-unsigned long long get_moves(const unsigned long long, const unsigned long long);
-bool can_move(const unsigned long long, const unsigned long long);
-unsigned long long get_moves_6x6(const unsigned long long, const unsigned long long);
-bool can_move_6x6(const unsigned long long, const unsigned long long);
-int get_mobility(const unsigned long long, const unsigned long long);
-int get_weighted_mobility(const unsigned long long, const unsigned long long);
-int get_potential_mobility(const unsigned long long, const unsigned long long);
-void edge_stability_init(void);
-int get_stability(const unsigned long long, const unsigned long long);
-int get_edge_stability(const unsigned long long, const unsigned long long);
-int get_corner_stability(const unsigned long long);
+#elif defined(ANDROID) && !defined(__ARM_NEON) && !defined(hasSSE2)
+	void init_neon (void);
+	unsigned long long get_moves_sse(unsigned long long, unsigned long long);
+#endif
+
+extern unsigned char edge_stability[256 * 256];
+
+// a1/a8/h1/h8 are already stable in horizontal line, so omit them in vertical line to ease kindergarten for CPU_64
+#if 0 // defined(__BMI2__) && defined(HAS_CPU_64) && !defined(__bdver4__) && !defined(__znver1__) && !defined(__znver2__) // pdep is slow on AMD before Zen3
+	#define	unpackA2A7(x)	_pdep_u64((x), 0x0101010101010101)
+	#define	unpackH2H7(x)	_pdep_u64((x), 0x8080808080808080)
+#else
+	#define	unpackA2A7(x)	((((x) & 0x7e) * 0x0000040810204080) & 0x0001010101010100)
+	#define	unpackH2H7(x)	((((x) & 0x7e) * 0x0002040810204000) & 0x0080808080808000)
+#endif
 
+#if (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_CARRY) || (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_KINDERGARTEN) || (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_BITSCAN) || (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_32)
+	extern int (*count_last_flip[BOARD_SIZE + 1])(const unsigned long long);
+	#define	last_flip(x,P)	count_last_flip[x](P)
+#else
+	extern int last_flip(int pos, unsigned long long P);
 #endif
 
+#if (MOVE_GENERATOR == MOVE_GENERATOR_AVX) || (MOVE_GENERATOR == MOVE_GENERATOR_AVX512)
+	extern __m128i vectorcall mm_Flip(const __m128i OP, int pos);
+	inline __m128i vectorcall reduce_vflip(__m128i flip) { return _mm_or_si128(flip, _mm_shuffle_epi32(flip, 0x4e)); }
+	#define	Flip(x,P,O)	((unsigned long long) _mm_cvtsi128_si64(reduce_vflip(mm_Flip(_mm_set_epi64x((O), (P)), (x)))))
+	#define	board_flip(board,x)	((unsigned long long) _mm_cvtsi128_si64(reduce_vflip(mm_Flip(_mm_loadu_si128((__m128i *) (board)), (x)))))
+	#define	vboard_flip(board,x)	((unsigned long long) _mm_cvtsi128_si64(reduce_vflip(mm_Flip((board).v2, (x)))))
+
+#elif MOVE_GENERATOR == MOVE_GENERATOR_SSE
+	extern __m128i (vectorcall *mm_flip[BOARD_SIZE + 2])(const __m128i);
+	#define	Flip(x,P,O)	((unsigned long long) _mm_cvtsi128_si64(mm_flip[x](_mm_set_epi64x((O), (P)))))
+	#define mm_Flip(OP,x)	mm_flip[x](OP)
+	#define reduce_vflip(x)	(x)
+	#define	board_flip(board,x)	((unsigned long long) _mm_cvtsi128_si64(mm_flip[x](_mm_loadu_si128((__m128i *) (board)))))
+	#define	vboard_flip(board,x)	((unsigned long long) _mm_cvtsi128_si64(mm_flip[x]((board).v2)))
+
+#elif MOVE_GENERATOR == MOVE_GENERATOR_NEON
+	extern uint64x2_t mm_Flip(uint64x2_t OP, int pos);
+	#define	Flip(x,P,O)	vgetq_lane_u64(mm_Flip(vcombine_u64(vcreate_u64(P), vcreate_u64(O)), (x)), 0)
+	#define	board_flip(board,x)	vgetq_lane_u64(mm_Flip(vld1q_u64((uint64_t *) (board)), (x)), 0)
+	#define	vboard_flip(board,x)	vgetq_lane_u64(mm_Flip((board).v2, (x)), 0)
+
+#elif MOVE_GENERATOR == MOVE_GENERATOR_SVE
+	extern uint64_t Flip(int pos, uint64_t P, uint64_t O);
+	#define mm_Flip(OP,x)	vdupq_n_u64(Flip((x), vgetq_lane_u64((OP), 0), vgetq_lane_u64((OP), 1)))
+	#define	board_flip(board,x)	Flip((x), (board)->player, (board)->opponent)
+	#define	vboard_flip(board,x)	Flip((x), vgetq_lane_u64((board).v2, 0), vgetq_lane_u64((board).v2, 1))
+
+#elif MOVE_GENERATOR == MOVE_GENERATOR_32
+	extern unsigned long long (*flip[BOARD_SIZE + 2])(unsigned int, unsigned int, unsigned int, unsigned int);
+	#define Flip(x,P,O)	flip[x]((unsigned int)(P), (unsigned int)((P) >> 32), (unsigned int)(O), (unsigned int)((O) >> 32))
+  #ifdef __BIG_ENDIAN__
+	#define	board_flip(board,x)	flip[x]((unsigned int)((board)->player), ((unsigned int *) &(board)->player)[0], (unsigned int)((board)->opponent), ((unsigned int *) &(board)->opponent)[0])
+  #else
+	#define	board_flip(board,x)	flip[x]((unsigned int)((board)->player), ((unsigned int *) &(board)->player)[1], (unsigned int)((board)->opponent), ((unsigned int *) &(board)->opponent)[1])
+  #endif
+  #if defined(USE_GAS_MMX) && !defined(hasSSE2)
+	extern void init_flip_sse(void);
+  #endif
+
+#else
+  #if MOVE_GENERATOR == MOVE_GENERATOR_SSE_BSWAP
+	extern unsigned long long Flip(int, unsigned long long, unsigned long long);
+  #else
+	extern unsigned long long (*flip[BOARD_SIZE + 2])(const unsigned long long, const unsigned long long);
+	#define	Flip(x,P,O)	flip[x]((P), (O))
+  #endif
+
+	#define	board_flip(board,x)	Flip((x), (board)->player, (board)->opponent)
+#endif
+
+#ifndef vboard_flip
+	#define	vboard_flip(vboard,x)	board_flip(&(vboard).board, (x))
+#endif
+
+// Use backup copy of search->board in a vector register if available (assume *pboard == vboard on entry)
+#ifdef hasSSE2
+	#define	vboard_update(pboard,vboard,move)	_mm_storeu_si128((__m128i *) (pboard), _mm_shuffle_epi32(_mm_xor_si128((vboard).v2, _mm_or_si128(_mm_set1_epi64x((move)->flipped), _mm_loadl_epi64((__m128i *) &X_TO_BIT[move->x]))), 0x4e))
+#else
+	#define	vboard_update(pboard,vboard,move)	board_update((pboard), (move))
+#endif
+
+// Pass Board in a vector register to Flip
+#if (MOVE_GENERATOR == MOVE_GENERATOR_AVX) || (MOVE_GENERATOR == MOVE_GENERATOR_AVX512) || (MOVE_GENERATOR == MOVE_GENERATOR_SSE)
+	unsigned long long vectorcall board_next_sse(__m128i OP, const int x, Board *next);
+	#define	board_next(board,x,next)	board_next_sse(_mm_loadu_si128((__m128i *) (board)), (x), (next))
+	#define vboard_next(vboard,x,next)	board_next_sse((vboard).v2, (x), (next))
+#elif MOVE_GENERATOR == MOVE_GENERATOR_NEON
+	unsigned long long board_next_neon(uint64x2_t OP, const int x, Board *next);
+	#define	board_next(board,x,next)	board_next_neon(vld1q_u64((uint64_t *) (board)), (x), (next))
+	#define vboard_next(vboard,x,next)	board_next_neon((vboard).v2, (x), (next))
+#else
+	unsigned long long board_next(const Board *board, const int x, Board *next);
+	#define	vboard_next(vboard,x,next)	board_next(&(vboard).board, (x), (next))
+#endif
+
+// Pass vboard to get_moves if vectorcall available, otherwise board
+#if defined(__AVX2__) && (defined(_MSC_VER) || defined(__linux__))
+	unsigned long long vectorcall get_moves_avx(__m256i PP, __m256i OO);
+	#define	get_moves(P,O)	get_moves_avx(_mm256_set1_epi64x(P), _mm256_set1_epi64x(O))
+	#define	board_get_moves(board)	get_moves_avx(_mm256_set1_epi64x((board)->player), _mm256_set1_epi64x((board)->opponent))
+	#define	vboard_get_moves(vboard)	get_moves_avx(_mm256_broadcastq_epi64((vboard).v2), _mm256_broadcastq_epi64(_mm_unpackhi_epi64((vboard).v2, (vboard).v2)))
+#else
+	unsigned long long get_moves(const unsigned long long, const unsigned long long);
+	#define	board_get_moves(board)	get_moves((board)->player, (board)->opponent)
+	#define	vboard_get_moves(vboard)	get_moves((vboard).board.player, (vboard).board.opponent)
+#endif
+
+#endif
diff --git a/src/board_mmx.c b/src/board_mmx.c
new file mode 100644
index 00000000..a9dff19b
--- /dev/null
+++ b/src/board_mmx.c
@@ -0,0 +1,414 @@
+/**
+ * @file board_mmx.c
+ *
+ * MMX translation of some board.c functions for X86-32
+ *
+ * If both hasMMX and hasSSE2 are undefined, dynamic dispatching code
+ * will be generated.  (This setting requires VC or GCC 4.4+)
+ *
+ * @date 2014 - 2023
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+#include "hash.h"
+#include "board.h"
+#include "move.h"
+
+#ifdef USE_GAS_MMX
+  #ifndef hasMMX
+	#pragma GCC push_options
+	#pragma GCC target ("mmx")
+  #endif
+	#include <mmintrin.h>
+#endif
+
+static const unsigned long long mask_7e = 0x7e7e7e7e7e7e7e7eULL;
+#ifndef POPCOUNT
+static const unsigned long long mask_55 = 0x5555555555555555ULL;
+static const unsigned long long mask_33 = 0x3333333333333333ULL;
+static const unsigned long long mask_0F = 0x0f0f0f0f0f0f0f0fULL;
+#endif
+
+#ifndef hasMMX
+bool	hasMMX = false;
+#endif
+bool	hasSSE2 = false;
+
+void init_mmx (void)
+{
+	int	flg1, flg2, cpuid_edx, cpuid_ecx;
+#ifdef USE_MSVC_X86
+	int	cpuinfo[4];
+
+	__asm {
+		pushfd
+		pop	eax
+		mov	flg2, eax
+		btc	eax, 21
+		push	eax
+		popfd
+		pushfd
+		pop	flg1
+	}
+
+	if (flg1 == flg2)	/* CPUID not supported */
+		return;
+
+	__cpuid(cpuinfo, 1);
+	cpuid_edx = cpuinfo[3];
+	cpuid_ecx = cpuinfo[2];
+
+#else
+	__asm__ (
+		"pushfl\n\t"
+		"popl	%0\n\t"
+		"movl	%0, %1\n\t"
+		"btc	$21, %0\n\t"	/* flip ID bit in EFLAGS */
+		"pushl	%0\n\t"
+		"popfl\n\t"
+		"pushfl\n\t"
+		"popl	%0"
+	: "=r" (flg1), "=r" (flg2) );
+
+	if (flg1 == flg2)	/* CPUID not supported */
+		return;
+
+	__asm__ (
+		"movl	$1, %%eax\n\t"
+		"cpuid"
+	: "=d" (cpuid_edx), "=c" (cpuid_ecx) :: "%eax", "%ebx" );
+
+#endif
+
+#ifndef hasMMX
+	hasMMX  = ((cpuid_edx & 0x00800000u) != 0);
+#endif
+	hasSSE2 = ((cpuid_edx & 0x04000000u) != 0);
+	// hasPOPCNT = ((cpuid_ecx & 0x00800000u) != 0);
+
+#if (MOVE_GENERATOR == MOVE_GENERATOR_32)
+	if (hasSSE2)
+		init_flip_sse();
+#endif
+}
+
+/**
+ * @brief MMX translation of get_moves
+ *
+ * x 2 faster bench mobility on 32-bit x86.
+ *
+ */
+#ifdef USE_MSVC_X86
+
+unsigned long long get_moves_mmx(const unsigned long long P_, const unsigned long long O_)
+{
+	unsigned int movesL, movesH, mO1, flip1, pre1;
+	__m64	P, O, M, mO, flip, pre;
+
+	P = _m_punpckldq(_m_from_int(P_), _m_from_int(P_ >> 32));
+	O = _m_punpckldq(_m_from_int(O_), _m_from_int(O_ >> 32));	mO1 = (unsigned int) O_ & 0x7e7e7e7e;
+		/* shift = +8 */						/* shift = +1 */
+	flip = _m_pand(O, _m_psllqi(P, 8));				flip1  = mO1 & ((unsigned int) P_ << 1);
+	flip = _m_por(flip, _m_pand(O, _m_psllqi(flip, 8)));		flip1 |= mO1 & (flip1 << 1);
+	pre  = _m_pand(O, _m_psllqi(O, 8));				pre1   = mO1 & (mO1 << 1);
+	flip = _m_por(flip, _m_pand(pre, _m_psllqi(flip, 16)));		flip1 |= pre1 & (flip1 << 2);
+	flip = _m_por(flip, _m_pand(pre, _m_psllqi(flip, 16)));		flip1 |= pre1 & (flip1 << 2);
+	M = _m_psllqi(flip, 8);						movesL = flip1 << 1;
+		/* shift = -8 */						/* shift = -1 */
+	flip = _m_pand(O, _m_psrlqi(P, 8));				flip1  = mO1 & ((unsigned int) P_ >> 1);
+	flip = _m_por(flip, _m_pand(O, _m_psrlqi(flip, 8)));		flip1 |= mO1 & (flip1 >> 1);
+	pre  = _m_psrlqi(pre, 8);					pre1 >>= 1;
+	flip = _m_por(flip, _m_pand(pre, _m_psrlqi(flip, 16)));		flip1 |= pre1 & (flip1 >> 2);
+	flip = _m_por(flip, _m_pand(pre, _m_psrlqi(flip, 16)));		flip1 |= pre1 & (flip1 >> 2);
+	M = _m_por(M, _m_psrlqi(flip, 8));				movesL |= flip1 >> 1;
+		/* shift = +7 */
+	mO = _m_pand(O, *(__m64 *) &mask_7e);				mO1 = (unsigned int)(O_ >> 32) & 0x7e7e7e7e;
+	flip = _m_pand(mO, _m_psllqi(P, 7));
+	flip = _m_por(flip, _m_pand(mO, _m_psllqi(flip, 7)));
+	pre  = _m_pand(mO, _m_psllqi(mO, 7));
+	flip = _m_por(flip, _m_pand(pre, _m_psllqi(flip, 14)));
+	flip = _m_por(flip, _m_pand(pre, _m_psllqi(flip, 14)));
+	M = _m_por(M, _m_psllqi(flip, 7));
+		/* shift = -7 */						/* shift = +1 */
+	flip = _m_pand(mO, _m_psrlqi(P, 7));				flip1  = mO1 & ((unsigned int)(P_ >> 32) << 1);
+	flip = _m_por(flip, _m_pand(mO, _m_psrlqi(flip, 7)));		flip1 |= mO1 & (flip1 << 1);
+	pre  = _m_psrlqi(pre, 7);					pre1   = mO1 & (mO1 << 1);
+	flip = _m_por(flip, _m_pand(pre, _m_psrlqi(flip, 14)));		flip1 |= pre1 & (flip1 << 2);
+	flip = _m_por(flip, _m_pand(pre, _m_psrlqi(flip, 14)));		flip1 |= pre1 & (flip1 << 2);
+	M = _m_por(M, _m_psrlqi(flip, 7));				movesH = flip1 << 1;
+		/* shift = +9 */						/* shift = -1 */
+	flip = _m_pand(mO, _m_psllqi(P, 9));				flip1  = mO1 & ((unsigned int)(P_ >> 32) >> 1);
+	flip = _m_por(flip, _m_pand(mO, _m_psllqi(flip, 9)));		flip1 |= mO1 & (flip1 >> 1);
+	pre  = _m_pand(mO, _m_psllqi(mO, 9));				pre1 >>= 1;
+	flip = _m_por(flip, _m_pand(pre, _m_psllqi(flip, 18)));		flip1 |= pre1 & (flip1 >> 2);
+	flip = _m_por(flip, _m_pand(pre, _m_psllqi(flip, 18)));		flip1 |= pre1 & (flip1 >> 2);
+	M = _m_por(M, _m_psllqi(flip, 9));				movesH |= flip1 >> 1;
+		/* shift = -9 */
+	flip = _m_pand(mO, _m_psrlqi(P, 9));
+	flip = _m_por(flip, _m_pand(mO, _m_psrlqi(flip, 9)));
+	pre  = _m_psrlqi(pre, 9);
+	flip = _m_por(flip, _m_pand(pre, _m_psrlqi(flip, 18)));
+	flip = _m_por(flip, _m_pand(pre, _m_psrlqi(flip, 18)));
+	M = _m_por(M, _m_psrlqi(flip, 9));
+
+	movesL |= _m_to_int(M);
+	movesH |= _m_to_int(_m_punpckhdq(M, M));
+	_mm_empty();
+	return (((unsigned long long) movesH << 32) | movesL) & ~(P_|O_);	// mask with empties
+}
+
+#else
+
+unsigned long long get_moves_mmx(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long moves;
+	__asm__ (
+		"movl	%1, %%ebx\n\t"		"movd	%1, %%mm4\n\t"		// (movd for store-forwarding)
+		"movl	%3, %%edi\n\t"		"movd	%3, %%mm5\n\t"
+		"andl	$0x7e7e7e7e, %%edi\n\t"	"punpckldq %2, %%mm4\n\t"
+						"punpckldq %4, %%mm5\n\t"
+				/* shift=-1 */			/* shift=-8 */
+		"movl	%%ebx, %%eax\n\t"	"movq	%%mm4, %%mm0\n\t"
+		"shrl	$1, %%eax\n\t"		"psrlq	$8, %%mm0\n\t"
+		"andl	%%edi, %%eax\n\t"	"pand	%%mm5, %%mm0\n\t"	// 0 m7&o6 m6&o5 .. m1&o0
+		"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
+		"shrl	$1, %%eax\n\t"		"psrlq	$8, %%mm0\n\t"
+		"movl	%%edi, %%ecx\n\t"	"movq	%%mm5, %%mm3\n\t"
+		"andl	%%edi, %%eax\n\t"	"pand	%%mm5, %%mm0\n\t"	// 0 0 m7&o6&o5 .. m2&o1&o0
+		"shrl	$1, %%ecx\n\t"		"psrlq	$8, %%mm3\n\t"
+		"orl	%%edx, %%eax\n\t"	"por	%%mm1, %%mm0\n\t"	// 0 m7&o6 (m6&o5)|(m7&o6&o5) .. (m1&o0)
+		"andl	%%edi, %%ecx\n\t"	"pand	%%mm5, %%mm3\n\t"	// 0 o7&o6 o6&o5 o5&o4 o4&o3 ..
+		"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm2\n\t"
+		"shrl	$2, %%eax\n\t"		"psrlq	$16, %%mm0\n\t"
+		"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"	// 0 0 0 m7&o6&o5&o4 (m6&o5&o4&o3)|(m7&o6&o5&o4&o3) ..
+		"orl	%%eax, %%edx\n\t"	"por	%%mm0, %%mm2\n\t"
+		"shrl	$2, %%eax\n\t"		"psrlq	$16, %%mm0\n\t"
+		"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"	// 0 0 0 0 0 m7&o6&..&o2 (m6&o5&..&o1)|(m7&o6&..&o1) ..
+		"orl	%%edx, %%eax\n\t"	"por	%%mm0, %%mm2\n\t"
+		"shrl	$1, %%eax\n\t"		"psrlq	$8, %%mm2\n\t"
+				/* shift=+1 */			/* shift=+8 */
+						"movq	%%mm4, %%mm0\n\t"
+		"addl	%%ebx, %%ebx\n\t"	"psllq	$8, %%mm0\n\t"
+		"andl	%%edi, %%ebx\n\t"	"pand	%%mm5, %%mm0\n\t"
+		"movl	%%ebx, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
+		"addl	%%ebx, %%ebx\n\t"	"psllq	$8, %%mm0\n\t"
+		"andl	%%edi, %%ebx\n\t"	"pand	%%mm5, %%mm0\n\t"
+		"orl	%%ebx, %%edx\n\t"	"por	%%mm1, %%mm0\n\t"
+		"addl	%%ecx, %%ecx\n\t"	"psllq	$8, %%mm3\n\t"
+						"movq	%%mm0, %%mm1\n\t"
+		"leal	(,%%edx,4), %%ebx\n\t"	"psllq	$16, %%mm0\n\t"
+		"andl	%%ecx, %%ebx\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"orl	%%ebx, %%edx\n\t"	"por	%%mm0, %%mm1\n\t"
+		"shll	$2, %%ebx\n\t"		"psllq	$16, %%mm0\n\t"
+		"andl	%%ecx, %%ebx\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"orl	%%edx, %%ebx\n\t"	"por	%%mm1, %%mm0\n\t"
+		"addl	%%ebx, %%ebx\n\t"	"psllq	$8, %%mm0\n\t"
+		"orl	%%eax, %%ebx\n\t"	"por	%%mm0, %%mm2\n\t"
+								/* shift=-7 */
+						"pand	%5, %%mm5\n\t"
+						"movq	%%mm4, %%mm0\n\t"
+						"psrlq	$7, %%mm0\n\t"
+						"pand	%%mm5, %%mm0\n\t"
+						"movq	%%mm0, %%mm1\n\t"
+						"psrlq	$7, %%mm0\n\t"
+						"pand	%%mm5, %%mm0\n\t"
+						"movq	%%mm5, %%mm3\n\t"
+						"por	%%mm1, %%mm0\n\t"
+						"psrlq	$7, %%mm3\n\t"
+						"movq	%%mm0, %%mm1\n\t"
+						"pand	%%mm5, %%mm3\n\t"
+						"psrlq	$14, %%mm0\n\t"
+						"pand	%%mm3, %%mm0\n\t"
+		"movl	%2, %%esi\n\t"		"por	%%mm0, %%mm1\n\t"
+		"movl	%4, %%edi\n\t"		"psrlq	$14, %%mm0\n\t"
+		"andl	$0x7e7e7e7e,%%edi\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"movl	%%edi, %%ecx\n\t"	"por	%%mm1, %%mm0\n\t"
+		"shrl	$1, %%ecx\n\t"		"psrlq	$7, %%mm0\n\t"
+		"andl	%%edi, %%ecx\n\t"	"por	%%mm0, %%mm2\n\t"
+				/* shift=-1 */			/* shift=+7 */
+		"movl	%%esi, %%eax\n\t"	"movq	%%mm4, %%mm0\n\t"
+		"shrl	$1, %%eax\n\t"		"psllq	$7, %%mm0\n\t"
+		"andl	%%edi, %%eax\n\t"	"pand	%%mm5, %%mm0\n\t"
+		"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
+		"shrl	$1, %%eax\n\t"		"psllq	$7, %%mm0\n\t"
+		"andl	%%edi, %%eax\n\t"	"pand	%%mm5, %%mm0\n\t"
+		"orl	%%edx, %%eax\n\t"	"por	%%mm1, %%mm0\n\t"
+						"psllq	$7, %%mm3\n\t"
+		"movl	%%eax, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
+		"shrl	$2, %%eax\n\t"		"psllq	$14, %%mm0\n\t"
+		"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"orl	%%eax, %%edx\n\t"	"por	%%mm0, %%mm1\n\t"
+		"shrl	$2, %%eax\n\t"		"psllq	$14, %%mm0\n\t"
+		"andl	%%ecx, %%eax\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"orl	%%edx, %%eax\n\t"	"por	%%mm1, %%mm0\n\t"
+		"shrl	$1, %%eax\n\t"		"psllq	$7, %%mm0\n\t"
+						"por	%%mm0, %%mm2\n\t"
+				/* shift=+1 */			/* shift=-9 */
+						"movq	%%mm4, %%mm0\n\t"
+		"addl	%%esi, %%esi\n\t"	"psrlq	$9, %%mm0\n\t"
+		"andl	%%edi, %%esi\n\t"	"pand	%%mm5, %%mm0\n\t"
+		"movl	%%esi, %%edx\n\t"	"movq	%%mm0, %%mm1\n\t"
+		"addl	%%esi, %%esi\n\t"	"psrlq	$9, %%mm0\n\t"
+		"andl	%%edi, %%esi\n\t"	"pand	%%mm5, %%mm0\n\t"
+						"movq	%%mm5, %%mm3\n\t"
+		"orl	%%esi, %%edx\n\t"	"por	%%mm1, %%mm0\n\t"
+						"psrlq	$9, %%mm3\n\t"
+						"movq	%%mm0, %%mm1\n\t"
+		"addl	%%ecx, %%ecx\n\t"	"pand	%%mm5, %%mm3\n\t"
+		"leal	(,%%edx,4), %%esi\n\t"	"psrlq	$18, %%mm0\n\t"
+		"andl	%%ecx, %%esi\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"orl	%%esi, %%edx\n\t"	"por	%%mm0, %%mm1\n\t"
+		"shll	$2, %%esi\n\t"		"psrlq	$18, %%mm0\n\t"
+		"andl	%%ecx, %%esi\n\t"	"pand	%%mm3, %%mm0\n\t"
+		"orl	%%edx, %%esi\n\t"	"por	%%mm1, %%mm0\n\t"
+		"addl	%%esi, %%esi\n\t"	"psrlq	$9, %%mm0\n\t"
+		"orl	%%eax, %%esi\n\t"	"por	%%mm0, %%mm2\n\t"
+								/* shift=+9 */
+						"movq	%%mm4, %%mm0\n\t"
+						"psllq	$9, %%mm0\n\t"
+						"pand	%%mm5, %%mm0\n\t"
+						"movq	%%mm0, %%mm1\n\t"
+						"psllq	$9, %%mm0\n\t"
+						"pand	%%mm5, %%mm0\n\t"
+						"por	%%mm1, %%mm0\n\t"
+						"psllq	$9, %%mm3\n\t"
+						"movq	%%mm0, %%mm1\n\t"
+						"psllq	$18, %%mm0\n\t"
+						"pand	%%mm3, %%mm0\n\t"
+		"movl	%1, %%eax\n\t"		"por	%%mm0, %%mm1\n\t"
+		"movl	%2, %%edx\n\t"		"psllq	$18, %%mm0\n\t"
+		"orl	%3, %%eax\n\t"		"pand	%%mm3, %%mm0\n\t"
+		"orl	%4, %%edx\n\t"		"por	%%mm1, %%mm0\n\t"
+		"notl	%%eax\n\t"		"psllq	$9, %%mm0\n\t"
+		"notl	%%edx\n\t"		"por	%%mm0, %%mm2\n\t"
+		/* mm2|(esi:ebx) is the pseudo-feasible moves at this point. */
+		/* Let edx:eax be the feasible moves, i.e., mm2 restricted to empty squares. */
+		"movd	%%mm2, %%ecx\n\t"	"punpckhdq %%mm2, %%mm2\n\t"
+		"orl	%%ecx, %%ebx\n\t"
+		"movd	%%mm2, %%ecx\n\t"
+		"orl	%%ecx, %%esi\n\t"
+		"andl	%%ebx, %%eax\n\t"
+		"andl	%%esi, %%edx\n\t"
+		"emms"		/* Reset the FP/MMX unit. */
+	: "=&A" (moves)
+	: "m" (P), "m" (((unsigned int *)&P)[1]), "m" (O), "m" (((unsigned int *)&O)[1]), "m" (mask_7e)
+	: "ebx", "ecx", "esi", "edi", "mm0", "mm1", "mm2", "mm3", "mm4", "mm5" );
+
+	return moves;
+}
+#endif
+
+/**
+ * @brief MMX translation of get_stability()
+ *
+ * x 1.5 faster bench stability on 32-bit x86.
+ *
+ */
+#ifdef hasMMX
+static void get_full_lines(const unsigned long long disc_, unsigned long long full[4])
+{
+	__m64	disc = *(__m64 *) &disc_;
+	__m64	full_l, full_r;
+	unsigned int	full_v;
+	const __m64	kFF = _m_pcmpeqb(disc, disc);
+	static const unsigned long long e7[] = { 0xff01010101010101, 0x80808080808080ff, 0xffff030303030303, 0xc0c0c0c0c0c0ffff, 0xffffffff0f0f0f0f, 0xf0f0f0f0ffffffff };
+	static const unsigned long long e9[] = { 0xff80808080808080, 0x01010101010101ff, 0xffffc0c0c0c0c0c0, 0x030303030303ffff, 0x0f0f0f0ff0f0f0f0 };
+
+	// get_full_lines_mmx(full_d7, disc, 7, e7);
+	full_l = _m_pand(disc, _m_por(((__m64 *) e7)[0], _m_psrlqi(disc, 7)));
+	full_r = _m_pand(disc, _m_por(((__m64 *) e7)[1], _m_psllqi(disc, 7)));
+	full_l = _m_pand(full_l, _m_por(((__m64 *) e7)[2], _m_psrlqi(full_l, 14)));
+	full_r = _m_pand(full_r, _m_por(((__m64 *) e7)[3], _m_psllqi(full_r, 14)));
+	full_l = _m_pand(full_l, _m_por(((__m64 *) e7)[4], _m_psrlqi(full_l, 28)));
+	full_r = _m_pand(full_r, _m_por(((__m64 *) e7)[5], _m_psllqi(full_r, 28)));
+	((__m64 *) full)[3] = _m_pand(full_l, full_r);
+
+	// get_full_lines_mmx(full_d9, disc, 9, e9);
+	full_l = _m_pand(disc, _m_por(((__m64 *) e9)[0], _m_psrlqi(disc, 9)));
+	full_r = _m_pand(disc, _m_por(((__m64 *) e9)[1], _m_psllqi(disc, 9)));
+	full_l = _m_pand(full_l, _m_por(((__m64 *) e9)[2], _m_psrlqi(full_l, 18)));
+	full_r = _m_pand(full_r, _m_por(((__m64 *) e9)[3], _m_psllqi(full_r, 18)));
+	((__m64 *) full)[2] = _m_pand(_m_pand(full_l, full_r), _m_por(((__m64 *) e9)[4], _m_por(_m_psrlqi(full_l, 36), _m_psllqi(full_r, 36))));
+
+	// get_full_lines_mmx(full_h, disc, 1, e1);
+	((__m64 *) full)[0] = _m_pcmpeqb(kFF, disc);
+	_mm_empty();
+
+	// get_full_lines_mmx(full_v, disc, 8, e8);
+	full_v = (unsigned int) disc_ & (unsigned int)(disc_ >> 32);
+	full_v &= (full_v >> 16) | (full_v << 16);	// ror 16
+	full_v &= (full_v >> 8) | (full_v << 24);	// ror 8
+	full[1] = full_v | ((unsigned long long) full_v << 32);
+}
+
+// returns all full in full[4] in addition to stability count
+int get_stability_fulls(unsigned long long P, unsigned long long O, unsigned long long full[5])
+{
+	__m64	P_central, stable, stable_h, stable_v, stable_d7, stable_d9, old_stable, m;
+	unsigned int	OL, OH, PL, PH, t, a1a8, h1h8, SL, SH;
+
+	get_full_lines(P | O, full);
+
+	OL = (unsigned int) O;	OH = (unsigned int)(O >> 32);
+	PL = (unsigned int) P;	PH = (unsigned int)(P >> 32);
+	SL = PL & 0x7f7f7f00;	SH = PH & 0x007f7f7f;
+	P_central = _m_punpckldq(_m_from_int(SL), _m_from_int(SH));
+
+	// P_central & allfull
+	full[4] = full[0] & full[1] & full[2] & full[3];
+	SL &= (unsigned int) full[4];
+	SH &= (unsigned int)(full[4] >> 32);
+
+	// compute the exact stable edges (from precomputed tables)
+	a1a8 = edge_stability[((((PL & 0x01010101) + ((PH & 0x01010101) << 4)) * 0x01020408) >> 24) * 256
+		+ ((((OL & 0x01010101) + ((OH & 0x01010101) << 4)) * 0x01020408) >> 24)];
+	h1h8 = edge_stability[((((PH & 0x80808080) + ((PL & 0x80808080) >> 4)) * 0x00204081) >> 24) * 256
+		+ ((((OH & 0x80808080) + ((OL & 0x80808080) >> 4)) * 0x00204081) >> 24)];
+	SL |= edge_stability[(PL & 0xff) * 256 + (OL & 0xff)]
+		| (((a1a8 & 0x0f) * 0x00204081) & 0x01010101)
+		| (((h1h8 & 0x0f) * 0x10204080) & 0x80808080);
+	SH |= (edge_stability[((PH >> 16) & 0xff00) + (OH >> 24)] << 24)
+		| (((a1a8 >> 4) * 0x00204081) & 0x01010101)
+		| (((h1h8 >> 4) * 0x10204080) & 0x80808080);
+	stable = _m_punpckldq(_m_from_int(SL), _m_from_int(SH));
+
+	// now compute the other stable discs (ie discs touching another stable disc in each flipping direction).
+	t = SL | SH;
+	if (t) {
+		do {
+			old_stable = stable;
+			stable_h = _m_por(_m_por(_m_psrlqi(stable, 1), _m_psllqi(stable, 1)), ((__m64 *) full)[0]);
+			stable_v = _m_por(_m_por(_m_psrlqi(stable, 8), _m_psllqi(stable, 8)), ((__m64 *) full)[1]);
+			stable_d7 = _m_por(_m_por(_m_psrlqi(stable, 7), _m_psllqi(stable, 7)), ((__m64 *) full)[3]);
+			stable_d9 = _m_por(_m_por(_m_psrlqi(stable, 9), _m_psllqi(stable, 9)), ((__m64 *) full)[2]);
+			stable = _m_por(stable, _m_pand(_m_pand(_m_pand(_m_pand(stable_h, stable_v), stable_d7), stable_d9), P_central));
+			m = _m_pxor(stable, old_stable);
+		} while (_m_to_int(_m_packsswb(m, m)) != 0);
+
+  #ifdef POPCOUNT
+		t = bit_count_32(_m_to_int(stable)) + bit_count_32(_m_to_int(_m_psrlqi(stable, 32)));
+  #else
+		m = _m_psubd(stable, _m_pand(_m_psrlqi(stable, 1), *(__m64 *) &mask_55));
+		m = _m_paddd(_m_pand(m, *(__m64 *) &mask_33), _m_pand(_m_psrlqi(m, 2), *(__m64 *) &mask_33));
+		m = _m_pand(_m_paddd(m, _m_psrlqi(m, 4)), *(__m64 *) &mask_0F);
+		t = ((unsigned int) _m_to_int(_m_paddb(m, _m_psrlqi(m, 32))) * 0x01010101u) >> 24;
+  #endif
+	}
+	_mm_empty();
+	return t;
+}
+
+// returns stability count only
+int get_stability(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long full[5];
+
+	return get_stability_fulls(P, O, full);
+}
+#endif // hasMMX
+
+#if !defined(hasMMX) && defined(USE_GAS_MMX)
+	#pragma GCC pop_options
+#endif
diff --git a/src/board_sse.c b/src/board_sse.c
new file mode 100644
index 00000000..9a5ef40a
--- /dev/null
+++ b/src/board_sse.c
@@ -0,0 +1,954 @@
+/**
+ * @file board_sse.c
+ *
+ * SSE/AVX translation of some board.c functions
+ *
+ * @date 2014 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+#include "hash.h"
+#include "board.h"
+
+#if defined(ANDROID) && !defined(HAS_CPU_64) && !defined(hasSSE2)
+#include "android/cpu-features.h"
+
+bool	hasSSE2 = false;
+
+void init_neon (void)
+{
+  #ifdef __arm__
+	if (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) {
+	#if (MOVE_GENERATOR == MOVE_GENERATOR_BITSCAN)
+		extern unsigned long long (*flip_neon[66])(const unsigned long long, const unsigned long long);
+		memcpy(flip, flip_neon, sizeof(flip_neon));
+	#endif
+		hasSSE2 = true;	// for eval_update_sse
+	}
+  #elif defined(__i386__)	// android x86 w/o SSE2 - uncommon and not tested
+	int	cpuid_edx, cpuid_ecx;
+	__asm__ (
+		"movl	$1, %%eax\n\t"
+		"cpuid"
+	: "=d" (cpuid_edx), "=c" (cpuid_ecx) :: "%eax", "%ebx" );
+	if ((cpuid_edx & 0x04000000u) != 0)
+		hasSSE2 = true;
+  #endif
+}
+#endif
+
+/**
+ * @brief SSE2 translation of board_symetry
+ *
+ * @param board input board
+ * @param sym symetric output board
+ */
+#ifdef hasSSE2
+
+static __m128i vectorcall board_horizontal_mirror_sse(__m128i bb)
+{
+	const __m128i mask0F0F = _mm_set1_epi16(0x0F0F);
+  #if defined(__SSSE3__) || defined(__AVX__)	// pshufb (cf. http://wm.ite.pl/articles/sse-popcount.html)
+	const __m128i mbitrev  = _mm_set_epi8(15, 7, 11, 3, 13, 5, 9, 1, 14, 6, 10, 2, 12, 4, 8, 0);
+	bb = _mm_or_si128(_mm_shuffle_epi8(mbitrev, _mm_and_si128(_mm_srli_epi64(bb, 4), mask0F0F)),
+		_mm_slli_epi64(_mm_shuffle_epi8(mbitrev, _mm_and_si128(bb, mask0F0F)), 4));
+  #else
+	const __m128i mask5555 = _mm_set1_epi16(0x5555);
+	const __m128i mask3333 = _mm_set1_epi16(0x3333);
+	bb = _mm_or_si128(_mm_and_si128(_mm_srli_epi64(bb, 1), mask5555), _mm_slli_epi64(_mm_and_si128(bb, mask5555), 1));
+	bb = _mm_or_si128(_mm_and_si128(_mm_srli_epi64(bb, 2), mask3333), _mm_slli_epi64(_mm_and_si128(bb, mask3333), 2));
+	bb = _mm_or_si128(_mm_and_si128(_mm_srli_epi64(bb, 4), mask0F0F), _mm_slli_epi64(_mm_and_si128(bb, mask0F0F), 4));
+  #endif
+	return bb;
+}
+
+void board_horizontal_mirror(const Board *board, Board *sym)
+{
+	_mm_storeu_si128((__m128i *) sym, board_horizontal_mirror_sse(_mm_loadu_si128((__m128i *) board)));
+}
+
+static __m128i vectorcall board_vertical_mirror_sse(__m128i bb)
+{
+  #if defined(__SSSE3__) || defined(__AVX__)	// pshufb
+	return _mm_shuffle_epi8(bb, _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7));
+  #else
+	bb = _mm_or_si128(_mm_srli_epi16(bb, 8), _mm_slli_epi16(bb, 8));
+	return _mm_shufflehi_epi16(_mm_shufflelo_epi16(bb, 0x1b), 0x1b);
+  #endif
+}
+
+void board_vertical_mirror(const Board *board, Board *sym)
+{
+  #if defined(__SSSE3__) || defined(__AVX__) || !defined(HAS_CPU_64)
+	_mm_storeu_si128((__m128i *) sym, board_vertical_mirror_sse(_mm_loadu_si128((__m128i *) board)));
+  #else	// use BSWAP64
+	sym->player = vertical_mirror(board->player);
+	sym->opponent = vertical_mirror(board->opponent);
+  #endif
+}
+
+static __m128i vectorcall board_transpose_sse(__m128i bb)
+{
+	const __m128i mask00AA = _mm_set1_epi16(0x00AA);
+	const __m128i maskCCCC = _mm_set1_epi32(0x0000CCCC);
+	const __m128i mask00F0 = _mm_set1_epi64x(0x00000000F0F0F0F0);
+	__m128i tt = _mm_and_si128(_mm_xor_si128(bb, _mm_srli_epi64(bb, 7)), mask00AA);
+	bb = _mm_xor_si128(_mm_xor_si128(bb, tt), _mm_slli_epi64(tt, 7));
+	tt = _mm_and_si128(_mm_xor_si128(bb, _mm_srli_epi64(bb, 14)), maskCCCC);
+	bb = _mm_xor_si128(_mm_xor_si128(bb, tt), _mm_slli_epi64(tt, 14));
+	tt = _mm_and_si128(_mm_xor_si128(bb, _mm_srli_epi64(bb, 28)), mask00F0);
+	bb = _mm_xor_si128(_mm_xor_si128(bb, tt), _mm_slli_epi64(tt, 28));
+	return bb;
+}
+
+void board_transpose(const Board *board, Board *sym)
+{
+	_mm_storeu_si128((__m128i *) sym, board_transpose_sse(_mm_loadu_si128((__m128i *) board)));
+}
+
+void board_symetry(const Board *board, const int s, Board *sym)
+{
+	__m128i	bb = _mm_loadu_si128((__m128i *) board);
+	if (s & 1)
+		bb = board_horizontal_mirror_sse(bb);
+	if (s & 2)
+		bb = board_vertical_mirror_sse(bb);
+	if (s & 4)
+		bb = board_transpose_sse(bb);
+
+	_mm_storeu_si128((__m128i *) sym, bb);
+	board_check(sym);
+}
+
+#elif defined(__ARM_NEON) && !defined(DISPATCH_NEON)
+
+static uint64x2_t board_horizontal_mirror_neon(uint64x2_t bb)
+{
+  #ifdef HAS_CPU_64
+	bb = vreinterpretq_u64_u8(vrbitq_u8(vreinterpretq_u8_u64(bb)));
+  #else
+	bb = vbslq_u64(vdupq_n_u64(0x5555555555555555), vshrq_n_u64(bb, 1), vshlq_n_u64(bb, 1));
+	bb = vbslq_u64(vdupq_n_u64(0x3333333333333333), vshrq_n_u64(bb, 2), vshlq_n_u64(bb, 2));
+	bb = vreinterpretq_u64_u8(vsliq_n_u8(vshrq_n_u8(vreinterpretq_u8_u64(bb), 4), vreinterpretq_u8_u64(bb), 4));
+  #endif
+	return bb;
+}
+
+void board_horizontal_mirror(const Board *board, Board *sym)
+{
+	vst1q_u64((uint64_t *) sym, board_horizontal_mirror_neon(vld1q_u64((uint64_t *) board)));
+}
+
+static uint64x2_t board_vertical_mirror_neon(uint64x2_t bb)
+{
+	return vreinterpretq_u64_u8(vrev64q_u8(vreinterpretq_u8_u64(bb)));
+}
+
+void board_vertical_mirror(const Board *board, Board *sym)
+{
+	vst1q_u64((uint64_t *) sym, board_vertical_mirror_neon(vld1q_u64((uint64_t *) board)));
+}
+
+static uint64x2_t board_transpose_neon(uint64x2_t bb)
+{
+	uint64x2_t tt = vandq_u64(veorq_u64(bb, vshrq_n_u64(bb, 7)), vdupq_n_u64(0x00AA00AA00AA00AA));
+	bb = veorq_u64(veorq_u64(bb, tt), vshlq_n_u64(tt, 7));
+	tt = vandq_u64(veorq_u64(bb, vshrq_n_u64(bb, 14)), vdupq_n_u64(0x0000CCCC0000CCCC));
+	bb = veorq_u64(veorq_u64(bb, tt), vshlq_n_u64(tt, 14));
+	tt = vandq_u64(veorq_u64(bb, vshrq_n_u64(bb, 28)), vdupq_n_u64(0x00000000F0F0F0F0));
+	bb = veorq_u64(veorq_u64(bb, tt), vshlq_n_u64(tt, 28));
+	return bb;
+}
+
+void board_transpose(const Board *board, Board *sym)
+{
+	vst1q_u64((uint64_t *) sym, board_transpose_neon(vld1q_u64((uint64_t *) board)));
+}
+
+void board_symetry(const Board *board, const int s, Board *sym)
+{
+	uint64x2_t bb = vld1q_u64((uint64_t *) board);
+	if (s & 1)
+		bb = board_horizontal_mirror_neon(bb);
+	if (s & 2)
+		bb = board_vertical_mirror_neon(bb);
+	if (s & 4)
+		bb = board_transpose_neon(bb);
+
+	vst1q_u64((uint64_t *) sym, bb);
+	board_check(sym);
+}
+
+#endif // hasSSE2/Neon
+
+#ifdef __AVX2__
+/**
+ * @brief unique board
+ *
+ * Compute a board unique from all its possible symertries.
+ *
+ * @param board input board
+ * @param unique output board
+ */
+static void board_horizontal_mirror_avx(const __m256i *bb, __m256i *sym)
+{
+	const __m256i mask0F0F = _mm256_set1_epi16(0x0F0F);
+	const __m256i mbitrev  = _mm256_set_epi8(	//cf. http://wm.ite.pl/articles/sse-popcount.html
+		15, 7, 11, 3, 13, 5, 9, 1, 14, 6, 10, 2, 12, 4, 8, 0,
+		15, 7, 11, 3, 13, 5, 9, 1, 14, 6, 10, 2, 12, 4, 8, 0);
+	*sym = _mm256_or_si256(_mm256_shuffle_epi8(mbitrev, _mm256_and_si256(_mm256_srli_epi64(*bb, 4), mask0F0F)),
+		_mm256_slli_epi64(_mm256_shuffle_epi8(mbitrev, _mm256_and_si256(*bb, mask0F0F)), 4));
+}
+
+static void board_vertical_mirror_avx(const __m256i *bb, __m256i *sym)
+{
+	*sym = _mm256_shuffle_epi8(*bb, _mm256_set_epi8(
+		8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7,
+		8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7));
+}
+
+int board_unique(const Board *board, Board *unique)
+{
+	Board sym[8];
+	int i, j, s = 0;
+	static const char reorder[8] = { 0, 2, 4, 6, 1, 5, 3, 7 };
+
+	sym[0] = *board;
+	board_transpose(board, &sym[1]);	// was sym[4]
+	board_horizontal_mirror_avx((__m256i *) &sym[0], (__m256i *) &sym[2]);	// were sym[1] & sym[6]
+	board_vertical_mirror_avx((__m256i *) &sym[0], (__m256i *) &sym[4]);	// were sym[2] & sym[5]
+	board_vertical_mirror_avx((__m256i *) &sym[2], (__m256i *) &sym[6]);	// were sym[3] & sym[7]
+
+	*unique = *board;
+	for (i = 1; i < 8; ++i) {
+		j = reorder[i];
+		if (board_lesser(&sym[j], unique)) {
+			*unique = sym[j];
+			s = i;
+		}
+	}
+
+	board_check(unique);
+	return s;
+}
+#endif
+
+/**
+ * @brief Compute a board resulting of a move played on a previous board.
+ *
+ * @param OP board to play the move on.
+ * @param x move to play.
+ * @param next resulting board.
+ * @return flipped discs.
+ */
+#if (MOVE_GENERATOR == MOVE_GENERATOR_AVX) || (MOVE_GENERATOR == MOVE_GENERATOR_AVX512) || (MOVE_GENERATOR == MOVE_GENERATOR_SSE)
+
+unsigned long long vectorcall board_next_sse(__m128i OP, const int x, Board *next)
+{
+	__m128i flipped = reduce_vflip(mm_Flip(OP, x));
+
+	OP = _mm_xor_si128(OP, _mm_or_si128(flipped, _mm_loadl_epi64((__m128i *) &X_TO_BIT[x])));
+	_mm_storeu_si128((__m128i *) next, _mm_shuffle_epi32(OP, 0x4e));
+
+	return _mm_cvtsi128_si64(flipped);
+}
+
+#elif MOVE_GENERATOR == MOVE_GENERATOR_NEON
+
+unsigned long long board_next_neon(uint64x2_t OP, const int x, Board *next)
+{
+	uint64x2_t flipped = mm_Flip(OP, x);
+  #if !defined(_MSC_VER) && !defined(__clang__)	// MSVC-arm32 does not have vld1q_lane_u64
+	// arm64-gcc-13: 21, armv8a-clang-16: 23, msvc-arm64-19: 22, gcc-arm-13: 18, clang-armv7-11: 29 // https://godbolt.org/z/cvhns39rK
+	OP = veorq_u64(OP, vorrq_u64(flipped, vld1q_lane_u64((uint64_t *) &X_TO_BIT[x], flipped, 0)));
+	vst1q_u64((uint64_t *) next, vextq_u64(OP, OP, 1));
+  #else	// arm64-gcc-13: 21, armv8a-clang-16: 22, msvc-arm64-19: 21, gcc-arm-13: 23, clang-armv7-11: 27
+	OP = veorq_u64(OP, flipped);
+	vst1q_u64((uint64_t *) next, vcombine_u64(vget_high_u64(OP), vorr_u64(vget_low_u64(OP), vld1_u64((uint64_t *) &X_TO_BIT[x]))));
+  #endif
+	return vgetq_lane_u64(flipped, 0);
+}
+#endif
+
+/**
+ * @brief X64 optimized get_moves
+ *
+ * Diag-7 is converted to diag-9 (v.v.) using vertical mirroring
+ * in SSE versions.
+ *
+ * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
+ * @return all legal moves in a 64-bit unsigned integer.
+ */
+#ifdef __AVX2__	// 4 AVX
+
+  #if defined(_MSC_VER) || defined(__linux__)	// vectorcall and SYSV-ABI passes __m256i in registers
+unsigned long long vectorcall get_moves_avx(__m256i PP, __m256i OO)
+{
+  #else
+unsigned long long get_moves(unsigned long long P, unsigned long long O)	// minGW
+{
+	__m256i	PP = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(P));
+	__m256i OO = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(O));
+  #endif
+	__m256i	MM, flip_l, flip_r, pre_l, pre_r, shift2;
+	__m128i	M;
+	const __m256i shift1897 = _mm256_set_epi64x(7, 9, 8, 1);
+	__m256i	mOO = _mm256_and_si256(OO, _mm256_set_epi64x(0x007E7E7E7E7E7E00, 0x007E7E7E7E7E7E00, 0x00FFFFFFFFFFFF00, 0x7E7E7E7E7E7E7E7E));
+	__m128i occupied = _mm_or_si128(_mm256_castsi256_si128(PP), _mm256_castsi256_si128(OO));
+
+	flip_l = _mm256_and_si256(mOO, _mm256_sllv_epi64(PP, shift1897));
+	flip_r = _mm256_and_si256(mOO, _mm256_srlv_epi64(PP, shift1897));
+	flip_l = _mm256_or_si256(flip_l, _mm256_and_si256(mOO, _mm256_sllv_epi64(flip_l, shift1897)));
+	flip_r = _mm256_or_si256(flip_r, _mm256_and_si256(mOO, _mm256_srlv_epi64(flip_r, shift1897)));
+	pre_l = _mm256_and_si256(mOO, _mm256_sllv_epi64(mOO, shift1897));
+	pre_r = _mm256_srlv_epi64(pre_l, shift1897);
+	shift2 = _mm256_add_epi64(shift1897, shift1897);
+	flip_l = _mm256_or_si256(flip_l, _mm256_and_si256(pre_l, _mm256_sllv_epi64(flip_l, shift2)));
+	flip_r = _mm256_or_si256(flip_r, _mm256_and_si256(pre_r, _mm256_srlv_epi64(flip_r, shift2)));
+	flip_l = _mm256_or_si256(flip_l, _mm256_and_si256(pre_l, _mm256_sllv_epi64(flip_l, shift2)));
+	flip_r = _mm256_or_si256(flip_r, _mm256_and_si256(pre_r, _mm256_srlv_epi64(flip_r, shift2)));
+	MM = _mm256_or_si256(_mm256_sllv_epi64(flip_l, shift1897), _mm256_srlv_epi64(flip_r, shift1897));
+
+	M = _mm_or_si128(_mm256_castsi256_si128(MM), _mm256_extracti128_si256(MM, 1));
+	return _mm_cvtsi128_si64(_mm_andnot_si128(occupied, _mm_or_si128(M, _mm_unpackhi_epi64(M, M))));	// mask with empties
+}
+
+#elif defined(__x86_64__) || defined(_M_X64)	// 2 SSE, 2 CPU
+
+unsigned long long get_moves(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long moves, mO, flip1, pre1, flip8, pre8;
+	__m128i	PP, mOO, MM, flip, pre;
+
+	mO = O & 0x7e7e7e7e7e7e7e7eULL;
+	PP  = _mm_set_epi64x(vertical_mirror(P), P);
+	mOO = _mm_set_epi64x(vertical_mirror(mO), mO);
+		/* shift=-9:+7 */								/* shift=+1 */			/* shift = +8 */
+	flip = _mm_and_si128(mOO, _mm_slli_epi64(PP, 7));				flip1  = mO & (P << 1);		flip8  = O & (P << 8);
+	flip = _mm_or_si128(flip, _mm_and_si128(mOO, _mm_slli_epi64(flip, 7)));		flip1 |= mO & (flip1 << 1);	flip8 |= O & (flip8 << 8);
+	pre  = _mm_and_si128(mOO, _mm_slli_epi64(mOO, 7));				pre1   = mO & (mO << 1);	pre8   = O & (O << 8);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 14)));	flip1 |= pre1 & (flip1 << 2);	flip8 |= pre8 & (flip8 << 16);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 14)));	flip1 |= pre1 & (flip1 << 2);	flip8 |= pre8 & (flip8 << 16);
+	MM = _mm_slli_epi64(flip, 7);							moves = flip1 << 1;		moves |= flip8 << 8;
+		/* shift=-7:+9 */								/* shift=-1 */			/* shift = -8 */
+	flip = _mm_and_si128(mOO, _mm_slli_epi64(PP, 9));				flip1  = mO & (P >> 1);		flip8  = O & (P >> 8);
+	flip = _mm_or_si128(flip, _mm_and_si128(mOO, _mm_slli_epi64(flip, 9)));		flip1 |= mO & (flip1 >> 1);	flip8 |= O & (flip8 >> 8);
+	pre = _mm_and_si128(mOO, _mm_slli_epi64(mOO, 9));				pre1 >>= 1;			pre8 >>= 8;
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 18)));	flip1 |= pre1 & (flip1 >> 2);	flip8 |= pre8 & (flip8 >> 16);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 18)));	flip1 |= pre1 & (flip1 >> 2);	flip8 |= pre8 & (flip8 >> 16);
+	MM = _mm_or_si128(MM, _mm_slli_epi64(flip, 9));					moves |= flip1 >> 1;		moves |= flip8 >> 8;
+
+	moves |= _mm_cvtsi128_si64(MM) | vertical_mirror(_mm_cvtsi128_si64(_mm_unpackhi_epi64(MM, MM)));
+	return moves & ~(P|O);	// mask with empties
+}
+
+#elif defined(__aarch64__) || defined(_M_ARM64)	// 4 CPU
+
+unsigned long long get_moves(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long moves, mO;
+	unsigned long long flip1, flip7, flip9, flip8, pre1, pre7, pre9, pre8;
+
+	mO = O & 0x7e7e7e7e7e7e7e7eULL;
+	flip1  = mO & (P << 1);		flip7  = mO & (P << 7);		flip9  = mO & (P << 9);		flip8  = O & (P << 8);
+	flip1 |= mO & (flip1 << 1);	flip7 |= mO & (flip7 << 7);	flip9 |= mO & (flip9 << 9);	flip8 |= O & (flip8 << 8);
+	pre1 = mO & (mO << 1);		pre7 = mO & (mO << 7);		pre9 = mO & (mO << 9);		pre8 = O & (O << 8);
+	flip1 |= pre1 & (flip1 << 2);	flip7 |= pre7 & (flip7 << 14);	flip9 |= pre9 & (flip9 << 18);	flip8 |= pre8 & (flip8 << 16);
+	flip1 |= pre1 & (flip1 << 2);	flip7 |= pre7 & (flip7 << 14);	flip9 |= pre9 & (flip9 << 18);	flip8 |= pre8 & (flip8 << 16);
+	moves = flip1 << 1;		moves |= flip7 << 7;		moves |= flip9 << 9;		moves |= flip8 << 8;
+	flip1  = mO & (P >> 1);		flip7  = mO & (P >> 7);		flip9  = mO & (P >> 9);		flip8  = O & (P >> 8);
+	flip1 |= mO & (flip1 >> 1);	flip7 |= mO & (flip7 >> 7);	flip9 |= mO & (flip9 >> 9);	flip8 |= O & (flip8 >> 8);
+	pre1 >>= 1;			pre7 >>= 7;			pre9 >>= 9;			pre8 >>= 8;
+	flip1 |= pre1 & (flip1 >> 2);	flip7 |= pre7 & (flip7 >> 14);	flip9 |= pre9 & (flip9 >> 18);	flip8 |= pre8 & (flip8 >> 16);
+	flip1 |= pre1 & (flip1 >> 2);	flip7 |= pre7 & (flip7 >> 14);	flip9 |= pre9 & (flip9 >> 18);	flip8 |= pre8 & (flip8 >> 16);
+	moves |= flip1 >> 1;		moves |= flip7 >> 7;		moves |= flip9 >> 9;		moves |= flip8 >> 8;
+
+	return moves & ~(P|O);	// mask with empties
+}
+
+#elif defined(__ARM_NEON)	// 3 Neon, 1 CPU(32)
+
+  #ifndef DISPATCH_NEON
+	#define	get_moves_sse	get_moves	// no dispatch
+  #endif
+
+unsigned long long get_moves_sse(unsigned long long P, unsigned long long O)
+{
+	unsigned int	mO, movesL, movesH, flip1, pre1;
+	uint64x1_t	rP, rO;
+	uint64x2_t	PP, OO, MM, flip, pre;
+
+		/* vertical_mirror in PP[1], OO[1] */				mO = (unsigned int) O & 0x7e7e7e7e;
+	rP = vreinterpret_u64_u8(vrev64_u8(vcreate_u8(P)));			flip1  = mO & ((unsigned int) P << 1);
+	PP = vcombine_u64(vcreate_u64(P), rP);					flip1 |= mO & (flip1 << 1);
+										pre1   = mO & (mO << 1);
+	rO = vreinterpret_u64_u8(vrev64_u8(vcreate_u8(O)));			flip1 |= pre1 & (flip1 << 2);
+	OO = vcombine_u64(vcreate_u64(O), rO);					flip1 |= pre1 & (flip1 << 2);
+										movesL = flip1 << 1;
+
+	flip = vandq_u64(OO, vshlq_n_u64(PP, 8));				flip1  = mO & ((unsigned int) P >> 1);
+	flip = vorrq_u64(flip, vandq_u64(OO, vshlq_n_u64(flip, 8)));		flip1 |= mO & (flip1 >> 1);
+	pre  = vandq_u64(OO, vshlq_n_u64(OO, 8));				pre1 >>= 1;
+	flip = vorrq_u64(flip, vandq_u64(pre, vshlq_n_u64(flip, 16)));		flip1 |= pre1 & (flip1 >> 2);
+	flip = vorrq_u64(flip, vandq_u64(pre, vshlq_n_u64(flip, 16)));		flip1 |= pre1 & (flip1 >> 2);
+	MM = vshlq_n_u64(flip, 8);						movesL |= flip1 >> 1;
+
+	OO = vandq_u64(OO, vdupq_n_u64(0x7e7e7e7e7e7e7e7e));			mO = (unsigned int) (O >> 32) & 0x7e7e7e7e;
+	flip = vandq_u64(OO, vshlq_n_u64(PP, 7));				flip1  = mO & ((unsigned int) (P >> 32) << 1);
+	flip = vorrq_u64(flip, vandq_u64(OO, vshlq_n_u64(flip, 7)));		flip1 |= mO & (flip1 << 1);
+	pre  = vandq_u64(OO, vshlq_n_u64(OO, 7));				pre1   = mO & (mO << 1);
+	flip = vorrq_u64(flip, vandq_u64(pre, vshlq_n_u64(flip, 14)));		flip1 |= pre1 & (flip1 << 2);
+	flip = vorrq_u64(flip, vandq_u64(pre, vshlq_n_u64(flip, 14)));		flip1 |= pre1 & (flip1 << 2);
+	MM = vorrq_u64(MM, vshlq_n_u64(flip, 7));				movesH = flip1 << 1;
+
+	flip = vandq_u64(OO, vshlq_n_u64(PP, 9));				flip1  = mO & ((unsigned int) (P >> 32) >> 1);
+	flip = vorrq_u64(flip, vandq_u64(OO, vshlq_n_u64(flip, 9)));		flip1 |= mO & (flip1 >> 1);
+	pre  = vandq_u64(OO, vshlq_n_u64(OO, 9));				pre1 >>= 1;
+	flip = vorrq_u64(flip, vandq_u64(pre, vshlq_n_u64(flip, 18)));		flip1 |= pre1 & (flip1 >> 2);
+	flip = vorrq_u64(flip, vandq_u64(pre, vshlq_n_u64(flip, 18)));		flip1 |= pre1 & (flip1 >> 2);
+	MM = vorrq_u64(MM, vshlq_n_u64(flip, 9));				movesH |= flip1 >> 1;
+
+	movesL |= vgetq_lane_u32(vreinterpretq_u32_u64(MM), 0) | bswap_int(vgetq_lane_u32(vreinterpretq_u32_u64(MM), 3));
+	movesH |= vgetq_lane_u32(vreinterpretq_u32_u64(MM), 1) | bswap_int(vgetq_lane_u32(vreinterpretq_u32_u64(MM), 2));
+	return (movesL | ((unsigned long long) movesH << 32)) & ~(P|O);	// mask with empties
+}
+
+#else // AVX/x86_64/arm
+/**
+ * @brief SSE optimized get_moves for x86 - 3 SSE, 1 CPU(32)
+ *
+ */
+  #if defined(hasSSE2) || defined(USE_MSVC_X86) || defined(ANDROID)
+
+    #ifdef hasSSE2
+	#define	get_moves_sse	get_moves	// no dispatch
+    #endif
+
+unsigned long long get_moves_sse(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int	mO, movesL, movesH, flip1, pre1;
+	__m128i	OP, rOP, PP, OO, MM, flip, pre;
+
+		// vertical_mirror in PP[1], OO[1]
+	OP  = _mm_unpacklo_epi64(_mm_cvtsi64_si128(P), _mm_cvtsi64_si128(O));		mO = (unsigned int) O & 0x7e7e7e7eU;
+	rOP = _mm_shufflelo_epi16(OP, 0x1B);						flip1  = mO & ((unsigned int) P << 1);
+	rOP = _mm_shufflehi_epi16(rOP, 0x1B);						flip1 |= mO & (flip1 << 1);
+	rOP = _mm_or_si128(_mm_srli_epi16(rOP, 8), _mm_slli_epi16(rOP, 8));		pre1   = mO & (mO << 1);
+	    										flip1 |= pre1 & (flip1 << 2);
+	PP  = _mm_unpacklo_epi64(OP, rOP);						flip1 |= pre1 & (flip1 << 2);
+	OO  = _mm_unpackhi_epi64(OP, rOP);						movesL = flip1 << 1;
+
+	flip = _mm_and_si128(OO, _mm_slli_epi64(PP, 8));				flip1  = mO & ((unsigned int) P >> 1);
+	flip = _mm_or_si128(flip, _mm_and_si128(OO, _mm_slli_epi64(flip, 8)));		flip1 |= mO & (flip1 >> 1);
+	pre = _mm_and_si128(OO, _mm_slli_epi64(OO, 8));					pre1 >>= 1;
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 16)));	flip1 |= pre1 & (flip1 >> 2);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 16)));	flip1 |= pre1 & (flip1 >> 2);
+	MM = _mm_slli_epi64(flip, 8);							movesL |= flip1 >> 1;
+
+	OO = _mm_and_si128(OO, _mm_set1_epi8(0x7e));					mO = (unsigned int) (O >> 32) & 0x7e7e7e7eU;
+	flip = _mm_and_si128(OO, _mm_slli_epi64(PP, 7));				flip1  = mO & ((unsigned int) (P >> 32) << 1);
+	flip = _mm_or_si128(flip, _mm_and_si128(OO, _mm_slli_epi64(flip, 7)));		flip1 |= mO & (flip1 << 1);
+	pre = _mm_and_si128(OO, _mm_slli_epi64(OO, 7));					pre1   = mO & (mO << 1);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 14)));	flip1 |= pre1 & (flip1 << 2);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 14)));	flip1 |= pre1 & (flip1 << 2);
+	MM = _mm_or_si128(MM, _mm_slli_epi64(flip, 7));					movesH = flip1 << 1;
+
+	flip = _mm_and_si128(OO, _mm_slli_epi64(PP, 9));				flip1  = mO & ((unsigned int) (P >> 32) >> 1);
+	flip = _mm_or_si128(flip, _mm_and_si128(OO, _mm_slli_epi64(flip, 9)));		flip1 |= mO & (flip1 >> 1);
+	pre = _mm_and_si128(OO, _mm_slli_epi64(OO, 9));					pre1 >>= 1;
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 18)));	flip1 |= pre1 & (flip1 >> 2);
+	flip = _mm_or_si128(flip, _mm_and_si128(pre, _mm_slli_epi64(flip, 18)));	flip1 |= pre1 & (flip1 >> 2);
+	MM = _mm_or_si128(MM, _mm_slli_epi64(flip, 9));					movesH |= flip1 >> 1;
+
+	movesL |= _mm_cvtsi128_si32(MM);	MM = _mm_srli_si128(MM, 4);
+	movesH |= _mm_cvtsi128_si32(MM);	MM = _mm_srli_si128(MM, 4);
+	movesH |= bswap_int(_mm_cvtsi128_si32(MM));
+	movesL |= bswap_int(_mm_cvtsi128_si32(_mm_srli_si128(MM, 4)));
+	return (movesL | ((unsigned long long) movesH << 32)) & ~(P|O);	// mask with empties
+}
+
+  #else // non-VEX asm
+
+unsigned long long get_moves_sse(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long moves;
+	static const V2DI mask7e = {{ 0x7e7e7e7e7e7e7e7eULL, 0x7e7e7e7e7e7e7e7eULL }};
+
+	__asm__ (
+		"movl	%1, %%ebx\n\t"
+		"movl	%3, %%edi\n\t"
+		"andl	$0x7e7e7e7e, %%edi\n\t"
+				/* shift=-1 */			/* vertical mirror in PP[1], OO[1] */
+		"movl	%%ebx, %%eax\n\t"	"movd	%1, %%xmm4\n\t"		// (movd for store-forwarding)
+		"shrl	$1, %%eax\n\t"		"movd	%2, %%xmm0\n\t"
+		"andl	%%edi, %%eax\n\t"	"movd	%3, %%xmm5\n\t"
+		"movl	%%eax, %%edx\n\t"	"movd	%4, %%xmm1\n\t"
+		"shrl	$1, %%eax\n\t"		"punpckldq %%xmm0, %%xmm4\n\t"		// P
+		"movl	%%edi, %%ecx\n\t"	"punpckldq %%xmm1, %%xmm5\n\t"		// O
+		"andl	%%edi, %%eax\n\t"	"punpcklqdq %%xmm5, %%xmm4\n\t"		// OP
+		"shrl	$1, %%ecx\n\t"		"pshuflw $0x1b, %%xmm4, %%xmm0\n\t"
+		"orl	%%edx, %%eax\n\t"	"pshufhw $0x1b, %%xmm0, %%xmm0\n\t"
+		"andl	%%edi, %%ecx\n\t"	"movdqa	%%xmm0, %%xmm1\n\t"
+		"movl	%%eax, %%edx\n\t"	"psllw	$8, %%xmm0\n\t"
+		"shrl	$2, %%eax\n\t"		"psrlw	$8, %%xmm1\n\t"
+		"andl	%%ecx, %%eax\n\t"	"por	%%xmm1, %%xmm0\n\t"		// rOP
+		"orl	%%eax, %%edx\n\t"
+		"shrl	$2, %%eax\n\t"		"movdqa	%%xmm4, %%xmm5\n\t"
+		"andl	%%ecx, %%eax\n\t"	"punpcklqdq %%xmm0, %%xmm4\n\t"		// PP
+		"orl	%%edx, %%eax\n\t"	"punpckhqdq %%xmm0, %%xmm5\n\t"		// OO
+		"shrl	$1, %%eax\n\t"
+				/* shift=+1 */			/* shift=-8:+8 */
+						"movdqa	%%xmm4, %%xmm0\n\t"
+		"addl	%%ebx, %%ebx\n\t"	"psllq	$8, %%xmm0\n\t"
+		"andl	%%edi, %%ebx\n\t"	"pand	%%xmm5, %%xmm0\n\t"	// 0 m7&o6 m6&o5 .. m1&o0
+		"movl	%%ebx, %%edx\n\t"	"movdqa	%%xmm0, %%xmm1\n\t"
+		"addl	%%ebx, %%ebx\n\t"	"psllq	$8, %%xmm0\n\t"
+						"movdqa	%%xmm5, %%xmm3\n\t"
+		"andl	%%edi, %%ebx\n\t"	"pand	%%xmm5, %%xmm0\n\t"	// 0 0 m7&o6&o5 .. m2&o1&o0
+						"psllq	$8, %%xmm3\n\t"
+		"orl	%%ebx, %%edx\n\t"	"por	%%xmm1, %%xmm0\n\t"	// 0 m7&o6 (m6&o5)|(m7&o6&o5) .. (m1&o0)
+		"addl	%%ecx, %%ecx\n\t"	"pand	%%xmm5, %%xmm3\n\t"	// 0 o7&o6 o6&o5 o5&o4 o4&o3 ..
+						"movdqa	%%xmm0, %%xmm2\n\t"
+		"leal	(,%%edx,4), %%ebx\n\t"	"psllq	$16, %%xmm0\n\t"
+		"andl	%%ecx, %%ebx\n\t"	"pand	%%xmm3, %%xmm0\n\t"	// 0 0 0 m7&o6&o5&o4 (m6&o5&o4&o3)|(m7&o6&o5&o4&o3) ..
+		"orl	%%ebx, %%edx\n\t"	"por	%%xmm0, %%xmm2\n\t"
+		"shll	$2, %%ebx\n\t"		"psllq	$16, %%xmm0\n\t"
+		"andl	%%ecx, %%ebx\n\t"	"pand	%%xmm3, %%xmm0\n\t"	// 0 0 0 0 0 m7&o6&..&o2 (m6&o5&..&o1)|(m7&o6&..&o1) ..
+		"orl	%%edx, %%ebx\n\t"	"por	%%xmm0, %%xmm2\n\t"
+		"addl	%%ebx, %%ebx\n\t"	"psllq	$8, %%xmm2\n\t"
+		"orl	%%eax, %%ebx\n\t"
+
+		"movl	%2, %%esi\n\t"
+		"movl	%4, %%edi\n\t"
+				/* shift=-1 */			/* shift=-9:+7 */
+		"andl	$0x7e7e7e7e,%%edi\n\t"	"pand	%5, %%xmm5\n\t"
+		"movl	%%esi, %%eax\n\t"	"movdqa	%%xmm4, %%xmm0\n\t"
+		"shrl	$1, %%eax\n\t"		"psllq	$7, %%xmm0\n\t"
+		"andl	%%edi, %%eax\n\t"	"pand	%%xmm5, %%xmm0\n\t"
+		"movl	%%eax, %%edx\n\t"	"movdqa	%%xmm0, %%xmm1\n\t"
+		"shrl	$1, %%eax\n\t"		"psllq	$7, %%xmm0\n\t"
+		"andl	%%edi, %%eax\n\t"	"pand	%%xmm5, %%xmm0\n\t"
+		"movl	%%edi, %%ecx\n\t"	"movdqa	%%xmm5, %%xmm3\n\t"
+		"orl	%%edx, %%eax\n\t"	"por	%%xmm1, %%xmm0\n\t"
+		"shrl	$1, %%ecx\n\t"		"psllq	$7, %%xmm3\n\t"
+		"movl	%%eax, %%edx\n\t"	"movdqa	%%xmm0, %%xmm1\n\t"
+		"andl	%%edi, %%ecx\n\t"	"pand	%%xmm5, %%xmm3\n\t"
+		"shrl	$2, %%eax\n\t"		"psllq	$14, %%xmm0\n\t"
+		"andl	%%ecx, %%eax\n\t"	"pand	%%xmm3, %%xmm0\n\t"
+		"orl	%%eax, %%edx\n\t"	"por	%%xmm0, %%xmm1\n\t"
+		"shrl	$2, %%eax\n\t"		"psllq	$14, %%xmm0\n\t"
+		"andl	%%ecx, %%eax\n\t"	"pand	%%xmm3, %%xmm0\n\t"
+		"orl	%%edx, %%eax\n\t"	"por	%%xmm1, %%xmm0\n\t"
+		"shrl	$1, %%eax\n\t"		"psllq	$7, %%xmm0\n\t"
+						"por	%%xmm0, %%xmm2\n\t"
+				/* shift=+1 */			/* shift=-7:+9 */
+						"movdqa	%%xmm4, %%xmm0\n\t"
+		"addl	%%esi, %%esi\n\t"	"psllq	$9, %%xmm0\n\t"
+		"andl	%%edi, %%esi\n\t"	"pand	%%xmm5, %%xmm0\n\t"
+		"movl	%%esi, %%edx\n\t"	"movdqa	%%xmm0, %%xmm1\n\t"
+		"addl	%%esi, %%esi\n\t"	"psllq	$9, %%xmm0\n\t"
+		"andl	%%edi, %%esi\n\t"	"pand	%%xmm5, %%xmm0\n\t"
+						"movdqa	%%xmm5, %%xmm3\n\t"
+		"orl	%%esi, %%edx\n\t"	"por	%%xmm1, %%xmm0\n\t"
+						"psllq	$9, %%xmm3\n\t"
+						"movdqa	%%xmm0, %%xmm1\n\t"
+		"addl	%%ecx, %%ecx\n\t"	"pand	%%xmm5, %%xmm3\n\t"
+		"leal	(,%%edx,4), %%esi\n\t"	"psllq	$18, %%xmm0\n\t"
+		"andl	%%ecx, %%esi\n\t"	"pand	%%xmm3, %%xmm0\n\t"
+		"orl	%%esi, %%edx\n\t"	"por	%%xmm0, %%xmm1\n\t"
+		"shll	$2, %%esi\n\t"		"psllq	$18, %%xmm0\n\t"
+		"andl	%%ecx, %%esi\n\t"	"pand	%%xmm3, %%xmm0\n\t"
+		"orl	%%edx, %%esi\n\t"	"por	%%xmm1, %%xmm0\n\t"
+		"addl	%%esi, %%esi\n\t"	"psllq	$9, %%xmm0\n\t"
+		"orl	%%eax, %%esi\n\t"	"por	%%xmm0, %%xmm2\n\t"
+
+		"movl	%1, %%eax\n\t"		"movhlps %%xmm2, %%xmm3\n\t"
+		"movl	%2, %%edx\n\t"		"movd	%%xmm3, %%edi\n\t"	"movd	%%xmm2, %%ecx\n\t"
+						"psrlq	$32, %%xmm3\n\t"	"psrlq	$32, %%xmm2\n\t"
+						"bswapl	%%edi\n\t"		"orl	%%ecx, %%ebx\n\t"
+		"orl	%3, %%eax\n\t"		"orl	%%edi, %%esi\n\t"
+		"orl	%4, %%edx\n\t"		"movd	%%xmm3, %%edi\n\t"	"movd	%%xmm2, %%ecx\n\t"
+		"notl	%%eax\n\t"		"bswapl	%%edi\n\t"
+		"notl	%%edx\n\t"		"orl	%%edi, %%ebx\n\t"	"orl	%%ecx, %%esi\n\t"
+		"andl	%%esi, %%edx\n\t"
+		"andl	%%ebx, %%eax"
+	: "=&A" (moves)
+	: "m" (P), "m" (((unsigned int *)&P)[1]), "m" (O), "m" (((unsigned int *)&O)[1]), "m" (mask7e)
+	: "ebx", "ecx", "esi", "edi" );
+
+	return moves;
+}
+
+  #endif // hasSSE2
+#endif // x86
+
+#if defined(hasSSE2) || (defined(__ARM_NEON) && !defined(DISPATCH_NEON))
+
+/**
+ * @brief SSE/neon optimized get_stable_edge
+ *
+ * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
+ * @return a bitboard with (some of) player's stable discs.
+ *
+ */
+  #if defined(__aarch64__) || defined(_M_ARM64)	// for vaddvq
+unsigned long long get_stable_edge(unsigned long long P, unsigned long long O)
+{	// compute the exact stable edges (from precomputed tables)
+	// const int16x8_t shiftv = { 0, 1, 2, 3, 4, 5, 6, 7 };	// error on MSVC
+	const uint64x2_t shiftv = { 0x0003000200010000, 0x0007000600050004 };
+	uint8x16_t PO = vzip1q_u8(vreinterpretq_u8_u64(vdupq_n_u64(O)), vreinterpretq_u8_u64(vdupq_n_u64(P)));
+	unsigned int a1a8 = edge_stability[vaddvq_u16(vshlq_u16(vreinterpretq_u16_u8(vandq_u8(PO, vdupq_n_u8(1))), vreinterpretq_s16_u64(shiftv)))];
+	unsigned int h1h8 = edge_stability[vaddvq_u16(vshlq_u16(vreinterpretq_u16_u8(vshrq_n_u8(PO, 7)), vreinterpretq_s16_u64(shiftv)))];
+	return edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 0)]
+	    |  (unsigned long long) edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 7)] << 56
+	    |  unpackA2A7(a1a8) | unpackH2H7(h1h8);
+}
+
+  #elif defined(__ARM_NEON)	// Neon kindergarten
+unsigned long long get_stable_edge(unsigned long long P, unsigned long long O)
+{	// compute the exact stable edges (from precomputed tables)
+	const uint64x2_t kMul  = { 0x1020408001020408, 0x1020408001020408 };
+	uint64x2_t PP = vcombine_u64(vshl_n_u64(vcreate_u64(P), 7), vcreate_u64(P));
+	uint64x2_t OO = vcombine_u64(vshl_n_u64(vcreate_u64(O), 7), vcreate_u64(O));
+	uint32x4_t QP = vmulq_u32(vreinterpretq_u32_u64(kMul), vreinterpretq_u32_u8(vshrq_n_u8(vreinterpretq_u8_u64(PP), 7)));
+	uint32x4_t QO = vmulq_u32(vreinterpretq_u32_u64(kMul), vreinterpretq_u32_u8(vshrq_n_u8(vreinterpretq_u8_u64(OO), 7)));
+	uint32x2_t DP = vpadd_u32(vget_low_u32(QP), vget_high_u32(QP));	// P_h1h8 * * * P_a1a8 * * *
+	uint32x2_t DO = vpadd_u32(vget_low_u32(QO), vget_high_u32(QO));	// O_h1h8 * * * O_a1a8 * * *
+	uint8x8_t DB = vtrn_u8(vreinterpret_u8_u32(DO), vreinterpret_u8_u32(DP)).val[1];	// P_h1h8 O_h1h8 * * P_a1a8 O_a1a8 * *
+	unsigned int a1a8 = edge_stability[vget_lane_u16(vreinterpret_u16_u8(DB), 1)];
+	unsigned int h1h8 = edge_stability[vget_lane_u16(vreinterpret_u16_u8(DB), 3)];
+	uint8x16_t PO = vzipq_u8(vreinterpretq_u8_u64(OO), vreinterpretq_u8_u64(PP)).val[1];
+	return edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 0)]
+	    |  (unsigned long long) edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 7)] << 56
+	    |  unpackA2A7(a1a8) | unpackH2H7(h1h8);
+}
+
+  #elif defined(hasSSE2)
+unsigned long long get_stable_edge(const unsigned long long P, const unsigned long long O)
+{
+	// compute the exact stable edges (from precomputed tables)
+	unsigned int a1a8, h1h8;
+	unsigned long long stable_edge;
+
+	__m128i	P0 = _mm_cvtsi64_si128(P);
+	__m128i	O0 = _mm_cvtsi64_si128(O);
+	__m128i	PO = _mm_unpacklo_epi8(O0, P0);
+	stable_edge = edge_stability[_mm_extract_epi16(PO, 0)]
+		| ((unsigned long long) edge_stability[_mm_extract_epi16(PO, 7)] << 56);
+
+	PO = _mm_unpacklo_epi64(O0, P0);
+	a1a8 = edge_stability[_mm_movemask_epi8(_mm_slli_epi64(PO, 7))];
+	h1h8 = edge_stability[_mm_movemask_epi8(PO)];
+	stable_edge |= unpackA2A7(a1a8) | unpackH2H7(h1h8);
+
+	return stable_edge;
+}
+  #endif
+
+/**
+ * @brief SSE/neon optimized get_edge_stability
+ *
+ * Compute the exact stable edges from precomputed tables.
+ *
+ * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
+ * @return the number of stable discs on the edges.
+ *
+ */
+  #if defined(__aarch64__) || defined(_M_ARM64)	// for vaddvq
+int get_edge_stability(const unsigned long long P, const unsigned long long O)
+{
+	const uint64x2_t shiftv = { 0x0003000200010000, 0x0007000600050004 };
+	uint8x16_t PO = vzip1q_u8(vreinterpretq_u8_u64(vdupq_n_u64(O)), vreinterpretq_u8_u64(vdupq_n_u64(P)));
+	uint8x8_t packedstable = vcreate_u8((edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 0)]
+	  | edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 7)] << 8) & 0x7e7e);
+	packedstable = vset_lane_u8(edge_stability[vaddvq_u16(vshlq_u16(vreinterpretq_u16_u8(vandq_u8(PO, vdupq_n_u8(1))), vreinterpretq_s16_u64(shiftv)))], packedstable, 2);
+	packedstable = vset_lane_u8(edge_stability[vaddvq_u16(vshlq_u16(vreinterpretq_u16_u8(vshrq_n_u8(PO, 7)), vreinterpretq_s16_u64(shiftv)))], packedstable, 3);
+	return vaddv_u8(vcnt_u8(packedstable));
+}
+
+  #elif defined(__ARM_NEON)	// Neon kindergarten
+int get_edge_stability(const unsigned long long P, const unsigned long long O)
+{
+	const uint64x2_t kMul  = { 0x1020408001020408, 0x1020408001020408 };
+	uint64x2_t PP = vcombine_u64(vshl_n_u64(vcreate_u64(P), 7), vcreate_u64(P));
+	uint64x2_t OO = vcombine_u64(vshl_n_u64(vcreate_u64(O), 7), vcreate_u64(O));
+	uint32x4_t QP = vmulq_u32(vreinterpretq_u32_u64(kMul), vreinterpretq_u32_u8(vshrq_n_u8(vreinterpretq_u8_u64(PP), 7)));
+	uint32x4_t QO = vmulq_u32(vreinterpretq_u32_u64(kMul), vreinterpretq_u32_u8(vshrq_n_u8(vreinterpretq_u8_u64(OO), 7)));
+	uint32x2_t DP = vpadd_u32(vget_low_u32(QP), vget_high_u32(QP));	// P_h1h8 * * * P_a1a8 * * *
+	uint32x2_t DO = vpadd_u32(vget_low_u32(QO), vget_high_u32(QO));	// O_h1h8 * * * O_a1a8 * * *
+	uint8x8_t DB = vtrn_u8(vreinterpret_u8_u32(DO), vreinterpret_u8_u32(DP)).val[1];	// P_h1h8 O_h1h8 * * P_a1a8 O_a1a8 * *
+	uint8x16_t PO = vzipq_u8(vreinterpretq_u8_u64(OO), vreinterpretq_u8_u64(PP)).val[1];
+	uint8x8_t packedstable = vcreate_u8((edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 0)]
+	  | edge_stability[vgetq_lane_u16(vreinterpretq_u16_u8(PO), 7)] << 8) & 0x7e7e);
+	packedstable = vset_lane_u8(edge_stability[vget_lane_u16(vreinterpret_u16_u8(DB), 1)], packedstable, 2);
+	packedstable = vset_lane_u8(edge_stability[vget_lane_u16(vreinterpret_u16_u8(DB), 3)], packedstable, 3);
+	return vget_lane_u32(vpaddl_u16(vpaddl_u8(vcnt_u8(packedstable))), 0);
+}
+
+  #elif defined(hasSSE2)
+int get_edge_stability(const unsigned long long P, const unsigned long long O)
+{
+	__m128i	P0 = _mm_cvtsi64_si128(P);
+	__m128i	O0 = _mm_cvtsi64_si128(O);
+	__m128i	PO = _mm_unpacklo_epi8(O0, P0);
+	unsigned int packedstable = edge_stability[_mm_extract_epi16(PO, 0)] | edge_stability[_mm_extract_epi16(PO, 7)] << 8;
+	PO = _mm_unpacklo_epi64(O0, P0);
+	packedstable |= edge_stability[_mm_movemask_epi8(_mm_slli_epi64(PO, 7))] << 16 | edge_stability[_mm_movemask_epi8(PO)] << 24;
+	return bit_count_32(packedstable & 0xffff7e7e);
+}
+  #endif
+
+/**
+ * @brief AVX2/SSE/neon optimized get_full_lines.
+ *
+ * SSE pcmpeqb for horizontal get_full_lines.
+ * CPU rotate for vertical get_full_lines.
+ * Diag-7 is converted to diag-9 using vertical mirroring.
+ * 
+ * @param disc all discs on the board.
+ * @param full all 1 if full line, otherwise all 0.
+ */
+  #ifdef __AVX2__
+
+static __m256i vectorcall get_full_lines(const unsigned long long disc)
+{
+	__m128i l81, l79, l8;
+	__m256i	v4_disc, lr79;
+	const __m128i kff  = _mm_set1_epi8(-1);
+    #if 0 // PCMPEQQ
+	static const V4DI m791 = {{ 0x0402010000804020, 0x2040800000010204, 0x0804020180402010, 0x1020408001020408 }};	// V8SI
+	static const V4DI m792 = {{ 0x0000008040201008, 0x0000000102040810, 0x1008040201000000, 0x0810204080000000 }};
+	static const V4DI m793 = {{ 0x0000804020100804, 0x0000010204081020, 0x2010080402010000, 0x0408102040800000 }};
+	static const V4DI m794 = {{ 0x0080402010080402, 0x0001020408102040, 0x4020100804020100, 0x0204081020408000 }};
+	static const V2DI m795 = {{ 0x8040201008040201, 0x0102040810204080 }};
+
+	l81 = _mm_cvtsi64_si128(disc);				v4_disc = _mm256_broadcastq_epi64(l81);
+	l81 = _mm_cmpeq_epi8(kff, l81);				lr79 = _mm256_and_si256(_mm256_cmpeq_epi32(_mm256_and_si256(v4_disc, m791.v4), m791.v4), m791.v4);
+								lr79 = _mm256_or_si256(lr79, _mm256_and_si256(_mm256_cmpeq_epi64(_mm256_and_si256(v4_disc, m792.v4), m792.v4), m792.v4));
+	l8 = _mm256_castsi256_si128(v4_disc);			lr79 = _mm256_or_si256(lr79, _mm256_and_si256(_mm256_cmpeq_epi64(_mm256_and_si256(v4_disc, m793.v4), m793.v4), m793.v4));
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 1));	lr79 = _mm256_or_si256(lr79, _mm256_and_si256(_mm256_cmpeq_epi64(_mm256_and_si256(v4_disc, m794.v4), m794.v4), m794.v4));
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 2));	l79 = _mm_and_si128(_mm_cmpeq_epi64(_mm_and_si128(_mm256_castsi256_si128(v4_disc), m795.v2), m795.v2), m795.v2);
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 4));	l79 = _mm_or_si128(l79, _mm_or_si128(_mm256_extracti128_si256(lr79, 1), _mm256_castsi256_si128(lr79)));
+
+    #elif 0 // PCMPEQD
+	__m256i lm79;
+	static const V4DI m790 = {{ 0x80c0e0f0783c1e0f, 0x0103070f1e3c78f0, 0x70381c0e07030100, 0x0e1c3870e0c08000 }};
+	static const V4DI m791 = {{ 0x0402010000804020, 0x2040800000010204, 0x0804020180402010, 0x1020408001020408 }};	// V8SI
+	static const V4DI m792 = {{ 0x2010884440201088, 0x0408112202040811, 0x2211080411080402, 0x4488102088102040 }};	// V8SI
+	static const V4DI m793 = {{ 0x8844221110884422, 0x1122448808112244, 0x0000000044221108, 0x0000000022448810 }};	// V8SI
+
+	l81 = _mm_cvtsi64_si128(disc);				v4_disc = _mm256_broadcastq_epi64(l81);
+	l81 = _mm_cmpeq_epi8(kff, l81);				lm79 = _mm256_and_si256(v4_disc, m790.v4);
+								lm79 = _mm256_or_si256(lm79, _mm256_shuffle_epi32(lm79, 0xb1));
+	l8 = _mm256_castsi256_si128(v4_disc);			lr79 = _mm256_and_si256(_mm256_cmpeq_epi32(_mm256_and_si256(lm79, m792.v4), m792.v4), m792.v4);
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 1));	lr79 = _mm256_or_si256(lr79, _mm256_and_si256(_mm256_cmpeq_epi32(_mm256_and_si256(lm79, m793.v4), m793.v4), m793.v4));
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 2));	lr79 = _mm256_and_si256(_mm256_or_si256(lr79, _mm256_shuffle_epi32(lr79, 0xb1)), m790.v4);
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 4));	lr79 = _mm256_or_si256(lr79, _mm256_and_si256(_mm256_cmpeq_epi32(_mm256_and_si256(v4_disc, m791.v4), m791.v4), m791.v4));
+								l79 = _mm_or_si128(_mm256_extracti128_si256(lr79, 1), _mm256_castsi256_si128(lr79));
+
+    #else // Kogge-Stone
+	const __m128i mcpyswap = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0);
+	const __m128i mbswapll = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7);
+	static const V4DI shiftlr[] = {{{ 9, 7, 7, 9 }}, {{ 18, 14, 14, 18 }}, {{ 36, 28, 28, 36 }}};
+	static const V4DI e790 = {{ 0xff80808080808080, 0xff01010101010101, 0xff01010101010101, 0xff80808080808080 }};
+	static const V4DI e791 = {{ 0xffffc0c0c0c0c0c0, 0xffff030303030303, 0xffff030303030303, 0xffffc0c0c0c0c0c0 }};
+	static const V4DI e792 = {{ 0xfffffffff0f0f0f0, 0xffffffff0f0f0f0f, 0xffffffff0f0f0f0f, 0xfffffffff0f0f0f0 }};
+
+	l81 = _mm_cvtsi64_si128(disc);				v4_disc = _mm256_castsi128_si256(_mm_shuffle_epi8(l81, mcpyswap));
+	l81 = _mm_cmpeq_epi8(kff, l81);				v4_disc = _mm256_permute4x64_epi64(v4_disc, 0x50);	// disc, disc, rdisc, rdisc
+								lr79 = _mm256_and_si256(v4_disc, _mm256_or_si256(e790.v4, _mm256_srlv_epi64(v4_disc, shiftlr[0].v4)));
+	l8 = _mm256_castsi256_si128(v4_disc);			lr79 = _mm256_and_si256(lr79, _mm256_or_si256(e791.v4, _mm256_srlv_epi64(lr79, shiftlr[1].v4)));
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 1));	lr79 = _mm256_and_si256(lr79, _mm256_or_si256(e792.v4, _mm256_srlv_epi64(lr79, shiftlr[2].v4)));
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 2));	l79 = _mm_shuffle_epi8(_mm256_extracti128_si256(lr79, 1), mbswapll);
+	l8 = _mm_and_si128(l8, _mm_alignr_epi8(l8, l8, 4));	l79 = _mm_and_si128(l79, _mm256_castsi256_si128(lr79));
+    #endif
+	l81 = _mm_unpacklo_epi64(l81, l8);
+	return _mm256_insertf128_si256(_mm256_castsi128_si256(l81), l79, 1);
+}
+
+  #elif defined(__ARM_NEON)
+
+void get_full_lines(const unsigned long long disc, unsigned long long full[4])
+{
+	unsigned long long l8;
+	uint8x8_t l01;
+	uint64x2_t l79, r79;
+	const uint64x2_t e790 = vdupq_n_u64(0x007f7f7f7f7f7f7f);
+	const uint64x2_t e791 = vdupq_n_u64(0xfefefefefefefe00);
+	const uint64x2_t e792 = vdupq_n_u64(0x00003f3f3f3f3f3f);
+	const uint64x2_t e793 = vdupq_n_u64(0x0f0f0f0ff0f0f0f0);
+
+	l01 = vcreate_u8(disc);			l79 = r79 = vreinterpretq_u64_u8(vcombine_u8(l01, vrev64_u8(l01)));
+	l01 = vceq_u8(l01, vdup_n_u8(0xff));	l79 = vandq_u64(l79, vornq_u64(vshrq_n_u64(l79, 9), e790));
+	full[0] = vget_lane_u64(vreinterpret_u64_u8(l01), 0);
+						r79 = vandq_u64(r79, vornq_u64(vshlq_n_u64(r79, 9), e791));
+	l8 = disc;				l79 = vbicq_u64(l79, vbicq_u64(e792, vshrq_n_u64(l79, 18)));	// De Morgan
+	l8 &= (l8 >> 8) | (l8 << 56);		r79 = vbicq_u64(r79, vshlq_n_u64(vbicq_u64(e792, r79), 18));
+	l8 &= (l8 >> 16) | (l8 << 48);		l79 = vandq_u64(vandq_u64(l79, r79), vorrq_u64(e793, vsliq_n_u64(vshrq_n_u64(l79, 36), r79, 36)));
+	l8 &= (l8 >> 32) | (l8 << 32);		full[2] = vgetq_lane_u64(l79, 0);
+	full[1] = l8;				full[3] = vertical_mirror(vgetq_lane_u64(l79, 1));
+}
+
+  #else	// 1 CPU, 3 SSE
+
+void get_full_lines(const unsigned long long disc, unsigned long long full[4])
+{
+	unsigned long long rdisc = vertical_mirror(disc);
+	unsigned long long l8;
+	__m128i l01, l79, r79;	// full lines
+	const __m128i kff  = _mm_set1_epi8(-1);
+	const __m128i e790 = _mm_set1_epi64x(0xff80808080808080);
+	const __m128i e791 = _mm_set1_epi64x(0x01010101010101ff);
+	const __m128i e792 = _mm_set1_epi64x(0x00003f3f3f3f3f3f);
+	const __m128i e793 = _mm_set1_epi64x(0x0f0f0f0ff0f0f0f0);
+
+	l01 = l79 = _mm_cvtsi64_si128(disc);	l79 = r79 = _mm_unpacklo_epi64(l79, _mm_cvtsi64_si128(rdisc));
+	l01 = _mm_cmpeq_epi8(kff, l01);		l79 = _mm_and_si128(l79, _mm_or_si128(e790, _mm_srli_epi64(l79, 9)));
+	_mm_storel_epi64((__m128i*) &full[0], l01);
+						r79 = _mm_and_si128(r79, _mm_or_si128(e791, _mm_slli_epi64(r79, 9)));
+	l8 = disc;				l79 = _mm_andnot_si128(_mm_andnot_si128(_mm_srli_epi64(l79, 18), e792), l79);	// De Morgan
+	l8 &= (l8 >> 8) | (l8 << 56);		r79 = _mm_andnot_si128(_mm_slli_epi64(_mm_andnot_si128(r79, e792), 18), r79);
+	l8 &= (l8 >> 16) | (l8 << 48);		l79 = _mm_and_si128(_mm_and_si128(l79, r79), _mm_or_si128(e793, _mm_or_si128(_mm_srli_epi64(l79, 36), _mm_slli_epi64(r79, 36))));
+	l8 &= (l8 >> 32) | (l8 << 32);		_mm_storel_epi64((__m128i *) &full[2], l79);
+	full[1] = l8;				full[3] = vertical_mirror(_mm_cvtsi128_si64(_mm_unpackhi_epi64(l79, l79)));
+}
+
+  #endif
+#endif // hasSSE2/__ARM_NEON
+
+#ifdef __AVX2__
+/**
+ * @brief AVX2 optimized get_stability
+ *
+ * @param P bitboard with player's discs.
+ * @param O bitboard with opponent's discs.
+ * @return the number of stable discs.
+ */
+
+// compute the other stable discs (ie discs touching another stable disc in each flipping direction).
+static int vectorcall get_spreaded_stability(unsigned long long stable, unsigned long long P_central, __m256i v4_full)
+{
+	__m128i	v2_stable, v2_old_stable, v2_P_central;
+	__m256i	v4_stable;
+	const __m256i shift1897 = _mm256_set_epi64x(7, 9, 8, 1);
+
+	if (stable == 0)
+		return 0;
+
+	v2_stable = _mm_cvtsi64_si128(stable);
+	v2_P_central = _mm_cvtsi64_si128(P_central);
+	do {
+		v2_old_stable = v2_stable;
+		v4_stable = _mm256_broadcastq_epi64(v2_stable);
+		v4_stable = _mm256_or_si256(_mm256_or_si256(_mm256_srlv_epi64(v4_stable, shift1897), _mm256_sllv_epi64(v4_stable, shift1897)), v4_full);
+		v2_stable = _mm_and_si128(_mm256_castsi256_si128(v4_stable), _mm256_extracti128_si256(v4_stable, 1));
+		v2_stable = _mm_and_si128(v2_stable, _mm_unpackhi_epi64(v2_stable, v2_stable));
+		v2_stable = _mm_or_si128(v2_old_stable, _mm_and_si128(v2_stable, v2_P_central));
+	} while (!_mm_testc_si128(v2_old_stable, v2_stable));
+
+	return bit_count(_mm_cvtsi128_si64(v2_stable));
+}
+#elif defined(hasSSE2) && !defined(HAS_CPU_64)
+// 32bit SSE optimized get_spreaded_stability
+int get_spreaded_stability(unsigned long long stable, unsigned long long P_central, unsigned long long full[4])
+{
+	__m128i v_stable, stable_vh, stable_d79, old_stable;
+
+	if (stable == 0)	// (2%)
+		return 0;
+
+	v_stable = _mm_cvtsi64_si128(stable);
+	do {
+		old_stable = v_stable;
+		stable_vh = _mm_loadu_si128((__m128i *) &full[0]);
+		stable_vh = _mm_or_si128(stable_vh, _mm_unpacklo_epi64(_mm_srli_epi64(v_stable, 1), _mm_srli_epi64(v_stable, 8)));
+		stable_vh = _mm_or_si128(stable_vh, _mm_unpacklo_epi64(_mm_slli_epi64(v_stable, 1), _mm_slli_epi64(v_stable, 8)));
+		stable_d79 = _mm_loadu_si128((__m128i *) &full[2]);
+		stable_d79 = _mm_or_si128(stable_d79, _mm_unpacklo_epi64(_mm_srli_epi64(v_stable, 9), _mm_srli_epi64(v_stable, 7)));
+		stable_d79 = _mm_or_si128(stable_d79, _mm_unpacklo_epi64(_mm_slli_epi64(v_stable, 9), _mm_slli_epi64(v_stable, 7)));
+		v_stable = _mm_and_si128(stable_vh, stable_d79);
+		v_stable = _mm_and_si128(v_stable, _mm_unpackhi_epi64(v_stable, v_stable));
+		v_stable = _mm_or_si128(old_stable, _mm_and_si128(v_stable, _mm_loadl_epi64((__m128i *) &P_central)));
+	} while (_mm_movemask_epi8(_mm_cmpeq_epi8(v_stable, old_stable)) != 0xffff);	// (44%)
+
+	return bit_count_si64(v_stable);
+}
+#endif
+
+#ifdef __AVX2__
+// returns stability count only
+int get_stability(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long stable = get_stable_edge(P, O);	// compute the exact stable edges
+	unsigned long long P_central = P & 0x007e7e7e7e7e7e00;
+
+	__m256i	v4_full = get_full_lines(P | O);	// add full lines
+	__m128i v2_full = _mm_and_si128(_mm256_castsi256_si128(v4_full), _mm256_extracti128_si256(v4_full, 1));
+	stable |= (P_central & _mm_cvtsi128_si64(_mm_and_si128(v2_full, _mm_unpackhi_epi64(v2_full, v2_full))));
+
+	return get_spreaded_stability(stable, P_central, v4_full);	// compute the other stable discs
+}
+
+// returns all full in full[4] in addition to stability count
+int get_stability_fulls(const unsigned long long P, const unsigned long long O, unsigned long long full[5])
+{
+	unsigned long long stable = get_stable_edge(P, O);	// compute the exact stable edges
+	unsigned long long P_central = P & 0x007e7e7e7e7e7e00;
+
+	__m256i	v4_full = get_full_lines(P | O);	// add full lines
+	__m128i v2_full = _mm_and_si128(_mm256_castsi256_si128(v4_full), _mm256_extracti128_si256(v4_full, 1));
+	// _mm256_storeu_si256((__m256i *) full, v4_full);
+	full[4] = _mm_cvtsi128_si64(_mm_and_si128(v2_full, _mm_unpackhi_epi64(v2_full, v2_full)));
+	stable |= (P_central & full[4]);
+
+	return get_spreaded_stability(stable, P_central, v4_full);	// compute the other stable discs
+}
+
+// returns all full lines only
+unsigned long long get_all_full_lines(const unsigned long long disc)
+{
+	__m256i v4_full = get_full_lines(disc);
+	__m128i v2_full = _mm_and_si128(_mm256_castsi256_si128(v4_full), _mm256_extracti128_si256(v4_full, 1));
+	return _mm_cvtsi128_si64(_mm_and_si128(v2_full, _mm_unpackhi_epi64(v2_full, v2_full)));
+}
+
+/**
+ * @brief AVX2 optimized get_moves + get_potential_moves.
+ *
+ * Get the bitboard of empty squares in contact of a player square, as well as real mobility.
+ *
+ * @param PP broadcasted bitboard with player's discs.
+ * @param OO broadcasted bitboard with opponent's discs.
+ * @return potential moves in a higner 64-bit, real moves in a lower 64-bit.
+ */
+__m128i vectorcall get_moves_and_potential(__m256i PP, __m256i OO)
+{
+	__m256i	MM, potmob, flip_l, flip_r, pre_l, pre_r, shift2;
+	const __m256i shift1897 = _mm256_set_epi64x(7, 9, 8, 1);
+	__m256i	mOO = _mm256_and_si256(OO, _mm256_set_epi64x(0x007E7E7E7E7E7E00, 0x007E7E7E7E7E7E00, 0x00FFFFFFFFFFFF00, 0x7E7E7E7E7E7E7E7E));
+	__m128i occupied = _mm_or_si128(_mm256_castsi256_si128(PP), _mm256_castsi256_si128(OO));
+
+	flip_l = _mm256_and_si256(mOO, _mm256_sllv_epi64(PP, shift1897));
+	flip_r = _mm256_and_si256(mOO, _mm256_srlv_epi64(PP, shift1897));
+	flip_l = _mm256_or_si256(flip_l, _mm256_and_si256(mOO, _mm256_sllv_epi64(flip_l, shift1897)));
+	flip_r = _mm256_or_si256(flip_r, _mm256_and_si256(mOO, _mm256_srlv_epi64(flip_r, shift1897)));
+	pre_l = _mm256_sllv_epi64(mOO, shift1897);	pre_r = _mm256_srlv_epi64(mOO, shift1897);
+	potmob = _mm256_or_si256(pre_l, pre_r);
+	pre_l = _mm256_and_si256(mOO, pre_l);		pre_r = _mm256_and_si256(mOO, pre_r);
+	shift2 = _mm256_add_epi64(shift1897, shift1897);
+	flip_l = _mm256_or_si256(flip_l, _mm256_and_si256(pre_l, _mm256_sllv_epi64(flip_l, shift2)));
+	flip_r = _mm256_or_si256(flip_r, _mm256_and_si256(pre_r, _mm256_srlv_epi64(flip_r, shift2)));
+	flip_l = _mm256_or_si256(flip_l, _mm256_and_si256(pre_l, _mm256_sllv_epi64(flip_l, shift2)));
+	flip_r = _mm256_or_si256(flip_r, _mm256_and_si256(pre_r, _mm256_srlv_epi64(flip_r, shift2)));
+	MM = _mm256_or_si256(_mm256_sllv_epi64(flip_l, shift1897), _mm256_srlv_epi64(flip_r, shift1897));
+
+	MM = _mm256_or_si256(_mm256_unpacklo_epi64(MM, potmob), _mm256_unpackhi_epi64(MM, potmob));
+	return _mm_andnot_si128(occupied, _mm_or_si128(_mm256_castsi256_si128(MM), _mm256_extracti128_si256(MM, 1)));	// mask with empties
+}
+
+#endif
diff --git a/src/book.c b/src/book.c
index 0e36ee1d..b0784d2b 100644
--- a/src/book.c
+++ b/src/book.c
@@ -10,9 +10,9 @@
  * with two bounds from retropropagated error.
  * Several algorithms are present to add positions in the book, in the most usefull way.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "book.h"
@@ -49,7 +49,7 @@ static void bprint(const char *format, ...)
 		vprintf(format, args);
 		va_end(args);
 		fflush (stdout);
-		
+
 	}
 }
 
@@ -107,7 +107,7 @@ static inline bool link_is_bad(const Link *link)
  * @brief A position stored in the book.
  */
 typedef struct Position {
-	Board board[1];            /**< (unique) board */
+	Board board;               /**< (unique) board */
 	Link leaf;                 /**< best remaining move */
 	Link* link;                /**< linking moves */
 	unsigned int n_wins;       /**< game win count */
@@ -158,29 +158,29 @@ static int get_book_depth(const int depth)
  */
 static bool position_is_ok(const Position *position)
 {
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 	const Link *l;
 	int i, j;
 	char s[4];
 
 	// board is legal ?
-	if (position->board->player & position->board->opponent) {
+	if (position->board.player & position->board.opponent) {
 		warn("Board is illegal: Two discs on the same square?\n");
-		board_print(position->board, BLACK, stderr);
+		board_print(&position->board, BLACK, stderr);
 		return false;
 	}
-	if (((position->board->player|position->board->opponent) & 0x0000001818000000ULL) != 0x0000001818000000ULL) {
+	if (((position->board.player | position->board.opponent) & 0x0000001818000000ULL) != 0x0000001818000000ULL) {
 		warn("Board is illegal: Empty center?\n");
-		board_print(position->board, BLACK, stderr);
+		board_print(&position->board, BLACK, stderr);
 		return false;
 	}
 
 	// is board unique
-	board_unique(position->board, board);
-	if (!board_equal(position->board, board)) {
+	board_unique(&position->board, &board);
+	if (!board_equal(&position->board, &board)) {
 		warn("board is not unique\n");
-		position_print(position, position->board, stdout);
+		position_print(position, &position->board, stdout);
 		return false;
 	}
 
@@ -188,18 +188,18 @@ static bool position_is_ok(const Position *position)
 	foreach_link(l, position) {
 		if (l->move == PASS) {
 			if (position->n_link > 1
-			 || can_move(board->player, board->opponent)
-			 || !can_move(board->opponent, board->player)) {
+			 || can_move(board.player, board.opponent)
+			 || !can_move(board.opponent, board.player)) {
 				warn("passing move is wrong\n");
-				position_print(position, position->board, stdout);
+				position_print(position, &position->board, stdout);
 				return false;
 			}
 		} else {
 			if (/*l->move < A1 ||*/ l->move > H8
-			 || board_is_occupied(board, l->move)
-			 || board_get_move(board, l->move, move) == 0) {
+			 || board_is_occupied(&board, l->move)
+			 || board_get_move_flip(&board, l->move, &move) == 0) {
 				warn("link %s is wrong\n", move_to_string(l->move, WHITE, s));
-				position_print(position, position->board, stdout);
+				position_print(position, &position->board, stdout);
 				return false;
 			}
 		}
@@ -208,23 +208,23 @@ static bool position_is_ok(const Position *position)
 	l = &position->leaf;
 	if (l->move == PASS) {
 		if (position->n_link > 0
-		 || can_move(board->player, board->opponent)
-		 || !can_move(board->opponent, board->player)) {
+		 || can_move(board.player, board.opponent)
+		 || !can_move(board.opponent, board.player)) {
 			warn("passing move is wrong\n");
-			position_print(position, position->board, stdout);
+			position_print(position, &position->board, stdout);
 			return false;
 		}
 	} else if (l->move == NOMOVE) {
-		if (get_mobility(position->board->player, position->board->opponent) != position->n_link && !(position->n_link == 1 && position->link->move == PASS)) {
+		if (get_mobility(position->board.player, position->board.opponent) != position->n_link && !(position->n_link == 1 && position->link->move == PASS)) {
 			warn("nomove is wrong\n");
-			position_print(position, position->board, stdout);
+			position_print(position, &position->board, stdout);
 			return false;
 		}
 	} else if (/*l->move < A1 ||*/ l->move > H8
-		 || board_is_occupied(board, l->move)
-		 || board_get_move(board, l->move, move) == 0) {
+		 || board_is_occupied(&board, l->move)
+		 || board_get_move_flip(&board, l->move, &move) == 0) {
 			warn("leaf %s is wrong\n", move_to_string(l->move, WHITE, s));
-			position_print(position, position->board, stdout);
+			position_print(position, &position->board, stdout);
 			return false;
 	}
 
@@ -233,13 +233,13 @@ static bool position_is_ok(const Position *position)
 		for (j = i + 1; j < position->n_link; ++j) {
 			if (position->link[j].move == position->link[i].move) {
 				warn("doublon found in links\n");
-				position_print(position, position->board, stdout);
+				position_print(position, &position->board, stdout);
 				return false;
 			}
 		}
 		if (position->leaf.move == position->link[i].move) {
 			warn("doublon found in links/leaf\n");
-			position_print(position, position->board, stdout);
+			position_print(position, &position->board, stdout);
 			return false;
 		}
 	}
@@ -253,7 +253,7 @@ static bool position_is_ok(const Position *position)
  */
 static void position_init(Position *position)
 {
-	position->board->player = position->board->opponent = 0;
+	position->board.player = position->board.opponent = 0;
 
 	position->leaf = BAD_LINK;
 	position->link = NULL;
@@ -283,10 +283,10 @@ static void position_merge(Position *dest, const Position *src)
 {
 	Link *l;
 
-	position_init(dest);
-	*dest->board = *src->board;
+	position_init(dest);		//??? dest->n_link = 0,
+	dest->board = src->board;
 	if (dest->level == src->level) { 
-		foreach_link(l, dest) {
+		foreach_link(l, dest) {	// so this does nothing
 			if (l->move == src->leaf.move) return;
 		}
 		dest->leaf = src->leaf;
@@ -319,8 +319,8 @@ static bool position_read(Position *position, FILE *f)
 	int i;
 	int r;
 
-	r  = fread(&position->board->player, sizeof (unsigned long long), 1, f);
-	r += fread(&position->board->opponent, sizeof (unsigned long long), 1, f);
+	r  = fread(&position->board.player, sizeof (unsigned long long), 1, f);
+	r += fread(&position->board.opponent, sizeof (unsigned long long), 1, f);
 
 	r += fread(&position->n_wins, sizeof (unsigned int), 1, f);
 	r += fread(&position->n_draws, sizeof (unsigned int), 1, f);
@@ -362,12 +362,12 @@ static bool position_import(Position *position, FILE *f)
 {
 	char *line, *s, *old;
 	int value;
-	Move move[1];
+	Move move;
 	bool ok = false;
 
 	if ((line = string_read_line(f)) != NULL) {
 		position_init(position);
-		s = parse_board(line, position->board, &value);
+		s = parse_board(line, &position->board, &value);
 		if (s != line) {
 			s = parse_find(s, ',');
 			if (*s == ',') {
@@ -376,13 +376,13 @@ static bool position_import(Position *position, FILE *f)
 					position->level = value;
 					s = parse_find(s, ',');
 					if (*s == ',') {
-						s = parse_move(old = s + 1, position->board, move);
+						s = parse_move(old = s + 1, &position->board, &move);
 						if (s != old) {
 							s = parse_find(s, ',');
 							if (*s == ',') {
 								s = parse_int(old = s + 1, &value);
 								if (s != old) {
-									position->leaf.move = move->x;
+									position->leaf.move = move.x;
 									position->leaf.score = value;
 								}
 							}
@@ -417,8 +417,8 @@ static bool position_write(const Position *position, FILE* f)
 	int i;
 	int r;
 
-	r  = fwrite(&position->board->player, sizeof (unsigned long long), 1, f);
-	r += fwrite(&position->board->opponent, sizeof (unsigned long long), 1, f);
+	r  = fwrite(&position->board.player, sizeof (unsigned long long), 1, f);
+	r += fwrite(&position->board.opponent, sizeof (unsigned long long), 1, f);
 
 	r += fwrite(&position->n_wins, sizeof (unsigned int), 1, f);
 	r += fwrite(&position->n_draws, sizeof (unsigned int), 1, f);
@@ -451,7 +451,7 @@ static bool position_export(const Position *p, FILE* f)
 {
 	char b[80], m[4];
 
-	board_to_string(p->board, BLACK, b);
+	board_to_string(&p->board, BLACK, b);
 	move_to_string(p->leaf.move, BLACK, m);
 	return (fprintf(f, "%s,%d,%s,%d\n", b, p->level, m, p->leaf.score) > 0);
 }
@@ -463,11 +463,11 @@ static bool position_export(const Position *p, FILE* f)
  */
 static void position_unique(Position *position)
 {
-	Board board[1];
+	Board board;
 	int i, s;
 
-	*board = *position->board;
-	if ((s = board_unique(board, position->board)) != 0) {
+	board = position->board;
+	if ((s = board_unique(&board, &position->board)) != 0) {
 		for (i = 0; i < position->n_link; ++i) {
 			position->link[i].move = symetry(position->link[i].move, s);
 		}
@@ -486,23 +486,23 @@ static int position_get_moves(const Position *position, const Board *board, Move
 {
 	Move *previous = movelist->move;
 	Move *move = movelist->move + 1;
-	Board sym[1];
+	Board sym;
 	int i, x, s;
 
 	for (s = 0; s < 8; ++s) {
-		board_symetry(position->board, s, sym);
+		board_symetry(&position->board, s, &sym);
 
-		if (board_equal(sym, board)) {
+		if (board_equal(&sym, board)) {
 			for (i = 0; i < position->n_link; ++i) {
 				x = symetry(position->link[i].move, s);
-				board_get_move(board, x, move);
+				board_get_move_flip(board, x, move);
 				move->score = position->link[i].score;
 				previous = previous->next = move;
 				++move;
 			}
 			x = symetry(position->leaf.move, s);
 			if (x != NOMOVE) {
-				board_get_move(board, x, move);
+				board_get_move_flip(board, x, move);
 				move->score = position->leaf.score;
 				previous = previous->next = move;
 				++move;
@@ -527,7 +527,7 @@ static int position_get_moves(const Position *position, const Board *board, Move
  */
 static void position_show(const Position *position, const Board *board, FILE *f)
 {
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *move;
 	const int n_empties = board_count_empties(board);
 	const int color = n_empties & 1;
@@ -539,7 +539,7 @@ static void position_show(const Position *position, const Board *board, FILE *f)
 	fprintf(f, "\nLevel: %d\n", position->level);
 	fprintf(f, "Best score: %+02d [%+02d, %+02d]\n", position->score.value, position->score.lower, position->score.upper);
 	fprintf(f, "Moves:");
-	sym = position_get_moves(position, board, movelist);
+	sym = position_get_moves(position, board, &movelist);
 	foreach_move(move, movelist) {
 		move_to_string(move->x, color, s);
 		if (symetry(position->leaf.move, sym) == move->x) {
@@ -559,7 +559,7 @@ static void position_show(const Position *position, const Board *board, FILE *f)
  */
 static void position_print(const Position *position, const Board *board, FILE *f)
 {
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *move;
 	int color = board_count_empties(board) & 1, sym;
 	char b[80], m[4];
@@ -569,7 +569,7 @@ static void position_print(const Position *position, const Board *board, FILE *f
 	fprintf(f, "level:%d; ", position->level);
 	fprintf(f, "best: %+02d [%+02d, %+02d];", position->score.value, position->score.lower, position->score.upper);
 	fprintf(f, "moves:");
-	sym = position_get_moves(position, board, movelist);
+	sym = position_get_moves(position, board, &movelist);
 	foreach_move(move, movelist) {
 		move_to_string(move->x, color, m);
 		if (symetry(position->leaf.move, sym) == move->x) {
@@ -592,11 +592,11 @@ static void position_print(const Position *position, const Board *board, FILE *f
  */
 static void position_get_random_move(const Position *position, const Board *board, Move *move, Random *r, const int randomness)
 {
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *m;
 	int i, n;
 
-	position_get_moves(position, board, movelist);
+	position_get_moves(position, board, &movelist);
 
 	n = 0;
 	foreach_best_move(m, movelist) {
@@ -691,7 +691,7 @@ static void position_search(Position *position, Book *book)
 {
 	Search *search = book->search;
 	Link *l;
-	const int n_moves = get_mobility(position->board->player, position->board->opponent);
+	const int n_moves = get_mobility(position->board.player, position->board.opponent);
 	long long time;
 	bool time_per_move;
 
@@ -701,15 +701,15 @@ static void position_search(Position *position, Book *book)
 	}
 
 	if (position->n_link < n_moves || (position->n_link == 0 && n_moves == 0 && position->score.value == -SCORE_INF)) {
-		search_set_board(search, position->board, BLACK);
-		search_set_level(search, position->level, search->n_empties);
+		search_set_board(search, &position->board, BLACK);
+		search_set_level(search, position->level, search->eval.n_empties);
 
 		foreach_link (l, position) {
-			movelist_exclude(search->movelist, l->move);
+			movelist_exclude(&search->movelist, l->move);
 		}
 
 		if (search->options.verbosity >= 2) {
-			board_print(search->board, search->player, stdout);
+			board_print(&search->board, search->player, stdout);
 			puts(search->options.header);
 			puts(search->options.separator);
 		}
@@ -744,29 +744,29 @@ static void position_search(Position *position, Book *book)
 static void position_link(Position *position, Book *book)
 {
 	int x;
-	unsigned long long moves = get_moves(position->board->player, position->board->opponent);
-	Board next[1];
-	Link link[1];
+	unsigned long long moves = board_get_moves(&position->board);
+	Board next;
+	Link link;
 	Position *child;
 
 	if (moves) {
 		foreach_bit(x, moves) {
-			board_next(position->board, x, next);
-			child = book_probe(book, next);
+			board_next(&position->board, x, &next);
+			child = book_probe(book, &next);
 			if (child) {
-				link->score = -child->score.value;
-				link->move = x;
-				book->stats.n_links += position_add_link(position, link);
+				link.score = -child->score.value;
+				link.move = x;
+				book->stats.n_links += position_add_link(position, &link);
 			}
 		}
-	} else if (can_move(position->board->opponent, position->board->player)) {// pass ?
-		next->player = position->board->opponent;
-		next->opponent = position->board->player;
-		child = book_probe(book, next);
+	} else if (can_move(position->board.opponent, position->board.player)) {// pass ?
+		next.player = position->board.opponent;
+		next.opponent = position->board.player;
+		child = book_probe(book, &next);
 		if (child) {
-			link->score = -child->score.value;
-			link->move = PASS;
-			book->stats.n_links += position_add_link(position, link);
+			link.score = -child->score.value;
+			link.move = PASS;
+			book->stats.n_links += position_add_link(position, &link);
 		}
 	}
 }
@@ -783,21 +783,21 @@ static void position_link(Position *position, Book *book)
  */
 static void position_expand(Position *position, Book *book)
 {
-	Position child[1];
+	Position child;
 
 	if (position->leaf.move != NOMOVE) {
-		position_init(child);
+		position_init(&child);
 
-		board_next(position->board, position->leaf.move, child->board);
+		board_next(&position->board, position->leaf.move, &child.board);
 
-		child->level = position->level;
-		position_link(child, book);
+		child.level = position->level;
+		position_link(&child, book);
 		search_cleanup(book->search);
-		position_search(child, book);
-		position->leaf.score = -child->score.value;
+		position_search(&child, book);
+		position->leaf.score = -child.score.value;
 		position_search(position, book);
-		position_unique(child);
-		book_add(book, child);
+		position_unique(&child);
+		book_add(book, &child);
 	}
 }
 
@@ -812,12 +812,12 @@ static void position_expand(Position *position, Book *book)
 static int position_negamax(Position *position, Book *book)
 {
 	Link *l;
-	Board target[1];
+	Board target;
 	Position *child;
 
 	if (!position->done) {
 		GameStats stat = {0,0,0,0};
-		const int n_empties = board_count_empties(position->board);
+		const int n_empties = board_count_empties(&position->board);
 		const int search_depth = LEVEL[position->level][n_empties].depth;
 		const int bias = (search_depth & 1) - (n_empties & 1);
 
@@ -845,8 +845,8 @@ static int position_negamax(Position *position, Book *book)
 		}
 
 		foreach_link(l, position) {
-			board_next(position->board, l->move, target);
-			child = book_probe(book, target);
+			board_next(&position->board, l->move, &target);
+			child = book_probe(book, &target);
 			position_negamax(child, book);
 			if (l->score != -child->score.value) {
 				l->score = -child->score.value;
@@ -885,18 +885,18 @@ static int position_negamax(Position *position, Book *book)
 static void position_prune(Position *position, Book *book, const int player_deviation, const int opponent_deviation, const int lower, const int upper)
 {
 	Link *l;
-	Board target[1];
+	Board target;
 	Position *child;
 
 	// if position is not done yet & good enough & inside the book height limit
-	if (lower <= position->score.value && position->score.value <= upper && board_count_empties(position->board) >= book->options.n_empties - 1) {
+	if (lower <= position->score.value && position->score.value <= upper && board_count_empties(&position->board) >= book->options.n_empties - 1) {
 		position->done = true; book->stats.n_todo++;
 
 		// prune all children close to the best move
 		foreach_link(l, position) {
 			if (position->score.value - l->score <= player_deviation && lower <= l->score && l->score <= upper) {
-				board_next(position->board, l->move, target);
-				child = book_probe(book, target);
+				board_next(&position->board, l->move, &target);
+				child = book_probe(book, &target);
 				position_prune(child, book, opponent_deviation, player_deviation, -upper, -lower);
 			}
 		}
@@ -917,11 +917,11 @@ static void position_remove_links(Position *position, Book *book)
 {
 	int i, j;
 	Link *l = position->link;
-	Board target[1];
+	Board target;
 
 	for (i = 0; i < position->n_link; ++i) {
-		board_next(position->board, l[i].move, target);
-		if (!book_probe(book, target)) {
+		board_next(&position->board, l[i].move, &target);
+		if (!book_probe(book, &target)) {
 			if (l[i].score > position->leaf.score) position->leaf = l[i];
 			for (j = i + 1; j < position->n_link; ++j) l[j - 1] = l[j];
 			--position->n_link;
@@ -950,18 +950,18 @@ static void position_remove_links(Position *position, Book *book)
 static void position_deviate(Position *position, Book *book, const int player_deviation, const int opponent_deviation, const int lower, const int upper)
 {
 	Link *l;
-	Board target[1];
+	Board target;
 	Position *child;
 
 	// if position is not done yet & good enough & inside the book height limit
-	if (!position->done && lower <= position->score.value && position->score.value <= upper && board_count_empties(position->board) >= book->options.n_empties && !board_is_game_over(position->board)) {
+	if (!position->done && lower <= position->score.value && position->score.value <= upper && board_count_empties(&position->board) >= book->options.n_empties && !board_is_game_over(&position->board)) {
 		position->done = true;
 
 		// deviate all children close to the best move
 		foreach_link(l, position) {
 			if (position->score.value - l->score <= player_deviation && lower <= l->score && l->score <= upper) {
-				board_next(position->board, l->move, target);
-				child = book_probe(book, target);
+				board_next(&position->board, l->move, &target);
+				child = book_probe(book, &target);
 				position_deviate(child, book, opponent_deviation, player_deviation, -upper, -lower);
 			}
 		}
@@ -989,22 +989,22 @@ static void position_deviate(Position *position, Book *book, const int player_de
 static void position_enhance(Position *position, Book *book)
 {
 	Link *l;
-	Board target[1];
+	Board target;
 	Position *child;
 
-	if (!position->done && board_count_empties(position->board) >= book->options.n_empties && !board_is_game_over(position->board)) {
+	if (!position->done && board_count_empties(&position->board) >= book->options.n_empties && !board_is_game_over(&position->board)) {
 		position->done = true;
 
 		foreach_link(l, position) {
-			board_next(position->board, l->move, target);
-			child = book_probe(book, target);
+			board_next(&position->board, l->move, &target);
+			child = book_probe(book, &target);
 			if (-child->score.upper >= position->score.lower || -child->score.lower >= position->score.upper) {
 				position_enhance(child, book);
 			}
 		}
 
 		if (position->leaf.score > -SCORE_INF) {
-			const int n_empties = board_count_empties(position->board);
+			const int n_empties = board_count_empties(&position->board);
 			const int search_depth = LEVEL[position->level][n_empties].depth;
 			const int bias = (search_depth & 1) - (n_empties & 1);
 			int lower, upper;
@@ -1041,26 +1041,31 @@ static void board_feed_hash(Board *board, const Book *book, Search *search, cons
 {
 	Position *position;
 	const unsigned long long hash_code = board_get_hash_code(board);
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *m;
+	HashStoreData hash_data;
 
 	position = book_probe(book, board);
 	if (position) {
-		const int n_empties = board_count_empties(position->board);
-		const int depth = LEVEL[position->level][n_empties].depth;
-		const int selectivity = LEVEL[position->level][n_empties].selectivity;
+		const int n_empties = board_count_empties(&position->board);
 		const int score = position->score.value;
 		int move = NOMOVE;
 
-		position_get_moves(position, board, movelist);
+		hash_data.data.wl.c.depth = LEVEL[position->level][n_empties].depth;
+		hash_data.data.wl.c.selectivity = LEVEL[position->level][n_empties].selectivity;
+
+		position_get_moves(position, board, &movelist);
 		foreach_move(m, movelist) {
 			if (move == NOMOVE) move = m->x;
 			board_update(board, m);
 				board_feed_hash(board, book, search, is_pv && m->score == score);
 			board_restore(board, m);
 		}
-		hash_feed(search->hash_table, board, hash_code, depth, selectivity, score, score, move);
-		if (is_pv) hash_feed(search->pv_table, board, hash_code, depth, selectivity, score, score, move);
+
+		hash_data.data.lower = hash_data.data.upper = score;
+		hash_data.data.move[0] = move;
+		hash_feed(&search->hash_table, board, hash_code, &hash_data);
+		if (is_pv) hash_feed(&search->pv_table, board, hash_code, &hash_data);
 	}
 }
 
@@ -1077,12 +1082,12 @@ static void board_feed_hash(Board *board, const Book *book, Search *search, cons
 static bool board_fill(Board *board, Book *book, int depth)
 {
 	if (depth > 0) {
-		MoveList movelist[1];
+		MoveList movelist;
 		Move *m;
 		bool filled = false;
 
-		movelist_get_moves(movelist, board);
-		if (movelist->n_moves == 0 && can_move(board->opponent, board->player)) {
+		movelist_get_moves(&movelist, board);
+		if (movelist.n_moves == 0 && can_move(board->opponent, board->player)) {
 			board_pass(board);
 			if (board_fill(board, book, depth - 1)) {
 				book_add_board(book, board);
@@ -1114,18 +1119,18 @@ static bool board_fill(Board *board, Book *book, int depth)
  */
 static void position_fix(Position *position, Book *book)
 {
-	Board board[1];
+	Board board;
 
-	if ((position->board->player & position->board->opponent) || 
-	    ((position->board->player | position->board->opponent) & 0x0000001818000000ULL) != 0x0000001818000000ULL) {
+	if ((position->board.player & position->board.opponent) || 
+	    ((position->board.player | position->board.opponent) & 0x0000001818000000ULL) != 0x0000001818000000ULL) {
 		position_free(position);
 		position_init(position);
 		return;
 	}
-	board_unique(position->board, board);
+	board_unique(&position->board, &board);
 	position_free(position);
 	position_init(position);
-	*position->board = *board;
+	position->board = board;
 	position->level = book->options.level;
 	position_link(position, book);
 	position_search(position, book);
@@ -1163,10 +1168,10 @@ static bool position_array_add(PositionArray *a, const Position *p)
 {
 	int i;
 
-	board_check(p->board);
+	board_check(&p->board);
 	assert(position_is_ok(p));
 
-	for (i = 0; i < a->n; ++i) if (board_equal(a->positions[i].board, p->board)) return false;
+	for (i = 0; i < a->n; ++i) if (board_equal(&a->positions[i].board, &p->board)) return false;
 	if (a->n == a->size) {
 		Position *n;
 		a->size += a->size / 2 + 1;
@@ -1197,7 +1202,7 @@ static bool position_array_remove(PositionArray *a, const Position *p)
 	int i, j;
 
 	for (i = 0; i < a->n; ++i) {
-		if (board_equal(a->positions[i].board, p->board)) {
+		if (board_equal(&a->positions[i].board, &p->board)) {
 			position_free(a->positions + i);
 			for (j = i + 1; j < a->n; ++j) {
 				a->positions[j - 1] = a->positions[j];
@@ -1231,7 +1236,7 @@ static void position_array_free(PositionArray *a)
 static Position* position_array_probe(PositionArray *a, const Board *board)
 {
 	int i;
-	for (i = 0; i < a->n; ++i) if (board_equal(a->positions[i].board, board)) return a->positions + i;
+	for (i = 0; i < a->n; ++i) if (board_equal(&a->positions[i].board, board)) return a->positions + i;
 	return NULL;
 }
 
@@ -1292,9 +1297,9 @@ static double book_get_age(Book *book)
  */
 static Position* book_probe(const Book *book, const Board *board)
 {
-	Board unique[1];
-	board_unique(board, unique);
-	return position_array_probe(book->array + (board_get_hash_code(unique) & (book->n - 1)), unique);
+	Board unique;
+	board_unique(board, &unique);
+	return position_array_probe(book->array + (board_get_hash_code(&unique) & (book->n - 1)), &unique);
 }
 
 /**
@@ -1305,7 +1310,7 @@ static Position* book_probe(const Book *book, const Board *board)
  */
 static void book_add(Book *book, const Position *p)
 {
-	const unsigned long long i = board_get_hash_code(p->board) & (book->n - 1);
+	const unsigned long long i = board_get_hash_code(&p->board) & (book->n - 1);
 
 	if (position_array_add(book->array + i, p)) {
 		++book->n_nodes;
@@ -1321,7 +1326,7 @@ static void book_add(Book *book, const Position *p)
  */
 static void book_remove(Book *book, const Position *p)
 {
-	const unsigned long long i = board_get_hash_code(p->board) & (book->n - 1);
+	const unsigned long long i = board_get_hash_code(&p->board) & (book->n - 1);
 
 	if (position_array_remove(book->array + i, p)) {
 		--book->n_nodes;
@@ -1355,10 +1360,10 @@ static void book_clean(Book *book)
  */
 static Position *book_root(Book *book)
 {
-	Board board[1];
+	Board board;
 
-	board_init(board);
-	return book_probe(book, board);
+	board_init(&board);
+	return book_probe(book, &board);
 }
 
 /**
@@ -1385,7 +1390,7 @@ void book_init(Book *book)
 	for (i = 0; i < book->n; ++i) position_array_init(book->array + i);
 
 	book->n_nodes = 0;
-	random_seed(book->random, real_clock());
+	random_seed(&book->random, real_clock());
 	book->need_saving = false;
 }
 
@@ -1414,15 +1419,15 @@ void book_free(Book *book)
  */
 void book_new(Book *book, int level, int n_empties)
 {
-	Board board[1];
+	Board board;
 
 	bprint("New book %d %d...", level, n_empties);
 	book_init(book);
 	book->options.level = level;
 	book->options.n_empties = n_empties;
 
-	board_init(board);
-	book_add_board(book, board);
+	board_init(&board);
+	book_add_board(book, &board);
 	bprint("...done>\n");
 	book->need_saving = true;
 }
@@ -1489,7 +1494,7 @@ void book_load(Book *book, const char *file)
 			error("error while reading %s", file);
 		}
 
-		random_seed(book->random, real_clock());
+		random_seed(&book->random, real_clock());
 		book->need_saving = false;
 
 		info("done\n");
@@ -1527,12 +1532,12 @@ void book_import(Book *book, const char *file)
 		book->options.n_empties = 60;
 		book->options.level = 0;
 		foreach_position(p, a, book) {
-			n_empties = board_count_empties(p->board);
+			n_empties = board_count_empties(&p->board);
 			if (p->level > book->options.level) book->options.level = p->level;
 			if (n_empties < book->options.n_empties) book->options.n_empties = n_empties;
 		}
 
-		random_seed(book->random, real_clock());
+		random_seed(&book->random, real_clock());
 		book->need_saving = true;
 
 		bprint("...done\n");
@@ -1631,12 +1636,12 @@ void book_merge(Book *dest, const Book *src)
 {
 	PositionArray *a;
 	const Position *p_src;
-	Position p_dest[1];
+	Position p_dest;
 
 	foreach_position(p_src, a, src) {
-		if (!book_probe(dest, p_src->board)) {
-			position_merge(p_dest, p_src);
-			book_add(dest, p_dest);
+		if (!book_probe(dest, &p_src->board)) {
+			position_merge(&p_dest, p_src);
+			book_add(dest, &p_dest);
 		}
 	}
 }
@@ -1720,7 +1725,7 @@ void book_deepen(Book *book)
 
 	bprint("Deepening book...\r"); 
 	foreach_position(p, a, book) {
-		int n_empties = board_count_empties(p->board);
+		int n_empties = board_count_empties(&p->board);
 		if (LEVEL[p->level][n_empties].depth != LEVEL[book->options.level][n_empties].depth
 		 || LEVEL[p->level][n_empties].selectivity != LEVEL[book->options.level][n_empties].selectivity) { // No! compare depth & selectivity;
 			p->leaf = BAD_LINK;
@@ -1759,7 +1764,7 @@ void book_correct_solved(Book *book)
 
 	bprint("Correcting solved positions...\r"); 
 	foreach_position(p, a, book) {
-		int n_empties = board_count_empties(p->board);
+		int n_empties = board_count_empties(&p->board);
 		if (LEVEL[p->level][n_empties].depth == n_empties && LEVEL[p->level][n_empties].selectivity == NO_SELECTIVITY) { // No! compare depth & selectivity;
 			old_leaf = p->leaf;
 			p->leaf = BAD_LINK;
@@ -1767,7 +1772,7 @@ void book_correct_solved(Book *book)
 			if (p->leaf.score != old_leaf.score) {
 				++n_error;
 				bprint("\nError found:\n");
-				position_print(p, p->board, stdout);
+				position_print(p, &p->board, stdout);
 				move_to_string(old_leaf.move, n_empties & 1, s);
 				bprint("instead of <%s:%d>\n\n", s, old_leaf.score);
 			}
@@ -1855,7 +1860,7 @@ void book_play(Book *book)
 		n_diffs = 0;
 		book->stats.n_nodes = book->stats.n_links = book->stats.n_todo = 0;
 		foreach_position(p, a, book) {
-			if (p->n_link == 0 && board_count_empties(p->board) >= book->options.n_empties && !board_is_game_over(p->board)) {
+			if (p->n_link == 0 && board_count_empties(&p->board) >= book->options.n_empties && !board_is_game_over(&p->board)) {
 				p->todo = true; ++book->stats.n_todo;
 			} else {
 				p->todo = false;
@@ -1896,9 +1901,9 @@ void book_fill(Book *book, const int depth)
 		for (a = book->array; a < book->array + book->n; ++a)
 		for (k = 0; k < a->n; ++k) { // do not use foreach_positions here! a->positions may change!
 			p = a->positions + k;
-			n_empties = board_count_empties(p->board);
+			n_empties = board_count_empties(&p->board);
 			if (n_empties >= book->options.n_empties) {
-				board_fill(p->board, book, depth);
+				board_fill(&p->board, book, depth);
 				if (n_diffs < book->stats.n_nodes + book->stats.n_links) {
 					n_diffs = book->stats.n_nodes + book->stats.n_links;
 					bprint("Book fill...%d %d done\r", book->stats.n_nodes, book->stats.n_links); 
@@ -1982,7 +1987,7 @@ void book_prune(Book *book)
 
 		book_clean(book);
 		position_prune(root, book, 2*SCORE_INF, 0, -SCORE_INF, SCORE_INF);
-		position_print(root, root->board, stdout);
+		position_print(root, &root->board, stdout);
 		bprint("Book prune %d... done\n", book->stats.n_todo);
 
 		position_prune(root, book, 0, 2*SCORE_INF, -SCORE_INF, SCORE_INF);
@@ -2014,7 +2019,7 @@ void book_subtree(Book *book, const Board *board)
 
 		book_clean(book);
 		position_prune(root, book, 2*SCORE_INF, 2*SCORE_INF, -SCORE_INF, SCORE_INF);
-		position_print(root, root->board, stdout);
+		position_print(root, &root->board, stdout);
 		bprint("Book subtree %d... done\n", book->stats.n_todo);
 		for (a = book->array; a < book->array + book->n; ++a)
 		for (i = 0; i < a->n; ++i) if (!a->positions[i].done) {book_remove(book, a->positions + i); --i;}
@@ -2083,7 +2088,7 @@ void book_info(Book *book)
 		if (p->leaf.move != NOMOVE) ++n_leaves;
 		++n_level[p->level];
 		if (p->level != book->options.level) {
-			position_print(p, p->board, stdout);
+			position_print(p, &p->board, stdout);
 		}
 	}
 
@@ -2160,16 +2165,16 @@ bool book_get_moves(Book *book, const Board *board, MoveList *movelist)
 void book_get_line(Book *book, const Board *board, const Move *move, Line *line)
 {
 	Position *position;
-	Board b[1];
-	Move m[1];
+	Board b;
+	Move m;
 
 	line_push(line, move->x);
-	board_next(board, move->x, b);
+	board_next(board, move->x, &b);
 
-	while ((position = book_probe(book, b)) != NULL && !board_is_game_over(position->board)) {
-		position_get_random_move(position, b, m, book->random, 0);
-		line_push(line, m->x);
-		board_update(b, m);
+	while ((position = book_probe(book, &b)) != NULL && !board_is_game_over(&position->board)) {
+		position_get_random_move(position, &b, &m, &book->random, 0);
+		line_push(line, m.x);
+		board_update(&b, &m);
 	}
 }
 
@@ -2182,16 +2187,20 @@ void book_get_line(Book *book, const Board *board, const Move *move, Line *line)
  * @param move Chosen move.
  * @param randomness Randomness.
  */
+#if 0
+#include "srbook.c"
+#else
 bool book_get_random_move(Book *book, const Board *board, Move *move, const int randomness)
 {
 	Position *position = book_probe(book, board);
 	if (position) {
-		position_get_random_move(position, board, move, book->random, randomness);
+		position_get_random_move(position, board, move, &book->random, randomness);
 		return true;
 	}
 
 	return false;
 }
+#endif
 
 /**
  * @brief Get game statistics from a position.
@@ -2213,13 +2222,13 @@ void book_get_game_stats(Book *book, const Board *board, GameStats *stat)
 	position = book_probe(book, board);
 	if (position) {
 		if (position->n_wins == UINT_MAX || position->n_losses == UINT_MAX || position->n_draws == UINT_MAX || position->n_lines == UINT_MAX) {
-			Board target[1];
+			Board target;
 			Link *l;
 			GameStats child;
 			
 			foreach_link(l, position) {
-				board_next(position->board, l->move, target);
-				book_get_game_stats(book, target, &child);
+				board_next(&position->board, l->move, &target);
+				book_get_game_stats(book, &target, &child);
 				stat->n_wins += child.n_losses;
 				stat->n_draws += child.n_draws;
 				stat->n_losses += child.n_wins;
@@ -2243,7 +2252,7 @@ void book_get_game_stats(Book *book, const Board *board, GameStats *stat)
  */
 void book_add_board(Book *book, const Board *board)
 {
-	Position position[1];
+	Position position;
 	Position *probe;
 
 	if (board_count_empties(board) >= book->options.n_empties - 1) {
@@ -2253,14 +2262,14 @@ void book_add_board(Book *book, const Board *board)
 			if (probe->leaf.move == NOMOVE) position_search(probe, book);
 			if (BOOK_DEBUG) {printf("update: "); position_print(probe, board, stdout);}
 		} else {
-			position_init(position);
-			*position->board = *board;
-			position->level = book->options.level;
-			position_link(position, book);
-			position_search(position, book);
-			if (BOOK_DEBUG) {printf("new: "); position_print(position, board, stdout);}
-			position_unique(position);
-			book_add(book, position);
+			position_init(&position);
+			position.board = *board;
+			position.level = book->options.level;
+			position_link(&position, book);
+			position_search(&position, book);
+			if (BOOK_DEBUG) {printf("new: "); position_print(&position, board, stdout);}
+			position_unique(&position);
+			book_add(book, &position);
 		}
 	}
 }
@@ -2273,7 +2282,7 @@ void book_add_board(Book *book, const Board *board)
  */
 void book_add_game(Book *book, const Game *game)
 {
-	Board board[1];
+	Board board;
 	Move stack[99];
 	int i, n_moves;
 	char file[FILENAME_MAX + 1];
@@ -2281,15 +2290,15 @@ void book_add_game(Book *book, const Game *game)
 
 	file_add_ext(options.book_file, ".gam", file);
 	
-	board_init(board);
-	if (!board_equal(board, game->initial_board)) return; // skip non standard game
+	board_init(&board);
+	if (!board_equal(&board, &game->initial_board)) return; // skip non standard game
 	for (i = n_moves = 0; i < 60 - book->options.n_empties && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			stack[n_moves++] = MOVE_PASS;
-			board_pass(board);
+			board_pass(&board);
 		}
-		if (!board_is_occupied(board, game->move[i]) && board_get_move(board, game->move[i], &stack[n_moves])) {
-			board_update(board, stack + n_moves);
+		if (!board_is_occupied(&board, game->move[i]) && board_get_move_flip(&board, game->move[i], &stack[n_moves])) {
+			board_update(&board, stack + n_moves);
 			++n_moves;
 		} else {
 			warn("illegal move in game");
@@ -2299,8 +2308,8 @@ void book_add_game(Book *book, const Game *game)
 
 	search_cleanup(book->search);
 	while (--n_moves >= 0) {
-		book_add_board(book, board);
-		board_restore(board, stack + n_moves);
+		book_add_board(book, &board);
+		board_restore(&board, stack + n_moves);
 	}
 
 	if (book->stats.n_nodes + book->stats.n_links > n_stats && book_get_age(book) > 3600) book_save(book, file);
@@ -2355,21 +2364,21 @@ typedef struct BookCheckGame {
  */
 void book_check_game(Book *book, MoveHash *hash, const Game *game, BookCheckGame *stat)
 {
-	Board board[1];
+	Board board;
 	Move stack[99], *iter;
-	MoveList movelist[1];
+	MoveList movelist;
 	int i, n_moves;
 	int bestscore;
 
-	board_init(board);
-	if (!board_equal(board, game->initial_board)) return; // skip non standard game
+	board_init(&board);
+	if (!board_equal(&board, &game->initial_board)) return; // skip non standard game
 	for (i = n_moves = 0; i <= 60 - book->options.n_empties && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			stack[n_moves++] = MOVE_PASS;
-			board_pass(board);
+			board_pass(&board);
 		}
-		if (!board_is_occupied(board, game->move[i]) && board_get_move(board, game->move[i], &stack[n_moves])) {
-			board_update(board, stack + n_moves);
+		if (!board_is_occupied(&board, game->move[i]) && board_get_move_flip(&board, game->move[i], &stack[n_moves])) {
+			board_update(&board, stack + n_moves);
 			++n_moves;
 		} else {
 			warn("illegal move in game");
@@ -2378,10 +2387,10 @@ void book_check_game(Book *book, MoveHash *hash, const Game *game, BookCheckGame
 	}
 
 	while (--n_moves >= 0) {
-		board_restore(board, stack + n_moves);
-		if (movehash_append(hash, board, stack[n_moves].x)) {
-			if (book_get_moves(book, board, movelist)) {
-				bestscore = movelist_first(movelist)->score;
+		board_restore(&board, stack + n_moves);
+		if (movehash_append(hash, &board, stack[n_moves].x)) {
+			if (book_get_moves(book, &board, &movelist)) {
+				bestscore = movelist_first(&movelist)->score;
 				foreach_move(iter, movelist) {
 					if (iter->x == stack[n_moves].x) {
 						if (iter->score < bestscore) ++stat->bad;
@@ -2389,7 +2398,7 @@ void book_check_game(Book *book, MoveHash *hash, const Game *game, BookCheckGame
 						break;
 					}
 				}
-			} else ++stat->missing;		
+			} else ++stat->missing;
 		}
 	}
 }
@@ -2429,14 +2438,14 @@ void book_check_base(Book *book, const Base *base)
  */
 static void extract_skeleton(Book *book, Board *board, Line *pv, Base *base)
 {
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *move;
-	Board init[1];
-	Game game[1];
+	Board init;
+	Game game;
 	int bestscore;
 
-	if (book_get_moves(book, board, movelist)) {
-		bestscore = movelist_best(movelist)->score;
+	if (book_get_moves(book, board, &movelist)) {
+		bestscore = movelist_best(&movelist)->score;
 		
 		foreach_move(move, movelist) {
 			if (move->score == bestscore) {
@@ -2446,12 +2455,11 @@ static void extract_skeleton(Book *book, Board *board, Line *pv, Base *base)
 			}
 		}
 	} else if (pv->n_moves) {
-		board_init(init);
-		line_to_game(init, pv, game);
-		base_append(base, game);
+		board_init(&init);
+		line_to_game(&init, pv, &game);
+		base_append(base, &game);
 		if (base->n_games % 1000 == 0) {
 			bprint("extracting %d games\r", base->n_games);
-			
 		}
 	}
 }
@@ -2467,21 +2475,21 @@ static void extract_skeleton(Book *book, Board *board, Line *pv, Base *base)
  */
 void book_extract_skeleton(Book *book, Base *base)
 {
-	Line pv[1];
-	Board board[1];
+	Line pv;
+	Board board;
 
-	line_init(pv, BLACK);
-	line_push(pv, F5); line_push(pv, D6); line_push(pv, C4);
-	board_init(board);
-	board_next(board, F5, board); board_next(board, D6, board); board_next(board, C4, board);
-	extract_skeleton(book, board, pv, base);
+	line_init(&pv, BLACK);
+	line_push(&pv, F5); line_push(&pv, D6); line_push(&pv, C4);
+	board_init(&board);
+	board_next(&board, F5, &board); board_next(&board, D6, &board); board_next(&board, C4, &board);
+	extract_skeleton(book, &board, &pv, base);
 	
-	line_init(pv, BLACK);
-	line_push(pv, F5); line_push(pv, F6); line_push(pv, E6); line_push(pv, F4);
-	board_init(board);
-	board_next(board, F5, board); board_next(board, F6, board);
-	board_next(board, E6, board); board_next(board, F4, board);	
-	extract_skeleton(book, board, pv, base);
+	line_init(&pv, BLACK);
+	line_push(&pv, F5); line_push(&pv, F6); line_push(&pv, E6); line_push(&pv, F4);
+	board_init(&board);
+	board_next(&board, F5, &board); board_next(&board, F6, &board);
+	board_next(&board, E6, &board); board_next(&board, F4, &board);	
+	extract_skeleton(book, &board, &pv, base);
 	bprint("%d games extracted   \n", base->n_games);
 }
 
@@ -2497,7 +2505,7 @@ void book_extract_positions(Book *book, const int n_empties, const int n_positio
 {
 	PositionArray *a;
 	Position *p;
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *best, *second_best;
 	int i = 0;
 	char s[80];
@@ -2505,14 +2513,14 @@ void book_extract_positions(Book *book, const int n_empties, const int n_positio
 	bprint("Extracting %d positions at %d ...\n", n_positions, n_empties); 
 	foreach_position(p, a, book) {
 		if (i == n_positions) break;
-		if (board_count_empties(p->board) == n_empties) {
-			position_get_moves(p, p->board, movelist);
-			best = movelist_first(movelist);
+		if (board_count_empties(&p->board) == n_empties) {
+			position_get_moves(p, &p->board, &movelist);
+			best = movelist_first(&movelist);
 			if (best) {
 				second_best = move_next(best);
 				if (second_best && best->score > second_best->score) {
 					++i;
-					board_to_string(p->board, n_empties & 1, s);
+					board_to_string(&p->board, n_empties & 1, s);
 					bprint("%s %% bm ", s);
 					move_print(best->x, n_empties & 1, stdout);
 					bprint(":%+2d; ba ", best->score);
@@ -2554,7 +2562,7 @@ void book_stats(Book *book)
 	printf("stage    positions        links       leaves      terminal nodes\n");
 	for (i = 0; i < 61; ++i) n_pos[i] = n_leaf[i] = n_link[i] = n_terminal[i] = 0;
 	foreach_position(p, a, book) {
-		i = board_count_empties(p->board);
+		i = board_count_empties(&p->board);
 		++n_pos[i];
 		if (p->leaf.move != NOMOVE) ++n_leaf[i];
 		if (p->n_link == 0) ++n_terminal[i];
diff --git a/src/book.h b/src/book.h
index a2018a74..c28d521f 100644
--- a/src/book.h
+++ b/src/book.h
@@ -3,7 +3,7 @@
  *
  * Header file for opening book management
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -45,7 +45,7 @@ typedef struct Book {
 	int n;
 	int n_nodes;
 	bool need_saving;
-	Random random[1];
+	Random random;
 	Search *search;
 } Book;
 
diff --git a/src/cassio.c b/src/cassio.c
index 0a154a5a..c262b44a 100644
--- a/src/cassio.c
+++ b/src/cassio.c
@@ -13,9 +13,9 @@
  *  - With "-follow-cassio" Edax will follow more closely Cassio's search request. By default, it
  * searches with settings that make it better in tournament mode against Roxane, Cassio, etc.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "cassio.h"
@@ -200,9 +200,9 @@ static bool is_position_new(Engine *engine, Board *board)
 	cassio_debug("Position list: adding position %llx\n", board_get_hash_code(board));
 	engine->last_position.board[0] = *board;
 	engine->last_position.n = MIN(ENGINE_N_POSITION, engine->last_position.n + 1);
-	hash_clear(engine->search->hash_table);
-	hash_clear(engine->search->pv_table);
-	hash_clear(engine->search->shallow_table);
+	hash_clear(&engine->search->hash_table);
+	hash_clear(&engine->search->pv_table);
+	hash_clear(&engine->search->shallow_table);
 	
 	return true;
 }
@@ -220,8 +220,8 @@ static void engine_observer(Result *result)
 	n += sprintf(engine_result + n, ", depth %d, @%d%%, %c%+d.00 <= v <= %c%+d.00, ",
 		 result->depth, selectivity_table[result->selectivity].percent,
 		 color, result->bound[result->move].lower, color, result->bound[result->move].upper);
-	line_to_string(result->pv, result->pv->n_moves, NULL, engine_result + n);
-	n += 2 * result->pv->n_moves;
+	line_to_string(&result->pv, result->pv.n_moves, NULL, engine_result + n);
+	n += 2 * result->pv.n_moves;
 	n += sprintf(engine_result + n, ", node %llu, time %.3f", result->n_nodes, 0.001 * result->time);
 
 	// avoid to send multiple times the same result.
@@ -238,8 +238,8 @@ static void engine_observer(Result *result)
 static Search* engine_create_search(void)
 {
 	Search *search;
-	
-	search = (Search*) malloc(sizeof (Search));
+
+	search = (Search*) mm_malloc(sizeof (Search));
 	if (search == NULL) {
 		engine_send("ERROR: Cannot allocate a new search engine.");
 		engine_send("bye bye!");
@@ -268,7 +268,7 @@ static Search* engine_create_search(void)
 static int engine_open(Search *search, const Board *board, const int player, const int alpha, const int beta, const int depth, const int precision)
 {
 	int k;
-	HashData hash_data[1];
+	HashData hash_data;
 	Move *move;
 	int score = 0;
 	
@@ -287,9 +287,9 @@ static int engine_open(Search *search, const Board *board, const int player, con
 	search->child_nodes = 0;
 	search_time_init(search);
 	if (!search->options.keep_date) {
-		hash_clear(search->hash_table);
-		hash_clear(search->pv_table);
-		hash_clear(search->shallow_table);
+		hash_clear(&search->hash_table);
+		hash_clear(&search->pv_table);
+		hash_clear(&search->shallow_table);
 	}
 
 	search->height = 0;
@@ -299,17 +299,17 @@ static int engine_open(Search *search, const Board *board, const int player, con
 	search->stability_bound.lower = 2 * get_stability(board->player, board->opponent) - SCORE_MAX;
 
 	// set the board
-	if (player != search->player || !board_equal(search->board, board)) {
+	if (player != search->player || !board_equal(&search->board, board)) {
 		search_set_board(search, board, player);
 
-		if (hash_get(search->pv_table, board, board_get_hash_code(board), hash_data)) {
-			if (hash_data->lower == -SCORE_INF && hash_data->upper < SCORE_INF) score = hash_data->upper;
-			else if (hash_data->upper == +SCORE_INF && hash_data->lower > -SCORE_INF) score = hash_data->lower;
-			else score = (hash_data->upper + hash_data->lower) / 2;
+		if (hash_get_from_board(&search->pv_table, board, &hash_data)) {
+			if (hash_data.lower == -SCORE_INF && hash_data.upper < SCORE_INF) score = hash_data.upper;
+			else if (hash_data.upper == +SCORE_INF && hash_data.lower > -SCORE_INF) score = hash_data.lower;
+			else score = (hash_data.upper + hash_data.lower) / 2;
 		}
-		if (!movelist_is_empty(search->movelist)) {
-			movelist_evaluate(search->movelist, search, hash_data, options.alpha, depth);
-			movelist_sort(search->movelist);
+		if (!movelist_is_empty(&search->movelist)) {
+			movelist_evaluate(&search->movelist, search, &hash_data, options.alpha, depth);
+			movelist_sort(&search->movelist);
 		}
 	}
 
@@ -318,19 +318,19 @@ static int engine_open(Search *search, const Board *board, const int player, con
 		search->result->bound[move->x].upper = SCORE_MAX;
 	}
 
-	search->result->n_moves_left = search->result->n_moves = search->movelist->n_moves;
+	search->result->n_moves_left = search->result->n_moves = search->movelist.n_moves;
 	search->result->book_move = false;
 
 	// set level
 	search->depth = depth;
-	if (options.transgress_cassio && (search->n_empties & 1) != (depth & 1)) ++search->depth;
-	if (options.transgress_cassio && search->depth > search->n_empties - 10) search->depth = search->n_empties;
+	if (options.transgress_cassio && (search->eval.n_empties & 1) != (depth & 1)) ++search->depth;
+	if (options.transgress_cassio && search->depth > search->eval.n_empties - 10) search->depth = search->eval.n_empties;
 	search->options.depth = search->depth;
 
-	BOUND(search->depth, 0, search->n_empties, "depth");
-	search->depth_pv_extension = get_pv_extension(search->depth, search->n_empties);
+	BOUND(search->depth, 0, search->eval.n_empties, "depth");
+	search->depth_pv_extension = get_pv_extension(search->depth, search->eval.n_empties);
 
-	if (options.transgress_cassio && depth < search->n_empties) k = 0;
+	if (options.transgress_cassio && depth < search->eval.n_empties) k = 0;
 	else if (precision <= 73) k = 0;
 	else if (precision <= 87) k = 1;
 	else if (precision <= 95) k = 2;
@@ -376,7 +376,7 @@ static void engine_close(Search *search)
 void* engine_init(void)
 {
 	Engine *engine;
-	
+
 	log_open(engine_log, options.ui_log_file);
 
 	engine = (Engine*) malloc(sizeof (Engine));
@@ -401,10 +401,11 @@ void* engine_init(void)
  */
 void engine_free(void *v)
 {
-	Search *search = (Search*) v;
+	Search *const search = (Search*) v;
+
 	if (search) {
 		search_free(search);
-		free(search);
+		mm_free(search);
 	}
 	log_close(engine_log);
 }
@@ -413,10 +414,16 @@ void engine_free(void *v)
 
 void feed_all_hash_table(Search *search, Board *board, const int depth, const int selectivity, const int lower, const int upper, const int move)
 {
+	HashStoreData hash_data;
 	const unsigned long long hash_code = board_get_hash_code(board);
 
-	hash_feed(search->hash_table, board, hash_code, depth, selectivity, lower, upper, move);
-	hash_feed(search->pv_table, board, hash_code, depth, selectivity, lower, upper, move);	
+	hash_data.data.wl.c.depth = depth;
+	hash_data.data.wl.c.selectivity = selectivity;
+	hash_data.data.move[0] = move;
+	hash_data.data.lower = lower;
+	hash_data.data.upper = upper;
+	hash_feed(&search->hash_table, board, hash_code, &hash_data);
+	hash_feed(&search->pv_table, board, hash_code, &hash_data);
 }
 
 /**
@@ -432,12 +439,12 @@ void feed_all_hash_table(Search *search, Board *board, const int depth, const in
  */
 void engine_feed_hash(void *v, Board *board, int lower, int upper, const int depth, const int precision, Line *pv)
 {
-	Engine *engine = (Engine*) v;
-	Search *search = engine->search;
+	Engine *const engine = (Engine*) v;
+	Search *const search = engine->search;
 	int i, selectivity, tmp;
 	int current_depth;
 	Move *move, *child_move;
-	MoveList movelist[1], child_movelist[1];
+	MoveList movelist, child_movelist;
 	
 	if (options.transgress_cassio && depth < board_count_empties(board)) selectivity = 0;
 	else if (precision <= 73) selectivity = 0;
@@ -453,15 +460,15 @@ void engine_feed_hash(void *v, Board *board, int lower, int upper, const int dep
 		current_depth = depth - i;
 		feed_all_hash_table(search, board, current_depth, selectivity, lower, upper, pv->move[i]);
 
-		movelist_get_moves(movelist, board);
-		movelist_sort_bestmove(movelist, pv->move[i]);
+		movelist_get_moves(&movelist, board);
+		movelist_sort_bestmove(&movelist, pv->move[i]);
 
 		foreach_move(move, movelist) {
 			board_update(board, move);
 				if (move->x == pv->move[i]) {
 					feed_all_hash_table(search, board, current_depth - 1, selectivity, -upper, -lower, NOMOVE);
 					if (lower > SCORE_MIN) {
-						movelist_get_moves(child_movelist, board);
+						movelist_get_moves(&child_movelist, board);
 						foreach_move(child_move, child_movelist) {
 							board_update(board, child_move);
 								feed_all_hash_table(search, board, current_depth - 2, selectivity, lower, SCORE_MAX, NOMOVE);
@@ -474,7 +481,7 @@ void engine_feed_hash(void *v, Board *board, int lower, int upper, const int dep
 			board_restore(board, move);
 		}
 
-		move = movelist_first(movelist);
+		move = movelist_first(&movelist);
 	
 		if (move && move->x == pv->move[i]) {
 			board_update(board, move);
@@ -500,14 +507,14 @@ void engine_feed_hash(void *v, Board *board, int lower, int upper, const int dep
  */
 void engine_empty_hash(void *v)
 {
-	Engine *engine = (Engine*) v;
+	Engine *const engine = (Engine*) v;
 	
-	if (engine && engine->search && engine->search->hash_table && engine->search->pv_table) {
+	if (engine && engine->search) {
 		cassio_debug("clear the hash-table.\n");
 		engine->last_position.n = 0;
-		hash_cleanup(engine->search->hash_table);
-		hash_cleanup(engine->search->pv_table);
-		hash_cleanup(engine->search->shallow_table);
+		hash_cleanup(&engine->search->hash_table);
+		hash_cleanup(&engine->search->pv_table);
+		hash_cleanup(&engine->search->shallow_table);
 	}
 }
 
@@ -519,49 +526,48 @@ void engine_empty_hash(void *v)
  */
 static bool skip_search(Engine *engine, int *old_score)
 {
-	Search *search = engine->search;
-	Board *board = search->board;
-	MoveList *movelist = search->movelist;
-	HashData hash_data[1];
+	Search *const search = engine->search;
+	MoveList *const movelist = &search->movelist;
+	HashData hash_data;
 	Move *bestmove;
 	int alpha = options.alpha;
 	int beta = options.beta;
 	Bound *bound;
 	char s[4], b[80];
-	const unsigned long long hash_code = board_get_hash_code(board);
+	const unsigned long long hash_code = board_get_hash_code(&search->board);
 	
 	*old_score = 0;
 	
-	if (hash_get(search->pv_table, board, hash_code, hash_data)
-	|| hash_get(search->hash_table, board, hash_code, hash_data)) {
+	if (hash_get(&search->pv_table, &search->board, hash_code, &hash_data)
+	|| hash_get(&search->hash_table, &search->board, hash_code, &hash_data)) {
 		// compute bounds
-		if (alpha < hash_data->lower) alpha = *old_score = hash_data->lower;
-		if (beta > hash_data->upper) beta = *old_score = hash_data->upper;
+		if (alpha < hash_data.lower) alpha = *old_score = hash_data.lower;
+		if (beta > hash_data.upper) beta = *old_score = hash_data.upper;
 		// skip search ?
-		if (hash_data->depth >= search->depth && hash_data->selectivity >= search->selectivity && alpha >= beta) {
-			if (hash_data->move[0] != NOMOVE) movelist_sort_bestmove(movelist, hash_data->move[0]);
-			else if (hash_data->lower > SCORE_MIN) return false;
+		if (hash_data.wl.c.depth >= search->depth && hash_data.wl.c.selectivity >= search->selectivity && alpha >= beta) {
+			if (hash_data.move[0] != NOMOVE) movelist_sort_bestmove(movelist, hash_data.move[0]);
+			else if (hash_data.lower > SCORE_MIN) return false;
 			bestmove = movelist_first(movelist);
 			bestmove->score = *old_score;
-			record_best_move(search, board, bestmove, options.alpha, options.beta, search->depth);
+			record_best_move(search, bestmove, options.alpha, options.beta, search->depth);
 			bound =  search->result->bound + bestmove->x;
 
 			if (bound->lower != bound->upper || is_pv_ok(search, bestmove->x, search->depth)) {
-				cassio_debug("Edax skips the search. The position is already in the hash table: %s (%d, %d) ?\n", move_to_string(bestmove->x, search->player, s), hash_data->lower, hash_data->upper);
+				cassio_debug("Edax skips the search. The position is already in the hash table: %s (%d, %d) ?\n", move_to_string(bestmove->x, search->player, s), hash_data.lower, hash_data.upper);
 				engine_observer(search->result);
 				return true;
 			} else {
 				cassio_debug("Edax does not skip the search : BAD PV!\n");
 			}
 		} else {
-			if (hash_data->depth < search->depth || hash_data->selectivity < search->selectivity) {
-				cassio_debug("Edax does not skip the search: Level %d@%d < %d@%d\n", hash_data->depth,selectivity_table[hash_data->selectivity].percent, search->depth, selectivity_table[search->selectivity].percent);
+			if (hash_data.wl.c.depth < search->depth || hash_data.wl.c.selectivity < search->selectivity) {
+				cassio_debug("Edax does not skip the search: Level %d@%d < %d@%d\n", hash_data.wl.c.depth, selectivity_table[hash_data.wl.c.selectivity].percent, search->depth, selectivity_table[search->selectivity].percent);
 			} else {
 				cassio_debug("Edax does not skip the search: unsolved score alpha %d < beta %d\n", alpha, beta); 
 			}
 		}
 	} else {
-		cassio_debug("Edax does not skip the search: Position %s (hash=%llx) not found\n", board_to_string(board, search->player, b), board_get_hash_code(board));
+		cassio_debug("Edax does not skip the search: Position %s (hash=%llx) not found\n", board_to_string(&search->board, search->player, b), hash_code);
 	}
 	
 	return false;
@@ -584,9 +590,9 @@ static bool skip_search(Engine *engine, int *old_score)
  */
 double engine_midgame_search(void *v, const char *position, const double alpha, const double beta, const int depth, const int precision)
 {
-	Engine *engine = (Engine*) v;
-	Search *search = engine->search;
-	Board board[1];
+	Engine *const engine = (Engine*) v;
+	Search *const search = engine->search;
+	Board board;
 	int player;
 	int old_score;
 	
@@ -596,12 +602,12 @@ double engine_midgame_search(void *v, const char *position, const double alpha,
 	}
 	
 	engine->is_searching = true;
-	player = board_set(board, position);
+	player = board_set(&board, position);
 	
-	old_score = engine_open(search, board, player, floor(alpha), ceil(beta), depth, precision);
+	old_score = engine_open(search, &board, player, floor(alpha), ceil(beta), depth, precision);
 	
 	if (skip_search(engine, &old_score)) {
-	} else if (is_position_new(engine, board)) {
+	} else if (is_position_new(engine, &board)) {
 		cassio_debug("iterative deepening.\n");
 		iterative_deepening(search, options.alpha, options.beta);
 	} else {
@@ -629,9 +635,9 @@ double engine_midgame_search(void *v, const char *position, const double alpha,
  */
 int engine_endgame_search(void *v, const char *position, const int  alpha, const int beta, const int precision)
 {
-	Engine *engine = (Engine*) v;
-	Search *search = engine->search;
-	Board board[1];
+	Engine *const engine = (Engine*) v;
+	Search *const search = engine->search;
+	Board board;
 	int player;
 	int old_score;
 	int depth;
@@ -642,13 +648,13 @@ int engine_endgame_search(void *v, const char *position, const int  alpha, const
 	}
 	
 	engine->is_searching = true;
-	player = board_set(board, position);
-	depth = board_count_empties(board);
+	player = board_set(&board, position);
+	depth = board_count_empties(&board);
 	
-	old_score = engine_open(search, board, player, alpha, beta, depth, precision);
+	old_score = engine_open(search, &board, player, alpha, beta, depth, precision);
 	
 	if (skip_search(engine, &old_score)) {
-	} else if (is_position_new(engine, board)) {
+	} else if (is_position_new(engine, &board)) {
 		cassio_debug("iterative deepening.\n");
 		iterative_deepening(search, options.alpha, options.beta);
 	} else {
@@ -669,7 +675,7 @@ int engine_endgame_search(void *v, const char *position, const int  alpha, const
  */
 void engine_stop(void *v)
 {
-	Search *search = (Search*) v;
+	Search *const search = (Search*) v;
 	if (search == NULL) {
 		engine_send("ERROR: Engine need to be initialized.");
 		return;
@@ -683,7 +689,7 @@ void engine_stop(void *v)
 void engine_loop(void)
 {
 	char *cmd = NULL, *param = NULL;
-	Engine *engine = (Engine*) engine_init();
+	Engine *const engine = (Engine*) engine_init();
 
 	// loop forever
 	for (;;) {
@@ -707,12 +713,12 @@ void engine_loop(void)
 		} else if (strcmp(cmd, "feed-hash") == 0) {
 			int depth = 21, precision = 73, player;
 			double lower = -SCORE_INF, upper = SCORE_INF;
-			Board board[1];
-			Line pv[1];
+			Board board;
+			Line pv;
 			char *string;
 			
 			errno = 0;
-			string = parse_board(param, board, &player);
+			string = parse_board(param, &board, &player);
 			if (string == param) engine_send("Error: in feed-hash, Edax cannot parse position.");
 			else {
 				string = parse_real(string, &lower);
@@ -727,9 +733,9 @@ void engine_loop(void)
 							string = parse_int(string, &precision);
 							if (errno) engine_send("Error: in feed-hash, Edax cannot parse precision.");
 							else {
-								line_init(pv, player);
-								parse_game(string, board, pv);
-								engine_feed_hash(engine, board, floor(lower), ceil(upper), depth, precision, pv);
+								line_init(&pv, player);
+								parse_game(string, &board, &pv);
+								engine_feed_hash(engine, &board, floor(lower), ceil(upper), depth, precision, &pv);
 							}
 						}
 					}
@@ -751,12 +757,12 @@ void engine_loop(void)
 		} else if (strcmp(cmd, "midgame-search") == 0) {
 			double alpha = -SCORE_INF, beta = SCORE_INF;
 			int player, depth = 60, precision = 100;
-			Board board[1];
+			Board board;
 			char b[80];
 			char *s;
 
 			errno = 0;
-			s = parse_board(param, board, &player);
+			s = parse_board(param, &board, &player);
 			if (s == param) engine_send("ERROR: midgame-search cannot parse position.");
 			else {
 				s = parse_real(s, &alpha);
@@ -770,7 +776,7 @@ void engine_loop(void)
 						else {
 							s = parse_int(s, &precision);
 							if (errno) engine_send("ERROR: midgame_search cannot parse precision.");
-							engine_midgame_search(engine, board_to_string(board, player, b), alpha, beta, depth, precision);
+							engine_midgame_search(engine, board_to_string(&board, player, b), alpha, beta, depth, precision);
 						}
 					}
 				}
@@ -780,12 +786,12 @@ void engine_loop(void)
 		} else if (strcmp(cmd, "endgame-search") == 0) {
 			int alpha = -SCORE_INF, beta = SCORE_INF;
 			int player, precision = 100;
-			Board board[1];
+			Board board;
 			char b[80];
 			char *s;
 
 			errno = 0;
-			s = parse_board(param, board, &player);
+			s = parse_board(param, &board, &player);
 			if (s == param) engine_send("ERROR: endgame_search cannot parse position.");
 			else {
 				s = parse_int(s, &alpha);
@@ -796,7 +802,7 @@ void engine_loop(void)
 					else {
 						s = parse_int(s, &precision);
 						if (errno) engine_send("ERROR: endgame_search cannot parse precision.");
-						engine_endgame_search(engine, board_to_string(board, player, b), alpha, beta, precision);
+						engine_endgame_search(engine, board_to_string(&board, player, b), alpha, beta, precision);
 					}
 				}
 			}
diff --git a/src/const.h b/src/const.h
index ef84651b..5b025d3d 100644
--- a/src/const.h
+++ b/src/const.h
@@ -3,9 +3,9 @@
  *
  * Constants as macros, enums, or global consts.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2024
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_CONST_H
@@ -15,7 +15,7 @@
 #define MAX_THREADS 64
 
 /** maximal number of moves */
-#define MAX_MOVE 32
+#define MAX_MOVE 33	// https://eukaryote.hateblo.jp/entry/2023/05/23/145945
 
 /** size of the board */
 #define BOARD_SIZE 64
@@ -45,9 +45,6 @@ enum {
 	OFF_SIDE
 };
 
-extern const unsigned long long X_TO_BIT[];
-extern const unsigned long long NEIGHBOUR[];
-
 /** infinite score: a huge value unreachable as a score and fitting in a char */
 #define SCORE_INF 127
 
@@ -77,16 +74,17 @@ typedef enum Stop {
 } Stop;
 
 /** node type */
-typedef enum {
+enum {
 	PV_NODE,
 	CUT_NODE,
 	ALL_NODE
-} NodeType;
+};
+typedef	unsigned char	NodeType;
 
 #define VERSION 4
-#define RELEASE 4
-#define VERSION_STRING "4.4"
-#define EDAX_NAME "Edax 4.4"
+#define RELEASE 5
+#define VERSION_STRING "4.5.3"
+#define EDAX_NAME "Edax 4.5.3"
 #define BOOK 0x424f4f4b
 #define EDAX 0x45444158
 #define EVAL 0x4556414c
diff --git a/src/count_last_flip_carry_32.c b/src/count_last_flip_32.c
similarity index 96%
rename from src/count_last_flip_carry_32.c
rename to src/count_last_flip_32.c
index 59b0da62..492c2668 100644
--- a/src/count_last_flip_carry_32.c
+++ b/src/count_last_flip_32.c
@@ -1,5 +1,5 @@
 /**
- * @file count_last_flip_carry_32.c
+ * @file count_last_flip_32.c
  *
  *
  * A function is provided to count the number of fipped disc of the last move
@@ -107,7 +107,7 @@ static int count_last_flip_A1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x01010100u) + ((HIDWORD(P) & 0x01010101u) << 4)) * 0x01020408u) >> 25];
+	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x01010101u) + ((HIDWORD(P) & 0x01010101u) << 4)) * 0x01020408u) >> 25];
 	n_flipped += COUNT_FLIP_R[(LODWORD(P) >> 1) & 0x7f];
 	n_flipped += COUNT_FLIP_R[(((LODWORD(P) & 0x08040200u) + (HIDWORD(P) & 0x80402010u)) * 0x01010101u) >> 25];
 
@@ -124,7 +124,7 @@ static int count_last_flip_B1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x02020200u) + ((HIDWORD(P) & 0x02020202u) << 4)) * 0x00810204u) >> 25];
+	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x02020202u) + ((HIDWORD(P) & 0x02020202u) << 4)) * 0x00810204u) >> 25];
 	n_flipped += COUNT_FLIP_R[(LODWORD(P) >> 2) & 0x3f];
 	n_flipped += COUNT_FLIP_R[(((LODWORD(P) & 0x10080400u) + (HIDWORD(P) & 0x00804020u)) * 0x01010101u) >> 26];
 
@@ -141,9 +141,9 @@ static int count_last_flip_C1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x04040400u) + ((HIDWORD(P) & 0x04040404u) << 4)) * 0x00408102u) >> 25];
+	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x04040404u) + ((HIDWORD(P) & 0x04040404u) << 4)) * 0x00408102u) >> 25];
 	n_flipped += COUNT_FLIP_2[LODWORD(P) & 0xff];
-	n_flipped += COUNT_FLIP_2[(((LODWORD(P) & 0x20110A04u) + (HIDWORD(P) & 0x00008040u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_2[(((LODWORD(P) & 0x20110A04u) + (HIDWORD(P) & 0x00008040u)) * 0x01010101u) >> 24];	// A3C1H6
 
 	return n_flipped;
 }
@@ -158,9 +158,9 @@ static int count_last_flip_D1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x08080800u) + ((HIDWORD(P) & 0x08080808u) << 4)) * 0x00204081u) >> 25];
+	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x08080808u) + ((HIDWORD(P) & 0x08080808u) << 4)) * 0x00204081u) >> 25];
 	n_flipped += COUNT_FLIP_3[LODWORD(P) & 0xff];
-	n_flipped += COUNT_FLIP_3[(((LODWORD(P) & 0x41221408u) + (HIDWORD(P) & 0x00000080u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_3[(((LODWORD(P) & 0x41221408u) + (HIDWORD(P) & 0x00000080u)) * 0x01010101u) >> 24];	// A4D1H5
 
 	return n_flipped;
 }
@@ -175,9 +175,9 @@ static int count_last_flip_E1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x10101000u) >> 4) + (HIDWORD(P) & 0x10101010u)) * 0x01020408u) >> 25];
+	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x10101010u) >> 4) + (HIDWORD(P) & 0x10101010u)) * 0x01020408u) >> 25];
 	n_flipped += COUNT_FLIP_4[LODWORD(P) & 0xff];
-	n_flipped += COUNT_FLIP_4[(((LODWORD(P) & 0x82442810u) + (HIDWORD(P) & 0x00000001u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_4[(((LODWORD(P) & 0x82442810u) + (HIDWORD(P) & 0x00000001u)) * 0x01010101u) >> 24];	// A5E1H4
 
 	return n_flipped;
 }
@@ -192,9 +192,9 @@ static int count_last_flip_F1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[(((HIDWORD(P) & 0x20202020u) + ((LODWORD(P) >> 4) & 0x02020200u)) * 0x00810204u) >> 25];
+	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x20202020u) >> 4) + (HIDWORD(P) & 0x20202020u)) * 0x00810204u) >> 25];
 	n_flipped += COUNT_FLIP_5[LODWORD(P) & 0xff];
-	n_flipped += COUNT_FLIP_5[(((LODWORD(P) & 0x04885020u) + (HIDWORD(P) & 0x00000102u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_5[(((LODWORD(P) & 0x04885020u) + (HIDWORD(P) & 0x00000102u)) * 0x01010101u) >> 24];	// A6F1H3
 
 	return n_flipped;
 }
@@ -209,7 +209,7 @@ static int count_last_flip_G1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x40404000u) >> 4) + (HIDWORD(P) & 0x40404040u)) * 0x00408102u) >> 25];
+	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x40404040u) >> 4) + (HIDWORD(P) & 0x40404040u)) * 0x00408102u) >> 25];
 	n_flipped += COUNT_FLIP_L[(LODWORD(P) << 1) & 0x7e];
 	n_flipped += COUNT_FLIP_L[(((LODWORD(P) & 0x08102000u) + (HIDWORD(P) & 0x00010204u)) * 0x02020202u) >> 24];
 
@@ -226,7 +226,7 @@ static int count_last_flip_H1(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x80808000u) >> 4) + (HIDWORD(P) & 0x80808080u)) * 0x00204081u) >> 25];
+	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x80808080u) >> 4) + (HIDWORD(P) & 0x80808080u)) * 0x00204081u) >> 25];
 	n_flipped += COUNT_FLIP_L[LODWORD(P) & 0x7f];
 	n_flipped += COUNT_FLIP_L[(((LODWORD(P) & 0x10204000u) + (HIDWORD(P) & 0x01020408u)) * 0x01010101u) >> 24];
 
@@ -279,7 +279,7 @@ static int count_last_flip_C2(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x04040000u) + ((HIDWORD(P) & 0x04040404u) << 4)) * 0x00408102u) >> 26];
 	n_flipped += COUNT_FLIP_2[(LODWORD(P) >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_2[(((LODWORD(P) & 0x110A0400u) + (HIDWORD(P) & 0x00804020u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_2[(((LODWORD(P) & 0x110A0400u) + (HIDWORD(P) & 0x00804020u)) * 0x01010101u) >> 24];	// A4C2H7
 
 	return n_flipped;
 }
@@ -296,7 +296,7 @@ static int count_last_flip_D2(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_R[(((LODWORD(P) & 0x08080000u) + ((HIDWORD(P) & 0x08080808u) << 4)) * 0x00204081u) >> 26];
 	n_flipped += COUNT_FLIP_3[(LODWORD(P) >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_3[(((LODWORD(P) & 0x22140800u) + (HIDWORD(P) & 0x00008041u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_3[(((LODWORD(P) & 0x22140800u) + (HIDWORD(P) & 0x00008041u)) * 0x01010101u) >> 24];	// A5D2H6
 
 	return n_flipped;
 }
@@ -313,7 +313,7 @@ static int count_last_flip_E2(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_R[((((LODWORD(P) & 0x10100000u) >> 4) + (HIDWORD(P) & 0x10101010u)) * 0x01020408u) >> 26];
 	n_flipped += COUNT_FLIP_4[(LODWORD(P) >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_4[(((LODWORD(P) & 0x44281000u) + (HIDWORD(P) & 0x00000182u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_4[(((LODWORD(P) & 0x44281000u) + (HIDWORD(P) & 0x00000182u)) * 0x01010101u) >> 24];	// A6E2H5
 
 	return n_flipped;
 }
@@ -330,7 +330,7 @@ static int count_last_flip_F2(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_R[(((HIDWORD(P) & 0x20202020u) + ((LODWORD(P) & 0x20200000u) >> 4)) * 0x00810204u) >> 26];
 	n_flipped += COUNT_FLIP_5[(LODWORD(P) >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_5[(((LODWORD(P) & 0x88502000u) + (HIDWORD(P) & 0x00010204u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_5[(((LODWORD(P) & 0x88502000u) + (HIDWORD(P) & 0x00010204u)) * 0x01010101u) >> 24];	// A7F2H4
 
 	return n_flipped;
 }
@@ -975,7 +975,7 @@ static int count_last_flip_C7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[(((LODWORD(P) & 0x04040404u) + ((HIDWORD(P) & 0x00000404u) << 4)) * 0x00810204u) >> 24];
 	n_flipped += COUNT_FLIP_2[(HIDWORD(P) >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_2[(((HIDWORD(P) & 0x00040A11u) + (LODWORD(P) & 0x20408000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_2[(((HIDWORD(P) & 0x00040A11u) + (LODWORD(P) & 0x20408000u)) * 0x01010101u) >> 24];	// A5C7H2
 
 	return n_flipped;
 }
@@ -992,7 +992,7 @@ static int count_last_flip_D7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((((HIDWORD(P) & 0x00000808u) << 4) + (LODWORD(P) & 0x08080808u)) * 0x00408102u) >> 24];
 	n_flipped += COUNT_FLIP_3[(HIDWORD(P) >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_3[(((HIDWORD(P) & 0x00081422u) + (LODWORD(P) & 0x41800000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_3[(((HIDWORD(P) & 0x00081422u) + (LODWORD(P) & 0x41800000u)) * 0x01010101u) >> 24];	// A4D7H3
 
 	return n_flipped;
 }
@@ -1009,7 +1009,7 @@ static int count_last_flip_E7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[(((HIDWORD(P) & 0x00001010u) + ((LODWORD(P) & 0x10101010u) >> 4)) * 0x02040810u) >> 24];
 	n_flipped += COUNT_FLIP_4[(HIDWORD(P) >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_4[(((HIDWORD(P) & 0x00102844u) + (LODWORD(P) & 0x82010000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_4[(((HIDWORD(P) & 0x00102844u) + (LODWORD(P) & 0x82010000u)) * 0x01010101u) >> 24];	// A3E7H4
 
 	return n_flipped;
 }
@@ -1026,7 +1026,7 @@ static int count_last_flip_F7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[(((HIDWORD(P) & 0x00002020u) + ((LODWORD(P) & 0x20202020u) >> 4)) * 0x01020408u) >> 24];
 	n_flipped += COUNT_FLIP_5[(HIDWORD(P) >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_5[(((HIDWORD(P) & 0x00205088u) + (LODWORD(P) & 0x04020100u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_5[(((HIDWORD(P) & 0x00205088u) + (LODWORD(P) & 0x04020100u)) * 0x01010101u) >> 24];	// A2F7H5
 
 	return n_flipped;
 }
@@ -1111,7 +1111,7 @@ static int count_last_flip_C8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[(((LODWORD(P) & 0x04040404u) + ((HIDWORD(P) & 0x00040404u) << 4)) * 0x00408102u) >> 24];
 	n_flipped += COUNT_FLIP_2[HIDWORD(P) >> 24];
-	n_flipped += COUNT_FLIP_2[(((HIDWORD(P) & 0x040A1120u) + (LODWORD(P) & 0x40800000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_2[(((HIDWORD(P) & 0x040A1120u) + (LODWORD(P) & 0x40800000u)) * 0x01010101u) >> 24];	// A6C8H3
 
 	return n_flipped;
 }
@@ -1128,7 +1128,7 @@ static int count_last_flip_D8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((((HIDWORD(P) & 0x00080808u) << 4) + (LODWORD(P) & 0x08080808u)) * 0x00204081u) >> 24];
 	n_flipped += COUNT_FLIP_3[HIDWORD(P) >> 24];
-	n_flipped += COUNT_FLIP_3[(((HIDWORD(P) & 0x08142241u) + (LODWORD(P) & 0x80000000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_3[(((HIDWORD(P) & 0x08142241u) + (LODWORD(P) & 0x80000000u)) * 0x01010101u) >> 24];	// A5D8H4
 
 	return n_flipped;
 }
@@ -1145,7 +1145,7 @@ static int count_last_flip_E8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[(((HIDWORD(P) & 0x00101010u) + ((LODWORD(P) & 0x10101010u) >> 4)) * 0x01020408u) >> 24];
 	n_flipped += COUNT_FLIP_4[HIDWORD(P) >> 24];
-	n_flipped += COUNT_FLIP_4[(((HIDWORD(P) & 0x10284482u) + (LODWORD(P) & 0x01000000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_4[(((HIDWORD(P) & 0x10284482u) + (LODWORD(P) & 0x01000000u)) * 0x01010101u) >> 24];	// A4E8H5
 
 	return n_flipped;
 }
@@ -1162,7 +1162,7 @@ static int count_last_flip_F8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[(((HIDWORD(P) & 0x00202020u) + ((LODWORD(P) & 0x20202020u) >> 4)) * 0x00810204u) >> 24];
 	n_flipped += COUNT_FLIP_5[HIDWORD(P) >> 24];
-	n_flipped += COUNT_FLIP_5[(((HIDWORD(P) & 0x00508804u) + (LODWORD(P) & 0x02010000u)) * 0x01010101u) >> 24];
+	n_flipped += COUNT_FLIP_5[(((HIDWORD(P) & 0x00508804u) + (LODWORD(P) & 0x02010000u)) * 0x01010101u) >> 24];	// A3F8H6
 
 	return n_flipped;
 }
@@ -1214,7 +1214,7 @@ static int count_last_flip_pass(const unsigned long long P)
 }
 
 /** Array of functions to count flipped discs of the last move */
-int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
+int (*count_last_flip[])(const unsigned long long) = {
 	count_last_flip_A1, count_last_flip_B1, count_last_flip_C1, count_last_flip_D1,
 	count_last_flip_E1, count_last_flip_F1, count_last_flip_G1, count_last_flip_H1,
 	count_last_flip_A2, count_last_flip_B2, count_last_flip_C2, count_last_flip_D2,
@@ -1233,9 +1233,3 @@ int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
 	count_last_flip_E8, count_last_flip_F8, count_last_flip_G8, count_last_flip_H8,
 	count_last_flip_pass,
 };
-
-int count_last_flip(const int x, const unsigned long long P)
-{
-	return COUNT_LAST_FLIP[x](P);
-}
-
diff --git a/src/count_last_flip_avx512cd.c b/src/count_last_flip_avx512cd.c
new file mode 100644
index 00000000..54de932a
--- /dev/null
+++ b/src/count_last_flip_avx512cd.c
@@ -0,0 +1,51 @@
+/**
+ * @file count_last_flip_avx512cd.c
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * Count last flip using the flip_avx512cd way.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 2023 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include "bit.h"
+
+extern	const V8DI lrmask[66];
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+int last_flip(int pos, unsigned long long P)
+{
+	__m256i PP = _mm256_set1_epi64x(P);
+	__m256i	flip, outflank, eraser, rmask, lmask;
+	__m128i	flip2;
+
+		// left: look for player LS1B
+	lmask = lrmask[pos].v4[0];
+	outflank = _mm256_and_si256(PP, lmask);
+		// set below LS1B if P is in lmask
+	flip = _mm256_maskz_add_epi64(_mm256_test_epi64_mask(PP, lmask), outflank, _mm256_set1_epi64x(-1));
+	// flip = _mm256_and_si256(_mm256_andnot_si256(outflank, flip), lmask);
+	flip = _mm256_ternarylogic_epi64(outflank, flip, lmask, 0x08);
+
+		// right: look for player bit with lzcnt
+	rmask = lrmask[pos].v4[1];
+	eraser = _mm256_srlv_epi64(_mm256_set1_epi64x(-1),
+		_mm256_maskz_lzcnt_epi64(_mm256_test_epi64_mask(PP, rmask), _mm256_and_si256(PP, rmask)));
+	// flip = _mm256_or_si256(flip, _mm256_andnot_si256(eraser, rmask));
+	flip = _mm256_ternarylogic_epi64(flip, eraser, rmask, 0xf2);
+
+	flip2 = _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+	return 2 * bit_count(_mm_cvtsi128_si64(_mm_or_si128(flip2, _mm_unpackhi_epi64(flip2, flip2))));
+}
diff --git a/src/count_last_flip_avx_ppfill.c b/src/count_last_flip_avx_ppfill.c
new file mode 100644
index 00000000..073bc55b
--- /dev/null
+++ b/src/count_last_flip_avx_ppfill.c
@@ -0,0 +1,57 @@
+/**
+ * @file count_last_flip_avx_ppfill.c
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * Count last flip using the flip_avx_ppfill way.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 2023
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include "bit.h"
+
+extern	const V4DI lmask_v4[66], rmask_v4[66];
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+int last_flip(int pos, unsigned long long P)
+{
+	__m256i PP = _mm256_set1_epi64x(P);
+	__m256i	flip, outflank, eraser, rmask, lmask;
+	__m128i	flip2;
+
+	rmask = rmask_v4[pos].v4;
+		// isolate player MS1B by clearing lower shadow bits
+	outflank = _mm256_and_si256(PP, rmask);
+	eraser = _mm256_srlv_epi64(outflank, _mm256_set_epi64x(7, 9, 8, 1));
+		// eraser = player's shadow
+	eraser = _mm256_or_si256(eraser, outflank);
+	eraser = _mm256_or_si256(eraser, _mm256_srlv_epi64(eraser, _mm256_set_epi64x(14, 18, 16, 2)));
+	flip = _mm256_andnot_si256(eraser, rmask);
+	flip = _mm256_andnot_si256(_mm256_srlv_epi64(eraser, _mm256_set_epi64x(28, 36, 32, 4)), flip);
+		// clear if no player bit, i.e. all opponent
+	flip = _mm256_andnot_si256(_mm256_cmpeq_epi64(flip, rmask), flip);
+
+	lmask = lmask_v4[pos].v4;
+		// look for player LS1B
+	outflank = _mm256_and_si256(PP, lmask);
+	outflank = _mm256_and_si256(outflank, _mm256_sub_epi64(_mm256_setzero_si256(), outflank));	// LS1B
+		// set all bits if outflank = 0, otherwise higher bits than outflank
+	eraser = _mm256_sub_epi64(_mm256_cmpeq_epi64(outflank, _mm256_setzero_si256()), outflank);
+	flip = _mm256_or_si256(flip, _mm256_andnot_si256(eraser, lmask));
+
+	flip2 = _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+	flip2 = _mm_or_si128(flip2, _mm_shuffle_epi32(flip2, 0x4e));
+	return 2 * bit_count(_mm_cvtsi128_si64(flip2));
+}
diff --git a/src/count_last_flip_bitscan.c b/src/count_last_flip_bitscan.c
index e7a69127..6cae24ac 100644
--- a/src/count_last_flip_bitscan.c
+++ b/src/count_last_flip_bitscan.c
@@ -27,27 +27,14 @@
  * For top to bottom flip, LS1B isolation (http://chessprogramming.wikispaces.com/
  * General+Setwise+Operations) is used to get the outflank bit.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2018
  * @author Richard Delorme
  * @author Toshihiko Okuhara
  * @version 4.4
  * 
  */
 
-#include <x86intrin.h>
-
 /** precomputed count flip array */
-static const char COUNT_FLIP_R[128] = {
-	 0,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	 8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	10,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	 8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	12,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	 8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	10,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
-	 8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0
-};
-
 static const char COUNT_FLIP_2[256] = {
 	 0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
 	 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
@@ -92,6 +79,28 @@ static const char COUNT_FLIP_5[256] = {
 	 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 };
 
+#include "bit_intrinsics.h"
+
+#ifdef lzcnt_u64
+
+static inline int count_V_flip_reverse (unsigned long long P, int ofs) {
+	return (lzcnt_u64(P << ofs) & 0x38) >> 2;
+}
+
+static inline int count_H_flip_left (unsigned long long P, int pos, int mask) {
+	if (pos < 8)
+		return (lzcnt_u32((P << (8 - pos)) & (mask << 1)) & 0x07) * 2;
+	else
+		return (lzcnt_u32((P >> (pos - 8)) & (mask << 1)) & 0x07) * 2;
+}
+
+#else
+
+// with guardian bit to avoid __builtin_clz(0)	// Not used
+static inline int count_V_flip_reverse (unsigned long long P, int ofs) {
+	return ((__builtin_clzll((P << ofs) | 1) + 1) & 0x38) >> 2;
+}
+
 static const char COUNT_FLIP_L[128] = {
 	 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 	 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
@@ -99,369 +108,302 @@ static const char COUNT_FLIP_L[128] = {
 	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 };
 
-#ifdef __LZCNT__
-static inline int count_V_flip_reverse (unsigned long long P, int ofs) {
-	return ((__lzcnt64(P) - ofs) >> 2) & 0x0E;
-}
-#else
-// with guardian bit to avoid __builtin_clz(0)
-static inline int count_V_flip_reverse (unsigned long long P, int ofs) {
-	return ((__builtin_clzll((P << ofs) | 1) + 1) >> 2) & 0x0E;
+static inline int count_H_flip_left (unsigned long long P, int pos, int mask) {
+	if (pos < 8)
+		return COUNT_FLIP_L[(P << (7 - pos)) & mask];
+	else
+		return COUNT_FLIP_L[(P >> (pos - 7)) & mask];
 }
-#endif
 
-/**
- * Count last flipped discs when playing on square A1.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_A1(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v, P_d9;
+#endif
 
-	P_v = P & 0x0101010101010100ULL;
-	n_flipped  = ((P_v & -P_v) * 0x000020406080a0c0ULL) >> 60;
-	n_flipped += COUNT_FLIP_R[(P >> 1) & 0x7f];
-	P_d9 = (P & 0x8040201008040200ULL) >> 8;
-	n_flipped += ((P_d9 & -P_d9) * 0x0008080604028180ULL) >> 60;
+#ifdef tzcnt_u32
 
-	return n_flipped;
+static inline int count_H_flip_right (unsigned long long P, int pos) {
+	if (pos >= 56)
+		return (tzcnt_u32(P >> (pos + 1)) & 0x07) * 2;
+	else if ((pos >= 24) && (pos < 32))
+		return (tzcnt_u32((unsigned int) P >> (pos + 1)) & 0x07) * 2;
+	else
+		return (tzcnt_u32((P >> (pos + 1)) & (0x7f >> (pos & 0x07))) & 0x07) * 2;
 }
 
-/**
- * Count last flipped discs when playing on square B1.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_B1(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v, P_d9;
+#else
 
-	P_v = P & 0x0202020202020200ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000102030405060ULL) >> 60;
-	n_flipped += COUNT_FLIP_R[(P >> 2) & 0x3f];
-	P_d9 = P & 0x0080402010080400ULL;
-	n_flipped += ((P_d9 & -P_d9) * 0x0000040403020140ULL) >> 60;
+static const char COUNT_FLIP_R[128] = {
+	 0,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,  8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
+	10,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,  8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
+	12,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,  8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,
+	10,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0,  8,  0,  2,  0,  4,  0,  2,  0,  6,  0,  2,  0,  4,  0,  2,  0
+};
 
-	return n_flipped;
+static inline int count_H_flip_right (unsigned long long P, int pos) {
+	if (pos >= 56)
+		return COUNT_FLIP_R[P >> (pos + 1)];
+	else if ((pos >= 24) && (pos < 32))
+		return COUNT_FLIP_R[(unsigned int) P >> (pos + 1)];
+	else
+		return COUNT_FLIP_R[(P >> (pos + 1)) & (0x7f >> (pos & 0x07))];
 }
 
+#endif
+
+#ifndef lzcnt_u64
+
 /**
- * Count last flipped discs when playing on square C1.
+ * Count last flipped discs when playing on square A1/A2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_C1(const unsigned long long P)
+static int count_last_flip_A1(const unsigned long long P)
 {
 	int n_flipped;
-	unsigned long long P_v;
+	unsigned long long P_v, P_d9;
 
-	P_v = P & 0x0404040404040400ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000081018202830ULL) >> 60;
-	n_flipped += COUNT_FLIP_2[P & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x0000804020110A04ULL) * 0x0101010101010101ULL) >> 56];
+	P_v = P & 0x0101010101010100;
+	n_flipped  = ((P_v & -P_v) * 0x000020406080a0c0) >> 60;
+	n_flipped += count_H_flip_right(P, 0);
+	P_d9 = P & 0x8040201008040200;
+	n_flipped += (((P_d9 & -P_d9) >> 1) * 0x000010100c080503) >> 60;
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square D1.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_D1(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v;
+static int count_last_flip_A2(const unsigned long long P) {
+	return count_last_flip_A1(P >> 8);
+}
 
-	P_v = P & 0x0808080808080800ULL;
-	n_flipped  = ((P_v & -P_v) * 0x000004080c101418ULL) >> 60;
-	n_flipped += COUNT_FLIP_3[P & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0000008041221408ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_A8(const unsigned long long P) {
+	return count_last_flip_A1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_A7(const unsigned long long P) {
+	return count_last_flip_A1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square E1.
+ * Count last flipped discs when playing on square B1/B2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_E1(const unsigned long long P)
+static int count_last_flip_B1(const unsigned long long P)
 {
 	int n_flipped;
-	unsigned long long P_v;
+	unsigned long long P_v, P_d9;
 
-	P_v = P & 0x1010101010101000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000020406080a0cULL) >> 60;
-	n_flipped += COUNT_FLIP_4[P & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0000000182442810ULL) * 0x0101010101010101ULL) >> 56];
+	P_v = P & 0x0202020202020200;
+	n_flipped  = ((P_v & -P_v) * 0x0000102030405060) >> 60;
+	n_flipped += count_H_flip_right(P, 1);
+	P_d9 = P & 0x0080402010080400;
+	n_flipped += ((P_d9 & -P_d9) * 0x0000040403020140) >> 60;
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square F1.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_F1(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v;
+static int count_last_flip_B2(const unsigned long long P) {
+	return count_last_flip_B1(P >> 8);
+}
 
-	P_v = P & 0x2020202020202000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000010203040506ULL) >> 60;
-	n_flipped += COUNT_FLIP_5[P & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0000010204885020ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_B8(const unsigned long long P) {
+	return count_last_flip_B1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_B7(const unsigned long long P) {
+	return count_last_flip_B1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square G1.
+ * Count last flipped discs when playing on square C1/C2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_G1(const unsigned long long P)
+static int count_last_flip_C1(const unsigned long long P)
 {
 	int n_flipped;
-	unsigned long long P_v, P_d7;
+	unsigned long long P_v;
 
-	P_v = P & 0x4040404040404000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000008101820283ULL) >> 60;
-	n_flipped += COUNT_FLIP_L[(P << 1) & 0x7e];
-	P_d7 = P & 0x0001020408102000ULL;
-	n_flipped += ((P_d7 & -P_d7) * 0x000002081840a000ULL) >> 60;
+	P_v = P & 0x0404040404040400;
+	n_flipped  = ((P_v & -P_v) * 0x0000081018202830) >> 60;
+	n_flipped += COUNT_FLIP_2[P & 0xff];
+	n_flipped += COUNT_FLIP_2[((P & 0x0000804020110A04) * 0x0101010101010101) >> 56];	// A3C1H6
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square H1.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_H1(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v, P_d7;
+static int count_last_flip_C2(const unsigned long long P) {
+	return count_last_flip_C1(P >> 8);
+}
 
-	P_v = (P & 0x8080808080808000ULL) >> 1;
-	n_flipped  = ((P_v & -P_v) * 0x0000008101820283ULL) >> 60;
-	n_flipped += COUNT_FLIP_L[P & 0x7f];
-	P_d7 = P & 0x0102040810204000ULL;
-	n_flipped += ((P_d7 & -P_d7) * 0x000001040c2050c0ULL) >> 60;
+static int count_last_flip_C8(const unsigned long long P) {
+	return count_last_flip_C1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_C7(const unsigned long long P) {
+	return count_last_flip_C1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square A2.
+ * Count last flipped discs when playing on square D1/D2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_A2(const unsigned long long P)
+static int count_last_flip_D1(const unsigned long long P)
 {
 	int n_flipped;
-	unsigned long long P_v, P_d9;
+	unsigned long long P_v;
 
-	P_v = P & 0x0101010101010000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x00000020406080a0ULL) >> 60;
-	n_flipped += COUNT_FLIP_R[(P >> 9) & 0x7f];
-	P_d9 = (P & 0x4020100804020000ULL) >> 8;
-	n_flipped += ((P_d9 & -P_d9) * 0x0000080806040280ULL) >> 60;
+	P_v = P & 0x0808080808080800;
+	n_flipped  = ((P_v & -P_v) * 0x000004080c101418) >> 60;
+	n_flipped += COUNT_FLIP_3[P & 0xff];
+	n_flipped += COUNT_FLIP_3[((P & 0x0000008041221408) * 0x0101010101010101) >> 56];	// A4D1H5
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square B2.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_B2(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v, P_d9;
+static int count_last_flip_D2(const unsigned long long P) {
+	return count_last_flip_D1(P >> 8);
+}
 
-	P_v = P & 0x0202020202020000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000001020304050ULL) >> 60;
-	n_flipped += COUNT_FLIP_R[(P >> 10) & 0x3f];
-	P_d9 = (P & 0x8040201008040000ULL) >> 8;
-	n_flipped += ((P_d9 & -P_d9) * 0x0000040403020140ULL) >> 60;
+static int count_last_flip_D8(const unsigned long long P) {
+	return count_last_flip_D1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_D7(const unsigned long long P) {
+	return count_last_flip_D1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square C2.
+ * Count last flipped discs when playing on square E1/E2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_C2(const unsigned long long P)
+static int count_last_flip_E1(const unsigned long long P)
 {
 	int n_flipped;
 	unsigned long long P_v;
 
-	P_v = P & 0x0404040404040000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000000810182028ULL) >> 60;
-	n_flipped += COUNT_FLIP_2[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x00804020110A0400ULL) * 0x0101010101010101ULL) >> 56];
+	P_v = P & 0x1010101010101000;
+	n_flipped  = ((P_v & -P_v) * 0x0000020406080a0c) >> 60;
+	n_flipped += COUNT_FLIP_4[P & 0xff];
+	n_flipped += COUNT_FLIP_4[((P & 0x0000000182442810) * 0x0101010101010101) >> 56];	// A5E1H4
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square D2.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_D2(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v;
+static int count_last_flip_E2(const unsigned long long P) {
+	return count_last_flip_E1(P >> 8);
+}
 
-	P_v = P & 0x0808080808080000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x00000004080c1014ULL) >> 60;
-	n_flipped += COUNT_FLIP_3[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0000804122140800ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_E8(const unsigned long long P) {
+	return count_last_flip_E1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_E7(const unsigned long long P) {
+	return count_last_flip_E1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square E2.
+ * Count last flipped discs when playing on square F1/F2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_E2(const unsigned long long P)
+static int count_last_flip_F1(const unsigned long long P)
 {
 	int n_flipped;
 	unsigned long long P_v;
 
-	P_v = P & 0x1010101010100000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x000000020406080aULL) >> 60;
-	n_flipped += COUNT_FLIP_4[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0000018244281000ULL) * 0x0101010101010101ULL) >> 56];
+	P_v = P & 0x2020202020202000;
+	n_flipped  = ((P_v & -P_v) * 0x0000010203040506) >> 60;
+	n_flipped += COUNT_FLIP_5[P & 0xff];
+	n_flipped += COUNT_FLIP_5[((P & 0x0000010204885020) * 0x0101010101010101) >> 56];	// A6F1H3
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square F2.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_F2(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v;
+static int count_last_flip_F2(const unsigned long long P) {
+	return count_last_flip_F1(P >> 8);
+}
 
-	P_v = P & 0x2020202020200000ULL;
-	n_flipped  = ((P_v & -P_v) * 0x0000000102030405ULL) >> 60;
-	n_flipped += COUNT_FLIP_5[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0001020488502000ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_F8(const unsigned long long P) {
+	return count_last_flip_F1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_F7(const unsigned long long P) {
+	return count_last_flip_F1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square G2.
+ * Count last flipped discs when playing on square G1/G2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_G2(const unsigned long long P)
+static int count_last_flip_G1(const unsigned long long P)
 {
 	int n_flipped;
 	unsigned long long P_v, P_d7;
 
-	P_v = (P & 0x4040404040400000ULL) >> 1;
-	n_flipped  = ((P_v & -P_v) * 0x0000000102030405ULL) >> 60;
-	n_flipped += COUNT_FLIP_L[(P >> 7) & 0x7e];
-	P_d7 = P & 0x0102040810200000ULL;
-	n_flipped += ((P_d7 & -P_d7) * 0x00000002081840a0ULL) >> 60;
+	P_v = P & 0x4040404040404000;
+	n_flipped  = ((P_v & -P_v) * 0x0000008101820283) >> 60;
+	n_flipped += count_H_flip_left(P, 6, 0x7e);
+	P_d7 = P & 0x0001020408102000;
+	n_flipped += ((P_d7 & -P_d7) * 0x000002081840a000) >> 60;
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square H2.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_H2(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_v, P_d7;
+static int count_last_flip_G2(const unsigned long long P) {
+	return count_last_flip_G1(P >> 8);
+}
 
-	P_v = (P & 0x8080808080800000ULL) >> 2;
-	n_flipped  = ((P_v & -P_v) * 0x0000000102030405ULL) >> 60;
-	n_flipped += COUNT_FLIP_L[(P >> 8) & 0x7f];
-	P_d7 = (P & 0x0204081020400000ULL) >> 2;
-	n_flipped += ((P_d7 & -P_d7) * 0x0000000410308143ULL) >> 60;
+static int count_last_flip_G8(const unsigned long long P) {
+	return count_last_flip_G1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_G7(const unsigned long long P) {
+	return count_last_flip_G1(vertical_mirror(P) >> 8);
 }
 
 /**
- * Count last flipped discs when playing on square A3.
+ * Count last flipped discs when playing on square H1/H2.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_A3(const unsigned long long P)
+static int count_last_flip_H1(const unsigned long long P)
 {
 	int n_flipped;
-	unsigned long long P_d9;
+	unsigned long long P_v, P_d7;
 
-	n_flipped  = COUNT_FLIP_2[((P & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56];
-	n_flipped += COUNT_FLIP_R[(P >> 17) & 0x7f];
-	P_d9 = P & 0x2010080402000000ULL;
-	n_flipped += ((P_d9 & -P_d9) * 0x0000000008080604ULL) >> 60;
-	n_flipped += (P >> 1) & (~P >> 8) & 2;
+	P_v = P & 0x8080808080808000;
+	n_flipped  = (((P_v & -P_v) >> 1) * 0x0000008101820283) >> 60;
+	n_flipped += count_H_flip_left(P, 7, 0x7f);
+	P_d7 = P & 0x0102040810204000;
+	n_flipped += ((P_d7 & -P_d7) * 0x000001040c2050c0) >> 60;
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square B3.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_B3(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_d9;
+static int count_last_flip_H2(const unsigned long long P) {
+	return count_last_flip_H1(P >> 8);
+}
 
-	n_flipped  = COUNT_FLIP_2[((P & 0x0202020202020202ULL) * 0x0081020408102040ULL) >> 56];
-	n_flipped += COUNT_FLIP_R[(P >> 18) & 0x3f];
-	P_d9 = P & 0x4020100804000000ULL;
-	n_flipped += ((P_d9 & -P_d9) * 0x0000000004040302ULL) >> 60;
-	n_flipped += (P >> 2) & (~P >> 9) & 2;
+static int count_last_flip_H8(const unsigned long long P) {
+	return count_last_flip_H1(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_H7(const unsigned long long P) {
+	return count_last_flip_H1(vertical_mirror(P) >> 8);
 }
 
+#endif // no lzcnt_u64
+
 /**
  * Count last flipped discs when playing on square C3.
  *
@@ -472,10 +414,10 @@ static int count_last_flip_C3(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_2[((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56];
+	n_flipped  = COUNT_FLIP_2[((P & 0x0404040404040404) * 0x0040810204081020) >> 56];
 	n_flipped += COUNT_FLIP_2[(P >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x0000000102040810ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_2[((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x0000000102040810) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x8040201008040201) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -490,10 +432,10 @@ static int count_last_flip_D3(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_2[((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56];
+	n_flipped  = COUNT_FLIP_2[((P & 0x0808080808080808) * 0x0020408102040810) >> 56];
 	n_flipped += COUNT_FLIP_3[(P >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0000010204081020ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_3[((P & 0x0080402010080402ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0000010204081020) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0080402010080402) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -508,10 +450,10 @@ static int count_last_flip_E3(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_2[((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56];
+	n_flipped  = COUNT_FLIP_2[((P & 0x1010101010101010) * 0x0010204081020408) >> 56];
 	n_flipped += COUNT_FLIP_4[(P >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0001020408102040ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_4[((P & 0x0000804020100804ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0001020408102040) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0000804020100804) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -526,50 +468,10 @@ static int count_last_flip_F3(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_2[((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56];
+	n_flipped  = COUNT_FLIP_2[((P & 0x2020202020202020) * 0x0008102040810204) >> 56];
 	n_flipped += COUNT_FLIP_5[(P >> 16) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_5[((P & 0x0000008040201008ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
-}
-
-/**
- * Count last flipped discs when playing on square G3.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_G3(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_d7;
-
-	n_flipped  = COUNT_FLIP_2[((P & 0x4040404040404040ULL) * 0x0004081020408102ULL) >> 56];
-	n_flipped += COUNT_FLIP_L[(P >> 15) & 0x7e];
-	P_d7 = P & 0x0204081020000000ULL;
-	n_flipped += ((P_d7 & -P_d7) * 0x0000000002081840ULL) >> 60;
-	n_flipped += (P >> 3) & (~P >> 12) & 2;
-
-	return n_flipped;
-}
-
-/**
- * Count last flipped discs when playing on square H3.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_H3(const unsigned long long P)
-{
-	int n_flipped;
-	unsigned long long P_d7;
-
-	n_flipped  = COUNT_FLIP_2[((P & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56];
-	n_flipped += COUNT_FLIP_L[(P >> 16) & 0x7f];
-	P_d7 = P & 0x0408102040000000ULL;
-	n_flipped += ((P_d7 & -P_d7) * 0x0000000001040c20ULL) >> 60;
-	n_flipped += (P >> 4) & (~P >> 13) & 2;
+	n_flipped += COUNT_FLIP_5[((P & 0x0102040810204080) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0000008040201008) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -584,9 +486,9 @@ static int count_last_flip_A4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x1008040201010101ULL) * 0x0102040808080808ULL) >> 56];	// A1A4E8
-	n_flipped += COUNT_FLIP_R[(P >> 25) & 0x7f];
-	n_flipped += COUNT_FLIP_4[((P & 0x0101010101020408ULL) * 0x1010101008040201ULL) >> 56];	// D1A4A8
+	n_flipped  = COUNT_FLIP_3[((P & 0x1008040201010101) * 0x0102040808080808) >> 56];	// A1A4E8
+	n_flipped += count_H_flip_right(P, 24);
+	n_flipped += COUNT_FLIP_4[((P & 0x0101010101020408) * 0x1010101008040201) >> 56];	// D1A4A8
 
 	return n_flipped;
 }
@@ -601,9 +503,9 @@ static int count_last_flip_B4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x2010080402020202ULL) * 0x0081020404040404ULL) >> 56];	// B1B4F8
-	n_flipped += COUNT_FLIP_R[(P >> 26) & 0x3f];
-	n_flipped += COUNT_FLIP_4[(((P & 0x0202020202040810ULL) >> 1) * 0x1010101008040201ULL) >> 56];	// E1B4B8
+	n_flipped  = COUNT_FLIP_3[((P & 0x2010080402020202) * 0x0081020404040404) >> 56];	// B1B4F8
+	n_flipped += count_H_flip_right(P, 25);
+	n_flipped += COUNT_FLIP_4[(((P & 0x0202020202040810) >> 1) * 0x1010101008040201) >> 56];	// E1B4B8
 
 	return n_flipped;
 }
@@ -618,10 +520,10 @@ static int count_last_flip_C4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56];
+	n_flipped  = COUNT_FLIP_3[((P & 0x0404040404040404) * 0x0040810204081020) >> 56];
 	n_flipped += COUNT_FLIP_2[(P >> 24) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x0000010204081020ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_2[((P & 0x4020100804020100ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x0000010204081020) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x4020100804020100) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -636,10 +538,10 @@ static int count_last_flip_D4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56];
+	n_flipped  = COUNT_FLIP_3[((P & 0x0808080808080808) * 0x0020408102040810) >> 56];
 	n_flipped += COUNT_FLIP_3[(P >> 24) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0001020408102040ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_3[((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0001020408102040) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x8040201008040201) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -654,10 +556,10 @@ static int count_last_flip_E4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56];
+	n_flipped  = COUNT_FLIP_3[((P & 0x1010101010101010) * 0x0010204081020408) >> 56];
 	n_flipped += COUNT_FLIP_4[(P >> 24) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_4[((P & 0x0080402010080402ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0102040810204080) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0080402010080402) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -672,10 +574,10 @@ static int count_last_flip_F4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56];
+	n_flipped  = COUNT_FLIP_3[((P & 0x2020202020202020) * 0x0008102040810204) >> 56];
 	n_flipped += COUNT_FLIP_5[(P >> 24) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0204081020408000ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_5[((P & 0x0000804020100804ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0204081020408000) * 0x0101010101010101) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0000804020100804) * 0x0101010101010101) >> 56];
 
 	return n_flipped;
 }
@@ -690,9 +592,9 @@ static int count_last_flip_G4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x4040404040201008ULL) * 0x0020202020408102ULL) >> 56];	// D1G4G8
-	n_flipped += COUNT_FLIP_L[(P >> 23) & 0x7e];
-	n_flipped += COUNT_FLIP_4[(((P & 0x0408102040404040ULL) >> 2) * 0x0804020101010101ULL) >> 56];	// G1G4C8
+	n_flipped  = COUNT_FLIP_3[((P & 0x4040404040201008) * 0x0020202020408102) >> 56];	// D1G4G8
+	n_flipped += count_H_flip_left(P, 30, 0x7e);
+	n_flipped += COUNT_FLIP_4[(((P & 0x0408102040404040) >> 2) * 0x0804020101010101) >> 56];	// G1G4C8
 
 	return n_flipped;
 }
@@ -707,9 +609,9 @@ static int count_last_flip_H4(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_3[((P & 0x8080808080402010ULL) * 0x0010101010204081ULL) >> 56];	// E1H4H8
-	n_flipped += COUNT_FLIP_L[(P >> 24) & 0x7f];
-	n_flipped += COUNT_FLIP_4[(((P & 0x0810204080808080ULL) >> 3) * 0x0804020101010101ULL) >> 56];	// H1H4D8
+	n_flipped  = COUNT_FLIP_3[((P & 0x8080808080402010) * 0x0010101010204081) >> 56];	// E1H4H8
+	n_flipped += count_H_flip_left(P, 31, 0x7f);
+	n_flipped += COUNT_FLIP_4[(((P & 0x0810204080808080) >> 3) * 0x0804020101010101) >> 56];	// H1H4D8
 
 	return n_flipped;
 }
@@ -720,15 +622,8 @@ static int count_last_flip_H4(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_A5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x0804020101010101ULL) * 0x0102040810101010ULL) >> 56];	// A1A5D8
-	n_flipped += COUNT_FLIP_R[(P >> 33) & 0x7f];
-	n_flipped += COUNT_FLIP_3[((P & 0x0101010102040810ULL) * 0x0808080808040201ULL) >> 56];	// E1A5A8
-
-	return n_flipped;
+static int count_last_flip_A5(const unsigned long long P) {
+	return count_last_flip_A4(vertical_mirror(P));
 }
 
 /**
@@ -737,15 +632,8 @@ static int count_last_flip_A5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_B5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x1008040202020202ULL) * 0x0081020408080808ULL) >> 56];	// B1B5E8
-	n_flipped += COUNT_FLIP_R[(P >> 34) & 0x3f];
-	n_flipped += COUNT_FLIP_3[(((P & 0x0202020204081020ULL) >> 1) * 0x0808080808040201ULL) >> 56];	// F1B5B8
-
-	return n_flipped;
+static int count_last_flip_B5(const unsigned long long P) {
+	return count_last_flip_B4(vertical_mirror(P));
 }
 
 /**
@@ -754,16 +642,8 @@ static int count_last_flip_B5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_C5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56];
-	n_flipped += COUNT_FLIP_2[(P >> 32) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x0001020408102040ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_2[((P & 0x2010080402010000ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_C5(const unsigned long long P) {
+	return count_last_flip_C4(vertical_mirror(P));
 }
 
 /**
@@ -772,16 +652,8 @@ static int count_last_flip_C5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_D5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56];
-	n_flipped += COUNT_FLIP_3[(P >> 32) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_3[((P & 0x4020100804020100ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_D5(const unsigned long long P) {
+	return count_last_flip_D4(vertical_mirror(P));
 }
 
 /**
@@ -790,16 +662,8 @@ static int count_last_flip_D5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_E5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56];
-	n_flipped += COUNT_FLIP_4[(P >> 32) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0204081020408000ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_4[((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_E5(const unsigned long long P) {
+	return count_last_flip_E4(vertical_mirror(P));
 }
 
 /**
@@ -808,16 +672,8 @@ static int count_last_flip_E5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_F5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56];
-	n_flipped += COUNT_FLIP_5[(P >> 32) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0408102040800000ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_5[((P & 0x0080402010080402ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_F5(const unsigned long long P) {
+	return count_last_flip_F4(vertical_mirror(P));
 }
 
 /**
@@ -826,15 +682,8 @@ static int count_last_flip_F5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_G5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x4040404020100804ULL) * 0x0040404040408102ULL) >> 56];	// C1G5G8
-	n_flipped += COUNT_FLIP_L[(P >> 31) & 0x7e];
-	n_flipped += COUNT_FLIP_3[(((P & 0x0810204040404040ULL) >> 3) * 0x1008040201010101ULL) >> 56];	// G1G5D8
-
-	return n_flipped;
+static int count_last_flip_G5(const unsigned long long P) {
+	return count_last_flip_G4(vertical_mirror(P));
 }
 
 /**
@@ -843,19 +692,12 @@ static int count_last_flip_G5(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_H5(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_4[((P & 0x8080808040201008ULL) * 0x0020202020204081ULL) >> 56];	// D1H5H8
-	n_flipped += COUNT_FLIP_L[(P >> 32) & 0x7f];
-	n_flipped += COUNT_FLIP_3[(((P & 0x1020408080808080ULL) >> 4) * 0x1008040201010101ULL) >> 56];	// H1H5E8
-
-	return n_flipped;
+static int count_last_flip_H5(const unsigned long long P) {
+	return count_last_flip_H4(vertical_mirror(P));
 }
 
 /**
- * Count last flipped discs when playing on square A6.
+ * Count last flipped discs when playing on square A3/A6.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
@@ -864,15 +706,25 @@ static int count_last_flip_A6(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_5[((P & 0x0402010101010101ULL) * 0x0102040810202020ULL) >> 56];	// A1A6C8
-	n_flipped += COUNT_FLIP_R[(P >> 41) & 0x7f];
-	n_flipped += COUNT_FLIP_2[((P & 0x0101010204081020ULL) * 0x0404040404040201ULL) >> 56];	// F1A6A8
+#ifdef __ARM_FEATURE_CLZ // shorter on arm
+	n_flipped  = count_V_flip_reverse((P & 0x0000000101010101), 31);
+	n_flipped += count_V_flip_reverse((P & 0x0000000204081020), 24);
+	n_flipped += (((P >> 56) & ~(P >> 48) & 1) + ((P >> 58) & ~(P >> 49) & 1)) * 2;
+#else
+	n_flipped  = COUNT_FLIP_5[((P & 0x0402010101010101) * 0x0102040810202020) >> 56];	// A1A6C8
+	n_flipped += COUNT_FLIP_2[((P & 0x0101010204081020) * 0x0404040404040201) >> 56];	// F1A6A8
+#endif
+	n_flipped += count_H_flip_right(P, 40);
 
 	return n_flipped;
 }
 
+static int count_last_flip_A3(const unsigned long long P) {
+	return count_last_flip_A6(vertical_mirror(P));
+}
+
 /**
- * Count last flipped discs when playing on square B6.
+ * Count last flipped discs when playing on square B3/B6.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
@@ -881,29 +733,31 @@ static int count_last_flip_B6(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_5[((P & 0x0804020202020202ULL) * 0x0081020408101010ULL) >> 56];	// B1B6D8
-	n_flipped += COUNT_FLIP_R[(P >> 42) & 0x3f];
-	n_flipped += COUNT_FLIP_2[(((P & 0x0202020408102040ULL) >> 1) * 0x0404040404040201ULL) >> 56];	// G1B6B8
+#ifdef __ARM_FEATURE_CLZ
+	n_flipped  = count_V_flip_reverse((P & 0x0000000202020202), 30);
+	n_flipped += count_V_flip_reverse((P & 0x0000000408102040), 23);
+	n_flipped += (((P >> 57) & ~(P >> 49) & 1) + ((P >> 59) & ~(P >> 50) & 1)) * 2;
+#else
+	n_flipped  = COUNT_FLIP_5[((P & 0x0804020202020202) * 0x0081020408101010) >> 56];	// B1B6D8
+	n_flipped += COUNT_FLIP_2[(((P & 0x0202020408102040) >> 1) * 0x0404040404040201) >> 56];	// G1B6B8
+#endif
+	n_flipped += count_H_flip_right(P, 41);
 
 	return n_flipped;
 }
 
+static int count_last_flip_B3(const unsigned long long P) {
+	return count_last_flip_B6(vertical_mirror(P));
+}
+
 /**
  * Count last flipped discs when playing on square C6.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_C6(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_5[((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56];
-	n_flipped += COUNT_FLIP_2[(P >> 40) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_2[((P & 0x1008040201000000ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_C6(const unsigned long long P) {
+	return count_last_flip_C3(vertical_mirror(P));
 }
 
 /**
@@ -912,16 +766,8 @@ static int count_last_flip_C6(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_D6(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_5[((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56];
-	n_flipped += COUNT_FLIP_3[(P >> 40) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0204081020408000ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_3[((P & 0x2010080402010000ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_D6(const unsigned long long P) {
+	return count_last_flip_D3(vertical_mirror(P));
 }
 
 /**
@@ -930,16 +776,8 @@ static int count_last_flip_D6(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_E6(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_5[((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56];
-	n_flipped += COUNT_FLIP_4[(P >> 40) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0408102040800000ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_4[((P & 0x4020100804020100ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_E6(const unsigned long long P) {
+	return count_last_flip_E3(vertical_mirror(P));
 }
 
 /**
@@ -948,20 +786,12 @@ static int count_last_flip_E6(const unsigned long long P)
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_F6(const unsigned long long P)
-{
-	int n_flipped;
-
-	n_flipped  = COUNT_FLIP_5[((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56];
-	n_flipped += COUNT_FLIP_5[(P >> 40) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0810204080000000ULL) * 0x0101010101010101ULL) >> 56];
-	n_flipped += COUNT_FLIP_5[((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56];
-
-	return n_flipped;
+static int count_last_flip_F6(const unsigned long long P) {
+	return count_last_flip_F3(vertical_mirror(P));
 }
 
 /**
- * Count last flipped discs when playing on square G6.
+ * Count last flipped discs when playing on square G3/G6.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
@@ -970,15 +800,25 @@ static int count_last_flip_G6(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_5[((P & 0x4040402010080402ULL) * 0x0080808080808102ULL) >> 56];	// B1G6G8
-	n_flipped += COUNT_FLIP_L[(P >> 39) & 0x7e];
-	n_flipped += COUNT_FLIP_2[(((P & 0x1020404040404040ULL) >> 4) * 0x2010080402010101ULL) >> 56];	// G1G6E8
+#ifdef __ARM_FEATURE_CLZ
+	n_flipped  = count_V_flip_reverse((P & 0x0000004040404040), 23);
+	n_flipped += count_V_flip_reverse((P & 0x0000002010080402), 24);
+	n_flipped += (((P >> 62) & ~(P >> 54) & 1) + ((P >> 60) & ~(P >> 53) & 1)) * 2;
+#else
+	n_flipped  = COUNT_FLIP_5[((P & 0x4040402010080402) * 0x0080808080808102) >> 56];	// B1G6G8
+	n_flipped += COUNT_FLIP_2[(((P & 0x1020404040404040) >> 4) * 0x2010080402010101) >> 56];	// G1G6E8
+#endif
+	n_flipped += count_H_flip_left(P, 46, 0x7e);
 
 	return n_flipped;
 }
 
+static int count_last_flip_G3(const unsigned long long P) {
+	return count_last_flip_G6(vertical_mirror(P));
+}
+
 /**
- * Count last flipped discs when playing on square H6.
+ * Count last flipped discs when playing on square H3/H6.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
@@ -987,285 +827,259 @@ static int count_last_flip_H6(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = COUNT_FLIP_5[((P & 0x8080804020100804ULL) * 0x0040404040404081ULL) >> 56];	// C1H6H8
-	n_flipped += COUNT_FLIP_L[(P >> 40) & 0x7f];
-	n_flipped += COUNT_FLIP_2[(((P & 0x2040808080808080ULL) >> 5) * 0x2010080402010101ULL) >> 56];	// H1H6F8
+#ifdef __ARM_FEATURE_CLZ
+	n_flipped  = count_V_flip_reverse((P & 0x0000008080808080), 24);
+	n_flipped += count_V_flip_reverse((P & 0x0000004020100804), 25);
+	n_flipped += (((P >> 63) & ~(P >> 55) & 1) + ((P >> 61) & ~(P >> 54) & 1)) * 2;
+#else
+	n_flipped  = COUNT_FLIP_5[((P & 0x8080804020100804) * 0x0040404040404081) >> 56];	// C1H6H8
+	n_flipped += COUNT_FLIP_2[(((P & 0x2040808080808080) >> 5) * 0x2010080402010101) >> 56];	// H1H6F8
+#endif
+	n_flipped += count_H_flip_left(P, 47, 0x7f);
 
 	return n_flipped;
 }
 
+static int count_last_flip_H3(const unsigned long long P) {
+	return count_last_flip_H6(vertical_mirror(P));
+}
+
+#ifdef lzcnt_u64
+
 /**
- * Count last flipped discs when playing on square A7.
+ * Count last flipped discs when playing on square A7/A8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_A7(const unsigned long long P)
+static int count_last_flip_A8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000010101010101ULL), 23);
-	n_flipped += COUNT_FLIP_R[(P >> 49) & 0x7f];
-	n_flipped += count_V_flip_reverse((P & 0x0000020408102040ULL), 16);
+	n_flipped  = count_V_flip_reverse((P & 0x0101010101010101), 15);
+	n_flipped += count_H_flip_right(P, 56);
+	n_flipped += count_V_flip_reverse((P & 0x0002040810204080), 8);
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square B7.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_B7(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_A7(const unsigned long long P) {
+	return count_last_flip_A8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000020202020202ULL), 22);
-	n_flipped += COUNT_FLIP_R[(P >> 50) & 0x3f];
-	n_flipped += count_V_flip_reverse((P & 0x0000040810204080ULL), 15);
+static int count_last_flip_A1(const unsigned long long P) {
+	return count_last_flip_A8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_A2(const unsigned long long P) {
+	return count_last_flip_A8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square C7.
+ * Count last flipped discs when playing on square B7/B8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_C7(const unsigned long long P)
+static int count_last_flip_B8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000040404040404ULL), 21);
-	n_flipped += COUNT_FLIP_2[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x00040A1120408000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped  = count_V_flip_reverse((P & 0x0202020202020202), 14);
+	n_flipped += count_H_flip_right(P, 57);
+	n_flipped += count_V_flip_reverse((P & 0x0004081020408000), 7);
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square D7.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_D7(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_B7(const unsigned long long P) {
+	return count_last_flip_B8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000080808080808ULL), 20);
-	n_flipped += COUNT_FLIP_3[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0008142241800000ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_B1(const unsigned long long P) {
+	return count_last_flip_B8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_B2(const unsigned long long P) {
+	return count_last_flip_B8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square E7.
+ * Count last flipped discs when playing on square C7/C8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_E7(const unsigned long long P)
+static int count_last_flip_C8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000101010101010ULL), 19);
-	n_flipped += COUNT_FLIP_4[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0010284482010000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped  = count_V_flip_reverse((P & 0x0404040404040404), 13);
+	n_flipped += COUNT_FLIP_2[P >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x040A112040800000) * 0x0101010101010101) >> 56];	// A6C8H3
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square F7.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_F7(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_C7(const unsigned long long P) {
+	return count_last_flip_C8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000202020202020ULL), 18);
-	n_flipped += COUNT_FLIP_5[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0020508804020100ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_C1(const unsigned long long P) {
+	return count_last_flip_C8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_C2(const unsigned long long P) {
+	return count_last_flip_C8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square G7.
+ * Count last flipped discs when playing on square D7/D8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_G7(const unsigned long long P)
+static int count_last_flip_D8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000404040404040ULL), 17);
-	n_flipped += COUNT_FLIP_L[(P >> 47) & 0x7e];
-	n_flipped += count_V_flip_reverse((P & 0x0000201008040201ULL), 18);
+	n_flipped  = count_V_flip_reverse((P & 0x0808080808080808), 12);
+	n_flipped += COUNT_FLIP_3[P >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0814224180000000) * 0x0101010101010101) >> 56];	// A5D8H4
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square H7.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_H7(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_D7(const unsigned long long P) {
+	return count_last_flip_D8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0000808080808080ULL), 16);
-	n_flipped += COUNT_FLIP_L[(P >> 48) & 0x7f];
-	n_flipped += count_V_flip_reverse((P & 0x0000402010080402ULL), 17);
+static int count_last_flip_D1(const unsigned long long P) {
+	return count_last_flip_D8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_D2(const unsigned long long P) {
+	return count_last_flip_D8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square A8.
+ * Count last flipped discs when playing on square E7/E8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_A8(const unsigned long long P)
+static int count_last_flip_E8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0001010101010101ULL), 15);
-	n_flipped += COUNT_FLIP_R[P >> 57];
-	n_flipped += count_V_flip_reverse((P & 0x0002040810204080ULL), 8);
+	n_flipped  = count_V_flip_reverse((P & 0x1010101010101010), 11);
+	n_flipped += COUNT_FLIP_4[P >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x1028448201000000) * 0x0101010101010101) >> 56];	// A4E8H5
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square B8.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_B8(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_E7(const unsigned long long P) {
+	return count_last_flip_E8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0002020202020202ULL), 14);
-	n_flipped += COUNT_FLIP_R[P >> 58];
-	n_flipped += count_V_flip_reverse((P & 0x0004081020408000ULL), 7);
+static int count_last_flip_E1(const unsigned long long P) {
+	return count_last_flip_E8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_E2(const unsigned long long P) {
+	return count_last_flip_E8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square C8.
+ * Count last flipped discs when playing on square F7/F8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_C8(const unsigned long long P)
+static int count_last_flip_F8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0004040404040404ULL), 13);
-	n_flipped += COUNT_FLIP_2[P >> 56];
-	n_flipped += COUNT_FLIP_2[((P & 0x040A112040800000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped  = count_V_flip_reverse((P & 0x2020202020202020), 10);
+	n_flipped += COUNT_FLIP_5[P >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0050880402010000) * 0x0101010101010101) >> 56];	// A3F8H6
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square D8.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_D8(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_F7(const unsigned long long P) {
+	return count_last_flip_F8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0008080808080808ULL), 12);
-	n_flipped += COUNT_FLIP_3[P >> 56];
-	n_flipped += COUNT_FLIP_3[((P & 0x0814224180000000ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_F1(const unsigned long long P) {
+	return count_last_flip_F8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_F2(const unsigned long long P) {
+	return count_last_flip_F8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square E8.
+ * Count last flipped discs when playing on square G7/G8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_E8(const unsigned long long P)
+static int count_last_flip_G8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0010101010101010ULL), 11);
-	n_flipped += COUNT_FLIP_4[P >> 56];
-	n_flipped += COUNT_FLIP_4[((P & 0x1028448201000000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped  = count_V_flip_reverse((P & 0x4040404040404040), 9);
+	n_flipped += count_H_flip_left(P, 62, 0x7e);
+	n_flipped += count_V_flip_reverse((P & 0x0020100804020100), 10);
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square F8.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_F8(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_G7(const unsigned long long P) {
+	return count_last_flip_G8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0020202020202020ULL), 10);
-	n_flipped += COUNT_FLIP_5[P >> 56];
-	n_flipped += COUNT_FLIP_5[((P & 0x0050880402010000ULL) * 0x0101010101010101ULL) >> 56];
+static int count_last_flip_G1(const unsigned long long P) {
+	return count_last_flip_G8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_G2(const unsigned long long P) {
+	return count_last_flip_G8(vertical_mirror(P) << 8);
 }
 
 /**
- * Count last flipped discs when playing on square G8.
+ * Count last flipped discs when playing on square H7/H8.
  *
  * @param P player's disc pattern.
  * @return flipped disc count.
  */
-static int count_last_flip_G8(const unsigned long long P)
+static int count_last_flip_H8(const unsigned long long P)
 {
 	int n_flipped;
 
-	n_flipped  = count_V_flip_reverse((P & 0x0040404040404040ULL), 9);
-	n_flipped += COUNT_FLIP_L[(P >> 55) & 0x7e];
-	n_flipped += count_V_flip_reverse((P & 0x0020100804020100ULL), 10);
+	n_flipped  = count_V_flip_reverse((P & 0x8080808080808080), 8);
+	n_flipped += count_H_flip_left(P, 63, 0x7f);
+	n_flipped += count_V_flip_reverse((P & 0x0040201008040201), 9);
 
 	return n_flipped;
 }
 
-/**
- * Count last flipped discs when playing on square H8.
- *
- * @param P player's disc pattern.
- * @return flipped disc count.
- */
-static int count_last_flip_H8(const unsigned long long P)
-{
-	int n_flipped;
+static int count_last_flip_H7(const unsigned long long P) {
+	return count_last_flip_H8(P << 8);
+}
 
-	n_flipped  = count_V_flip_reverse((P & 0x0080808080808080ULL), 8);
-	n_flipped += COUNT_FLIP_L[(P >> 56) & 0x7f];
-	n_flipped += count_V_flip_reverse((P & 0x0040201008040201ULL), 9);
+static int count_last_flip_H1(const unsigned long long P) {
+	return count_last_flip_H8(vertical_mirror(P));
+}
 
-	return n_flipped;
+static int count_last_flip_H2(const unsigned long long P) {
+	return count_last_flip_H8(vertical_mirror(P) << 8);
 }
 
+#endif // lzcnt_u64
+
 /**
  * Count last flipped discs when plassing.
  *
@@ -1279,7 +1093,7 @@ static int count_last_flip_pass(const unsigned long long P)
 }
 
 /** Array of functions to count flipped discs of the last move */
-int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
+int (*count_last_flip[])(const unsigned long long) = {
 	count_last_flip_A1, count_last_flip_B1, count_last_flip_C1, count_last_flip_D1,
 	count_last_flip_E1, count_last_flip_F1, count_last_flip_G1, count_last_flip_H1,
 	count_last_flip_A2, count_last_flip_B2, count_last_flip_C2, count_last_flip_D2,
@@ -1298,9 +1112,3 @@ int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
 	count_last_flip_E8, count_last_flip_F8, count_last_flip_G8, count_last_flip_H8,
 	count_last_flip_pass,
 };
-
-int count_last_flip(const int x, const unsigned long long P)
-{
-	return COUNT_LAST_FLIP[x](P);
-}
-
diff --git a/src/count_last_flip_bmi.c b/src/count_last_flip_bmi.c
new file mode 100644
index 00000000..fc80a5d8
--- /dev/null
+++ b/src/count_last_flip_bmi.c
@@ -0,0 +1,172 @@
+/**
+ * @file count_last_flip_bmi.c
+ *
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * This implementation uses BMI1 instructions, lzcnt and tzcnt.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 1998 - 2018
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ * 
+ */
+
+#include "bit.h"
+
+/** precomputed count flip array */
+static const unsigned char COUNT_FLIP[8][256] = {
+	{
+		 0,  0,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		12, 12,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+	},
+	{
+		 0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		10, 10, 10, 10,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 8, 10,  8,  8,  8, 10,  8,  8,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+	},
+	{
+		 0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 6, 10,  8,  8,  6,  6,  6,  6,  6, 10,  8,  8,  6,  6,  6,  6,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+};
+
+/* bit masks for diagonal lines */
+static const unsigned long long mask_d[2][64] = {
+	{
+		0x0000000000000001ULL, 0x0000000000000102ULL, 0x0000000000010204ULL, 0x0000000001020408ULL,
+		0x0000000102040810ULL, 0x0000010204081020ULL, 0x0001020408102040ULL, 0x0102040810204080ULL,
+		0x0000000000000102ULL, 0x0000000000010204ULL, 0x0000000001020408ULL, 0x0000000102040810ULL,
+		0x0000010204081020ULL, 0x0001020408102040ULL, 0x0102040810204080ULL, 0x0204081020408000ULL,
+		0x0000000000010204ULL, 0x0000000001020408ULL, 0x0000000102040810ULL, 0x0000010204081020ULL,
+		0x0001020408102040ULL, 0x0102040810204080ULL, 0x0204081020408000ULL, 0x0408102040800000ULL,
+		0x0000000001020408ULL, 0x0000000102040810ULL, 0x0000010204081020ULL, 0x0001020408102040ULL,
+		0x0102040810204080ULL, 0x0204081020408000ULL, 0x0408102040800000ULL, 0x0810204080000000ULL,
+		0x0000000102040810ULL, 0x0000010204081020ULL, 0x0001020408102040ULL, 0x0102040810204080ULL,
+		0x0204081020408000ULL, 0x0408102040800000ULL, 0x0810204080000000ULL, 0x1020408000000000ULL,
+		0x0000010204081020ULL, 0x0001020408102040ULL, 0x0102040810204080ULL, 0x0204081020408000ULL,
+		0x0408102040800000ULL, 0x0810204080000000ULL, 0x1020408000000000ULL, 0x2040800000000000ULL,
+		0x0001020408102040ULL, 0x0102040810204080ULL, 0x0204081020408000ULL, 0x0408102040800000ULL,
+		0x0810204080000000ULL, 0x1020408000000000ULL, 0x2040800000000000ULL, 0x4080000000000000ULL,
+		0x0102040810204080ULL, 0x0204081020408000ULL, 0x0408102040800000ULL, 0x0810204080000000ULL,
+		0x1020408000000000ULL, 0x2040800000000000ULL, 0x4080000000000000ULL, 0x8000000000000000ULL
+	},
+	{
+		0x8040201008040201ULL, 0x0080402010080402ULL, 0x0000804020100804ULL, 0x0000008040201008ULL,
+		0x0000000080402010ULL, 0x0000000000804020ULL, 0x0000000000008040ULL, 0x0000000000000080ULL,
+		0x4020100804020100ULL, 0x8040201008040201ULL, 0x0080402010080402ULL, 0x0000804020100804ULL,
+		0x0000008040201008ULL, 0x0000000080402010ULL, 0x0000000000804020ULL, 0x0000000000008040ULL,
+		0x2010080402010000ULL, 0x4020100804020100ULL, 0x8040201008040201ULL, 0x0080402010080402ULL,
+		0x0000804020100804ULL, 0x0000008040201008ULL, 0x0000000080402010ULL, 0x0000000000804020ULL,
+		0x1008040201000000ULL, 0x2010080402010000ULL, 0x4020100804020100ULL, 0x8040201008040201ULL,
+		0x0080402010080402ULL, 0x0000804020100804ULL, 0x0000008040201008ULL, 0x0000000080402010ULL,
+		0x0804020100000000ULL, 0x1008040201000000ULL, 0x2010080402010000ULL, 0x4020100804020100ULL,
+		0x8040201008040201ULL, 0x0080402010080402ULL, 0x0000804020100804ULL, 0x0000008040201008ULL,
+		0x0402010000000000ULL, 0x0804020100000000ULL, 0x1008040201000000ULL, 0x2010080402010000ULL,
+		0x4020100804020100ULL, 0x8040201008040201ULL, 0x0080402010080402ULL, 0x0000804020100804ULL,
+		0x0201000000000000ULL, 0x0402010000000000ULL, 0x0804020100000000ULL, 0x1008040201000000ULL,
+		0x2010080402010000ULL, 0x4020100804020100ULL, 0x8040201008040201ULL, 0x0080402010080402ULL,
+		0x0100000000000000ULL, 0x0201000000000000ULL, 0x0402010000000000ULL, 0x0804020100000000ULL,
+		0x1008040201000000ULL, 0x2010080402010000ULL, 0x4020100804020100ULL, 0x8040201008040201ULL
+	}
+};
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+int last_flip(int pos, unsigned long long P)
+{
+	unsigned long long	P8, P7, P9;
+	int	n_flipped;
+	int	x = pos & 7;
+	int	y = pos & 0x38;
+	int	ry = y ^ 0x38;
+
+	n_flipped = COUNT_FLIP[x][(unsigned char) (P >> y)];
+
+	P8 = P & (0x0101010101010101ULL << x);
+	P7 = P & mask_d[0][pos];
+	P9 = P & mask_d[1][pos];
+
+	n_flipped += ((((int) __tzcnt_u64((P8 >> y) >> 8) + (int) __lzcnt64((P8 << ry) << 8)) & 0x38)
+		+ ((int) __tzcnt_u64((P7 >> y) >> 8) & 0x38)
+		+ ((int) __tzcnt_u64((P9 >> y) >> 8) & 0x38)
+		+ ((int) __lzcnt64((P7 << ry) << 8) & 0x38)
+		+ ((int) __lzcnt64((P9 << ry) << 8) & 0x38)) >> 2;
+
+	return n_flipped;
+}
diff --git a/src/count_last_flip_bmi2.c b/src/count_last_flip_bmi2.c
new file mode 100644
index 00000000..f85c0e4f
--- /dev/null
+++ b/src/count_last_flip_bmi2.c
@@ -0,0 +1,204 @@
+/**
+ * @file count_last_flip_bmi2.c
+ *
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * The basic principle is to read into an array a precomputed result. Doing
+ * this is easy for a single line ; as we can use arrays of the form:
+ *  - COUNT_FLIP[square where we play][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by the 
+ * BMI2 PEXT instruction.
+ * Once we get our 8-bits disc patterns, we directly get the number of
+ * flipped discs from the precomputed array, and add them from each flipping
+ * lines.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 1998 - 2023
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include "bit.h"
+#include <stdint.h>
+
+/** precomputed count flip array */
+const uint8_t COUNT_FLIP[8][256] = {
+	{
+		 0,  0,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		12, 12,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+	},
+	{
+		 0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		10, 10, 10, 10,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 8, 10,  8,  8,  8, 10,  8,  8,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+	},
+	{
+		 0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 6, 10,  8,  8,  6,  6,  6,  6,  6, 10,  8,  8,  6,  6,  6,  6,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+};
+
+/* bit masks for diagonal/vertical/all lines */
+const unsigned long long mask_x[64][4] = {
+	{ 0x0000000000000001ULL, 0x8040201008040201ULL, 0x0101010101010101ULL, 0x81412111090503ffULL },
+	{ 0x0000000000000102ULL, 0x0080402010080402ULL, 0x0202020202020202ULL, 0x02824222120a07ffULL },
+	{ 0x0000000000010204ULL, 0x0000804020100804ULL, 0x0404040404040404ULL, 0x0404844424150effULL },
+	{ 0x0000000001020408ULL, 0x0000008040201008ULL, 0x0808080808080808ULL, 0x08080888492a1cffULL },
+	{ 0x0000000102040810ULL, 0x0000000080402010ULL, 0x1010101010101010ULL, 0x10101011925438ffULL },
+	{ 0x0000010204081020ULL, 0x0000000000804020ULL, 0x2020202020202020ULL, 0x2020212224a870ffULL },
+	{ 0x0001020408102040ULL, 0x0000000000008040ULL, 0x4040404040404040ULL, 0x404142444850e0ffULL },
+	{ 0x0102040810204080ULL, 0x0000000000000080ULL, 0x8080808080808080ULL, 0x8182848890a0c0ffULL },
+	{ 0x0000000000000102ULL, 0x4020100804020104ULL, 0x0101010101010101ULL, 0x412111090503ff03ULL },
+	{ 0x0000000000010204ULL, 0x8040201008040201ULL, 0x0202020202020202ULL, 0x824222120a07ff07ULL },
+	{ 0x0000000001020408ULL, 0x0080402010080402ULL, 0x0404040404040404ULL, 0x04844424150eff0eULL },
+	{ 0x0000000102040810ULL, 0x0000804020100804ULL, 0x0808080808080808ULL, 0x080888492a1cff1cULL },
+	{ 0x0000010204081020ULL, 0x0000008040201008ULL, 0x1010101010101010ULL, 0x101011925438ff38ULL },
+	{ 0x0001020408102040ULL, 0x0000000080402010ULL, 0x2020202020202020ULL, 0x20212224a870ff70ULL },
+	{ 0x0102040810204080ULL, 0x0000000000804020ULL, 0x4040404040404040ULL, 0x4142444850e0ffe0ULL },
+	{ 0x0204081020408001ULL, 0x0000000000008040ULL, 0x8080808080808080ULL, 0x82848890a0c0ffc0ULL },
+	{ 0x0000000000010204ULL, 0x201008040201000aULL, 0x0101010101010101ULL, 0x2111090503ff0305ULL },
+	{ 0x0000000001020408ULL, 0x4020100804020101ULL, 0x0202020202020202ULL, 0x4222120a07ff070aULL },
+	{ 0x0000000102040810ULL, 0x8040201008040201ULL, 0x0404040404040404ULL, 0x844424150eff0e15ULL },
+	{ 0x0000010204081020ULL, 0x0080402010080402ULL, 0x0808080808080808ULL, 0x0888492a1cff1c2aULL },
+	{ 0x0001020408102040ULL, 0x0000804020100804ULL, 0x1010101010101010ULL, 0x1011925438ff3854ULL },
+	{ 0x0102040810204080ULL, 0x0000008040201008ULL, 0x2020202020202020ULL, 0x212224a870ff70a8ULL },
+	{ 0x0204081020408001ULL, 0x0000000080402010ULL, 0x4040404040404040ULL, 0x42444850e0ffe050ULL },
+	{ 0x0408102040800003ULL, 0x0000000000804020ULL, 0x8080808080808080ULL, 0x848890a0c0ffc0a0ULL },
+	{ 0x0000000001020408ULL, 0x1008040201000016ULL, 0x0101010101010101ULL, 0x11090503ff030509ULL },
+	{ 0x0000000102040810ULL, 0x2010080402010005ULL, 0x0202020202020202ULL, 0x22120a07ff070a12ULL },
+	{ 0x0000010204081020ULL, 0x4020100804020101ULL, 0x0404040404040404ULL, 0x4424150eff0e1524ULL },
+	{ 0x0001020408102040ULL, 0x8040201008040201ULL, 0x0808080808080808ULL, 0x88492a1cff1c2a49ULL },
+	{ 0x0102040810204080ULL, 0x0080402010080402ULL, 0x1010101010101010ULL, 0x11925438ff385492ULL },
+	{ 0x0204081020408001ULL, 0x0000804020100804ULL, 0x2020202020202020ULL, 0x2224a870ff70a824ULL },
+	{ 0x0408102040800003ULL, 0x0000008040201008ULL, 0x4040404040404040ULL, 0x444850e0ffe05048ULL },
+	{ 0x0810204080000007ULL, 0x0000000080402010ULL, 0x8080808080808080ULL, 0x8890a0c0ffc0a090ULL },
+	{ 0x0000000102040810ULL, 0x080402010000002eULL, 0x0101010101010101ULL, 0x090503ff03050911ULL },
+	{ 0x0000010204081020ULL, 0x100804020100000dULL, 0x0202020202020202ULL, 0x120a07ff070a1222ULL },
+	{ 0x0001020408102040ULL, 0x2010080402010003ULL, 0x0404040404040404ULL, 0x24150eff0e152444ULL },
+	{ 0x0102040810204080ULL, 0x4020100804020101ULL, 0x0808080808080808ULL, 0x492a1cff1c2a4988ULL },
+	{ 0x0204081020408002ULL, 0x8040201008040201ULL, 0x1010101010101010ULL, 0x925438ff38549211ULL },
+	{ 0x0408102040800005ULL, 0x0080402010080402ULL, 0x2020202020202020ULL, 0x24a870ff70a82422ULL },
+	{ 0x081020408000000bULL, 0x0000804020100804ULL, 0x4040404040404040ULL, 0x4850e0ffe0504844ULL },
+	{ 0x1020408000000017ULL, 0x0000008040201008ULL, 0x8080808080808080ULL, 0x90a0c0ffc0a09088ULL },
+	{ 0x0000010204081020ULL, 0x040201000000005eULL, 0x0101010101010101ULL, 0x0503ff0305091121ULL },
+	{ 0x0001020408102040ULL, 0x080402010000001dULL, 0x0202020202020202ULL, 0x0a07ff070a122242ULL },
+	{ 0x0102040810204080ULL, 0x100804020100000bULL, 0x0404040404040404ULL, 0x150eff0e15244484ULL },
+	{ 0x0204081020408001ULL, 0x2010080402010003ULL, 0x0808080808080808ULL, 0x2a1cff1c2a498808ULL },
+	{ 0x0408102040800003ULL, 0x4020100804020101ULL, 0x1010101010101010ULL, 0x5438ff3854921110ULL },
+	{ 0x081020408000000eULL, 0x8040201008040201ULL, 0x2020202020202020ULL, 0xa870ff70a8242221ULL },
+	{ 0x102040800000001dULL, 0x0080402010080402ULL, 0x4040404040404040ULL, 0x50e0ffe050484442ULL },
+	{ 0x204080000000003bULL, 0x0000804020100804ULL, 0x8080808080808080ULL, 0xa0c0ffc0a0908884ULL },
+	{ 0x0001020408102040ULL, 0x02010000000000beULL, 0x0101010101010101ULL, 0x03ff030509112141ULL },
+	{ 0x0102040810204080ULL, 0x040201000000003dULL, 0x0202020202020202ULL, 0x07ff070a12224282ULL },
+	{ 0x0204081020408001ULL, 0x080402010000001bULL, 0x0404040404040404ULL, 0x0eff0e1524448404ULL },
+	{ 0x0408102040800003ULL, 0x1008040201000007ULL, 0x0808080808080808ULL, 0x1cff1c2a49880808ULL },
+	{ 0x0810204080000007ULL, 0x2010080402010003ULL, 0x1010101010101010ULL, 0x38ff385492111010ULL },
+	{ 0x102040800000000fULL, 0x4020100804020101ULL, 0x2020202020202020ULL, 0x70ff70a824222120ULL },
+	{ 0x204080000000003eULL, 0x8040201008040201ULL, 0x4040404040404040ULL, 0xe0ffe05048444241ULL },
+	{ 0x408000000000007dULL, 0x0080402010080402ULL, 0x8080808080808080ULL, 0xc0ffc0a090888482ULL },
+	{ 0x0102040810204080ULL, 0x010000000000027eULL, 0x0101010101010101ULL, 0xff03050911214181ULL },
+	{ 0x0204081020408001ULL, 0x020100000000007dULL, 0x0202020202020202ULL, 0xff070a1222428202ULL },
+	{ 0x0408102040800003ULL, 0x040201000000003bULL, 0x0404040404040404ULL, 0xff0e152444840404ULL },
+	{ 0x0810204080000007ULL, 0x0804020100000017ULL, 0x0808080808080808ULL, 0xff1c2a4988080808ULL },
+	{ 0x102040800000000fULL, 0x1008040201000007ULL, 0x1010101010101010ULL, 0xff38549211101010ULL },
+	{ 0x204080000000001fULL, 0x2010080402010003ULL, 0x2020202020202020ULL, 0xff70a82422212020ULL },
+	{ 0x408000000000003fULL, 0x4020100804020101ULL, 0x4040404040404040ULL, 0xffe0504844424140ULL },
+	{ 0x800000000000017eULL, 0x8040201008040201ULL, 0x8080808080808080ULL, 0xffc0a09088848281ULL }
+};
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+inline int last_flip(int pos, unsigned long long P)
+{
+	uint_fast8_t	n_flipped;
+	int	x = pos & 7;
+	int	y = pos >> 3;
+
+	P &= mask_x[pos][3];	// mask out unrelated bits to make dummy 0 bits for outside
+	// n_flipped  = COUNT_FLIP[x][_bextr_u64(P, pos & 0x38, 8)];
+	n_flipped  = COUNT_FLIP[x][(P >> (pos & 0x38)) & 0xFF];
+	n_flipped += COUNT_FLIP[y][_pext_u64(P, mask_x[pos][0])];
+	n_flipped += COUNT_FLIP[y][_pext_u64(P, mask_x[pos][1])];
+	n_flipped += COUNT_FLIP[y][_pext_u64(P, mask_x[pos][2])];
+
+	return n_flipped;
+}
diff --git a/src/count_last_flip_carry_64.c b/src/count_last_flip_carry_64.c
index 12bab37a..9d409a28 100644
--- a/src/count_last_flip_carry_64.c
+++ b/src/count_last_flip_carry_64.c
@@ -27,7 +27,7 @@
  * For top to bottom flip, LS1B isolation (http://chessprogramming.wikispaces.com/
  * General+Setwise+Operations) is used to get the outflank bit.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2018
  * @author Richard Delorme
  * @author Toshihiko Okuhara
  * @version 4.4
@@ -151,7 +151,7 @@ static int count_last_flip_C1(const unsigned long long P)
 	P_v = P & 0x0404040404040400ULL;
 	n_flipped  = ((P_v & -P_v) * 0x0000081018202830ULL) >> 60;
 	n_flipped += COUNT_FLIP_2[P & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x0000804020110A04ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x0000804020110A04ULL) * 0x0101010101010101ULL) >> 56];	// A3C1H6
 
 	return n_flipped;
 }
@@ -170,7 +170,7 @@ static int count_last_flip_D1(const unsigned long long P)
 	P_v = P & 0x0808080808080800ULL;
 	n_flipped  = ((P_v & -P_v) * 0x000004080c101418ULL) >> 60;
 	n_flipped += COUNT_FLIP_3[P & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0000008041221408ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0000008041221408ULL) * 0x0101010101010101ULL) >> 56];	// A4D1H5
 
 	return n_flipped;
 }
@@ -189,7 +189,7 @@ static int count_last_flip_E1(const unsigned long long P)
 	P_v = P & 0x1010101010101000ULL;
 	n_flipped  = ((P_v & -P_v) * 0x0000020406080a0cULL) >> 60;
 	n_flipped += COUNT_FLIP_4[P & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0000000182442810ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0000000182442810ULL) * 0x0101010101010101ULL) >> 56];	// A5E1H4
 
 	return n_flipped;
 }
@@ -208,7 +208,7 @@ static int count_last_flip_F1(const unsigned long long P)
 	P_v = P & 0x2020202020202000ULL;
 	n_flipped  = ((P_v & -P_v) * 0x0000010203040506ULL) >> 60;
 	n_flipped += COUNT_FLIP_5[P & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0000010204885020ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0000010204885020ULL) * 0x0101010101010101ULL) >> 56];	// A6F1H3
 
 	return n_flipped;
 }
@@ -307,7 +307,7 @@ static int count_last_flip_C2(const unsigned long long P)
 	P_v = P & 0x0404040404040000ULL;
 	n_flipped  = ((P_v & -P_v) * 0x0000000810182028ULL) >> 60;
 	n_flipped += COUNT_FLIP_2[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x00804020110A0400ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x00804020110A0400ULL) * 0x0101010101010101ULL) >> 56];	// A4C2H7
 
 	return n_flipped;
 }
@@ -326,7 +326,7 @@ static int count_last_flip_D2(const unsigned long long P)
 	P_v = P & 0x0808080808080000ULL;
 	n_flipped  = ((P_v & -P_v) * 0x00000004080c1014ULL) >> 60;
 	n_flipped += COUNT_FLIP_3[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0000804122140800ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0000804122140800ULL) * 0x0101010101010101ULL) >> 56];	// A5D2H6
 
 	return n_flipped;
 }
@@ -345,7 +345,7 @@ static int count_last_flip_E2(const unsigned long long P)
 	P_v = P & 0x1010101010100000ULL;
 	n_flipped  = ((P_v & -P_v) * 0x000000020406080aULL) >> 60;
 	n_flipped += COUNT_FLIP_4[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0000018244281000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0000018244281000ULL) * 0x0101010101010101ULL) >> 56];	// A6E2H5
 
 	return n_flipped;
 }
@@ -364,7 +364,7 @@ static int count_last_flip_F2(const unsigned long long P)
 	P_v = P & 0x2020202020200000ULL;
 	n_flipped  = ((P_v & -P_v) * 0x0000000102030405ULL) >> 60;
 	n_flipped += COUNT_FLIP_5[(P >> 8) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0001020488502000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0001020488502000ULL) * 0x0101010101010101ULL) >> 56];	// A7F2H4
 
 	return n_flipped;
 }
@@ -1015,7 +1015,7 @@ static int count_last_flip_C7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0000040404040404ULL) * 0x0040810204081020ULL) >> 55];
 	n_flipped += COUNT_FLIP_2[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_2[((P & 0x00040A1120408000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x00040A1120408000ULL) * 0x0101010101010101ULL) >> 56];	// A5C7H2
 
 	return n_flipped;
 }
@@ -1032,7 +1032,7 @@ static int count_last_flip_D7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0000080808080808ULL) * 0x0020408102040810ULL) >> 55];
 	n_flipped += COUNT_FLIP_3[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_3[((P & 0x0008142241800000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0008142241800000ULL) * 0x0101010101010101ULL) >> 56];	// A4D7H3
 
 	return n_flipped;
 }
@@ -1049,7 +1049,7 @@ static int count_last_flip_E7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0000101010101010ULL) * 0x0010204081020408ULL) >> 55];
 	n_flipped += COUNT_FLIP_4[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_4[((P & 0x0010284482010000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x0010284482010000ULL) * 0x0101010101010101ULL) >> 56];	// A3E7H4
 
 	return n_flipped;
 }
@@ -1066,7 +1066,7 @@ static int count_last_flip_F7(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0000202020202020ULL) * 0x0008102040810204ULL) >> 55];
 	n_flipped += COUNT_FLIP_5[(P >> 48) & 0xff];
-	n_flipped += COUNT_FLIP_5[((P & 0x0020508804020100ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0020508804020100ULL) * 0x0101010101010101ULL) >> 56];	// A2F7H5
 
 	return n_flipped;
 }
@@ -1151,7 +1151,7 @@ static int count_last_flip_C8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0004040404040404ULL) * 0x0040810204081020ULL) >> 56];
 	n_flipped += COUNT_FLIP_2[P >> 56];
-	n_flipped += COUNT_FLIP_2[((P & 0x040A112040800000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_2[((P & 0x040A112040800000ULL) * 0x0101010101010101ULL) >> 56];	// A6C8H3
 
 	return n_flipped;
 }
@@ -1168,7 +1168,7 @@ static int count_last_flip_D8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0008080808080808ULL) * 0x0020408102040810ULL) >> 56];
 	n_flipped += COUNT_FLIP_3[P >> 56];
-	n_flipped += COUNT_FLIP_3[((P & 0x0814224180000000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_3[((P & 0x0814224180000000ULL) * 0x0101010101010101ULL) >> 56];	// A5D8H4
 
 	return n_flipped;
 }
@@ -1185,7 +1185,7 @@ static int count_last_flip_E8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0010101010101010ULL) * 0x0010204081020408ULL) >> 56];
 	n_flipped += COUNT_FLIP_4[P >> 56];
-	n_flipped += COUNT_FLIP_4[((P & 0x1028448201000000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_4[((P & 0x1028448201000000ULL) * 0x0101010101010101ULL) >> 56];	// A4E8H5
 
 	return n_flipped;
 }
@@ -1202,7 +1202,7 @@ static int count_last_flip_F8(const unsigned long long P)
 
 	n_flipped  = COUNT_FLIP_L[((P & 0x0020202020202020ULL) * 0x0008102040810204ULL) >> 56];
 	n_flipped += COUNT_FLIP_5[P >> 56];
-	n_flipped += COUNT_FLIP_5[((P & 0x0050880402010000ULL) * 0x0101010101010101ULL) >> 56];
+	n_flipped += COUNT_FLIP_5[((P & 0x0050880402010000ULL) * 0x0101010101010101ULL) >> 56];	// A3F8H6
 
 	return n_flipped;
 }
@@ -1254,7 +1254,7 @@ static int count_last_flip_pass(const unsigned long long P)
 }
 
 /** Array of functions to count flipped discs of the last move */
-int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
+int (*count_last_flip[])(const unsigned long long) = {
 	count_last_flip_A1, count_last_flip_B1, count_last_flip_C1, count_last_flip_D1,
 	count_last_flip_E1, count_last_flip_F1, count_last_flip_G1, count_last_flip_H1,
 	count_last_flip_A2, count_last_flip_B2, count_last_flip_C2, count_last_flip_D2,
@@ -1274,8 +1274,3 @@ int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
 	count_last_flip_pass,
 };
 
-int count_last_flip(const int x, const unsigned long long P)
-{
-	return COUNT_LAST_FLIP[x](P);
-}
-
diff --git a/src/count_last_flip_kindergarten.c b/src/count_last_flip_kindergarten.c
index e70c55b1..26d10b64 100644
--- a/src/count_last_flip_kindergarten.c
+++ b/src/count_last_flip_kindergarten.c
@@ -22,7 +22,7 @@
  * For optimization purpose, the value returned is twice the number of flipped
  * disc, to facilitate the computation of disc difference.
  *
- * With Modifications by Valéry ClaudePierre (merging diagonals).
+ * With Modifications by Valery ClaudePierre (merging diagonals).
  * @todo 135° merge as done by Toshihiko Okuhara
  *
  * @date 1998 - 2017
@@ -1232,7 +1232,7 @@ static int count_last_flip_pass(const unsigned long long P)
 }
 
 /** Array of functions to count flipped discs of the last move */
-int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
+int (*count_last_flip[])(const unsigned long long) = {
 	count_last_flip_A1, count_last_flip_B1, count_last_flip_C1, count_last_flip_D1,
 	count_last_flip_E1, count_last_flip_F1, count_last_flip_G1, count_last_flip_H1,
 	count_last_flip_A2, count_last_flip_B2, count_last_flip_C2, count_last_flip_D2,
@@ -1252,8 +1252,3 @@ int (*COUNT_LAST_FLIP[])(const unsigned long long) = {
 	count_last_flip_pass,
 };
 
-int count_last_flip(const int x, const unsigned long long P)
-{
-	return COUNT_LAST_FLIP[x](P);
-}
-
diff --git a/src/count_last_flip_lzcnt.c b/src/count_last_flip_lzcnt.c
new file mode 100644
index 00000000..4094684f
--- /dev/null
+++ b/src/count_last_flip_lzcnt.c
@@ -0,0 +1,236 @@
+/**
+ * @file count_last_flip_lzcnt.c
+ *
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * The basic principle is to read into an array a precomputed result. Doing
+ * this is easy for a single line ; as we can use arrays of the form:
+ *  - COUNT_FLIP[square where we play][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by a simple
+ * multiplication and to right-shift the result to scale it into a number
+ * between 0 and 255.
+ * Once we get our 8-bits disc patterns, we directly get the number of
+ * flipped discs from the precomputed array, and add them from each flipping
+ * lines.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 1998 - 2014
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ * 
+ */
+
+#include "bit_intrinsics.h"
+
+/** precomputed count flip array */
+static const unsigned char COUNT_FLIP[8][256] = {
+	{
+		 0,  0,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		12, 12,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+	},
+	{
+		 0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		10, 10, 10, 10,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 8, 10,  8,  8,  8, 10,  8,  8,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+	},
+	{
+		 0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 6, 10,  8,  8,  6,  6,  6,  6,  6, 10,  8,  8,  6,  6,  6,  6,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	}
+};
+
+#ifdef lzcnt_u64
+
+/* bit masks for vertical and diagonal lines for A8..H8 */
+static const unsigned long long mask_9_7[8][2] = {
+	{ 0x0204081020408000, 0x0000000000000000 },
+	{ 0x0204081020400000, 0x8000000000000000 },
+	{ 0x0204081020000000, 0x8040000000000000 },
+	{ 0x0204081000000000, 0x8040200000000000 },
+	{ 0x0204080000000000, 0x8040201000000000 },
+	{ 0x0204000000000000, 0x8040201008000000 },
+	{ 0x0200000000000000, 0x8040201008040000 },
+	{ 0x0000000000000000, 0x8040201008040200 }
+};
+
+#else
+
+/* bit masks for vertical and diagonal lines for A1..H1 */
+static const unsigned long long mask_9_7[8][2] = {
+	{ 0x0000000000000000, 0x4020100804020100 },
+	{ 0x0000000000000040, 0x0020100804020100 },
+	{ 0x0000000000002040, 0x0000100804020100 },
+	{ 0x0000000000102040, 0x0000000804020100 },
+	{ 0x0000000008102040, 0x0000000004020100 },
+	{ 0x0000000408102040, 0x0000000000020100 },
+	{ 0x0000020408102040, 0x0000000000000100 },
+	{ 0x0001020408102040, 0x0000000000000000 }
+};
+
+#endif
+
+/* bit masks for diagonal lines for A5..H6 */
+static const unsigned long long mask_d[16][2] = {
+	{ 0x0000000102040810, 0x0804020100000000 },
+	{ 0x0000010204081020, 0x1008040201000000 },
+	{ 0x0001020408102040, 0x2010080402010000 },
+	{ 0x0102040810204080, 0x4020100804020100 },
+	{ 0x0204081020408000, 0x8040201008040201 },
+	{ 0x0408102040800000, 0x0080402010080402 },
+	{ 0x0810204080000000, 0x0000804020100804 },
+	{ 0x1020408000000000, 0x0000008040201008 },
+	{ 0x0000010204081020, 0x0402010000000000 },
+	{ 0x0001020408102040, 0x0804020100000000 },
+	{ 0x0102040810204080, 0x1008040201000000 },
+	{ 0x0204081020408000, 0x2010080402010000 },
+	{ 0x0408102040800000, 0x4020100804020100 },
+	{ 0x0810204080000000, 0x8040201008040201 },
+	{ 0x1020408000000000, 0x0080402010080402 },
+	{ 0x2040800000000000, 0x0000804020100804 }
+};
+
+#ifdef HAS_CPU_64
+
+#define	packV(P, x)	(((((P) >> (x)) & 0x0101010101010101) * 0x0102040810204080) >> 56)
+#define packD(PM)	(((PM) * 0x0101010101010101) >> 56)
+
+#else
+
+#define	packV(P, x)	(((((((unsigned int)(P)) >> (x)) & 0x01010101u) + (((((unsigned int)((P) >> 32)) >> (x)) & 0x01010101u) << 4)) * 0x01020408u) >> 24)
+#define	packD(PM)	(((((unsigned int)(PM)) * 0x01010101u) + (((unsigned int)((PM) >> 32)) * 0x01010101u)) >> 24)
+
+#endif // HAS_CPU_64
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+int last_flip(int pos, unsigned long long P)
+{
+	unsigned long long	P8, P7, P9;
+	int	n_flipped;
+	int	x = pos & 7;
+
+	n_flipped = COUNT_FLIP[x][(unsigned char) (P >> (pos & 0x38))];
+
+#ifdef lzcnt_u64
+
+	if (pos < 0x20) {
+		P = vertical_mirror(P);
+		pos ^= 0x38;
+	}
+
+	if (pos >= 0x30) {
+		P <<= (64 - pos);
+		P8 = P & 0x0101010101010101;
+		P7 = P & mask_9_7[x][0];
+		P9 = (P << 8) & mask_9_7[x][1];
+		n_flipped += ((lzcnt_u64(P8) & 0x38) + (lzcnt_u64(P7) & 0x38) + (lzcnt_u64(P9) & 0x38)) >> 2;
+
+		return n_flipped;
+	}
+
+#else // ls1b - slow
+
+	if (pos & 0x10) {	// 0 1 2 3 4 5 6 7 -> 0 1 4 5 4 5 0 1
+		P = vertical_mirror(P);
+		pos ^= 0x38;
+	}
+
+	if (pos < 0x10) {
+		P >>= (pos + 1);
+		P8 = P & 0x0080808080808080;
+		n_flipped += ((P8 & -P8) * 0x00004080c1014180) >> 60;
+		P7 = P & mask_9_7[x][0];
+		n_flipped += ((P7 & -P7) * 0x0001040c2050c000) >> 60;
+		P9 = P & mask_9_7[x][1];
+		n_flipped += ((P9 & -P9) * 0x000010100c080503) >> 60;
+
+		return n_flipped;
+	}
+#endif
+
+	n_flipped += COUNT_FLIP[pos >> 3][packV(P, x)];
+	P7 = P & mask_d[pos - 0x20][0];
+	n_flipped += COUNT_FLIP[x][packD(P7)];
+	P9 = P & mask_d[pos - 0x20][1];
+	n_flipped += COUNT_FLIP[x][packD(P9)];
+
+	return n_flipped;
+}
diff --git a/src/count_last_flip_neon.c b/src/count_last_flip_neon.c
new file mode 100644
index 00000000..45cb89ea
--- /dev/null
+++ b/src/count_last_flip_neon.c
@@ -0,0 +1,293 @@
+/**
+ * @file count_last_flip_neon.c
+ *
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * The basic principle is to read into an array a precomputed result. Doing
+ * this is easy for a single line ; as we can use arrays of the form:
+ *  - COUNT_FLIP[square where we play][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by the 
+ * neon vaddvq_u16 instruction.
+ * Once we get our 8-bits disc patterns, we directly get the number of
+ * flipped discs from the precomputed array, and add them from each flipping
+ * lines.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 1998 - 2023
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include <arm_neon.h>
+
+/** precomputed count flip array */
+const unsigned char COUNT_FLIP[8][256] = {
+	{
+		 0,  0,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		12, 12,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+	},
+	{
+		 0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		10, 10, 10, 10,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 8, 10,  8,  8,  8, 10,  8,  8,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+	},
+	{
+		 0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 6, 10,  8,  8,  6,  6,  6,  6,  6, 10,  8,  8,  6,  6,  6,  6,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+};
+
+#ifdef HAS_CPU_64
+/* bit masks for diagonal lines (interleaved) */
+const uint64x2_t mask_dvhd[64][2] = {
+	{{ 0x000000000000ff01, 0x0000000000000000 }, { 0x0801040102010101, 0x8001400120011001 }},
+	{{ 0x000000000001ff02, 0x0000000000000000 }, { 0x1002080204020202, 0x0002800240022002 }},
+	{{ 0x000000010002ff04, 0x0000000000000000 }, { 0x2004100408040404, 0x0004000480044004 }},
+	{{ 0x000100020004ff08, 0x0000000000000000 }, { 0x4008200810080808, 0x0008000800088008 }},
+	{{ 0x000200040008ff10, 0x0000000000000001 }, { 0x8010401020101010, 0x0010001000100010 }},
+	{{ 0x000400080010ff20, 0x0000000000010002 }, { 0x0020802040202020, 0x0020002000200020 }},
+	{{ 0x000800100020ff40, 0x0000000100020004 }, { 0x0040004080404040, 0x0040004000400040 }},
+	{{ 0x001000200040ff80, 0x0001000200040008 }, { 0x0080008000808080, 0x0080008000800080 }},
+	{{ 0x00000000ff010002, 0x0000000000000000 }, { 0x0401020101010001, 0x4001200110010801 }},
+	{{ 0x00000001ff020004, 0x0000000000000000 }, { 0x0802040202020102, 0x8002400220021002 }},
+	{{ 0x00010002ff040008, 0x0000000000000000 }, { 0x1004080404040204, 0x0004800440042004 }},
+	{{ 0x00020004ff080010, 0x0000000000000001 }, { 0x2008100808080408, 0x0008000880084008 }},
+	{{ 0x00040008ff100020, 0x0000000000010002 }, { 0x4010201010100810, 0x0010001000108010 }},
+	{{ 0x00080010ff200040, 0x0000000100020004 }, { 0x8020402020201020, 0x0020002000200020 }},
+	{{ 0x00100020ff400080, 0x0001000200040008 }, { 0x0040804040402040, 0x0040004000400040 }},
+	{{ 0x00200040ff800000, 0x0002000400080010 }, { 0x0080008080804080, 0x0080008000800080 }},
+	{{ 0x0000ff0100020004, 0x0000000000000000 }, { 0x0201010100010001, 0x2001100108010401 }},
+	{{ 0x0001ff0200040008, 0x0000000000000000 }, { 0x0402020201020002, 0x4002200210020802 }},
+	{{ 0x0002ff0400080010, 0x0000000000000001 }, { 0x0804040402040104, 0x8004400420041004 }},
+	{{ 0x0004ff0800100020, 0x0000000000010002 }, { 0x1008080804080208, 0x0008800840082008 }},
+	{{ 0x0008ff1000200040, 0x0000000100020004 }, { 0x2010101008100410, 0x0010001080104010 }},
+	{{ 0x0010ff2000400080, 0x0001000200040008 }, { 0x4020202010200820, 0x0020002000208020 }},
+	{{ 0x0020ff4000800000, 0x0002000400080010 }, { 0x8040404020401040, 0x0040004000400040 }},
+	{{ 0x0040ff8000000000, 0x0004000800100020 }, { 0x0080808040802080, 0x0080008000800080 }},
+	{{ 0xff01000200040008, 0x0000000000000000 }, { 0x0101000100010001, 0x1001080104010201 }},
+	{{ 0xff02000400080010, 0x0000000000000001 }, { 0x0202010200020002, 0x2002100208020402 }},
+	{{ 0xff04000800100020, 0x0000000000010002 }, { 0x0404020401040004, 0x4004200410040804 }},
+	{{ 0xff08001000200040, 0x0000000100020004 }, { 0x0808040802080108, 0x8008400820081008 }},
+	{{ 0xff10002000400080, 0x0001000200040008 }, { 0x1010081004100210, 0x0010801040102010 }},
+	{{ 0xff20004000800000, 0x0002000400080010 }, { 0x2020102008200420, 0x0020002080204020 }},
+	{{ 0xff40008000000000, 0x0004000800100020 }, { 0x4040204010400840, 0x0040004000408040 }},
+	{{ 0xff80000000000000, 0x0008001000200040 }, { 0x8080408020801080, 0x0080008000800080 }},
+	{{ 0x0002000400080010, 0x000000000000ff01 }, { 0x0001000100010001, 0x0801040102010101 }},
+	{{ 0x0004000800100020, 0x000000000001ff02 }, { 0x0102000200020002, 0x1002080204020202 }},
+	{{ 0x0008001000200040, 0x000000010002ff04 }, { 0x0204010400040004, 0x2004100408040404 }},
+	{{ 0x0010002000400080, 0x000100020004ff08 }, { 0x0408020801080008, 0x4008200810080808 }},
+	{{ 0x0020004000800000, 0x000200040008ff10 }, { 0x0810041002100110, 0x8010401020101010 }},
+	{{ 0x0040008000000000, 0x000400080010ff20 }, { 0x1020082004200220, 0x0020802040202020 }},
+	{{ 0x0080000000000000, 0x000800100020ff40 }, { 0x2040104008400440, 0x0040004080404040 }},
+	{{ 0x0000000000000000, 0x001000200040ff80 }, { 0x4080208010800880, 0x0080008000808080 }},
+	{{ 0x0004000800100020, 0x00000000ff010002 }, { 0x0001000100010001, 0x0401020101010001 }},
+	{{ 0x0008001000200040, 0x00000001ff020004 }, { 0x0002000200020002, 0x0802040202020102 }},
+	{{ 0x0010002000400080, 0x00010002ff040008 }, { 0x0104000400040004, 0x1004080404040204 }},
+	{{ 0x0020004000800000, 0x00020004ff080010 }, { 0x0208010800080008, 0x2008100808080408 }},
+	{{ 0x0040008000000000, 0x00040008ff100020 }, { 0x0410021001100010, 0x4010201010100810 }},
+	{{ 0x0080000000000000, 0x00080010ff200040 }, { 0x0820042002200120, 0x8020402020201020 }},
+	{{ 0x0000000000000000, 0x00100020ff400080 }, { 0x1040084004400240, 0x0040804040402040 }},
+	{{ 0x0000000000000000, 0x00200040ff800000 }, { 0x2080108008800480, 0x0080008080804080 }},
+	{{ 0x0008001000200040, 0x0000ff0100020004 }, { 0x0001000100010001, 0x0201010100010001 }},
+	{{ 0x0010002000400080, 0x0001ff0200040008 }, { 0x0002000200020002, 0x0402020201020002 }},
+	{{ 0x0020004000800000, 0x0002ff0400080010 }, { 0x0004000400040004, 0x0804040402040104 }},
+	{{ 0x0040008000000000, 0x0004ff0800100020 }, { 0x0108000800080008, 0x1008080804080208 }},
+	{{ 0x0080000000000000, 0x0008ff1000200040 }, { 0x0210011000100010, 0x2010101008100410 }},
+	{{ 0x0000000000000000, 0x0010ff2000400080 }, { 0x0420022001200020, 0x4020202010200820 }},
+	{{ 0x0000000000000000, 0x0020ff4000800000 }, { 0x0840044002400140, 0x8040404020401040 }},
+	{{ 0x0000000000000000, 0x0040ff8000000000 }, { 0x1080088004800280, 0x0080808040802080 }},
+	{{ 0x0010002000400080, 0xff01000200040008 }, { 0x0001000100010001, 0x0101000100010001 }},
+	{{ 0x0020004000800000, 0xff02000400080010 }, { 0x0002000200020002, 0x0202010200020002 }},
+	{{ 0x0040008000000000, 0xff04000800100020 }, { 0x0004000400040004, 0x0404020401040004 }},
+	{{ 0x0080000000000000, 0xff08001000200040 }, { 0x0008000800080008, 0x0808040802080108 }},
+	{{ 0x0000000000000000, 0xff10002000400080 }, { 0x0110001000100010, 0x1010081004100210 }},
+	{{ 0x0000000000000000, 0xff20004000800000 }, { 0x0220012000200020, 0x2020102008200420 }},
+	{{ 0x0000000000000000, 0xff40008000000000 }, { 0x0440024001400040, 0x4040204010400840 }},
+	{{ 0x0000000000000000, 0xff80000000000000 }, { 0x0880048002800180, 0x8080408020801080 }}
+};
+#else
+/* bit masks for diagonal lines */
+const uint64x2_t mask_dvhd[64][2] = {
+	{{ 0x0000000000000001, 0x00000000000000ff }, { 0x0101010101010101, 0x8040201008040201 }},
+	{{ 0x0000000000000102, 0x00000000000000ff }, { 0x0202020202020202, 0x0080402010080402 }},
+	{{ 0x0000000000010204, 0x00000000000000ff }, { 0x0404040404040404, 0x0000804020100804 }},
+	{{ 0x0000000001020408, 0x00000000000000ff }, { 0x0808080808080808, 0x0000008040201008 }},
+	{{ 0x0000000102040810, 0x00000000000000ff }, { 0x1010101010101010, 0x0000000080402010 }},
+	{{ 0x0000010204081020, 0x00000000000000ff }, { 0x2020202020202020, 0x0000000000804020 }},
+	{{ 0x0001020408102040, 0x00000000000000ff }, { 0x4040404040404040, 0x0000000000008040 }},
+	{{ 0x0102040810204080, 0x00000000000000ff }, { 0x8080808080808080, 0x0000000000000080 }},
+	{{ 0x0000000000000102, 0x000000000000ff00 }, { 0x0101010101010101, 0x4020100804020100 }},
+	{{ 0x0000000000010204, 0x000000000000ff00 }, { 0x0202020202020202, 0x8040201008040201 }},
+	{{ 0x0000000001020408, 0x000000000000ff00 }, { 0x0404040404040404, 0x0080402010080402 }},
+	{{ 0x0000000102040810, 0x000000000000ff00 }, { 0x0808080808080808, 0x0000804020100804 }},
+	{{ 0x0000010204081020, 0x000000000000ff00 }, { 0x1010101010101010, 0x0000008040201008 }},
+	{{ 0x0001020408102040, 0x000000000000ff00 }, { 0x2020202020202020, 0x0000000080402010 }},
+	{{ 0x0102040810204080, 0x000000000000ff00 }, { 0x4040404040404040, 0x0000000000804020 }},
+	{{ 0x0204081020408000, 0x000000000000ff00 }, { 0x8080808080808080, 0x0000000000008040 }},
+	{{ 0x0000000000010204, 0x0000000000ff0000 }, { 0x0101010101010101, 0x2010080402010000 }},
+	{{ 0x0000000001020408, 0x0000000000ff0000 }, { 0x0202020202020202, 0x4020100804020100 }},
+	{{ 0x0000000102040810, 0x0000000000ff0000 }, { 0x0404040404040404, 0x8040201008040201 }},
+	{{ 0x0000010204081020, 0x0000000000ff0000 }, { 0x0808080808080808, 0x0080402010080402 }},
+	{{ 0x0001020408102040, 0x0000000000ff0000 }, { 0x1010101010101010, 0x0000804020100804 }},
+	{{ 0x0102040810204080, 0x0000000000ff0000 }, { 0x2020202020202020, 0x0000008040201008 }},
+	{{ 0x0204081020408000, 0x0000000000ff0000 }, { 0x4040404040404040, 0x0000000080402010 }},
+	{{ 0x0408102040800000, 0x0000000000ff0000 }, { 0x8080808080808080, 0x0000000000804020 }},
+	{{ 0x0000000001020408, 0x00000000ff000000 }, { 0x0101010101010101, 0x1008040201000000 }},
+	{{ 0x0000000102040810, 0x00000000ff000000 }, { 0x0202020202020202, 0x2010080402010000 }},
+	{{ 0x0000010204081020, 0x00000000ff000000 }, { 0x0404040404040404, 0x4020100804020100 }},
+	{{ 0x0001020408102040, 0x00000000ff000000 }, { 0x0808080808080808, 0x8040201008040201 }},
+	{{ 0x0102040810204080, 0x00000000ff000000 }, { 0x1010101010101010, 0x0080402010080402 }},
+	{{ 0x0204081020408000, 0x00000000ff000000 }, { 0x2020202020202020, 0x0000804020100804 }},
+	{{ 0x0408102040800000, 0x00000000ff000000 }, { 0x4040404040404040, 0x0000008040201008 }},
+	{{ 0x0810204080000000, 0x00000000ff000000 }, { 0x8080808080808080, 0x0000000080402010 }},
+	{{ 0x0000000102040810, 0x000000ff00000000 }, { 0x0101010101010101, 0x0804020100000000 }},
+	{{ 0x0000010204081020, 0x000000ff00000000 }, { 0x0202020202020202, 0x1008040201000000 }},
+	{{ 0x0001020408102040, 0x000000ff00000000 }, { 0x0404040404040404, 0x2010080402010000 }},
+	{{ 0x0102040810204080, 0x000000ff00000000 }, { 0x0808080808080808, 0x4020100804020100 }},
+	{{ 0x0204081020408000, 0x000000ff00000000 }, { 0x1010101010101010, 0x8040201008040201 }},
+	{{ 0x0408102040800000, 0x000000ff00000000 }, { 0x2020202020202020, 0x0080402010080402 }},
+	{{ 0x0810204080000000, 0x000000ff00000000 }, { 0x4040404040404040, 0x0000804020100804 }},
+	{{ 0x1020408000000000, 0x000000ff00000000 }, { 0x8080808080808080, 0x0000008040201008 }},
+	{{ 0x0000010204081020, 0x0000ff0000000000 }, { 0x0101010101010101, 0x0402010000000000 }},
+	{{ 0x0001020408102040, 0x0000ff0000000000 }, { 0x0202020202020202, 0x0804020100000000 }},
+	{{ 0x0102040810204080, 0x0000ff0000000000 }, { 0x0404040404040404, 0x1008040201000000 }},
+	{{ 0x0204081020408000, 0x0000ff0000000000 }, { 0x0808080808080808, 0x2010080402010000 }},
+	{{ 0x0408102040800000, 0x0000ff0000000000 }, { 0x1010101010101010, 0x4020100804020100 }},
+	{{ 0x0810204080000000, 0x0000ff0000000000 }, { 0x2020202020202020, 0x8040201008040201 }},
+	{{ 0x1020408000000000, 0x0000ff0000000000 }, { 0x4040404040404040, 0x0080402010080402 }},
+	{{ 0x2040800000000000, 0x0000ff0000000000 }, { 0x8080808080808080, 0x0000804020100804 }},
+	{{ 0x0001020408102040, 0x00ff000000000000 }, { 0x0101010101010101, 0x0201000000000000 }},
+	{{ 0x0102040810204080, 0x00ff000000000000 }, { 0x0202020202020202, 0x0402010000000000 }},
+	{{ 0x0204081020408000, 0x00ff000000000000 }, { 0x0404040404040404, 0x0804020100000000 }},
+	{{ 0x0408102040800000, 0x00ff000000000000 }, { 0x0808080808080808, 0x1008040201000000 }},
+	{{ 0x0810204080000000, 0x00ff000000000000 }, { 0x1010101010101010, 0x2010080402010000 }},
+	{{ 0x1020408000000000, 0x00ff000000000000 }, { 0x2020202020202020, 0x4020100804020100 }},
+	{{ 0x2040800000000000, 0x00ff000000000000 }, { 0x4040404040404040, 0x8040201008040201 }},
+	{{ 0x4080000000000000, 0x00ff000000000000 }, { 0x8080808080808080, 0x0080402010080402 }},
+	{{ 0x0102040810204080, 0xff00000000000000 }, { 0x0101010101010101, 0x0100000000000000 }},
+	{{ 0x0204081020408000, 0xff00000000000000 }, { 0x0202020202020202, 0x0201000000000000 }},
+	{{ 0x0408102040800000, 0xff00000000000000 }, { 0x0404040404040404, 0x0402010000000000 }},
+	{{ 0x0810204080000000, 0xff00000000000000 }, { 0x0808080808080808, 0x0804020100000000 }},
+	{{ 0x1020408000000000, 0xff00000000000000 }, { 0x1010101010101010, 0x1008040201000000 }},
+	{{ 0x2040800000000000, 0xff00000000000000 }, { 0x2020202020202020, 0x2010080402010000 }},
+	{{ 0x4080000000000000, 0xff00000000000000 }, { 0x4040404040404040, 0x4020100804020100 }},
+	{{ 0x8000000000000000, 0xff00000000000000 }, { 0x8080808080808080, 0x8040201008040201 }}
+};
+#endif
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+int last_flip(int pos, unsigned long long P)
+{
+	unsigned int	n_flips;
+	const unsigned char *COUNT_FLIP_X = COUNT_FLIP[pos & 7];
+	const unsigned char *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+	uint64x2_t	PP = vdupq_n_u64(P);
+	uint64x2_t	II;
+#ifdef HAS_CPU_64	// vaddvq
+	unsigned int t;
+	const uint64x2_t dmask = { 0x0808040402020101, 0x8080404020201010 };
+
+	PP = vreinterpretq_u64_u8(vzip1q_u8(vreinterpretq_u8_u64(PP), vreinterpretq_u8_u64(PP)));
+	II = vandq_u64(PP, mask_dvhd[pos][0]);	// 2 dirs interleaved
+	t = vaddvq_u16(vreinterpretq_u16_u64(II));
+	n_flips  = COUNT_FLIP_X[t >> 8];
+	n_flips += COUNT_FLIP_X[t & 0xFF];
+	II = vandq_u64(vreinterpretq_u64_u8(vtstq_u8(vreinterpretq_u8_u64(PP), vreinterpretq_u8_u64(mask_dvhd[pos][1]))), dmask);
+	t = vaddvq_u16(vreinterpretq_u16_u64(II));
+	n_flips += COUNT_FLIP_Y[t >> 8];
+	n_flips += COUNT_FLIP_Y[t & 0xFF];
+
+#else // Neon kindergarten
+	const uint64x2_t dmask = { 0x1020408001020408, 0x1020408001020408 };
+
+	II = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(vreinterpretq_u8_u64(vandq_u64(PP, mask_dvhd[pos][0])))));
+	n_flips  = COUNT_FLIP_X[vgetq_lane_u32(vreinterpretq_u32_u64(II), 2)];
+	n_flips += COUNT_FLIP_X[vgetq_lane_u32(vreinterpretq_u32_u64(II), 0)];
+	II = vreinterpretq_u64_s8(vnegq_s8(vreinterpretq_s8_u8(vtstq_u8(vreinterpretq_u8_u64(PP), vreinterpretq_u8_u64(mask_dvhd[pos][1])))));
+	II = vpaddlq_u32(vmulq_u32(vreinterpretq_u32_u64(dmask), vreinterpretq_u32_u64(II)));
+	n_flips += COUNT_FLIP_Y[vgetq_lane_u8(vreinterpretq_u8_u64(II), 11)];
+	n_flips += COUNT_FLIP_Y[vgetq_lane_u8(vreinterpretq_u8_u64(II), 3)];
+#endif
+	return n_flips;
+}
+
diff --git a/src/count_last_flip_plain.c b/src/count_last_flip_plain.c
index 24beb6e0..e13e3aad 100644
--- a/src/count_last_flip_plain.c
+++ b/src/count_last_flip_plain.c
@@ -26,7 +26,7 @@
  */
 
 /** precomputed count flip array */
-static const unsigned char COUNT_FLIP[8][256] = {
+const unsigned char COUNT_FLIP[8][256] = {
 	{
 		 0,  0,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
 		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
@@ -110,7 +110,7 @@ static const unsigned char COUNT_FLIP[8][256] = {
 };
 
 /* bit masks for diagonal lines */
-static const unsigned long long mask_d[2][64] = {
+const unsigned long long mask_d[2][64] = {
 	{
 		0x0000000000000001ULL, 0x0000000000000102ULL, 0x0000000000010204ULL, 0x0000000001020408ULL,
 		0x0000000102040810ULL, 0x0000010204081020ULL, 0x0001020408102040ULL, 0x0102040810204080ULL,
@@ -149,6 +149,18 @@ static const unsigned long long mask_d[2][64] = {
 	}
 };
 
+#ifdef HAS_CPU_64
+
+#define	packV(P, x)	(((((P) >> (x)) & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56)
+#define packD(PM)	(((PM) * 0x0101010101010101ULL) >> 56)
+
+#else
+
+#define	packV(P, x)	(((((((unsigned int)(P)) >> (x)) & 0x01010101u) + (((((unsigned int)((P) >> 32)) >> (x)) & 0x01010101u) << 4)) * 0x01020408u) >> 24)
+#define	packD(PM)	(((((unsigned int)(PM)) * 0x01010101u) + (((unsigned int)((PM) >> 32)) * 0x01010101u)) >> 24)
+
+#endif // HAS_CPU_64
+
 /**
  * Count last flipped discs when playing on the last empty.
  *
@@ -158,15 +170,17 @@ static const unsigned long long mask_d[2][64] = {
  */
 int last_flip(int pos, unsigned long long P)
 {
-	unsigned char	n_flipped;
+	unsigned long long PM;
+	int	n_flipped;
 	int	x = pos & 0x07;
 	int	y = pos >> 3;
-	const unsigned char *COUNT_FLIP_X = COUNT_FLIP[x];
 
-	n_flipped  = COUNT_FLIP[y][(((P >> x) & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56];
-	n_flipped += (*COUNT_FLIP_X)[(unsigned char) (P >> (y * 8))];
-	n_flipped += (*COUNT_FLIP_X)[((P & mask_d[0][pos]) * 0x0101010101010101ULL) >> 56];
-	n_flipped += (*COUNT_FLIP_X)[((P & mask_d[1][pos]) * 0x0101010101010101ULL) >> 56];
+	n_flipped  = COUNT_FLIP[y][packV(P, x)];
+	n_flipped += COUNT_FLIP[x][(unsigned char) (P >> (y * 8))];
+	PM = P & mask_d[0][pos];
+	n_flipped += COUNT_FLIP[x][packD(PM)];
+	PM = P & mask_d[1][pos];
+	n_flipped += COUNT_FLIP[x][packD(PM)];
 
 	return n_flipped;
 }
diff --git a/src/count_last_flip_sse.c b/src/count_last_flip_sse.c
new file mode 100644
index 00000000..45fe75de
--- /dev/null
+++ b/src/count_last_flip_sse.c
@@ -0,0 +1,225 @@
+/**
+ * @file count_last_flip_sse.c
+ *
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * The basic principle is to read into an array a precomputed result. Doing
+ * this is easy for a single line ; as we can use arrays of the form:
+ *  - COUNT_FLIP[square where we play][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by the 
+ * SSE PMOVMSKB or PSADBW instruction.
+ * Once we get our 8-bits disc patterns, we directly get the number of
+ * flipped discs from the precomputed array, and add them from each flipping
+ * lines.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 1998 - 2023
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include "bit.h"
+#include <stdint.h>
+
+/** precomputed count flip array */
+const uint8_t COUNT_FLIP[8][256] = {
+	{
+		 0,  0,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		12, 12,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		10, 10,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+		 8,  8,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,  6,  6,  0,  0,  2,  2,  0,  0,  4,  4,  0,  0,  2,  2,  0,  0,
+	},
+	{
+		 0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		10, 10, 10, 10,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 8,  8,  8,  8,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+		 6,  6,  6,  6,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  2,  2,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 8, 10,  8,  8,  8, 10,  8,  8,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 6,  8,  6,  6,  6,  8,  6,  6,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+		 4,  6,  4,  4,  4,  6,  4,  4,  0,  2,  0,  0,  0,  2,  0,  0,  2,  4,  2,  2,  2,  4,  2,  2,  0,  2,  0,  0,  0,  2,  0,  0,
+	},
+	{
+		 0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 6, 10,  8,  8,  6,  6,  6,  6,  6, 10,  8,  8,  6,  6,  6,  6,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 4,  8,  6,  6,  4,  4,  4,  4,  4,  8,  6,  6,  4,  4,  4,  4,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+		 2,  6,  4,  4,  2,  2,  2,  2,  2,  6,  4,  4,  2,  2,  2,  2,  0,  4,  2,  2,  0,  0,  0,  0,  0,  4,  2,  2,  0,  0,  0,  0,
+	},
+	{
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  4,  4,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 2, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  8,  6,  6,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 10,  8,  8,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+	{
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0, 12, 10, 10,  8,  8,  8,  8,  6,  6,  6,  6,  6,  6,  6,  6,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+		 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+	},
+};
+
+/* bit masks for diagonal lines */
+const V4DI mask_dvhd[64] = {
+	{{ 0x0000000000000001, 0x00000000000000ff, 0x0101010101010101, 0x8040201008040201 }},
+	{{ 0x0000000000000102, 0x00000000000000ff, 0x0202020202020202, 0x0080402010080402 }},
+	{{ 0x0000000000010204, 0x00000000000000ff, 0x0404040404040404, 0x0000804020100804 }},
+	{{ 0x0000000001020408, 0x00000000000000ff, 0x0808080808080808, 0x0000008040201008 }},
+	{{ 0x0000000102040810, 0x00000000000000ff, 0x1010101010101010, 0x0000000080402010 }},
+	{{ 0x0000010204081020, 0x00000000000000ff, 0x2020202020202020, 0x0000000000804020 }},
+	{{ 0x0001020408102040, 0x00000000000000ff, 0x4040404040404040, 0x0000000000008040 }},
+	{{ 0x0102040810204080, 0x00000000000000ff, 0x8080808080808080, 0x0000000000000080 }},
+	{{ 0x0000000000000102, 0x000000000000ff00, 0x0101010101010101, 0x4020100804020100 }},
+	{{ 0x0000000000010204, 0x000000000000ff00, 0x0202020202020202, 0x8040201008040201 }},
+	{{ 0x0000000001020408, 0x000000000000ff00, 0x0404040404040404, 0x0080402010080402 }},
+	{{ 0x0000000102040810, 0x000000000000ff00, 0x0808080808080808, 0x0000804020100804 }},
+	{{ 0x0000010204081020, 0x000000000000ff00, 0x1010101010101010, 0x0000008040201008 }},
+	{{ 0x0001020408102040, 0x000000000000ff00, 0x2020202020202020, 0x0000000080402010 }},
+	{{ 0x0102040810204080, 0x000000000000ff00, 0x4040404040404040, 0x0000000000804020 }},
+	{{ 0x0204081020408000, 0x000000000000ff00, 0x8080808080808080, 0x0000000000008040 }},
+	{{ 0x0000000000010204, 0x0000000000ff0000, 0x0101010101010101, 0x2010080402010000 }},
+	{{ 0x0000000001020408, 0x0000000000ff0000, 0x0202020202020202, 0x4020100804020100 }},
+	{{ 0x0000000102040810, 0x0000000000ff0000, 0x0404040404040404, 0x8040201008040201 }},
+	{{ 0x0000010204081020, 0x0000000000ff0000, 0x0808080808080808, 0x0080402010080402 }},
+	{{ 0x0001020408102040, 0x0000000000ff0000, 0x1010101010101010, 0x0000804020100804 }},
+	{{ 0x0102040810204080, 0x0000000000ff0000, 0x2020202020202020, 0x0000008040201008 }},
+	{{ 0x0204081020408000, 0x0000000000ff0000, 0x4040404040404040, 0x0000000080402010 }},
+	{{ 0x0408102040800000, 0x0000000000ff0000, 0x8080808080808080, 0x0000000000804020 }},
+	{{ 0x0000000001020408, 0x00000000ff000000, 0x0101010101010101, 0x1008040201000000 }},
+	{{ 0x0000000102040810, 0x00000000ff000000, 0x0202020202020202, 0x2010080402010000 }},
+	{{ 0x0000010204081020, 0x00000000ff000000, 0x0404040404040404, 0x4020100804020100 }},
+	{{ 0x0001020408102040, 0x00000000ff000000, 0x0808080808080808, 0x8040201008040201 }},
+	{{ 0x0102040810204080, 0x00000000ff000000, 0x1010101010101010, 0x0080402010080402 }},
+	{{ 0x0204081020408000, 0x00000000ff000000, 0x2020202020202020, 0x0000804020100804 }},
+	{{ 0x0408102040800000, 0x00000000ff000000, 0x4040404040404040, 0x0000008040201008 }},
+	{{ 0x0810204080000000, 0x00000000ff000000, 0x8080808080808080, 0x0000000080402010 }},
+	{{ 0x0000000102040810, 0x000000ff00000000, 0x0101010101010101, 0x0804020100000000 }},
+	{{ 0x0000010204081020, 0x000000ff00000000, 0x0202020202020202, 0x1008040201000000 }},
+	{{ 0x0001020408102040, 0x000000ff00000000, 0x0404040404040404, 0x2010080402010000 }},
+	{{ 0x0102040810204080, 0x000000ff00000000, 0x0808080808080808, 0x4020100804020100 }},
+	{{ 0x0204081020408000, 0x000000ff00000000, 0x1010101010101010, 0x8040201008040201 }},
+	{{ 0x0408102040800000, 0x000000ff00000000, 0x2020202020202020, 0x0080402010080402 }},
+	{{ 0x0810204080000000, 0x000000ff00000000, 0x4040404040404040, 0x0000804020100804 }},
+	{{ 0x1020408000000000, 0x000000ff00000000, 0x8080808080808080, 0x0000008040201008 }},
+	{{ 0x0000010204081020, 0x0000ff0000000000, 0x0101010101010101, 0x0402010000000000 }},
+	{{ 0x0001020408102040, 0x0000ff0000000000, 0x0202020202020202, 0x0804020100000000 }},
+	{{ 0x0102040810204080, 0x0000ff0000000000, 0x0404040404040404, 0x1008040201000000 }},
+	{{ 0x0204081020408000, 0x0000ff0000000000, 0x0808080808080808, 0x2010080402010000 }},
+	{{ 0x0408102040800000, 0x0000ff0000000000, 0x1010101010101010, 0x4020100804020100 }},
+	{{ 0x0810204080000000, 0x0000ff0000000000, 0x2020202020202020, 0x8040201008040201 }},
+	{{ 0x1020408000000000, 0x0000ff0000000000, 0x4040404040404040, 0x0080402010080402 }},
+	{{ 0x2040800000000000, 0x0000ff0000000000, 0x8080808080808080, 0x0000804020100804 }},
+	{{ 0x0001020408102040, 0x00ff000000000000, 0x0101010101010101, 0x0201000000000000 }},
+	{{ 0x0102040810204080, 0x00ff000000000000, 0x0202020202020202, 0x0402010000000000 }},
+	{{ 0x0204081020408000, 0x00ff000000000000, 0x0404040404040404, 0x0804020100000000 }},
+	{{ 0x0408102040800000, 0x00ff000000000000, 0x0808080808080808, 0x1008040201000000 }},
+	{{ 0x0810204080000000, 0x00ff000000000000, 0x1010101010101010, 0x2010080402010000 }},
+	{{ 0x1020408000000000, 0x00ff000000000000, 0x2020202020202020, 0x4020100804020100 }},
+	{{ 0x2040800000000000, 0x00ff000000000000, 0x4040404040404040, 0x8040201008040201 }},
+	{{ 0x4080000000000000, 0x00ff000000000000, 0x8080808080808080, 0x0080402010080402 }},
+	{{ 0x0102040810204080, 0xff00000000000000, 0x0101010101010101, 0x0100000000000000 }},
+	{{ 0x0204081020408000, 0xff00000000000000, 0x0202020202020202, 0x0201000000000000 }},
+	{{ 0x0408102040800000, 0xff00000000000000, 0x0404040404040404, 0x0402010000000000 }},
+	{{ 0x0810204080000000, 0xff00000000000000, 0x0808080808080808, 0x0804020100000000 }},
+	{{ 0x1020408000000000, 0xff00000000000000, 0x1010101010101010, 0x1008040201000000 }},
+	{{ 0x2040800000000000, 0xff00000000000000, 0x2020202020202020, 0x2010080402010000 }},
+	{{ 0x4080000000000000, 0xff00000000000000, 0x4040404040404040, 0x4020100804020100 }},
+	{{ 0x8000000000000000, 0xff00000000000000, 0x8080808080808080, 0x8040201008040201 }}
+};
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+int last_flip(int pos, unsigned long long P)
+{
+	uint_fast8_t	n_flips;
+	unsigned int	t;
+	const uint8_t *COUNT_FLIP_X = COUNT_FLIP[pos & 7];
+	const uint8_t *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+  #ifdef AVXLASTFLIP	// no gain
+	__m256i PP = _mm256_set1_epi64x(P);
+
+	n_flips  = COUNT_FLIP_X[(P >> (pos & 0x38)) & 0xFF];
+    #ifdef __AVX512VL__
+    	t = _cvtmask32_u32(_mm256_test_epi8_mask(PP, mask_dvhd[pos].v4));
+    #else
+	t = _mm256_movemask_epi8(_mm256_sub_epi8(_mm256_setzero_si256(), _mm256_and_si256(PP, mask_dvhd[pos].v4)));
+    #endif
+	n_flips += COUNT_FLIP_Y[t & 0xFF];
+	t >>= 16;
+
+  #else
+	__m128i PP = _mm_set1_epi64x(P);
+	__m128i II = _mm_sad_epu8(_mm_and_si128(PP, mask_dvhd[pos].v2[0]), _mm_setzero_si128());
+
+	n_flips  = COUNT_FLIP_X[_mm_extract_epi16(II, 4)];
+	n_flips += COUNT_FLIP_X[_mm_cvtsi128_si32(II)];
+    #ifdef __AVX512VL__
+    	t = _cvtmask16_u32(_mm_test_epi8_mask(PP, mask_dvhd[pos].v2[1]));
+    #else
+	t = _mm_movemask_epi8(_mm_sub_epi8(_mm_setzero_si128(), _mm_and_si128(PP, mask_dvhd[pos].v2[1])));
+    #endif
+  #endif
+	n_flips += COUNT_FLIP_Y[t >> 8];
+	n_flips += COUNT_FLIP_Y[t & 0xFF];
+
+	return n_flips;
+}
+
diff --git a/src/count_last_flip_sve_lzcnt.c b/src/count_last_flip_sve_lzcnt.c
new file mode 100644
index 00000000..85213e8e
--- /dev/null
+++ b/src/count_last_flip_sve_lzcnt.c
@@ -0,0 +1,72 @@
+/**
+ * @file count_last_flip_sve_lzcnt.c
+ *
+ * A function is provided to count the number of fipped disc of the last move.
+ *
+ * Count last flip using the flip_sve_lzcnt way.
+ * For optimization purpose, the value returned is twice the number of flipped
+ * disc, to facilitate the computation of disc difference.
+ *
+ * @date 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include <arm_sve.h>
+
+/** precomputed count flip array */
+extern const unsigned char COUNT_FLIP[8][256];
+
+/**
+ * Count last flipped discs when playing on the last empty.
+ *
+ * @param pos the last empty square.
+ * @param P player's disc pattern.
+ * @return flipped disc count.
+ */
+
+#ifndef __ARM_FEATURE_SVE2
+	// equivalent only if no intersection between masks
+#define svbsl_u64(op1,op2,op3)	svorr_u64_m(pg, (op2), svand_u64_x(pg, (op3), (op1)))
+#define svbsl1n_u64(op1,op2,op3)	svorr_u64_m(pg, (op2), svbic_u64_x(pg, (op3), (op1)))
+#endif
+
+int last_flip(int pos, unsigned long long P)
+{
+	svuint64_t	PP, p_flip, p_oflank, p_eraser, p_cap, mask;
+	svbool_t	pg;
+	const uint64_t	(*pmask)[8];
+
+	PP = svdup_u64(P);
+	pmask = &lrmask[pos];
+	pg = svwhilelt_b64(0, 4);
+
+	mask = svld1_u64(pg, *pmask + 4);	// right: clear all bits lower than outflank
+	p_oflank = svand_x(pg, mask, PP);
+	p_oflank = svand_x(pg, svclz_z(pg, p_oflank), 63);
+	p_eraser = svlsr_x(pg, svdup_u64(-1), p_oflank);
+	p_flip = svbic_x(pg, mask, p_eraser);
+
+	mask = svld1_u64(pg, *pmask + 0);	// left: look for player LS1B
+	p_oflank = svand_x(pg, mask, PP);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	p_cap = svbic_x(pg, svqsub(p_oflank, 1), p_oflank);
+	p_flip = svbsl_u64(p_cap, p_flip, mask);
+
+	if (svcntd() == 2) {	// sve128 only
+		mask = svld1_u64(pg, *pmask + 6);	// right: set all bits higher than outflank
+		p_oflank = svand_x(pg, mask, PP);
+		p_oflank = svand_x(pg, svclz_z(pg, p_oflank), 63);
+		p_eraser = svlsr_x(pg, svdup_u64(-1), p_oflank);
+		p_flip = svbsl1n_u64(p_eraser, p_flip, mask);
+
+		mask = svld1_u64(pg, *pmask + 2);	// left: look for player LS1B
+		p_oflank = svand_x(pg, mask, PP);
+			// set all bits lower than oflank, using satulation if oflank = 0
+		p_cap = svbic_x(pg, svqsub(p_oflank, 1), p_oflank);
+		p_flip = svbsl_u64(p_cap, p_flip, mask);
+	}
+
+	return svaddv_u64(pg, svcnt_u64_x(pg, p_flip)) * 2;
+}
diff --git a/src/edax.c b/src/edax.c
index cc380cbf..e25b9754 100644
--- a/src/edax.c
+++ b/src/edax.c
@@ -3,7 +3,7 @@
  *
  * @brief Edax protocol.
  *
- * This is version 4.4 of Edax User Interface. Several changes
+ * This is version 4.5 of Edax User Interface. Several changes
  * occurred between this version and 3.x previous versions because of the
  * evolution of the search engine. Here is a summary of the commands:
  *
@@ -12,7 +12,7 @@
  *   -verbose [n]          set Edax verbosity (default 1).
  *   -noise [n]            start displaying Edax search result from this depth\n  (default 5).
  *   -witdh [n]            display edax search results using <width> characters\n  (default 80).
- *   -hash-table-size [n]  set hashtable size (default 18 bits).
+ *   -hash-table-size [n]  set hashtable size (default 22 bits).
  *   -n-tasks [n]          control the number of parallel threads used in searching\n  (default 1).
  *   -l|level [n]          search using limited depth (default 21).
  *   -t|game-time <time>   search using limited time per game.
@@ -70,12 +70,12 @@
  *   -add [file]          add positions from a game base file (txt, ggf, sgf or\n  wthor format).
  *
  * Game DataBase Commands:
- *   -convert [file_in] [file_out]     convert between different format.
- *   -unique [file_in] [file_out]      remove doublons in the base.
+ *   -convert [file_in] [file_out]     convert between different format.
+ *   -unique [file_in] [file_out]      remove doublons in the base.
  *   -check [file_in] [n]              check error in the last <n> moves.
  *   -correct [file_in] [n]            correct error in the last <n> moves.
  *   -complete [file_in]               complete a database by playing the last\n  missing moves.
- *   -problem [file_in] [n] [file_out] build a set of <n> problems from a game\n  database.
+ *   -problem [file_in] [n] [file_out] build a set of <n> problems from a game\n  database.
  *
  * Tests commands:
  *   -solve [file]        solve a set of positions.
@@ -89,7 +89,7 @@
  *   -count shapes [d]    compute the number of shapes from the current position up\n  to depth [d].
  *
  *
- * @date 1998 - 2017
+ * @date 1998 - 2018
  * @author Richard Delorme
  * @version 4.4
  *
@@ -139,11 +139,11 @@ void ui_init_edax(UI *ui)
 	Play *play = ui->play;
 
 	book_verbose = true;
-	play_init(play, ui->book);
-	ui->book->search = play->search;
-	book_load(ui->book, options.book_file);
-	play->search->id = 1;
-	search_set_observer(play->search, edax_observer);
+	play_init(play, &ui->book);
+	ui->book.search = &play->search;
+	book_load(&ui->book, options.book_file);
+	play->search.id = 1;
+	search_set_observer(&play->search, edax_observer);
 	ui->mode = options.mode;
 	play->type = ui->type;
 
@@ -156,8 +156,8 @@ void ui_init_edax(UI *ui)
  */
 void ui_free_edax(UI *ui)
 {
-	if (ui->book->need_saving) book_save(ui->book, options.book_file);
-	book_free(ui->book);
+	if (ui->book.need_saving) book_save(&ui->book, options.book_file);
+	book_free(&ui->book);
 	play_free(ui->play);
 	log_close(edax_log);
 	book_verbose = false;
@@ -168,23 +168,23 @@ void ui_free_edax(UI *ui)
  */
 void help_options(void) 
 {
-	printf("Options:\n");
-	printf("Options must be entered in the form '[set] <option> [=] <value>', with [set] and\n[=] being optional.\n");
-	printf("  verbose [n]          set Edax verbosity (default 1).\n");
-	printf("  noise [n]            start displaying Edax search result from this depth\n  (default 5).\n");
-	printf("  witdh [n]            display edax search results using <width> characters\n  (default 80).\n");
-	printf("  hash-table-size [n]  set hashtable size (default 18 bits).\n");
-	printf("  n-tasks [n]          control the number of parallel threads used in searching\n  (default 1).\n");
-	printf("  l|level [n]          search using limited depth (default 21).\n");
-	printf("  t|game-time <time>   search using limited time per game.\n");
-	printf("  move-time <time>     search using limited time per move.\n");
-	printf("  ponder [on/off]      set pondering on/off.\n");
-	printf("  book-file [file]     use [file] as default book file (default data/book.dat).\n");
-	printf("  book-usage [on/off]  use or do not use the opening book.\n");
-	printf("  book-randomness [n]  play various but worse moves from the opening book.\n");
-	printf("  auto-start [on/off]  automatically start a new game.\n");
-	printf("  auto-swap [on/off]   automatically swap players between each game.\n");
-	printf("  auto-store [on/off]  automatically store each game into the opening book.\n");
+	printf(	"Options:\n"
+		"Options must be entered in the form '[set] <option> [=] <value>', with [set] and\n[=] being optional.\n"
+		"  verbose [n]          set Edax verbosity (default 1).\n"
+		"  noise [n]            start displaying Edax search result from this depth\n  (default 5).\n"
+		"  witdh [n]            display edax search results using <width> characters\n  (default 80).\n"
+		"  hash-table-size [n]  set hashtable size (default 22 bits).\n"
+		"  n-tasks [n]          control the number of parallel threads used in searching\n  (default 1).\n"
+		"  l|level [n]          search using limited depth (default 21).\n"
+		"  t|game-time <time>   search using limited time per game.\n"
+		"  move-time <time>     search using limited time per move.\n"
+		"  ponder [on/off]      set pondering on/off.\n"
+		"  book-file [file]     use [file] as default book file (default data/book.dat).\n"
+		"  book-usage [on/off]  use or do not use the opening book.\n"
+		"  book-randomness [n]  play various but worse moves from the opening book.\n"
+		"  auto-start [on/off]  automatically start a new game.\n"
+		"  auto-swap [on/off]   automatically swap players between each game.\n"
+		"  auto-store [on/off]  automatically store each game into the opening book.\n");
 }
 
 /**
@@ -192,25 +192,25 @@ void help_options(void)
  */
 void help_commands(void) 
 {
-	printf("\nCommands:\n");
-	printf("Commands must be entered in the form '<command> <parameters>'.\n");
-	printf("  i|nit               start a new game from standard initial position.\n");
-	printf("  n|ew                start a new game from a personalized position.\n");
-	printf("  setboard <board>    set a personalized position to start from.\n");
-	printf("  o|open|load [file]  load a played game.\n");
-	printf("  s|save [file]       save a played game.\n");
-	printf("  q|quit|exit         quit from edax.\n");
-	printf("  u|undo              undo the last played move.\n");
-	printf("  r|redo              redo the last played move.\n");
-	printf("  play <moves>        play a sequence of moves.\n");
-	printf("  force <moves>       force to play an opening.\n");
-	printf("  go                  ask edax to play.\n");
-	printf("  stop                stop edax search.\n");
-	printf("  hint [n]            ask edax to search the first bestmoves.\n");
-	printf("  m|mode [n]          ask edax to automatically play (default = 3).\n");
-	printf("  a|analyze [n]       retro-analyze the game.\n");
-	printf("  ?|help              show this message.\n");
-	printf("  v|version           display the version number.\n");
+	printf(	"\nCommands:\n"
+		"Commands must be entered in the form '<command> <parameters>'.\n"
+		"  i|nit               start a new game from standard initial position.\n"
+		"  n|ew                start a new game from a personalized position.\n"
+		"  setboard <board>    set a personalized position to start from.\n"
+		"  o|open|load [file]  load a played game.\n"
+		"  s|save [file]       save a played game.\n"
+		"  q|quit|exit         quit from edax.\n"
+		"  u|undo              undo the last played move.\n"
+		"  r|redo              redo the last played move.\n"
+		"  play <moves>        play a sequence of moves.\n"
+		"  force <moves>       force to play an opening.\n"
+		"  go                  ask edax to play.\n"
+		"  stop                stop edax search.\n"
+		"  hint [n]            ask edax to search the first bestmoves.\n"
+		"  m|mode [n]          ask edax to automatically play (default = 3).\n"
+		"  a|analyze [n]       retro-analyze the game.\n"
+		"  ?|help              show this message.\n"
+		"  v|version           display the version number.\n");
 }
 
 /**
@@ -218,30 +218,30 @@ void help_commands(void)
  */
 void help_book(void) 
 {
-	printf("\nBook Commands:\n");
-	printf("Book Commands must be entered in the form 'b|book <command> <parameters>'.\n");
-	printf("  new <n1> <n2>       create a new empty book with level <n1> and depth <n2>.\n");
-	printf("  load [file]         load an opening book from a binary opening file.\n");
-	printf("  merge [file]        merge an opening book with the current opening book.\n");
-	printf("  save [file]         save an opening book to a binary opening file.\n");
-	printf("  import [file]       load an opening book from a portable text file.\n");
-	printf("  export [file]       save an opening book to a portable text file.\n");
-	printf("  on                  use the opening book.\n");
-	printf("  off                 do not use the opening book.\n");
-	printf("  show                display details about the current position.\n");
-	printf("  info                display book general information.\n");
-	printf("  a|analyze [n]       retro-analyze the game using the opening book.\n");
-	printf("  randomness [n]      play more various but worse move from the opening book.\n");
-	printf("  depth [n]           change book depth (up to which to add positions).\n");
-	printf("  deepen [n]          change book level & reevalute the whole book (very slow!).\n");
-	printf("  fix                 fix the opening book: add missing links and negamax the\n  whole book tree.\n");
-	printf("  store               add the last played game to the opening book.\n");
-	printf("  deviate <n1> <n2>   add positions by deviating with a relative error <n1> and\n  an absolute error <n2>.\n");
-	printf("  enhance <n1> <n2>   add positions by improving score accuracy with a midgame\n  error <n1> and an endcut error <n2>.\n");
-	printf("  fill [n]            add positions between existing positions.\n");
-	printf("  prune               remove unreachable positions.\n");
-	printf("  subtree             only keep positions from the current position.\n");
-	printf("  add [file]          add positions from a game base file (txt, ggf, sgf or\n  wthor format).\n");
+	printf(	"\nBook Commands:\n"
+		"Book Commands must be entered in the form 'b|book <command> <parameters>'.\n"
+		"  new <n1> <n2>       create a new empty book with level <n1> and depth <n2>.\n"
+		"  load [file]         load an opening book from a binary opening file.\n"
+		"  merge [file]        merge an opening book with the current opening book.\n"
+		"  save [file]         save an opening book to a binary opening file.\n"
+		"  import [file]       load an opening book from a portable text file.\n"
+		"  export [file]       save an opening book to a portable text file.\n"
+		"  on                  use the opening book.\n"
+		"  off                 do not use the opening book.\n"
+		"  show                display details about the current position.\n"
+		"  info                display book general information.\n"
+		"  a|analyze [n]       retro-analyze the game using the opening book.\n"
+		"  randomness [n]      play more various but worse move from the opening book.\n"
+		"  depth [n]           change book depth (up to which to add positions).\n"
+		"  deepen [n]          change book level & reevalute the whole book (very slow!).\n"
+		"  fix                 fix the opening book: add missing links and negamax the\n  whole book tree.\n"
+		"  store               add the last played game to the opening book.\n"
+		"  deviate <n1> <n2>   add positions by deviating with a relative error <n1> and\n  an absolute error <n2>.\n"
+		"  enhance <n1> <n2>   add positions by improving score accuracy with a midgame\n  error <n1> and an endcut error <n2>.\n"
+		"  fill [n]            add positions between existing positions.\n"
+		"  prune               remove unreachable positions.\n"
+		"  subtree             only keep positions from the current position.\n"
+		"  add [file]          add positions from a game base file (txt, ggf, sgf or\n  wthor format).\n");
 }
 
 /**
@@ -249,13 +249,13 @@ void help_book(void)
  */
 void help_base(void) 
 {
-	printf("\nGame DataBase :\n");
-	printf("  convert [file_in] [file_out]     convert between different format.\n");
-	printf("  unique [file_in] [file_out]      remove doublons in the base.\n");
-	printf("  check [file_in] [n]              check error in the last <n> moves.\n");
-	printf("  correct [file_in] [n]            correct error in the last <n> moves.\n");
-	printf("  complete [file_in]               complete a database by playing the last\n  missing moves.\n");
-	printf("  problem [file_in] [n] [file_out] build a set of <n> problems from a game\n  database.\n");
+	printf(	"\nGame DataBase :\n"
+		"  convert [file_in] [file_out]     convert between different format.\n"
+		"  unique [file_in] [file_out]      remove doublons in the base.\n"
+		"  check [file_in] [n]              check error in the last <n> moves.\n"
+		"  correct [file_in] [n]            correct error in the last <n> moves.\n"
+		"  complete [file_in]               complete a database by playing the last\n  missing moves.\n"
+		"  problem [file_in] [n] [file_out] build a set of <n> problems from a game\n  database.\n");
 }
 
 /**
@@ -263,17 +263,17 @@ void help_base(void)
  */
 void help_test(void) 
 {
-	printf("\nTests:\n");
-	printf("  bench               test edax speed.\n");
-	printf("  microbench          test CPU cycle speed of some major functions.\n");
-	printf("  obftest [file]      Test from an obf file.\n");
-	printf("  script-to-obf [file]Convert a script to an obf file.\n");
-	printf("  wtest [file]        check the theoric scores of a wthor base file.\n");
-	printf("  count games [d]     compute the number of moves from the current position up\n  to depth [d].\n");
-	printf("  perft [d]           same as above, but without hash table.\n");
-	printf("  estimate [d] [n]    estimate the number of moves from the current position up\n  to depth [d].\n");
-	printf("  count positions [d] compute the number of positions from the current position\n  up to depth [d].\n");
-	printf("  count shapes [d]    compute the number of shapes from the current position up\n  to depth [d].\n");
+	printf(	"\nTests:\n"
+		"  bench               test edax speed.\n"
+		"  microbench          test CPU cycle speed of some major functions.\n"
+		"  obftest [file]      Test from an obf file.\n"
+		"  script-to-obf [file]Convert a script to an obf file.\n"
+		"  wtest [file]        check the theoric scores of a wthor base file.\n"
+		"  count games [d]     compute the number of moves from the current position up\n  to depth [d].\n"
+		"  perft [d]           same as above, but without hash table.\n"
+		"  estimate [d] [n]    estimate the number of moves from the current position up\n  to depth [d].\n"
+		"  count positions [d] compute the number of positions from the current position\n  up to depth [d].\n"
+		"  count shapes [d]    compute the number of shapes from the current position up\n  to depth [d].\n");
 }
 
 
@@ -281,6 +281,14 @@ void help_test(void)
  * @brief Loop event.
  * @param ui user interface.
  */
+static void ui_play_print(Play *play, FILE *f)
+{
+	putc('\n', f);
+	play_print(play, f);
+	if (play_is_game_over(play)) fputs("\n*** Game Over ***\n", f);
+	putc('\n', f);
+}
+
 void ui_loop_edax(UI *ui)
 {
 	char *cmd = NULL, *param = NULL;
@@ -295,19 +303,11 @@ void ui_loop_edax(UI *ui)
 	for (;;) {
 		errno = 0;
 
-		if (options.verbosity) {
-			putchar('\n');
-			play_print(play, stdout);
-			if (play_is_game_over(play)) printf("\n*** Game Over ***\n");
-			putchar('\n');
-		}
+		if (options.verbosity)
+			ui_play_print(play, stdout);
 
-		if (log_is_open(edax_log)) {
-			putc('\n', edax_log->f);
-			play_print(play, edax_log->f);
-			if (play_is_game_over(play)) fputs("\n*** Game Over ***\n", edax_log->f);
-			putc('\n', edax_log->f);
-		}
+		if (log_is_open(edax_log))
+			ui_play_print(play, edax_log->f);
 
 		// edax turn ? (automatic play mode)
 		if (!ui_event_exist(ui) && !play_is_game_over(play) && (ui->mode == !play->player || ui->mode == 2)) {
@@ -360,7 +360,7 @@ void ui_loop_edax(UI *ui)
 
 			// new game from standard position
 			} else if (strcmp(cmd, "i") == 0 || strcmp(cmd, "init") == 0) {
-				board_init(play->initial_board);
+				board_init(&play->initial_board);
 				play->initial_player = BLACK;
 				play_force_init(play, "F5");
 				play_new(play);
@@ -459,16 +459,16 @@ void ui_loop_edax(UI *ui)
 				char problem_file[FILENAME_MAX + 1], *hard_file;
 				hard_file = parse_word(param, problem_file, FILENAME_MAX);
 				parse_word(hard_file, hard_file, FILENAME_MAX);
-				obf_test(play->search, problem_file, hard_file);
-				search_set_observer(play->search, edax_observer);
+				obf_test(&play->search, problem_file, hard_file);
+				search_set_observer(&play->search, edax_observer);
 
 			// convert a set of problems in a .script file to a .obf file
 			} else if (strcmp(cmd, "script-to-obf") == 0) {
 				char script_file[FILENAME_MAX + 1], *obf_file;
 				obf_file = parse_word(param, script_file, FILENAME_MAX);
 				parse_word(obf_file, obf_file, FILENAME_MAX);
-				script_to_obf(play->search, script_file, obf_file);
-				search_set_observer(play->search, edax_observer);
+				script_to_obf(&play->search, script_file, obf_file);
+				search_set_observer(&play->search, edax_observer);
 
 			} else if (strcmp(cmd, "select-hard") == 0) {
 				char full_file[FILENAME_MAX + 1], *hard_file;
@@ -483,14 +483,14 @@ void ui_loop_edax(UI *ui)
 
 				count_param = parse_word(param, count_cmd, 15);
 				count_param = parse_int(count_param, &depth); BOUND(depth, 1, 90, "max-ply");
-				if (count_param) parse_int(count_param, &size); BOUND(size, 6, 8, "board-size");
+				/* if (count_param) */ parse_int(count_param, &size); BOUND(size, 6, 8, "board-size");
 
 				if (strcmp(count_cmd, "games") == 0) { // game enumeration
-					quick_count_games(play->board, depth, size);
+					quick_count_games(&play->board, depth, size);
 				} else if (strcmp(count_cmd, "positions") == 0) { // position enumeration
-					count_positions(play->board, depth, size);
+					count_positions(&play->board, depth, size);
 				} else if (strcmp(count_cmd, "shapes") == 0) { // shape enumeration
-					count_shapes(play->board, depth, size);
+					count_shapes(&play->board, depth, size);
 				} else {
 					warn("Unknown count command: \"%s %s\"\n", cmd, param);
 				}
@@ -498,21 +498,21 @@ void ui_loop_edax(UI *ui)
 			} else if (strcmp(cmd, "perft") == 0) {
 				int depth = 14;
 				depth = string_to_int(param, 10); BOUND(depth, 1, 90, "max-ply");
-				count_games(play->board, depth);
+				count_games(&play->board, depth);
 			
 			// game/position enumeration
 			} else if (strcmp(cmd, "estimate") == 0) {
 				int n = 1000;
 				n = string_to_int(param, 10); BOUND(n, 1, 2000000000, "max-trials");
 
-				estimate_games(play->board, n);
+				estimate_games(&play->board, n);
 	
 			// seek highest mobility
 			} else if (strcmp(cmd, "mobility") == 0) {
 				int t = 3600; // 1 hour
 				t = string_to_int(param, 10); BOUND(t, 1, 3600*24*365*10, "max time");
 
-				seek_highest_mobility(play->board, t);
+				seek_highest_mobility(&play->board, t);
 
 			// seek a position
 			} else if (strcmp(cmd, "seek") == 0) {
@@ -522,7 +522,7 @@ void ui_loop_edax(UI *ui)
 				board_set(&target, param);
 				line_init(&solution, play->player);
 				
-				if (seek_position(&target, play->board, &solution)) {
+				if (seek_position(&target, &play->board, &solution)) {
 					printf("Solution found:\n");
 					line_print(&solution, 200, " ", stdout);
 					putchar('\n');
@@ -535,11 +535,11 @@ void ui_loop_edax(UI *ui)
 			// bench (a serie of low level tests).
 			} else if (strcmp(cmd, "bench") == 0) {
 				int n = string_to_int(param, -1); BOUND(n, -1, 100, "n_problems");
-				obf_speed(play->search, n);
+				obf_speed(&play->search, n);
 
 			// wtest test the engine against wthor theoretical scores
 			} else if (strcmp(cmd, "wtest") == 0) {
-				wthor_test(param, play->search);
+				wthor_test(param, &play->search);
 
 			// make wthor games played by "Edax (Delorme)" as "Etudes" tournament.
 			} else if (strcmp(cmd, "edaxify") == 0) {
@@ -547,7 +547,7 @@ void ui_loop_edax(UI *ui)
 
 			// wtest test the engine against wthor theoretical scores
 			} else if (strcmp(cmd, "weval") == 0) {
-				wthor_eval(param, play->search, histogram);
+				wthor_eval(param, &play->search, histogram);
 				histogram_print(histogram);
 				histogram_stats(histogram);
 				histogram_to_ppm("weval.ppm", histogram);
@@ -579,10 +579,10 @@ void ui_loop_edax(UI *ui)
 
 			// debug pv
 			} else if (strcmp(cmd, "debug-pv") == 0) {
-				Move move[1];
-				if (parse_move(param, play->board, move) != param) {
-					search_set_board(play->search, play->board, play->player);
-					pv_debug(play->search, move, stdout);
+				Move move;
+				if (parse_move(param, &play->board, &move) != param) {
+					search_set_board(&play->search, &play->board, play->player);
+					pv_debug(&play->search, &move, stdout);
 				}
 			} else if (strcmp(cmd, "options") == 0) {
 					options_dump(stdout);
@@ -623,7 +623,7 @@ void ui_loop_edax(UI *ui)
 				int val_1, val_2;
 				Book *book = play->book;
 
-				book->search = play->search;
+				book->search = &play->search;
 				book->search->options.verbosity = book->options.verbosity;
 				book_param = parse_word(param, book_cmd, FILENAME_MAX);
 
@@ -684,12 +684,12 @@ void ui_loop_edax(UI *ui)
 
 				// merge an opening book to the current one
 				} else if (strcmp(book_cmd, "merge") == 0) {
-					Book src[1];
+					Book src;
 					parse_word(book_param, book_file, FILENAME_MAX);
-					src->search = play->search;
-					book_load(src, book_file);
-					book_merge(book, src);
-					book_free(src);
+					src.search = &play->search;
+					book_load(&src, book_file);
+					book_merge(book, &src);
+					book_free(&src);
 					warn("Book needs to be fixed before usage\n");
 
 				// fix an opening book
@@ -722,7 +722,7 @@ void ui_loop_edax(UI *ui)
 
 				// subtree an opening book
 				} else if (strcmp(book_cmd, "subtree") == 0) {
-					book_subtree(book, play->board); // remove unreachable lines.
+					book_subtree(book, &play->board); // remove unreachable lines.
 					book_fix(book); // do nothing (or edax is buggy)
 					book_link(book); // links nodes
 					book_negamax(book); // negamax nodes
@@ -730,7 +730,7 @@ void ui_loop_edax(UI *ui)
 
 				// show the current position as stored in the book
 				} else if (strcmp(book_cmd, "show") == 0) {
-					book_show(book, play->board);
+					book_show(book, &play->board);
 
 				// show book general information
 				} else if (strcmp(book_cmd, "info") == 0) {
@@ -753,21 +753,21 @@ void ui_loop_edax(UI *ui)
 
 				// add positions from a game database
 				} else if (strcmp(book_cmd, "add") == 0) {
-					Base base[1];
+					Base base;
 					parse_word(book_param, book_file, FILENAME_MAX);
-					base_init(base);
-					base_load(base, book_file);
-					book_add_base(book, base);
-					base_free(base);
+					base_init(&base);
+					base_load(&base, book_file);
+					book_add_base(book, &base);
+					base_free(&base);
 
 				// check positions from a game database
 				} else if (strcmp(book_cmd, "check") == 0) {
-					Base base[1];
+					Base base;
 					parse_word(book_param, book_file, FILENAME_MAX);
-					base_init(base);
-					base_load(base, book_file);
-					book_check_base(book, base);
-					base_free(base);
+					base_init(&base);
+					base_load(&base, book_file);
+					book_check_base(book, &base);
+					base_free(&base);
 
 				// extract positions
 				} else if (strcmp(book_cmd, "problem") == 0) {
@@ -777,24 +777,24 @@ void ui_loop_edax(UI *ui)
 					
 				// extract pv to a game database
 				} else if (strcmp(book_cmd, "extract") == 0) {
-					Base base[1];
+					Base base;
 					parse_word(book_param, book_file, FILENAME_MAX);
-					base_init(base);
-					book_extract_skeleton(book, base);
-					base_save(base, book_file);
-					base_free(base);
+					base_init(&base);
+					book_extract_skeleton(book, &base);
+					base_save(&base, book_file);
+					base_free(&base);
 
 				// add position using the "deviate algorithm"
 				} else if (strcmp(book_cmd, "deviate") == 0) {
 					val_1 = 2; book_param = parse_int(book_param, &val_1); BOUND(val_1, -129, 129, "relative error");
 					val_2 = 4; book_param = parse_int(book_param, &val_2); BOUND(val_2, 0, 65, "absolute error");
-					book_deviate(book, play->board, val_1, val_2);
+					book_deviate(book, &play->board, val_1, val_2);
 
 				// add position using the "enhance algorithm"
 				} else if (strcmp(book_cmd, "enhance") == 0) {
 					val_1 = 2; book_param = parse_int(book_param, &val_1); BOUND(val_1, 0, 129, "midgame error");
 					val_2 = 4; book_param = parse_int(book_param, &val_2); BOUND(val_2, 0, 129, "endcut error");
-					book_enhance(book, play->board, val_1, val_2);
+					book_enhance(book, &play->board, val_1, val_2);
 
 				// add position by filling hole in the book
 				} else if (strcmp(book_cmd, "fill") == 0) {
@@ -811,7 +811,7 @@ void ui_loop_edax(UI *ui)
 
 				// add book positions to the hash table
 				} else if (strcmp(book_cmd, "feed-hash") == 0) {
-					book_feed_hash(book, play->board, play->search);
+					book_feed_hash(book, &play->board, &play->search);
 
 				// wrong command ?
 				} else {
@@ -824,9 +824,9 @@ void ui_loop_edax(UI *ui)
 			} else if (strcmp(cmd, "base") == 0) {
 				char base_file[FILENAME_MAX + 1];
 				char base_cmd[512], *base_param;
-				Base base[1];
+				Base base;
 
-				base_init(base);
+				base_init(&base);
 				base_param = parse_word(param, base_cmd, 511);
 				base_param = parse_word(base_param, base_file, FILENAME_MAX);
 
@@ -837,8 +837,8 @@ void ui_loop_edax(UI *ui)
 					base_param = parse_int(base_param, &n_empties);
 					base_param = parse_word(base_param, problem_file, FILENAME_MAX);
 
-					base_load(base, base_file);
-					base_to_problem(base, n_empties, problem_file);
+					base_load(&base, base_file);
+					base_to_problem(&base, n_empties, problem_file);
 
 				// extract FEN 
 				} else if (strcmp(base_cmd, "tofen") == 0) {
@@ -847,46 +847,46 @@ void ui_loop_edax(UI *ui)
 					base_param = parse_int(base_param, &n_empties);
 					base_param = parse_word(base_param, problem_file, FILENAME_MAX);
 
-					base_load(base, base_file);
-					base_to_FEN(base, n_empties, problem_file);
+					base_load(&base, base_file);
+					base_to_FEN(&base, n_empties, problem_file);
 	
 				// correct erroneous games
 				} else if (strcmp(base_cmd, "correct") == 0) {
 					int n_empties = 24;
 					base_param = parse_int(base_param, &n_empties);
 
-					base_load(base, base_file);
-					base_analyze(base, play->search, n_empties, true);
+					base_load(&base, base_file);
+					base_analyze(&base, &play->search, n_empties, true);
 					remove(base_file);
-					base_save(base, base_file);
+					base_save(&base, base_file);
 
 				// check erroneous games
 				} else if (strcmp(base_cmd, "check") == 0) {
 					int n_empties = 24;
 					base_param = parse_int(base_param, &n_empties);
 
-					base_load(base, base_file);
-					base_analyze(base, play->search, n_empties, false);
+					base_load(&base, base_file);
+					base_analyze(&base, &play->search, n_empties, false);
 
 				// terminate unfinished base
 				} else if (strcmp(base_cmd, "complete") == 0) {
-					base_load(base, base_file);
-					base_complete(base, play->search);
+					base_load(&base, base_file);
+					base_complete(&base, &play->search);
 					remove(base_file);
-					base_save(base, base_file);
+					base_save(&base, base_file);
 
 				// convert a base to another format
 				} else if (strcmp(base_cmd, "convert") == 0) {
-					base_load(base, base_file);
+					base_load(&base, base_file);
 					base_param = parse_word(base_param, base_file, FILENAME_MAX);
-					base_save(base, base_file);
+					base_save(&base, base_file);
 
 				// make a base unique by removing identical games
 				} else if (strcmp(base_cmd, "unique") == 0) {
-					base_load(base, base_file);
+					base_load(&base, base_file);
 					base_param = parse_word(base_param, base_file, FILENAME_MAX);
-					base_unique(base);
-					base_save(base, base_file);
+					base_unique(&base);
+					base_save(&base, base_file);
 
 				// compare two game bases
 				} else if (strcmp(base_cmd, "compare") == 0) {
@@ -898,15 +898,15 @@ void ui_loop_edax(UI *ui)
 					warn("Unknown base command: \"%s %s\"\n", cmd, param);
 				}
 
-				base_free(base);
+				base_free(&base);
 
 			/* edax options */
 			} else if (options_read(cmd, param)) {
 				options_bound();
 				// parallel search changes:
-				if (search_count_tasks(play->search) != options.n_task) {
+				if (search_count_tasks(&play->search) != options.n_task) {
 					play_stop_pondering(play);
-					search_set_task_number(play->search, options.n_task);
+					search_set_task_number(&play->search, options.n_task);
 				}
 
 			/* switch to another protocol */
@@ -953,8 +953,8 @@ void ui_loop_edax(UI *ui)
 				char *w_name;
 				play_stop_pondering(play);
 				w_name = parse_word(param, problem, FILENAME_MAX);
-				tune_move_evaluate(play->search, problem, parse_skip_spaces(w_name));
-				search_set_observer(play->search, edax_observer);
+				tune_move_evaluate(&play->search, problem, parse_skip_spaces(w_name));
+				search_set_observer(&play->search, edax_observer);
 #endif
 			/* illegal cmd/move */
 			} else {
diff --git a/src/empty.h b/src/empty.h
index 63f4f6b2..e8ba902b 100644
--- a/src/empty.h
+++ b/src/empty.h
@@ -3,7 +3,7 @@
  *
  * List of empty squares.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -13,11 +13,8 @@
 
 /** double linked list of squares */
 typedef struct SquareList {
-	unsigned long long b;         /*!< bit representation of the square location */
-	int x;                        /*!< square location */
-	int quadrant;                 /*!< parity quadrant */
-	struct SquareList *previous;  /*!< link to previous square */
-	struct SquareList *next;      /*!< link to next square */
+	unsigned char previous;	/*!< link to previous square */
+	unsigned char next;	/*!< link to next square */
 } SquareList;
 
 /**
@@ -25,10 +22,12 @@ typedef struct SquareList {
  *
  * @param empty  empty square.
  */
-static inline void empty_remove(SquareList *empty)
+static inline void empty_remove(SquareList *empty, int index)
 {
-	empty->previous->next = empty->next;
-	empty->next->previous = empty->previous;
+	int	next = empty[index].next;
+	int	prev = empty[index].previous;
+	empty[prev].next = next;
+	empty[next].previous = prev;
 }
 
 /**
@@ -36,23 +35,15 @@ static inline void empty_remove(SquareList *empty)
  *
  * @param empty  empty square.
  */
-static inline void empty_restore(SquareList *empty)
+static inline void empty_restore(SquareList *empty, int index)
 {
-	empty->previous->next = empty;
-	empty->next->previous = empty;
+	empty[empty[index].previous].next = index;
+	empty[empty[index].next].previous = index;
 }
 
 /** Loop over all empty squares */
-#define foreach_empty(empty, list)\
-	for ((empty) = (list)->next; (empty)->next; (empty) = (empty)->next)
-
-/** Loop over all empty squares on even quadrants */
-#define foreach_even_empty(empty, list, parity)\
-	for ((empty) = (list)->next; (empty)->next; (empty) = (empty)->next) if ((parity & empty->quadrant) == 0)
-
-/** Loop over all empty squares on odd quadrants */
-#define foreach_odd_empty(empty, list, parity)\
-	for ((empty) = (list)->next; (empty)->next; (empty) = (empty)->next) if (parity & empty->quadrant)
+#define foreach_empty(index, empty)\
+	for ((index) = (empty)[NOMOVE].next; index != NOMOVE; (index) = (empty)[index].next)
 
 #endif
 
diff --git a/src/endgame.c b/src/endgame.c
index f1a81cac..375cb741 100644
--- a/src/endgame.c
+++ b/src/endgame.c
@@ -3,9 +3,10 @@
  *
  * Search near the end of the game.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2024
  * @author Richard Delorme
- * @version 4.4
+ * @author Toshihiko Okuhara
+ * @version 4.5
  */
 
 
@@ -18,26 +19,50 @@
 
 #include <assert.h>
 
+#if LAST_FLIP_COUNTER == COUNT_LAST_FLIP_CARRY
+	#include "count_last_flip_carry_64.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_SSE
+	#include "count_last_flip_sse.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_BITSCAN
+	#include "count_last_flip_bitscan.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_PLAIN
+	#include "count_last_flip_plain.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_32
+	#include "count_last_flip_32.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_BMI2
+	#include "count_last_flip_bmi2.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_AVX_PPFILL
+	#include "count_last_flip_avx_ppfill.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_AVX512
+	#include "count_last_flip_avx512cd.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_NEON
+	#include "count_last_flip_neon.c"
+#elif LAST_FLIP_COUNTER == COUNT_LAST_FLIP_SVE
+	#include "count_last_flip_sve_lzcnt.c"
+#else // LAST_FLIP_COUNTER == COUNT_LAST_FLIP_KINDERGARTEN
+	#include "count_last_flip_kindergarten.c"
+#endif
+
 /**
  * @brief Get the final score.
  *
  * Get the final score, when no move can be made.
  *
- * @param board Board.
+ * @param player Board.player
  * @param n_empties Number of empty squares remaining on the board.
  * @return The final score, as a disc difference.
  */
-static inline int board_solve(const Board *board, const int n_empties)
+static int board_solve(const unsigned long long player, const int n_empties)
 {
-	const int n_discs_p = bit_count(board->player);
-	const int n_discs_o = 64 - n_empties - n_discs_p;
-	register int score = n_discs_p - n_discs_o;
+	int score = bit_count(player) * 2 - SCORE_MAX;	// in case of opponents win
+	int diff = score + n_empties;		// = n_discs_p - (64 - n_empties - n_discs_p)
 
 	SEARCH_STATS(++statistics.n_search_solve);
 
-	if (score < 0) score -= n_empties;
-	else if (score > 0) score += n_empties;
-
+	if (diff == 0)
+		score = diff;
+	else if (diff > 0)
+		score = diff + n_empties;
 	return score;
 }
 
@@ -51,22 +76,7 @@ static inline int board_solve(const Board *board, const int n_empties)
  */
 int search_solve(const Search *search)
 {
-	return board_solve(search->board, search->n_empties);
-}
-
-/**
- * @brief Get the final score.
- *
- * Get the final score, when the board is full.
- *
- * @param board Board.
- * @return The final score, as a disc difference.
- */
-static inline int board_solve_0(const Board *board)
-{
-	SEARCH_STATS(++statistics.n_search_solve_0);
-
-	return 2 * bit_count(board->player) - SCORE_MAX;
+	return board_solve(search->board.player, search->eval.n_empties);
 }
 
 /**
@@ -79,41 +89,43 @@ static inline int board_solve_0(const Board *board)
  */
 int search_solve_0(const Search *search)
 {
-	return board_solve_0(search->board);
+	SEARCH_STATS(++statistics.n_search_solve_0);
+
+	return 2 * bit_count(search->board.player) - SCORE_MAX;
 }
 
+#if ((MOVE_GENERATOR == MOVE_GENERATOR_AVX) || (MOVE_GENERATOR == MOVE_GENERATOR_AVX512) || (MOVE_GENERATOR == MOVE_GENERATOR_SSE)) && ((LAST_FLIP_COUNTER == COUNT_LAST_FLIP_SSE) || (LAST_FLIP_COUNTER >= COUNT_LAST_FLIP_BMI2))
+	#include "endgame_sse.c"	// vectorcall version
+#elif ((MOVE_GENERATOR == MOVE_GENERATOR_NEON) || (MOVE_GENERATOR == MOVE_GENERATOR_SVE)) && ((LAST_FLIP_COUNTER == COUNT_LAST_FLIP_NEON) || ((LAST_FLIP_COUNTER == COUNT_LAST_FLIP_SVE) && defined(SIMULLASTFLIP)))
+	#include "endgame_neon.c"
+#else
 /**
  * @brief Get the final score.
  *
- * Get the final score, when 1 empty squares remain.
+ * Get the final score, when 1 empty square remain.
  * The following code has been adapted from Zebra by Gunnar Anderson.
  *
- * @param board  Board to evaluate.
- * @param beta   Beta bound.
+ * @param player Board.player to evaluate.
+ * @param alpha  Alpha bound. (beta - 1)
  * @param x      Last empty square to play.
- * @return       The final opponent score, as a disc difference.
+ * @return       The final score, as a disc difference.
  */
-inline int board_score_1(const Board *board, const int beta, const int x)
+int board_score_1(const unsigned long long player, const int alpha, const int x)
 {
-	register int score, n_flips;
-
-	score = 2 * bit_count(board->opponent) - SCORE_MAX;
-
-	if ((n_flips = count_last_flip(x, board->player)) != 0) {
-		score -= n_flips;
-	} else {
-		if (score >= 0) {
-			score += 2;
-			if (score < beta) { // lazy cut-off
-				n_flips = count_last_flip(x, board->opponent);
-				score += n_flips;
-			}
-		} else {
-			if (score < beta) { // lazy cut-off
-				if ((n_flips = count_last_flip(x, board->opponent)) != 0) {
-					score += n_flips + 2;
-				}
-			}
+	int score, score2, n_flips;
+
+	score = 2 * bit_count(player) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+
+	n_flips = last_flip(x, player);
+	score += n_flips;
+
+	if (n_flips == 0) {	// (23%)
+		score2 = score - 2;	// empty for opponent
+		if (score <= 0)
+			score = score2;
+		if (score > alpha) {	// lazy cut-off (40%)
+			if ((n_flips = last_flip(x, ~player)) != 0)	// (98%)
+				score = score2 - n_flips;
 		}
 	}
 
@@ -123,233 +135,263 @@ inline int board_score_1(const Board *board, const int beta, const int x)
 /**
  * @brief Get the final score.
  *
- * Get the final score, when 2 empty squares remain.
+ * Get the final min score, when 2 empty squares remain.
  *
- * @param board The board to evaluate.
+ * @param player Board.player to evaluate.
+ * @param opponent Board.opponent to evaluate.
  * @param alpha Alpha bound.
  * @param x1 First empty square coordinate.
  * @param x2 Second empty square coordinate.
- * @param search Search.
- * @return The final score, as a disc difference.
+ * @param n_nodes Node counter.
+ * @return The final min score, as a disc difference.
  */
-static int board_solve_2(Board *board, int alpha, const int x1, const int x2, Search *search)
+static int board_solve_2(unsigned long long player, unsigned long long opponent, int alpha, int x1, int x2, volatile unsigned long long *n_nodes)
 {
-	Board next[1];
-	register int score, bestscore;
-	const int beta = alpha + 1;
+	unsigned long long flipped;
+	int score, bestscore, nodes;
+	// const int beta = alpha + 1;
 
 	SEARCH_STATS(++statistics.n_board_solve_2);
-	SEARCH_UPDATE_INTERNAL_NODES();
-
-	if ((NEIGHBOUR[x1] & board->opponent) && board_next(board, x1, next)) {
-		SEARCH_UPDATE_INTERNAL_NODES();
-		bestscore = board_score_1(next, beta, x2);
-	} else bestscore = -SCORE_INF;
 
-	if (bestscore < beta) {
-		if ((NEIGHBOUR[x2] & board->opponent) && board_next(board, x2, next)) {
-			SEARCH_UPDATE_INTERNAL_NODES();
-			score = board_score_1(next, beta, x1);
-			if (score > bestscore) bestscore = score;
-		}
-
-		// pass
-		if (bestscore == -SCORE_INF) {
-
-			if ((NEIGHBOUR[x1] & board->player) && board_pass_next(board, x1, next)) {
-				SEARCH_UPDATE_INTERNAL_NODES();
-				bestscore = -board_score_1(next, -alpha, x2);
-			} else bestscore = SCORE_INF;
-
-			if (bestscore > alpha) {
-				if ((NEIGHBOUR[x2] & board->player) && board_pass_next(board, x2, next)) {
-					SEARCH_UPDATE_INTERNAL_NODES();
-					score = -board_score_1(next, -alpha, x1);
-					if (score < bestscore) bestscore = score;
-				}
-				// gameover
-				if (bestscore == SCORE_INF) bestscore = board_solve(board, 2);
-			}
+	if ((NEIGHBOUR[x1] & opponent) && (flipped = Flip(x1, player, opponent))) {	// (84%/84%)
+		bestscore = board_score_1(opponent ^ flipped, alpha, x2);
+
+		if ((bestscore > alpha) && (NEIGHBOUR[x2] & opponent) && (flipped = Flip(x2, player, opponent))) {	// (50%/93%/92%)
+			score = board_score_1(opponent ^ flipped, alpha, x1);
+			if (score < bestscore)
+				bestscore = score;
+			nodes = 3;
+		} else	nodes = 2;
+
+	} else if ((NEIGHBOUR[x2] & opponent) && (flipped = Flip(x2, player, opponent))) {	// (96%/75%)
+		bestscore = board_score_1(opponent ^ flipped, alpha, x1);
+		nodes = 2;
+
+	} else {	// pass (17%) - NEIGHBOUR test is almost 100% true
+		alpha = ~alpha;	// = -alpha - 1
+		if ((flipped = Flip(x1, opponent, player))) {	// (95%)
+			bestscore = board_score_1(player ^ flipped, alpha, x2);
+
+			if ((bestscore > alpha) && (flipped = Flip(x2, opponent, player))) {	// (20%/100%)
+				score = board_score_1(player ^ flipped, alpha, x1);
+				if (score < bestscore)
+					bestscore = score;
+				nodes = 3;
+			} else	nodes = 2;
+
+		} else if ((flipped = Flip(x2, opponent, player))) {	// (97%)
+			bestscore = board_score_1(player ^ flipped, alpha, x1);
+			nodes = 2;
+
+		} else {	// gameover
+			bestscore = board_solve(player, 2);
+			nodes = 1;
 		}
+		bestscore = -bestscore;
 	}
 
- 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
- 	assert((bestscore & 1) == 0);
+	SEARCH_UPDATE_2EMPTIES_NODES(*n_nodes += nodes;)
+	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+	assert((bestscore & 1) == 0);
 	return bestscore;
 }
 
 /**
  * @brief Get the final score.
  *
- * Get the final score, when 3 empty squares remain.
+ * Get the final max score, when 3 empty squares remain.
  *
- * @param search Search.
+ * @param player Board.player to evaluate.
+ * @param opponent Board.opponent to evaluate.
  * @param alpha Alpha bound.
- * @return The final score, as a disc difference.
+ * @param sort3 Parity flags.
+ * @param x1 First empty square coordinate.
+ * @param x2 Second empty square coordinate.
+ * @param x3 Third empty square coordinate.
+ * @param n_nodes Node counter.
+ * @return The final max score, as a disc difference.
  */
-static int search_solve_3(Search *search, const int alpha)
+static int search_solve_3(unsigned long long player, unsigned long long opponent, int alpha, int sort3, int x1, int x2, int x3, volatile unsigned long long *n_nodes)
 {
-	Board *board = search->board;
-	Board next[1];
-	SquareList *empty = search->empties->next;
-	int x1 = empty->x;
-	int x2 = (empty = empty->next)->x;
-	int x3 = empty->next->x;
-	register int score, bestscore;
-	const int beta = alpha + 1;
+	unsigned long long flipped, next_player, next_opponent;
+	int score, bestscore, pol, tmp;
+	// const int beta = alpha + 1;
 
 	SEARCH_STATS(++statistics.n_search_solve_3);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(*n_nodes);
 
 	// parity based move sorting
-	if (!(search->parity & QUADRANT_ID[x1])) {
-		if (search->parity & QUADRANT_ID[x2]) { // case 1(x2) 2(x1 x3)
-			int tmp = x1; x1 = x2; x2 = tmp;
-		} else { // case 1(x3) 2(x1 x2)
-			int tmp = x1; x1 = x3; x3 = x2; x2 = tmp;
-		}
-	}
-
-	// best move alphabeta search
-	if ((NEIGHBOUR[x1] & board->opponent) && board_next(board, x1, next)) {
-		bestscore = -board_solve_2(next, -beta, x2, x3, search);
-		if (bestscore >= beta) return bestscore;
-	} else bestscore = -SCORE_INF;
-
-	if ((NEIGHBOUR[x2] & board->opponent) && board_next(board, x2, next)) {
-		score = -board_solve_2(next, -beta, x1, x3, search);
-		if (score >= beta) return score;
-		else if (score > bestscore) bestscore = score;
+	switch (sort3 & 0x03) {
+		case 1:
+			tmp = x1; x1 = x2; x2 = tmp;	// case 1(x2) 2(x1 x3)
+			break;
+		case 2:
+			tmp = x1; x1 = x3; x3 = x2; x2 = tmp;	// case 1(x3) 2(x1 x2)
+			break;
+		case 3:
+			tmp = x2; x2 = x3; x3 = tmp;
+			break;
 	}
 
-	if ((NEIGHBOUR[x3] & board->opponent) && board_next(board, x3, next)) {
-		score = -board_solve_2(next, -beta, x1, x2, search);
-		if (score > bestscore) bestscore = score;
-	}
-
-	// pass ?
-	if (bestscore == -SCORE_INF) {
+	bestscore = -SCORE_INF;
+	pol = 1;
+	do {
 		// best move alphabeta search
-		if ((NEIGHBOUR[x1] & board->player) && board_pass_next(board, x1, next)) {
-			bestscore = board_solve_2(next, alpha, x2, x3, search);
-			if (bestscore <= alpha) return bestscore;
-		} else bestscore = SCORE_INF;
-
-		if ((NEIGHBOUR[x2] & board->player) && board_pass_next(board, x2, next)) {
-			score = board_solve_2(next, alpha, x1, x3, search);
-			if (score <= alpha) return score;
-			else if (score < bestscore) bestscore = score;
+		if ((NEIGHBOUR[x1] & opponent) && (flipped = Flip(x1, player, opponent))) {	// (89%/91%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x1));
+			bestscore = board_solve_2(next_player, next_opponent, alpha, x2, x3, n_nodes);
+			if (bestscore > alpha) return bestscore * pol;	// (78%/63%)
 		}
 
-		if ((NEIGHBOUR[x3] & board->player) && board_pass_next(board, x3, next)) {
-			score = board_solve_2(next, alpha, x1, x2, search);
-			if (score < bestscore) bestscore = score;
+		if (/* (NEIGHBOUR[x2] & opponent) && */ (flipped = Flip(x2, player, opponent))) {	// (97%/78%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x2));
+			score = board_solve_2(next_player, next_opponent, alpha, x1, x3, n_nodes);
+			if (score > alpha) return score * pol;	// (32%/9%)
+			else if (score > bestscore) bestscore = score;
 		}
 
-		// gameover
-		if (bestscore == SCORE_INF) bestscore = board_solve(board, 3);
-	}
+		if (/* (NEIGHBOUR[x3] & opponent) && */ (flipped = Flip(x3, player, opponent))) {	// (100%/89%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x3));
+			score = board_solve_2(next_player, next_opponent, alpha, x1, x2, n_nodes);
+			if (score > bestscore) bestscore = score;
+			return bestscore * pol;	// (26%)
+		}
 
- 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
-	return bestscore;
+		if (bestscore > -SCORE_INF)	// (76%)
+			return bestscore * pol;	// (9%)
+
+		next_opponent = player; player = opponent; opponent = next_opponent;	// pass
+		alpha = ~alpha;	// = -(alpha + 1)
+	} while ((pol = -pol) < 0);
+
+	return board_solve(player, 3);	// gameover
 }
 
 /**
  * @brief Get the final score.
  *
- * Get the final score, when 4 empty squares remain.
+ * Get the final min score, when 4 empty squares remain.
  *
  * @param search Search position.
  * @param alpha Upper score value.
- * @return The final score, as a disc difference.
+ * @return The final min score, as a disc difference.
  */
-static int search_solve_4(Search *search, const int alpha)
+static int search_solve_4(Search *search, int alpha)
 {
-	Board *board = search->board;
-	SquareList *empty = search->empties->next;
-	int x1 = empty->x;
-	int x2 = (empty = empty->next)->x;
-	int x3 = (empty = empty->next)->x;
-	int x4 = empty->next->x;
-	Move move[1];
-	int score, bestscore;
-	const int beta = alpha + 1;
+	unsigned long long player, opponent, flipped, next_player, next_opponent;
+	int x1, x2, x3, x4, tmp, paritysort, score, bestscore, pol;
+	// const int beta = alpha + 1;
+	static const unsigned char parity_case[64] = {	/* x4x3x2x1 = */
+		/*0000*/  0, /*0001*/  0, /*0010*/  1, /*0011*/  9, /*0100*/  2, /*0101*/ 10, /*0110*/ 11, /*0111*/  3,
+		/*0002*/  0, /*0003*/  0, /*0012*/  0, /*0013*/  0, /*0102*/  4, /*0103*/  4, /*0112*/  5, /*0113*/  5,
+		/*0020*/  1, /*0021*/  0, /*0030*/  1, /*0031*/  0, /*0120*/  6, /*0121*/  7, /*0130*/  6, /*0131*/  7,
+		/*0022*/  9, /*0023*/  0, /*0032*/  0, /*0033*/  9, /*0122*/  8, /*0123*/  0, /*0132*/  0, /*0133*/  8,
+		/*0200*/  2, /*0201*/  4, /*0210*/  6, /*0211*/  8, /*0300*/  2, /*0301*/  4, /*0310*/  6, /*0311*/  8,
+		/*0202*/ 10, /*0203*/  4, /*0212*/  7, /*0213*/  0, /*0302*/  4, /*0303*/ 10, /*0312*/  0, /*0313*/  7,
+		/*0220*/ 11, /*0221*/  5, /*0230*/  6, /*0231*/  0, /*0320*/  6, /*0321*/  0, /*0330*/ 11, /*0331*/  5,
+		/*0222*/  3, /*0223*/  5, /*0232*/  7, /*0233*/  8, /*0322*/  8, /*0323*/  7, /*0332*/  5, /*0333*/  3
+	};
+	int sort3;	// for move sorting on 3 empties
+	static const short sort3_shuf[] = {
+		0x0000,	//  0: 1(x1) 3(x2 x3 x4), 1(x1) 1(x2) 2(x3 x4), 1 1 1 1, 4		x4x1x2x3-x3x1x2x4-x2x1x3x4-x1x2x3x4
+		0x1100,	//  1: 1(x2) 3(x1 x3 x4)	x4x2x1x3-x3x2x1x4-x2x1x3x4-x1x2x3x4
+		0x2011,	//  2: 1(x3) 3(x1 x2 x4)	x4x3x1x2-x3x1x2x4-x2x3x1x4-x1x3x2x4
+		0x0222,	//  3: 1(x4) 3(x1 x2 x3)	x4x1x2x3-x3x4x1x2-x2x4x1x3-x1x4x2x3
+		0x3000,	//  4: 1(x1) 1(x3) 2(x2 x4)	x4x1x2x3-x2x1x3x4-x3x1x2x4-x1x3x2x4 <- x4x1x3x2-x2x1x3x4-x3x1x2x4-x1x3x2x4
+		0x3300,	//  5: 1(x1) 1(x4) 2(x2 x3)	x3x1x2x4-x2x1x3x4-x4x1x2x3-x1x4x2x3 <- x3x1x4x2-x2x1x4x3-x4x1x2x3-x1x4x2x3
+		0x2000,	//  6: 1(x2) 1(x3) 2(x1 x4)	x4x1x2x3-x1x2x3x4-x3x2x1x4-x2x3x1x4 <- x4x2x3x1-x1x2x3x4-x3x2x1x4-x2x3x1x4
+		0x2300,	//  7: 1(x2) 1(x4) 2(x1 x3)	x3x1x2x4-x1x2x3x4-x4x2x1x3-x2x4x1x3 <- x3x2x4x1-x1x2x4x3-x4x2x1x3-x2x4x1x3
+		0x2200,	//  8: 1(x3) 1(x4) 2(x1 x2)	x2x1x3x4-x1x2x3x4-x4x3x1x2-x3x4x1x2 <- x2x3x4x1-x1x3x4x2-x4x3x1x2-x3x4x1x2
+		0x2200,	//  9: 2(x1 x2) 2(x3 x4)	x4x3x1x2-x3x4x1x2-x2x1x3x4-x1x2x3x4
+		0x1021,	// 10: 2(x1 x3) 2(x2 x4)	x4x2x1x3-x3x1x2x4-x2x4x1x3-x1x3x2x4
+		0x0112	// 11: 2(x1 x4) 2(x2 x3)	x4x1x2x3-x3x2x1x4-x2x3x1x4-x1x4x2x3
+	};
 
 	SEARCH_STATS(++statistics.n_search_solve_4);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	// stability cutoff
-	if (search_SC_NWS(search, alpha, &score)) return score;
+	// stability cutoff (try 12%, cut 7%)
+	if (search_SC_NWS_4(search, alpha, &score)) return score;
+
+	x1 = search->empties[NOMOVE].next;
+	x2 = search->empties[x1].next;
+	x3 = search->empties[x2].next;
+	x4 = search->empties[x3].next;
 
 	// parity based move sorting.
 	// The following hole sizes are possible:
 	//    4 - 1 3 - 2 2 - 1 1 2 - 1 1 1 1
-	// Only the 1 1 2 case needs move sorting.
-	if (!(search->parity & QUADRANT_ID[x1])) {
-		if (search->parity & QUADRANT_ID[x2]) {
-			if (search->parity & QUADRANT_ID[x3]) { // case 1(x2) 1(x3) 2(x1 x4)
-				int tmp = x1; x1 = x2; x2 = x3; x3 = tmp;
-			} else { // case 1(x2) 1(x4) 2(x1 x3)
-				int tmp = x1; x1 = x2; x2 = x4; x4 = x3; x3 = tmp;
-			}
-		} else if (search->parity & QUADRANT_ID[x3]) { // case 1(x3) 1(x4) 2(x1 x2)
-			int tmp = x1; x1 = x3; x3 = tmp; tmp = x2; x2 = x4; x4 = tmp;
-		}
-	} else {
-		if (!(search->parity & QUADRANT_ID[x2])) {
-			if (search->parity & QUADRANT_ID[x3]) { // case 1(x1) 1(x3) 2(x2 x4)
-				int tmp = x2; x2 = x3; x3 = tmp;
-			} else { // case 1(x1) 1(x4) 2(x2 x3)
-				int tmp = x2; x2 = x4; x4 = x3; x3 = tmp;
-			}
-		}
+	// Only the 1 1 2 case needs move sorting on this ply.
+	paritysort = parity_case[((x3 ^ x4) & 0x24) + ((((x2 ^ x4) & 0x24) * 2 + ((x1 ^ x4) & 0x24)) >> 2)];
+	switch (paritysort) {
+		case 4: // case 1(x1) 1(x3) 2(x2 x4)
+			tmp = x2; x2 = x3; x3 = tmp;
+			break;
+		case 5: // case 1(x1) 1(x4) 2(x2 x3)
+			tmp = x2; x2 = x4; x4 = x3; x3 = tmp;
+			break;
+		case 6:	// case 1(x2) 1(x3) 2(x1 x4)
+			tmp = x1; x1 = x2; x2 = x3; x3 = tmp;
+			break;
+		case 7: // case 1(x2) 1(x4) 2(x1 x3)
+			tmp = x1; x1 = x2; x2 = x4; x4 = x3; x3 = tmp;
+			break;
+		case 8:	// case 1(x3) 1(x4) 2(x1 x2)
+			tmp = x1; x1 = x3; x3 = tmp; tmp = x2; x2 = x4; x4 = tmp;
+			break;
 	}
+	sort3 = sort3_shuf[paritysort];
 
-	// best move alphabeta search
-	if ((NEIGHBOUR[x1] & board->opponent) && board_get_move(board, x1, move)) {
-		search_update_endgame(search, move);
-			bestscore = -search_solve_3(search, -beta);
-		search_restore_endgame(search, move);
-		if (bestscore >= beta) return bestscore;
-	} else bestscore = -SCORE_INF;
-
-	if ((NEIGHBOUR[x2] & board->opponent) && board_get_move(board, x2, move)) {
-		search_update_endgame(search, move);
-			score = -search_solve_3(search, -beta);
-		search_restore_endgame(search, move);
-		if (score >= beta) return score;
-		else if (score > bestscore) bestscore = score;
-	}
+	player = search->board.player;
+	opponent = search->board.opponent;
+	bestscore = SCORE_INF;	// min stage
+	pol = 1;
+	do {
+		// best move alphabeta search
+		if ((NEIGHBOUR[x1] & opponent) && (flipped = Flip(x1, player, opponent))) {	// (76%/77%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x1));
+			bestscore = search_solve_3(next_player, next_opponent, alpha, sort3, x2, x3, x4, &search->n_nodes);
+			if (bestscore <= alpha) return bestscore * pol;	// (68%)
+		}
 
-	if ((NEIGHBOUR[x3] & board->opponent) && board_get_move(board, x3, move)) {
-		search_update_endgame(search, move);
-			score = -search_solve_3(search, -beta);
-		search_restore_endgame(search, move);
-		if (score >= beta) return score;
-		else if (score > bestscore) bestscore = score;
-	}
+		if ((NEIGHBOUR[x2] & opponent) && (flipped = Flip(x2, player, opponent))) {	// (87%/84%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x2));
+			score = search_solve_3(next_player, next_opponent, alpha, sort3 >> 4, x1, x3, x4, &search->n_nodes);
+			if (score <= alpha) return score * pol;	// (37%)
+			else if (score < bestscore) bestscore = score;
+		}
 
-	if ((NEIGHBOUR[x4] & board->opponent) && board_get_move(board, x4, move)) {
-		search_update_endgame(search, move);
-			score = -search_solve_3(search, -beta);
-		search_restore_endgame(search, move);
-		if (score > bestscore) bestscore = score;
-	}
+		if ((NEIGHBOUR[x3] & opponent) && (flipped = Flip(x3, player, opponent))) {	// (77%/80%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x3));
+			score = search_solve_3(next_player, next_opponent, alpha, sort3 >> 8, x1, x2, x4, &search->n_nodes);
+			if (score <= alpha) return score * pol;	// (14%)
+			else if (score < bestscore) bestscore = score;
+		}
 
-	// no move
-	if (bestscore == -SCORE_INF) {
-		if (can_move(board->opponent, board->player)) { // pass
-			search_pass_endgame(search);
-				bestscore = -search_solve_4(search, -beta);
-			search_pass_endgame(search);
-		} else { // gameover
-			bestscore = search_solve(search);
+		if ((NEIGHBOUR[x4] & opponent) && (flipped = Flip(x4, player, opponent))) {	// (79%/88%)
+			next_player = opponent ^ flipped;
+			next_opponent = player ^ (flipped | x_to_bit(x4));
+			score = search_solve_3(next_player, next_opponent, alpha, sort3 >> 12, x1, x2, x3, &search->n_nodes);
+			if (score < bestscore) bestscore = score;
+			return bestscore * pol;	// (37%)
 		}
-	}
 
- 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
-	return bestscore;
+		if (bestscore < SCORE_INF)	// (72%)
+			return bestscore * pol;	// (13%)
+
+		next_opponent = player; player = opponent; opponent = next_opponent;	// pass
+		alpha = ~alpha;	// = -(alpha + 1)
+	} while ((pol = -pol) < 0);
+
+	return board_solve(opponent, 4);	// gameover
 }
+#endif
 
 /**
  * @brief  Evaluate a position using a shallow NWS.
@@ -359,79 +401,101 @@ static int search_solve_4(Search *search, const int alpha)
  * Move ordering is constricted to the hole parity and the type of squares.
  * No hashtable are used and anticipated cut-off is limited to stability cut-off.
  *
- * @param search Search.
+ * @param search Search. (breaks board and parity; caller has a copy)
  * @param alpha Alpha bound.
  * @return The final score, as a disc difference.
  */
-static int search_shallow(Search *search, const int alpha)
+static int search_shallow(Search *search, const int alpha, bool pass1)
 {
-	Board *board = search->board;
-	SquareList *empty;
-	Move move;
-	int score, bestscore = -SCORE_INF;
-	const int beta = alpha + 1;
+	unsigned long long moves, prioritymoves;
+	int x, prev, score, bestscore;
+	// const int beta = alpha + 1;
+	V2DI board0;
+	unsigned int parity0;
 
 	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
-	assert(0 <= search->n_empties && search->n_empties <= DEPTH_TO_SHALLOW_SEARCH);
+	assert(0 <= search->eval.n_empties && search->eval.n_empties <= DEPTH_TO_SHALLOW_SEARCH);
 
 	SEARCH_STATS(++statistics.n_NWS_shallow);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	// stability cutoff
+	// stability cutoff (try 8%, cut 7%)
 	if (search_SC_NWS(search, alpha, &score)) return score;
 
-	if (search->parity > 0 && search->parity < 15) {
-
-		foreach_odd_empty (empty, search->empties, search->parity) {
-			if ((NEIGHBOUR[empty->x] & board->opponent)
-			&& board_get_move(board, empty->x, &move)) {
-				search_update_endgame(search, &move);
-					if (search->n_empties == 4) score = -search_solve_4(search, -beta);
-					else score = -search_shallow(search, -beta);
-				search_restore_endgame(search, &move);
-				if (score >= beta) return score;
-				else if (score > bestscore) bestscore = score;
-			}
-		}
+	board0.board = search->board;
+	moves = vboard_get_moves(board0);
+	if (moves == 0) {	// pass (2%)
+		if (pass1)	// gameover (1%)
+			return search_solve(search);
 
-		foreach_even_empty (empty, search->empties, search->parity) {
-			if ((NEIGHBOUR[empty->x] & board->opponent)
-			&& board_get_move(board, empty->x, &move)) {
-				search_update_endgame(search, &move);
-					if (search->n_empties == 4) score = -search_solve_4(search, -beta);
-					else score = -search_shallow(search, -beta);
-				search_restore_endgame(search, &move);
-				if (score >= beta) return score;
-				else if (score > bestscore) bestscore = score;
-			}
-		}
-	} else 	{
-		foreach_empty (empty, search->empties) {
-			if ((NEIGHBOUR[empty->x] & board->opponent)
-			&& board_get_move(board, empty->x, &move)) {
-				search_update_endgame(search, &move);
-					if (search->n_empties == 4) score = -search_solve_4(search, -beta);
-					else score = -search_shallow(search, -beta);
-				search_restore_endgame(search, &move);
-				if (score >= beta) return score;
-				else if (score > bestscore) bestscore = score;
-			}
-		}
+		search_pass(search);
+		bestscore = -search_shallow(search, ~alpha, true);
+		// search_pass(search);
+		return bestscore;
 	}
 
-	// no move
-	if (bestscore == -SCORE_INF) {
-		if (can_move(board->opponent, board->player)) { // pass
-			search_pass_endgame(search);
-				bestscore = -search_shallow(search, -beta);
-			search_pass_endgame(search);
-		} else { // gameover
-			bestscore = search_solve(search);
-		}
+	bestscore = -SCORE_INF;
+	parity0 = search->eval.parity;
+	prioritymoves = moves & quadrant_mask[parity0];
+	if (prioritymoves == 0)	// all even
+		prioritymoves = moves;
+
+	if (search->eval.n_empties == 5)	// transfer to search_solve_n, no longer uses n_empties, parity (53%)
+		do {
+			moves ^= prioritymoves;
+			x = NOMOVE;
+			do {
+				do {
+					x = search->empties[prev = x].next;
+				} while (!(prioritymoves & x_to_bit(x)));	// (58%)
+
+				prioritymoves &= ~x_to_bit(x);
+				search->empties[prev].next = search->empties[x].next;	// remove - maintain single link only
+				vboard_next(board0, x, &search->board);
+				score = search_solve_4(search, alpha);
+				search->empties[prev].next = x;	// restore
+
+				if (score > alpha)	// (49%)
+					return score;
+				else if (score > bestscore)
+					bestscore = score;
+			} while (prioritymoves);	// (34%)
+		} while ((prioritymoves = moves));	// (38%)
+
+	else {
+		--search->eval.n_empties;	// for next depth
+		do {
+			moves ^= prioritymoves;
+			x = NOMOVE;
+			do {
+				do {
+					x = search->empties[prev = x].next;
+				} while (!(prioritymoves & x_to_bit(x)));	// (57%)
+
+				prioritymoves &= ~x_to_bit(x);
+				search->eval.parity = parity0 ^ QUADRANT_ID[x];
+				search->empties[prev].next = search->empties[x].next;	// remove - maintain single link only
+				vboard_next(board0, x, &search->board);
+				score = -search_shallow(search, ~alpha, false);
+				search->empties[prev].next = x;	// restore
+
+				if (score > alpha) {	// (40%)
+					// search->board = board0.board;
+					// search->eval.parity = parity0;
+					++search->eval.n_empties;
+					return score;
+
+				} else if (score > bestscore)
+					bestscore = score;
+			} while (prioritymoves);	// (54%)
+		} while ((prioritymoves = moves));	// (23%)
+		++search->eval.n_empties;
 	}
+	// search->board = board0.board;
+	// search->eval.parity = parity0;
 
  	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
-	return bestscore;
+	return bestscore;	// (33%)
 }
 
 /**
@@ -448,79 +512,153 @@ static int search_shallow(Search *search, const int alpha)
  */
 int NWS_endgame(Search *search, const int alpha)
 {
-	int score;
-	HashTable *hash_table = search->hash_table;
-	unsigned long long hash_code;
-	const int beta = alpha + 1;
-	HashData hash_data[1];
-	Board *board = search->board;
-	MoveList movelist[1];
-	Move *move, *bestmove;
-	long long cost;
+	int score, ofssolid, bestscore;
+	unsigned long long hash_code, solid_opp;
+	// const int beta = alpha + 1;
+	HashStoreData hash_data;
+	Move *move;
+	long long nodes_org;
+	V2DI board0;
+	Board hashboard;
+	unsigned int parity0;
+	unsigned long long full[5];
+	MoveList movelist;
+
+	assert(bit_count(~(search->board.player|search->board.opponent)) < DEPTH_MIDGAME_TO_ENDGAME);
+	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
 
 	if (search->stop) return alpha;
 
-	assert(search->n_empties == bit_count(~(search->board->player|search->board->opponent)));
-	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
-
 	SEARCH_STATS(++statistics.n_NWS_endgame);
-
-	if (search->n_empties <= DEPTH_TO_SHALLOW_SEARCH) return search_shallow(search, alpha);
-
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
 	// stability cutoff
-	if (search_SC_NWS(search, alpha, &score)) return score;
+	hashboard = board0.board = search->board;
+	ofssolid = 0;
+	if (USE_SC && alpha >= NWS_STABILITY_THRESHOLD[search->eval.n_empties]) {	// (7%)
+		CUTOFF_STATS(++statistics.n_stability_try;)
+		score = SCORE_MAX - 2 * get_stability_fulls(search->board.opponent, search->board.player, full);
+		if (score <= alpha) {	// (3%)
+			CUTOFF_STATS(++statistics.n_stability_low_cutoff;)
+			return score;
+		}
 
-	// transposition cutoff
-	hash_code = board_get_hash_code(board);
-	if (hash_get(hash_table, board, hash_code, hash_data) && search_TC_NWS(hash_data, search->n_empties, NO_SELECTIVITY, alpha, &score)) return score;
+		// Improvement of Serch by Reducing Redundant Information in a Position of Othello
+		// Hidekazu Matsuo, Shuji Narazaki
+		// http://id.nii.ac.jp/1001/00156359/
+		if (search->eval.n_empties <= MASK_SOLID_DEPTH) {	// (99%)
+			solid_opp = full[4] & hashboard.opponent;	// full[4] = all full
+#ifndef POPCOUNT
+			if (solid_opp)	// (72%)
+#endif
+			{
+				hashboard.player ^= solid_opp;	// normalize solid to player
+				hashboard.opponent ^= solid_opp;
+				ofssolid = bit_count(solid_opp) * 2;	// hash score is ofssolid grater than real
+			}
+		}
+	}
 
-	search_get_movelist(search, movelist);
+	hash_code = board_get_hash_code(&hashboard);
+	hash_prefetch(&search->hash_table, hash_code);
 
-	cost = -search->n_nodes;
-	// special cases
-	if (movelist_is_empty(movelist)) {
-		bestmove = movelist->move->next = movelist->move + 1;
-		bestmove->next = 0;
-		if (can_move(board->opponent, board->player)) { // pass
-			search_pass_endgame(search);
-				bestmove->score = -NWS_endgame(search, -beta);
-			search_pass_endgame(search);
-			bestmove->x = PASS;
-		} else  { // game over
-			bestmove->score = search_solve(search);
-			bestmove->x = NOMOVE;
+	search_get_movelist(search, &movelist);
+
+	if (movelist.n_moves > 1) {	// (96%)
+		// transposition cutoff
+		if (hash_get(&search->hash_table, &hashboard, hash_code, &hash_data.data)) {	// (6%)
+			hash_data.data.lower -= ofssolid;
+			hash_data.data.upper -= ofssolid;
+			if (search_TC_NWS(&hash_data.data, search->eval.n_empties, NO_SELECTIVITY, alpha, &score))	// (6%)
+				return score;
 		}
-	} else {
-		movelist_evaluate(movelist, search, hash_data, alpha, 0);
+		// else if (ofssolid)	// slows down
+		//	hash_get_from_board(&search->hash_table, HBOARD_V(board0), &hash_data.data);
+
+		movelist_evaluate_fast(&movelist, search, &hash_data.data);
 
-		bestmove = movelist->move; bestmove->score = -SCORE_INF;
+		nodes_org = search->n_nodes;
+		parity0 = search->eval.parity;
+		bestscore = -SCORE_INF;
 		// loop over all moves
-		foreach_best_move(move, movelist) {
-			search_update_endgame(search, move);
-				move->score = -NWS_endgame(search, -beta);
-			search_restore_endgame(search, move);
-			if (move->score > bestmove->score) {
-				bestmove = move;
-				if (bestmove->score >= beta) break;
+		move = &movelist.move[0];
+		if (--search->eval.n_empties <= DEPTH_TO_SHALLOW_SEARCH)	// for next move (44%)
+			while ((move = move_next_best(move))) {	// (72%)
+				search->eval.parity = parity0 ^ QUADRANT_ID[move->x];
+				search->empties[search->empties[move->x].previous].next = search->empties[move->x].next;	// remove - maintain single link only
+				vboard_update(&search->board, board0, move);
+				score = -search_shallow(search, ~alpha, false);
+				search->empties[search->empties[move->x].previous].next = move->x;	// restore
+				search->board = board0.board;
+
+				if (score > bestscore) {	// (63%)
+					bestscore = score;
+					hash_data.data.move[0] = move->x;
+					if (bestscore > alpha) break;	// (48%)
+				}
 			}
-		}
-	}
+		else
+			while ((move = move_next_best(move))) {	// (76%)
+				search->eval.parity = parity0 ^ QUADRANT_ID[move->x];
+				empty_remove(search->empties, move->x);
+				vboard_update(&search->board, board0, move);
+				score = -NWS_endgame(search, ~alpha);
+				empty_restore(search->empties, move->x);
+				search->board = board0.board;
+
+				if (score > bestscore) {	// (63%)
+					bestscore = score;
+					hash_data.data.move[0] = move->x;
+					if (bestscore > alpha) break;	// (39%)
+				}
+			}
+		++search->eval.n_empties;
+		search->eval.parity = parity0;
 
-	if (!search->stop) {
-		cost += search->n_nodes;
-		hash_store(hash_table, board, hash_code, search->n_empties, NO_SELECTIVITY, last_bit(cost), alpha, beta, bestmove->score, bestmove->x);
-		if (SQUARE_STATS(1) + 0) {
-			foreach_move(move, movelist)
-				++statistics.n_played_square[search->n_empties][SQUARE_TYPE[move->x]];
-			if (bestmove->score > alpha) ++statistics.n_good_square[search->n_empties][SQUARE_TYPE[bestmove->score]];
+		if (search->stop)	// (1%)
+			return alpha;
+
+		hash_data.data.wl.c.depth = search->eval.n_empties;
+		hash_data.data.wl.c.selectivity = NO_SELECTIVITY;
+		hash_data.data.wl.c.cost = last_bit(search->n_nodes - nodes_org);
+		// hash_data.data.move[0] = bestmove;
+		hash_data.alpha = alpha + ofssolid;
+		hash_data.beta = alpha + ofssolid + 1;
+		hash_data.score = bestscore + ofssolid;
+		hash_store(&search->hash_table, &hashboard, hash_code, &hash_data);
+
+	// special cases
+	} else if (movelist.n_moves == 1) {	// (3%)
+		parity0 = search->eval.parity;
+		move = movelist_first(&movelist);
+		search_swap_parity(search, move->x);
+		empty_remove(search->empties, move->x);
+		vboard_update(&search->board, board0, move);
+		if (--search->eval.n_empties <= DEPTH_TO_SHALLOW_SEARCH)	// (56%)
+			bestscore = -search_shallow(search, ~alpha, false);
+		else	bestscore = -NWS_endgame(search, ~alpha);
+		++search->eval.n_empties;
+		empty_restore(search->empties, move->x);
+		search->eval.parity = parity0;
+		search->board = board0.board;
+
+	} else {	// (1%)
+		if (can_move(search->board.opponent, search->board.player)) { // pass
+			search_pass(search);
+			bestscore = -NWS_endgame(search, ~alpha);
+			search_pass(search);
+		} else  { // game over
+			bestscore = search_solve(search);
 		}
-	 	assert(SCORE_MIN <= bestmove->score && bestmove->score <= SCORE_MAX);
-	 	assert((bestmove->score & 1) == 0);
-		return bestmove->score;
 	}
 
-	return alpha;
+	if (SQUARE_STATS(1) + 0) {
+		foreach_move(move, movelist)
+			++statistics.n_played_square[search->eval.n_empties][SQUARE_TYPE[move->x]];
+		if (bestscore > alpha)
+			++statistics.n_good_square[search->eval.n_empties][SQUARE_TYPE[bestscore]];
+	}
+ 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+ 	assert((bestscore & 1) == 0);
+	return bestscore;
 }
-
diff --git a/src/endgame_neon.c b/src/endgame_neon.c
new file mode 100644
index 00000000..346063f0
--- /dev/null
+++ b/src/endgame_neon.c
@@ -0,0 +1,462 @@
+/**
+ * @file endgame_neon.c
+ *
+ *
+ * Arm Neon optimized version of endgame.c for the last four empties.
+ *
+ * Bitboard and empty list is kept in Neon registers.
+ *
+ * @date 1998 - 2024
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include "bit_intrinsics.h"
+#include "settings.h"
+#include "search.h"
+#include <assert.h>
+
+#define TESTZ_FLIP(X)	(!vgetq_lane_u64((X), 0))
+
+#ifndef HAS_CPU_64
+	#define vaddv_u8(x)	vget_lane_u32(vreinterpret_u32_u64(vpaddl_u32(vpaddl_u16(vpaddl_u8(x)))), 0)
+#endif
+
+// in count_last_flip_neon.c
+extern const unsigned char COUNT_FLIP[8][256];
+extern const uint64x2_t mask_dvhd[64][2];
+
+/**
+ * @brief Compute a board resulting of a move played on a previous board.
+ *
+ * @param OP board to play the move on.
+ * @param x move to play.
+ * @param flipped flipped returned from mm_Flip.
+ * @return resulting board.
+ */
+static inline uint64x2_t board_flip_next(uint64x2_t OP, int x, uint64x2_t flipped)
+{
+#if !defined(_MSC_VER) && !defined(__clang__)	// MSVC-arm32 does not have vld1q_lane_u64
+	// arm64-gcc-13: 8, armv8a-clang-16: 8, msvc-arm64-19: 8, gcc-arm-13: 16, clang-armv7-11: 18
+	OP = veorq_u64(OP, vorrq_u64(flipped, vld1q_lane_u64((uint64_t *) &X_TO_BIT[x], flipped, 0)));
+	return vextq_u64(OP, OP, 1);
+#else	// arm64-gcc-13: 8, armv8a-clang-16: 7, msvc-arm64-19: 7, gcc-arm-13: 21, clang-armv7-11: 15
+	OP = veorq_u64(OP, flipped);
+	return vcombine_u64(vget_high_u64(OP), vorr_u64(vget_low_u64(OP), vld1_u64((uint64_t *) &X_TO_BIT[x])));
+#endif
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final score, when no move can be made.
+ *
+ * @param P Board.player
+ * @param n_empties Number of empty squares remaining on the board.
+ * @return The final score, as a disc difference.
+ */
+static int board_solve_neon(uint64x1_t P, int n_empties)
+{
+	int score = vaddv_u8(vcnt_u8(vreinterpret_u8_u64(P))) * 2 - SCORE_MAX;	// in case of opponents win
+	int diff = score + n_empties;		// = n_discs_p - (64 - n_empties - n_discs_p)
+
+	SEARCH_STATS(++statistics.n_search_solve);
+
+	if (diff == 0)
+		score = diff;
+	else if (diff > 0)
+		score = diff + n_empties;
+	return score;
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final score, when 1 empty square remain.
+ * The original code has been adapted from Zebra by Gunnar Anderson.
+ *
+ * @param P      Board.player to evaluate.
+ * @param alpha  Alpha bound. (beta - 1)
+ * @param pos    Last empty square to play.
+ * @return       The final score, as a disc difference.
+ */
+#if (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_SVE) && defined(SIMULLASTFLIP)
+
+#include "arm_sve.h"
+
+extern	const uint64_t lrmask[66][8];	// in flip_sve_lzcnt.c
+
+  #ifndef __ARM_FEATURE_SVE2
+		// equivalent only if no intersection between masks
+	#define svbsl_u64(op1,op2,op3)	svorr_u64_m(pg, (op2), svand_u64_x(pg, (op3), (op1)))
+	#define svbsl1n_u64(op1,op2,op3)	svorr_u64_m(pg, (op2), svbic_u64_x(pg, (op3), (op1)))
+  #endif
+
+static int board_score_neon_1(uint64x1_t P, int alpha, int pos)
+{
+	int	score;
+	svuint64_t	PP, p_flip, o_flip, p_oflank, o_oflank, p_eraser, o_eraser, p_cap, o_cap, mask, po_flip, po_score;
+	svbool_t	pg, po_nopass;
+	const uint64_t	(*pmask)[8];
+
+	PP = svdup_u64(vget_lane_u64(P, 0));
+	pmask = &lrmask[pos];
+	pg = svwhilelt_b64(0, 4);
+
+	mask = svld1_u64(pg, *pmask + 4);	// right: clear all bits lower than outflank
+	p_oflank = svand_x(pg, mask, PP);			o_oflank = svbic_x(pg, mask, PP);
+	p_oflank = svand_x(pg, svclz_z(pg, p_oflank), 63);	o_oflank = svand_x(pg, svclz_z(pg, o_oflank), 63);
+	p_eraser = svlsr_x(pg, svdup_u64(-1), p_oflank);	o_eraser = svlsr_x(pg, svdup_u64(-1), o_oflank);
+	p_flip = svbic_x(pg, mask, p_eraser);			o_flip = svbic_x(pg, mask, o_eraser);
+
+	mask = svld1_u64(pg, *pmask + 0);	// left: look for player LS1B
+	p_oflank = svand_x(pg, mask, PP);			o_oflank = svbic_x(pg, mask, PP);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	p_cap = svbic_x(pg, svqsub(p_oflank, 1), p_oflank);	o_cap = svbic_x(pg, svqsub(o_oflank, 1), o_oflank);
+	p_flip = svbsl_u64(p_cap, p_flip, mask);		o_flip = svbsl_u64(o_cap, o_flip, mask);
+
+	if (svcntd() == 2) {	// sve128 only
+		mask = svld1_u64(pg, *pmask + 6);	// right: set all bits higher than outflank
+		p_oflank = svand_x(pg, mask, PP);			o_oflank = svbic_x(pg, mask, PP);
+		p_oflank = svand_x(pg, svclz_z(pg, p_oflank), 63);	o_oflank = svand_x(pg, svclz_z(pg, o_oflank), 63);
+		p_eraser = svlsr_x(pg, svdup_u64(-1), p_oflank);	o_eraser = svlsr_x(pg, svdup_u64(-1), o_oflank);
+		p_flip = svbsl1n_u64(p_eraser, p_flip, mask);		o_flip = svbsl1n_u64(o_eraser, o_flip, mask);
+
+		mask = svld1_u64(pg, *pmask + 2);	// left: look for player LS1B
+		p_oflank = svand_x(pg, mask, PP);			o_oflank = svbic_x(pg, mask, PP);
+			// set all bits lower than oflank, using satulation if oflank = 0
+		p_cap = svbic_x(pg, svqsub(p_oflank, 1), p_oflank);	o_cap = svbic_x(pg, svqsub(o_oflank, 1), o_oflank);
+		p_flip = svbsl_u64(p_cap, p_flip, mask);		o_flip = svbsl_u64(o_cap, o_flip, mask);
+	}
+
+	po_flip = svtrn1_u64(svdup_u64(svorv_u64(pg, o_flip)), svdup_u64(svorv_u64(pg, p_flip)));
+	po_nopass = svcmpne_n_u64(pg, po_flip, 0);
+	po_score = svcnt_u64_x(pg, sveor_u64_x(pg, po_flip, PP));
+		// last square for O if P pass and (not O pass or score < 32)
+	po_score = svsub_n_u64_m(svorr_b_z(svptrue_pat_b64(SV_VL1), svcmplt_n_u64(pg, po_score, 32), po_nopass), po_score, 1);
+	score = svlastb_u64(svorr_b_z(pg, po_nopass, svptrue_pat_b64(SV_VL1)), po_score);	// use o_score if p_pass
+	(void) alpha;	// no lazy cut-off
+	return score * 2 - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+}
+
+#else
+static int board_score_neon_1(uint64x1_t P, int alpha, int pos)
+{
+	int	score = 2 * vaddv_u8(vcnt_u8(vreinterpret_u8_u64(P))) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+	int	score2;
+	unsigned int	n_flips, m;
+	const unsigned char *COUNT_FLIP_X = COUNT_FLIP[pos & 7];
+	const unsigned char *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+	uint64x2_t	PP = vdupq_lane_u64(P, 0);
+	uint64x2_t	I0, I1;
+	static const unsigned short o_mask[64] = {
+		0xff01, 0x7f03, 0x3f07, 0x1f0f, 0x0f1f, 0x073f, 0x037f, 0x01ff,
+		0xfe03, 0xff07, 0x7f0f, 0x3f1f, 0x1f3f, 0x0f7f, 0x07ff, 0x03fe,
+		0xfc07, 0xfe0f, 0xff1f, 0x7f3f, 0x3f7f, 0x1fff, 0x0ffe, 0x07fc,
+		0xf80f, 0xfc1f, 0xfe3f, 0xff7f, 0x7fff, 0x3ffe, 0x1ffc, 0x0ff8,
+		0xf01f, 0xf83f, 0xfc7f, 0xfeff, 0xfffe, 0x7ffc, 0x3ff8, 0x1ff0,
+		0xe03f, 0xf07f, 0xf8ff, 0xfcfe, 0xfefc, 0xfff8, 0x7ff0, 0x3fe0,
+		0xc07f, 0xe0ff, 0xf0fe, 0xf8fc, 0xfcf8, 0xfef0, 0xffe0, 0x7fc0,
+		0x80ff, 0xc0fe, 0xe0fc, 0xf0f8, 0xf8f0, 0xfce0, 0xfec0, 0xff80
+	};
+
+	// n_flips = last_flip(pos, P);
+  #ifdef HAS_CPU_64	// vaddvq
+	unsigned int t0, t1;
+	const uint64x2_t dmask = { 0x0808040402020101, 0x8080404020201010 };
+
+	PP = vreinterpretq_u64_u8(vzip1q_u8(vreinterpretq_u8_u64(PP), vreinterpretq_u8_u64(PP)));
+	I0 = vandq_u64(PP, mask_dvhd[pos][0]);	// 2 dirs interleaved
+	t0 = vaddvq_u16(vreinterpretq_u16_u64(I0));
+	n_flips  = COUNT_FLIP_X[t0 >> 8];
+	n_flips += COUNT_FLIP_X[t0 & 0xFF];
+	I1 = vandq_u64(vreinterpretq_u64_u8(vtstq_u8(vreinterpretq_u8_u64(PP), vreinterpretq_u8_u64(mask_dvhd[pos][1]))), dmask);
+	t1 = vaddvq_u16(vreinterpretq_u16_u64(I1));
+	n_flips += COUNT_FLIP_Y[t1 >> 8];
+	n_flips += COUNT_FLIP_Y[t1 & 0xFF];
+
+  #else // Neon kindergarten
+	const uint64x2_t dmask = { 0x1020408001020408, 0x1020408001020408 };
+
+	I0 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(vreinterpretq_u8_u64(vandq_u64(PP, mask_dvhd[pos][0])))));
+	n_flips  = COUNT_FLIP_X[vgetq_lane_u32(vreinterpretq_u32_u64(I0), 2)];
+	n_flips += COUNT_FLIP_X[vgetq_lane_u32(vreinterpretq_u32_u64(I0), 0)];
+	I1 = vreinterpretq_u64_s8(vnegq_s8(vreinterpretq_s8_u8(vtstq_u8(vreinterpretq_u8_u64(PP), vreinterpretq_u8_u64(mask_dvhd[pos][1])))));
+	I1 = vpaddlq_u32(vmulq_u32(vreinterpretq_u32_u64(dmask), vreinterpretq_u32_u64(I1)));
+	n_flips += COUNT_FLIP_Y[vgetq_lane_u8(vreinterpretq_u8_u64(I1), 11)];
+	n_flips += COUNT_FLIP_Y[vgetq_lane_u8(vreinterpretq_u8_u64(I1), 3)];
+  #endif
+	score += n_flips;
+
+	if (n_flips == 0) {
+		score2 = score - 2;	// empty for opponent
+		if (score <= 0)
+			score = score2;
+
+		if (score > alpha) {	// lazy cut-off
+			// n_flips = last_flip(pos, O);
+			m = o_mask[pos];	// valid diagonal bits
+  #ifdef HAS_CPU_64
+			n_flips  = COUNT_FLIP_X[(t0 >> 8) ^ 0xFF];
+			n_flips += COUNT_FLIP_X[(t0 ^ m) & 0xFF];
+			n_flips += COUNT_FLIP_Y[(t1 ^ m) >> 8];
+			n_flips += COUNT_FLIP_Y[(~t1) & 0xFF];
+  #else
+			n_flips  = COUNT_FLIP_X[vgetq_lane_u32(vreinterpretq_u32_u64(I0), 2) ^ 0xFF];
+			n_flips += COUNT_FLIP_X[vgetq_lane_u32(vreinterpretq_u32_u64(I0), 0) ^ (m & 0xFF)];
+			n_flips += COUNT_FLIP_Y[vgetq_lane_u8(vreinterpretq_u8_u64(I1), 11) ^ (m >> 8)];
+			n_flips += COUNT_FLIP_Y[vgetq_lane_u8(vreinterpretq_u8_u64(I1), 3) ^ 0xFF];
+  #endif
+			if (n_flips != 0)
+				score = score2 - n_flips;
+		}
+	}
+
+	return score;
+}
+#endif
+
+// from bench.c
+int board_score_1(const unsigned long long player, const int beta, const int x)
+{
+	return board_score_neon_1(vcreate_u64(player), beta, x);
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final min score, when 2 empty squares remain.
+ *
+ * @param OP The board to evaluate.
+ * @param alpha Alpha bound.
+ * @param n_nodes Node counter.
+ * @param empties Packed empty square coordinates.
+ * @return The final min score, as a disc difference.
+ */
+static int board_solve_2(uint64x2_t OP, int alpha, volatile unsigned long long *n_nodes, uint8x8_t empties)
+{
+	uint64x2_t flipped;
+	int score, bestscore, nodes;
+	int x1 = vget_lane_u8(empties, 1);
+	int x2 = vget_lane_u8(empties, 0);
+	unsigned long long opponent;
+	// const int beta = alpha + 1;
+
+	SEARCH_STATS(++statistics.n_board_solve_2);
+
+	opponent = vgetq_lane_u64(OP, 1);
+	if ((NEIGHBOUR[x1] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x1))) {
+		bestscore = board_score_neon_1(vget_high_u64(veorq_u64(OP, flipped)), alpha, x2);
+
+		if ((bestscore > alpha) && (NEIGHBOUR[x2] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+			score = board_score_neon_1(vget_high_u64(veorq_u64(OP, flipped)), alpha, x1);
+			if (score < bestscore)
+				bestscore = score;
+			nodes = 3;
+		} else	nodes = 2;
+
+	} else if ((NEIGHBOUR[x2] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+		bestscore = board_score_neon_1(vget_high_u64(veorq_u64(OP, flipped)), alpha, x1);
+		nodes = 2;
+
+	} else {	// pass - NEIGHBOUR test is almost 100% true
+		alpha = ~alpha;	// = -alpha - 1
+		OP = vextq_u64(OP, OP, 1);
+		if (!TESTZ_FLIP(flipped = mm_Flip(OP, x1))) {
+			bestscore = board_score_neon_1(vget_high_u64(veorq_u64(OP, flipped)), alpha, x2);
+
+			if ((bestscore > alpha) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+				score = board_score_neon_1(vget_high_u64(veorq_u64(OP, flipped)), alpha, x1);
+				if (score < bestscore)
+					bestscore = score;
+				nodes = 3;
+			} else	nodes = 2;
+
+		} else if (!TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+			bestscore = board_score_neon_1(vget_high_u64(veorq_u64(OP, flipped)), alpha, x1);
+			nodes = 2;
+
+		} else {	// gameover
+			bestscore = board_solve_neon(vget_high_u64(OP), 2);
+			nodes = 1;
+		}
+		bestscore = -bestscore;
+	}
+
+	SEARCH_UPDATE_2EMPTIES_NODES(*n_nodes += nodes;)
+	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+	assert((bestscore & 1) == 0);
+	return bestscore;
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final max score, when 3 empty squares remain.
+ *
+ * @param OP The board to evaluate.
+ * @param alpha Alpha bound.
+ * @param n_nodes Node counter.
+ * @param empties Packed empty square coordinates.
+ * @return The final max score, as a disc difference.
+ */
+static int search_solve_3(uint64x2_t OP, int alpha, volatile unsigned long long *n_nodes, uint8x8_t empties)
+{
+	uint64x2_t flipped;
+	int score, bestscore, x, pol;
+	unsigned long long opponent;
+
+	SEARCH_STATS(++statistics.n_search_solve_3);
+	SEARCH_UPDATE_INTERNAL_NODES(*n_nodes);
+
+	bestscore = -SCORE_INF;
+	pol = 1;
+	do {
+		// best move alphabeta search
+		opponent = vgetq_lane_u64(OP, 1);
+		x = vget_lane_u8(empties, 2);
+		if ((NEIGHBOUR[x] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x))) {
+			bestscore = board_solve_2(board_flip_next(OP, x, flipped), alpha, n_nodes, empties);
+			if (bestscore > alpha) return bestscore * pol;
+		}
+
+		x = vget_lane_u8(empties, 1);
+		if (/* (NEIGHBOUR[x] & opponent) && */ !TESTZ_FLIP(flipped = mm_Flip(OP, x))) {
+			score = board_solve_2(board_flip_next(OP, x, flipped), alpha, n_nodes, vuzp_u8(empties, empties).val[0]);	// d2d0
+			if (score > alpha) return score * pol;
+			else if (score > bestscore) bestscore = score;
+		}
+
+		x = vget_lane_u8(empties, 0);
+		if (/* (NEIGHBOUR[x] & opponent) && */ !TESTZ_FLIP(flipped = mm_Flip(OP, x))) {
+			score = board_solve_2(board_flip_next(OP, x, flipped), alpha, n_nodes, vext_u8(empties, empties, 1));	// d2d1
+			if (score > bestscore) bestscore = score;
+			return bestscore * pol;
+		}
+
+		if (bestscore > -SCORE_INF)
+			return bestscore * pol;
+
+		OP = vextq_u64(OP, OP, 1);	// pass
+		alpha = ~alpha;	// = -(alpha + 1)
+	} while ((pol = -pol) < 0);
+
+	return board_solve_neon(vget_low_u64(OP), 3);	// gameover
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final min score, when 4 empty squares remain.
+ *
+ * @param search Search position.
+ * @param alpha Upper score value.
+ * @return The final min score, as a disc difference.
+ */
+
+static int search_solve_4(Search *search, int alpha)
+{
+	uint64x2_t	OP, flipped;
+	uint8x16_t	empties_series;	// B15:4th, B11:3rd, B7:2nd, B3:1st, lower 3 bytes for 3 empties
+	uint8x16_t	shuf;
+	int x1, x2, x3, x4, paritysort, score, bestscore, pol;
+	unsigned long long opponent;
+	// const int beta = alpha + 1;
+	static const unsigned char parity_case[64] = {	/* x4x3x2x1 = */
+		/*0000*/  0, /*0001*/  0, /*0010*/  1, /*0011*/  9, /*0100*/  2, /*0101*/ 10, /*0110*/ 11, /*0111*/  3,
+		/*0002*/  0, /*0003*/  0, /*0012*/  0, /*0013*/  0, /*0102*/  4, /*0103*/  4, /*0112*/  5, /*0113*/  5,
+		/*0020*/  1, /*0021*/  0, /*0030*/  1, /*0031*/  0, /*0120*/  6, /*0121*/  7, /*0130*/  6, /*0131*/  7,
+		/*0022*/  9, /*0023*/  0, /*0032*/  0, /*0033*/  9, /*0122*/  8, /*0123*/  0, /*0132*/  0, /*0133*/  8,
+		/*0200*/  2, /*0201*/  4, /*0210*/  6, /*0211*/  8, /*0300*/  2, /*0301*/  4, /*0310*/  6, /*0311*/  8,
+		/*0202*/ 10, /*0203*/  4, /*0212*/  7, /*0213*/  0, /*0302*/  4, /*0303*/ 10, /*0312*/  0, /*0313*/  7,
+		/*0220*/ 11, /*0221*/  5, /*0230*/  6, /*0231*/  0, /*0320*/  6, /*0321*/  0, /*0330*/ 11, /*0331*/  5,
+		/*0222*/  3, /*0223*/  5, /*0232*/  7, /*0233*/  8, /*0322*/  8, /*0323*/  7, /*0332*/  5, /*0333*/  3
+	};
+	static const uint64x2_t shuf_mask[] = {
+		{ 0x0203010003020100, 0x0003020101030200 },	//  0: 1(x1) 3(x2 x3 x4), 1(x1) 1(x2) 2(x3 x4), 1 1 1 1, 4
+		{ 0x0203010003020100, 0x0002030101020300 },	//  1: 1(x2) 3(x1 x3 x4)
+		{ 0x0201030003010200, 0x0001030201030200 },	//  2: 1(x3) 3(x1 x2 x4)
+		{ 0x0200030103000201, 0x0003020101000302 },	//  3: 1(x4) 3(x1 x2 x3)
+		{ 0x0103020003010200, 0x0003020102030100 },	//  4: 1(x1) 1(x3) 2(x2 x4)	x4x1x2x3-x2x1x3x4-x3x1x2x4-x1x3x2x4
+		{ 0x0003020103000201, 0x0103020002030100 },	//  5: 1(x1) 1(x4) 2(x2 x3)	x3x1x2x4-x2x1x3x4-x4x1x2x3-x1x4x2x3
+		{ 0x0102030002010300, 0x0003020103020100 },	//  6: 1(x2) 1(x3) 2(x1 x4)	x4x1x2x3-x1x2x3x4-x3x2x1x4-x2x3x1x4
+		{ 0x0002030102000301, 0x0103020003020100 },	//  7: 1(x2) 1(x4) 2(x1 x3)	x3x1x2x4-x1x2x3x4-x4x2x1x3-x2x4x1x3
+		{ 0x0001030201000302, 0x0203010003020100 },	//  8: 1(x3) 1(x4) 2(x1 x2)	x2x1x3x4-x1x2x3x4-x4x3x1x2-x3x4x1x2
+		{ 0x0203010003020100, 0x0001030201000302 },	//  9: 2(x1 x2) 2(x3 x4)	x4x3x1x2-x3x4x1x2-x2x1x3x4-x1x2x3x4
+		{ 0x0200030103010200, 0x0002030101030200 },	// 10: 2(x1 x3) 2(x2 x4)	x4x2x1x3-x3x1x2x4-x2x4x1x3-x1x3x2x4
+		{ 0x0201030003000201, 0x0003020101020300 }	// 11: 2(x1 x4) 2(x2 x3)	x4x1x2x3-x3x2x1x4-x2x3x1x4-x1x4x2x3
+	};
+
+	SEARCH_STATS(++statistics.n_search_solve_4);
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
+
+	// stability cutoff (try 12%, cut 7%)
+	if (search_SC_NWS_4(search, alpha, &score)) return score;
+
+	OP = vld1q_u64((uint64_t *) &search->board);
+	x1 = search->empties[NOMOVE].next;
+	x2 = search->empties[x1].next;
+	x3 = search->empties[x2].next;
+	x4 = search->empties[x3].next;
+
+	// parity based move sorting.
+	// The following hole sizes are possible:
+	//    4 - 1 3 - 2 2 - 1 1 2 - 1 1 1 1
+	// Only the 1 1 2 case needs move sorting on this ply.
+	empties_series = vreinterpretq_u8_u32(vdupq_n_u32((x1 << 24) | (x2 << 16) | (x3 << 8) | x4));
+	paritysort = parity_case[((x3 ^ x4) & 0x24) + (((x2 ^ x4) & 0x24) >> 1) + (((x1 ^ x4) & 0x24) >> 2)];
+	shuf = vreinterpretq_u8_u64(shuf_mask[paritysort]);
+#ifdef HAS_CPU_64
+	empties_series = vqtbl1q_u8(empties_series, shuf);
+#else
+	empties_series = vcombine_u8(vtbl1_u8(vget_low_u8(empties_series), vget_low_u8(shuf)),
+		vtbl1_u8(vget_low_u8(empties_series), vget_high_u8(shuf)));
+#endif
+
+	bestscore = SCORE_INF;	// min stage
+	pol = 1;
+	do {
+		// best move alphabeta search
+		opponent = vgetq_lane_u64(OP, 1);
+		x1 = vgetq_lane_u8(empties_series, 3);
+		if ((NEIGHBOUR[x1] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x1))) {
+			bestscore = search_solve_3(board_flip_next(OP, x1, flipped), alpha, &search->n_nodes,
+				vget_low_u8(empties_series));
+			if (bestscore <= alpha) return bestscore * pol;
+		}
+
+		x2 = vgetq_lane_u8(empties_series, 7);
+		if ((NEIGHBOUR[x2] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+			score = search_solve_3(board_flip_next(OP, x2, flipped), alpha, &search->n_nodes,
+				vget_low_u8(vextq_u8(empties_series, empties_series, 4)));
+			if (score <= alpha) return score * pol;
+			else if (score < bestscore) bestscore = score;
+		}
+
+		x3 = vgetq_lane_u8(empties_series, 11);
+		if ((NEIGHBOUR[x3] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x3))) {
+			score = search_solve_3(board_flip_next(OP, x3, flipped), alpha, &search->n_nodes,
+				vget_high_u8(empties_series));
+			if (score <= alpha) return score * pol;
+			else if (score < bestscore) bestscore = score;
+		}
+
+		x4 = vgetq_lane_u8(empties_series, 15);
+		if ((NEIGHBOUR[x4] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x4))) {
+			score = search_solve_3(board_flip_next(OP, x4, flipped), alpha, &search->n_nodes,
+				vget_low_u8(vextq_u8(empties_series, empties_series, 12)));
+			if (score < bestscore) bestscore = score;
+			return bestscore * pol;
+		}
+
+		if (bestscore < SCORE_INF)
+			return bestscore * pol;
+
+		OP = vextq_u64(OP, OP, 1);	// pass
+		alpha = ~alpha;	// = -(alpha + 1)
+	} while ((pol = -pol) < 0);
+
+	return board_solve_neon(vget_high_u64(OP), 4);	// gameover
+}
diff --git a/src/endgame_sse.c b/src/endgame_sse.c
new file mode 100644
index 00000000..f007739e
--- /dev/null
+++ b/src/endgame_sse.c
@@ -0,0 +1,839 @@
+/**
+ * @file endgame_sse.c
+ *
+ *
+ * SSE / AVX optimized version of endgame.c for the last four empties.
+ *
+ * Bitboard and empty list are kept in SSE registers.
+ *
+ * @date 1998 - 2024
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ * 
+ */
+
+#include "bit.h"
+#include "settings.h"
+#include "search.h"
+#include <stdint.h>
+#include <assert.h>
+
+#define	SWAP64	0x4e	// for _mm_shuffle_epi32
+#define	DUPLO	0x44
+#define	DUPHI	0xee
+
+#if defined(__AVX__) && (defined(__x86_64__) || defined(_M_X64))
+	#define	EXTRACT_O(OP)	_mm_extract_epi64(OP, 1)
+#else
+	#define	EXTRACT_O(OP)	_mm_cvtsi128_si64(_mm_shuffle_epi32(OP, DUPHI))
+#endif
+
+#if defined(__AVX__) || defined(__SSE4_1__)
+	static inline int vectorcall TESTZ_FLIP(__m128i X) { return _mm_testz_si128(X, X); }
+#elif defined(__x86_64__) || defined(_M_X64)
+	#define TESTZ_FLIP(X)	(!_mm_cvtsi128_si64(X))
+#else
+	static inline int vectorcall TESTZ_FLIP(__m128i X) { return !_mm_cvtsi128_si32(_mm_packs_epi16(X, X)); }
+#endif
+
+#if defined(__AVX512VL__) || defined(__AVX10_1__)
+	#define	TEST_EPI8_MASK32(X,Y)	_cvtmask32_u32(_mm256_test_epi8_mask((X), (Y)))
+	#define	TEST1_EPI8_MASK32(X)	_cvtmask32_u32(_mm256_test_epi8_mask((X), (X)))
+	#define	TEST_EPI8_MASK16(X,Y)	_cvtmask16_u32(_mm_test_epi8_mask((X), (Y)))
+#else	// AVX2
+	#define	TEST_EPI8_MASK32(X,Y)	_mm256_movemask_epi8(_mm256_sub_epi8(_mm256_setzero_si256(), _mm256_and_si256((X),(Y))))
+	#define	TEST1_EPI8_MASK32(X)	_mm256_movemask_epi8(_mm256_sub_epi8(_mm256_setzero_si256(), (X)))
+	#define	TEST_EPI8_MASK16(X,Y)	_mm_movemask_epi8(_mm_sub_epi8(_mm_setzero_si128(), _mm_and_si128((X),(Y))))
+#endif
+
+// in count_last_flip_sse.c
+extern const uint8_t COUNT_FLIP[8][256];
+extern const V4DI mask_dvhd[64];
+
+/**
+ * @brief Compute a board resulting of a move played on a previous board.
+ *
+ * @param OP board to play the move on.
+ * @param x move to play.
+ * @param flipped flipped returned from mm_Flip.
+ * @return resulting board.
+ */
+static inline __m128i vectorcall board_flip_next(__m128i OP, int x, __m128i flipped)
+{
+	OP = _mm_xor_si128(OP, _mm_or_si128(reduce_vflip(flipped), _mm_loadl_epi64((__m128i *) &X_TO_BIT[x])));
+	return _mm_shuffle_epi32(OP, SWAP64);
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final score, when 1 empty square remain.
+ * The original code has been adapted from Zebra by Gunnar Anderson.
+ *
+ * @param PO     Board to evaluate. (O ignored)
+ * @param alpha  Alpha bound. (beta - 1)
+ * @param pos    Last empty square to play.
+ * @return       The final score, as a disc difference.
+ */
+#if LAST_FLIP_COUNTER == COUNT_LAST_FLIP_BMI2
+// PEXT count last flip (2.60s on skylake, 2.35 on icelake, 2.16s on Zen4), very slow on Zen1/2
+extern const unsigned long long mask_x[64][4];
+
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	uint_fast8_t	n_flips;
+	unsigned int	th, tv;
+	unsigned long long P = _mm_cvtsi128_si64(OP);
+	unsigned long long mP;
+	int	score, score2;
+	const uint8_t *COUNT_FLIP_X = COUNT_FLIP[pos & 7];
+	const uint8_t *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+
+	mP = P & mask_x[pos][3];	// mask out unrelated bits to make dummy 0 bits for outside
+	// n_flips  = COUNT_FLIP_X[th = _bextr_u64(mP, pos & 0x38, 8)];
+	n_flips  = COUNT_FLIP_X[th = (mP >> (pos & 0x38)) & 0xFF];
+	n_flips += COUNT_FLIP_Y[_pext_u64(mP, mask_x[pos][0])];
+	n_flips += COUNT_FLIP_Y[_pext_u64(mP, mask_x[pos][1])];
+	n_flips += COUNT_FLIP_Y[tv = _pext_u64(mP, mask_x[pos][2])];
+
+	score = 2 * bit_count(P) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+	score += n_flips;
+
+	if (n_flips == 0) {
+		score2 = score - 2;	// empty for opponent
+		if (score <= 0)
+			score = score2;
+
+		if (score > alpha) {	// lazy cut-off
+			mP = ~P & mask_x[pos][3];
+			n_flips  = COUNT_FLIP_X[th ^ 0xFF];
+			n_flips += COUNT_FLIP_Y[_pext_u64(mP, mask_x[pos][0])];
+			n_flips += COUNT_FLIP_Y[_pext_u64(mP, mask_x[pos][1])];
+			n_flips += COUNT_FLIP_Y[tv ^ 0xFF];
+
+			if (n_flips != 0)
+				score = score2 - n_flips;
+		}
+	}
+
+	return score;
+}
+
+#elif (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_AVX512) && defined(SIMULLASTFLIP512)
+// branchless AVX512(512) lastflip (2.71s on skylake, 2.48 on icelake, 2.15s on Zen4)
+
+extern	const V8DI lrmask[66];	// in flip_avx512cd.c
+
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	int	score;
+	__m512i	op_outflank, op_flip, op_eraser, mask;
+	__m256i	o_flip, opop_flip;
+	__mmask8 op_pass;
+	__m512i	O4P4 = _mm512_xor_si512(_mm512_broadcastq_epi64(OP),
+		 _mm512_set_epi64(-1, -1, -1, -1, 0, 0, 0, 0));
+
+		// left: look for player LS1B
+	mask = _mm512_broadcast_i64x4(lrmask[pos].v4[0]);
+	op_outflank = _mm512_and_si512(O4P4, mask);
+		// set below LS1B if P is in lmask
+	op_flip = _mm512_maskz_add_epi64(_mm512_test_epi64_mask(op_outflank, op_outflank),
+		op_outflank, _mm512_set1_epi64(-1));
+	// op_flip = _mm512_and_si512(_mm512_andnot_si512(op_outflank, op_flip), mask);
+	op_flip = _mm512_ternarylogic_epi64(op_outflank, op_flip, mask, 0x08);
+
+		// right: clear all bits lower than outflank
+	mask = _mm512_broadcast_i64x4(lrmask[pos].v4[1]);
+	op_outflank = _mm512_and_si512(O4P4, mask);
+	op_eraser = _mm512_srlv_epi64(_mm512_set1_epi64(-1),
+		_mm512_maskz_lzcnt_epi64(_mm512_test_epi64_mask(op_outflank, op_outflank), op_outflank));
+	// op_flip = _mm512_or_si512(op_flip, _mm512_andnot_si512(op_eraser, mask));
+	op_flip = _mm512_ternarylogic_epi64(op_flip, op_eraser, mask, 0xf2);
+
+	o_flip = _mm512_extracti64x4_epi64(op_flip, 1);
+	opop_flip = _mm256_or_si256(_mm256_unpacklo_epi64(_mm512_castsi512_si256(op_flip), o_flip),
+		_mm256_unpackhi_epi64(_mm512_castsi512_si256(op_flip), o_flip));
+	OP = _mm_xor_si128(_mm512_castsi512_si128(O4P4),
+		_mm_or_si128(_mm256_castsi256_si128(opop_flip), _mm256_extracti128_si256(opop_flip, 1)));
+	op_pass = _mm_cmpeq_epi64_mask(OP, _mm512_castsi512_si128(O4P4));
+	OP = _mm_mask_unpackhi_epi64(OP, op_pass, OP, OP);	// use O if p_pass
+	score = bit_count(_mm_cvtsi128_si64(OP));
+		// last square for P if not P pass or (O pass and score >= 32)
+	// score += ((~op_pass & 1) | ((op_pass >> 1) & (score >= 32)));
+	score += (~op_pass | ((op_pass >> 1) & (score >> 5))) & 1;
+	(void) alpha;	// no lazy cut-off
+	return score * 2 - SCORE_MAX;	// = bit_count(P) - (SCORE_MAX - bit_count(P))
+}
+
+#elif (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_AVX512) && defined(SIMULLASTFLIP)
+// branchless AVX512(256) lastflip (2.61s on skylake, 2.38 on icelake, 2.13s on Zen4)
+
+extern	const V8DI lrmask[66];	// in flip_avx512cd.c
+
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	int	score;
+	__m256i	p_flip, o_flip, p_outflank, o_outflank, p_eraser, o_eraser, mask, opop_flip;
+	__mmask8 op_pass;
+	__m256i	P4 = _mm256_broadcastq_epi64(OP);
+
+		// left: look for player LS1B
+	mask = lrmask[pos].v4[0];
+	p_outflank = _mm256_and_si256(P4, mask);	o_outflank = _mm256_andnot_si256(P4, mask);
+		// set below LS1B if P is in lmask
+	p_flip = _mm256_maskz_add_epi64(_mm256_test_epi64_mask(P4, mask), p_outflank, _mm256_set1_epi64x(-1));
+		// set below LS1B if O is in lmask
+	o_flip = _mm256_maskz_add_epi64(_mm256_test_epi64_mask(o_outflank, o_outflank), o_outflank, _mm256_set1_epi64x(-1));
+	// p_flip = _mm256_and_si256(_mm256_andnot_si256(p_outflank, p_flip), mask);
+	p_flip = _mm256_ternarylogic_epi64(p_outflank, p_flip, mask, 0x08);
+	// o_flip = _mm256_and_si256(_mm256_andnot_si256(o_outflank, o_flip), mask);
+	o_flip = _mm256_ternarylogic_epi64(o_outflank, o_flip, mask, 0x08);
+
+		// right: clear all bits lower than outflank
+	mask = lrmask[pos].v4[1];
+	p_outflank = _mm256_and_si256(P4, mask);	o_outflank = _mm256_andnot_si256(P4, mask);
+	p_eraser = _mm256_srlv_epi64(_mm256_set1_epi64x(-1),
+		_mm256_maskz_lzcnt_epi64(_mm256_test_epi64_mask(P4, mask), p_outflank));
+	o_eraser = _mm256_srlv_epi64(_mm256_set1_epi64x(-1),
+		_mm256_maskz_lzcnt_epi64(_mm256_test_epi64_mask(o_outflank, o_outflank), o_outflank));
+	// p_flip = _mm256_or_si256(p_flip, _mm256_andnot_si256(p_eraser, mask));
+	p_flip = _mm256_ternarylogic_epi64(p_flip, p_eraser, mask, 0xf2);
+	// o_flip = _mm256_or_si256(o_flip, _mm256_andnot_si256(o_eraser, mask));
+	o_flip = _mm256_ternarylogic_epi64(o_flip, o_eraser, mask, 0xf2);
+
+	opop_flip = _mm256_or_si256(_mm256_unpacklo_epi64(p_flip, o_flip), _mm256_unpackhi_epi64(p_flip, o_flip));
+	OP = _mm_xor_si128(_mm256_castsi256_si128(P4),
+		_mm_or_si128(_mm256_castsi256_si128(opop_flip), _mm256_extracti128_si256(opop_flip, 1)));
+	op_pass = _mm_cmpeq_epi64_mask(OP, _mm256_castsi256_si128(P4));
+	OP = _mm_mask_unpackhi_epi64(OP, op_pass, OP, OP);	// use O if p_pass
+	score = bit_count(_mm_cvtsi128_si64(OP));
+		// last square for P if not P pass or (O pass and score >= 32)
+	// score += ((~op_pass & 1) | ((op_pass >> 1) & (score >= 32)));
+	score += (~op_pass | ((op_pass >> 1) & (score >> 5))) & 1;
+	(void) alpha;	// no lazy cut-off
+	return score * 2 - SCORE_MAX;	// = bit_count(P) - (SCORE_MAX - bit_count(P))
+}
+
+#elif (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_AVX512) && defined(LASTFLIP_HIGHCUT)
+// AVX512(256) NWS lazy high cut-off version (2.63s on skylake, 2.33 on icelake, 2.14s on Zen4)
+
+extern	const V8DI lrmask[66];	// in flip_avx_ppfill.c
+
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	int score = 2 * bit_count(_mm_cvtsi128_si64(OP)) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+		// if player can move, final score > this score.
+		// if player pass then opponent play, final score < score - 1 (cancel P) - 1 (last O).
+		// if both pass, score - 1 (cancel P) - 1 (empty for O) <= final score <= score (empty for P).
+	__m256i P4 = _mm256_broadcastq_epi64(OP);
+	__m256i lmask = lrmask[pos].v4[0];
+	__m256i rmask = lrmask[pos].v4[1];
+	__mmask16 lp = _mm256_test_epi64_mask(P4, lmask);	// P exists on mask
+	__mmask16 rp = _mm256_test_epi64_mask(P4, rmask);
+	__m256i F4, outflank, eraser, lmO, rmO;
+	__m128i F2;
+	int nflip;
+
+	if (score > alpha) {	// if player can move, high cut-off will occur regardress of n_flips.
+		lmO = _mm256_maskz_andnot_epi64(lp, P4, lmask);	// masked O, clear if all O
+		rmO = _mm256_maskz_andnot_epi64(rp, P4, rmask);	// (all O = all P = 0 flip)
+		if (_mm256_testz_si256(_mm256_or_si256(lmO, rmO), _mm256_set1_epi64x(NEIGHBOUR[pos]))) {
+			// nflip = last_flip(pos, ~P);
+				// left: set below LS1B if O is in lmask
+			F4 = _mm256_maskz_add_epi64(_mm256_test_epi64_mask(lmO, lmO), lmO, _mm256_set1_epi64x(-1));
+			// F4 = _mm256_and_si256(_mm256_andnot_si256(lmO, F4), lmask);
+			F4 = _mm256_ternarylogic_epi64(lmO, F4, lmask, 0x08);
+
+				// right: clear all bits lower than outflank
+			eraser = _mm256_srlv_epi64(_mm256_set1_epi64x(-1),
+				_mm256_maskz_lzcnt_epi64(_mm256_test_epi64_mask(rmO, rmO), rmO));
+			// F4 = _mm256_or_si256(F4, _mm256_andnot_si256(eraser, rmask));
+			F4 = _mm256_ternarylogic_epi64(F4, eraser, rmask, 0xf2);
+
+			F2 = _mm_or_si128(_mm256_castsi256_si128(F4), _mm256_extracti128_si256(F4, 1));
+			nflip = -bit_count(_mm_cvtsi128_si64(_mm_or_si128(F2, _mm_unpackhi_epi64(F2, F2))));
+				// last square for O if O can move or score <= 0
+			score += (nflip - (int)((nflip | (score - 1)) < 0)) * 2;
+
+		} else	score += 2;	// lazy high cut-off, return min flip
+
+	} else {	// if player cannot move, low cut-off will occur whether opponent can move.
+			// left: set below LS1B if P is in lmask
+		outflank = _mm256_and_si256(P4, lmask);
+		F4 = _mm256_maskz_add_epi64(lp, outflank, _mm256_set1_epi64x(-1));
+		// F4 = _mm256_and_si256(_mm256_andnot_si256(outflank, F4), lmask);
+		F4 = _mm256_ternarylogic_epi64(outflank, F4, lmask, 0x08);
+
+			// right: clear all bits lower than outflank
+		outflank = _mm256_and_si256(P4, rmask);
+		eraser = _mm256_srlv_epi64(_mm256_set1_epi64x(-1), _mm256_maskz_lzcnt_epi64(rp, outflank));
+		// F4 = _mm256_or_si256(F4, _mm256_andnot_si256(eraser, rmask));
+		F4 = _mm256_ternarylogic_epi64(F4, eraser, rmask, 0xf2);
+
+		F2 = _mm_or_si128(_mm256_castsi256_si128(F4), _mm256_extracti128_si256(F4, 1));
+		nflip = bit_count(_mm_cvtsi128_si64(_mm_or_si128(F2, _mm_unpackhi_epi64(F2, F2))));
+		score += nflip * 2;
+
+		// if nflip == 0, score <= alpha so lazy low cut-off
+	}
+
+	return score;
+}
+
+#elif (LAST_FLIP_COUNTER == COUNT_LAST_FLIP_AVX_PPFILL) && defined(LASTFLIP_HIGHCUT)
+// experimental AVX2 lastflip with lazy high cut-off version (a little slower)
+extern	const V8DI lrmask[66];	// in flip_avx_ppfill.c
+
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	int score = 2 * bit_count(_mm_cvtsi128_si64(OP)) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+		// if player can move, final score > this score.
+		// if player pass then opponent play, final score < score - 1 (cancel P) - 1 (last O).
+		// if both pass, score - 1 (cancel P) - 1 (empty for O) <= final score <= score (empty for P).
+	__m256i P4 = _mm256_broadcastq_epi64(OP);
+	__m256i F4, lmask, rmask, outflank, eraser, lmO, rmO, lp, rp;
+	__m128i F2;
+	int nflip;
+
+	lmask = lrmask[pos].v4[0];			rmask = lrmask[pos].v4[1];
+	lmO = _mm256_andnot_si256(P4, lmask);		rmO = _mm256_andnot_si256(P4, rmask);
+	lp = _mm256_cmpeq_epi64(lmO, lmask);		rp = _mm256_cmpeq_epi64(rmO, rmask);	// 0 if P exists on mask
+
+	if (score > alpha) {	// if player can move, high cut-off will occur regardress of n_flips.
+		F4 = _mm256_or_si256(_mm256_andnot_si256(lp, lmO), _mm256_andnot_si256(rp, rmO));	// clear if all O
+		if (_mm256_testz_si256(F4, _mm256_set1_epi64x(NEIGHBOUR[pos]))) {	// pass (16%)
+			// n_flips = last_flip(pos, ~P);
+				// right: isolate opponent MS1B by clearing lower shadow bits
+			eraser = _mm256_srlv_epi64(rmO, _mm256_set_epi64x(7, 9, 8, 1));
+				// eraser = opponent's shadow
+			eraser = _mm256_or_si256(eraser, rmO);
+			eraser = _mm256_or_si256(eraser, _mm256_srlv_epi64(eraser, _mm256_set_epi64x(14, 18, 16, 2)));
+			F4 = _mm256_andnot_si256(eraser, rmask);
+			F4 = _mm256_andnot_si256(_mm256_srlv_epi64(eraser, _mm256_set_epi64x(28, 36, 32, 4)), F4);
+				// clear if no opponent bit, i.e. all player
+			F4 = _mm256_andnot_si256(_mm256_cmpeq_epi64(F4, rmask), F4);
+
+				// left: look for opponent LS1B
+			outflank = _mm256_and_si256(lmO, _mm256_sub_epi64(_mm256_setzero_si256(), lmO));	// LS1B
+				// set all bits if outflank = 0, otherwise higher bits than outflank
+			eraser = _mm256_sub_epi64(_mm256_cmpeq_epi64(outflank, _mm256_setzero_si256()), outflank);
+			F4 = _mm256_or_si256(F4, _mm256_andnot_si256(eraser, lmask));
+
+			F2 = _mm_or_si128(_mm256_castsi256_si128(F4), _mm256_extracti128_si256(F4, 1));
+			nflip = -bit_count(_mm_cvtsi128_si64(_mm_or_si128(F2, _mm_unpackhi_epi64(F2, F2))));
+				// last square for O if O can move or score <= 0
+			score += (nflip - (int)((nflip | (score - 1)) < 0)) * 2;
+
+		} else	score += 2;	// lazy high cut-off, return min flip
+
+	} else {	// if player cannot move, low cut-off will occur whether opponent can move.
+			// right: isolate player MS1B by clearing lower shadow bits
+		outflank = _mm256_and_si256(P4, rmask);
+		eraser = _mm256_srlv_epi64(outflank, _mm256_set_epi64x(7, 9, 8, 1));
+			// eraser = player's shadow
+		eraser = _mm256_or_si256(eraser, outflank);
+		eraser = _mm256_or_si256(eraser, _mm256_srlv_epi64(eraser, _mm256_set_epi64x(14, 18, 16, 2)));
+		F4 = _mm256_andnot_si256(eraser, rmask);
+		F4 = _mm256_andnot_si256(_mm256_srlv_epi64(eraser, _mm256_set_epi64x(28, 36, 32, 4)), F4);
+			// clear if no player bit, i.e. all opponent
+		F4 = _mm256_andnot_si256(rp, F4);
+
+			// left: set below LS1B if P is in lmask
+		outflank = _mm256_and_si256(P4, lmask);
+		outflank = _mm256_andnot_si256(outflank, _mm256_add_epi64(outflank, _mm256_set1_epi64x(-1)));
+		F4 = _mm256_or_si256(F4, _mm256_andnot_si256(lp, _mm256_and_si256(outflank, lmask)));
+
+		F2 = _mm_or_si128(_mm256_castsi256_si128(F4), _mm256_extracti128_si256(F4, 1));
+		nflip = bit_count(_mm_cvtsi128_si64(_mm_or_si128(F2, _mm_unpackhi_epi64(F2, F2))));
+		score += nflip * 2;
+
+		// if nflip == 0, score <= alpha so lazy low cut-off
+	}
+
+	return score;
+}
+
+#elif defined(__AVX2__) && defined(SIMULLASTFLIP)
+// experimental branchless AVX2 MOVMSK version (slower on icc, par on msvc)
+// https://eukaryote.hateblo.jp/entry/2020/05/10/033228
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	int_fast8_t	p_flip, o_flip;
+	unsigned int	tP, tO, h;
+	unsigned long long P = _mm_cvtsi128_si64(OP);
+	int	score, score2;
+	const uint8_t *COUNT_FLIP_X = COUNT_FLIP[pos & 7];
+	const uint8_t *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+
+	__m256i M = mask_dvhd[pos].v4;
+	__m256i PP = _mm256_broadcastq_epi64(OP);
+
+	(void) alpha;	// no lazy cut-off
+	h = (P >> (pos & 0x38)) & 0xFF;
+	tP = TEST_EPI8_MASK32(PP, M);			tO = tP ^ TEST1_EPI8_MASK32(M);
+	p_flip  = COUNT_FLIP_X[h];			o_flip = -COUNT_FLIP_X[h ^ 0xFF];
+	p_flip += COUNT_FLIP_Y[tP & 0xFF];		o_flip -= COUNT_FLIP_Y[tO & 0xFF];
+	p_flip += COUNT_FLIP_Y[(tP >> 16) & 0xFF];	o_flip -= COUNT_FLIP_Y[(tO >> 16) & 0xFF];
+	p_flip += COUNT_FLIP_Y[tP >> 24];		o_flip -= COUNT_FLIP_Y[tO >> 24];
+
+	score = 2 * bit_count(P) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+	score2 = score + o_flip - (int)((o_flip | (score - 1)) < 0) * 2;	// last square for O if O can move or score <= 0
+	score += p_flip;
+	return p_flip ? score : score2;	// gcc/icc inserts branch here, since score2 may be wholly skipped.
+}
+
+#elif defined(__AVX2__) && defined(LASTFLIP_HIGHCUT)
+// AVX2 NWS lazy high cut-off version
+// http://www.amy.hi-ho.ne.jp/okuhara/edaxopt.htm#lazycutoff
+// lazy high cut-off idea was in Zebra by Gunnar Anderson (http://radagast.se/othello/zebra.html),
+// but commented out because mobility check was no faster than counting flips.
+// Now using AVX2, mobility check can be faster than counting flips.
+
+extern	const V8DI lrmask[66];	// in flip_avx_ppfill.c
+
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	int_fast8_t n_flips;
+	uint32_t t;
+	unsigned long long P = _mm_cvtsi128_si64(OP);
+	int score = 2 * bit_count(P) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+		// if player can move, final score > this score.
+		// if player pass then opponent play, final score < score - 1 (cancel P) - 1 (last O).
+		// if both pass, score - 1 (cancel P) - 1 (empty for O) <= final score <= score (empty for P).
+
+	if (score > alpha) {	// if player can move, high cut-off will occur regardress of n_flips.
+  #if 0 // def __AVX512VL__	// may trigger license base downclocking, wrong fingerprint on MSVC
+		__m512i P8 = _mm512_broadcastq_epi64(OP);
+		__m512i M = lrmask[pos].v8;
+		__m512i mO = _mm512_andnot_epi64(P8, M);
+		if (!_mm512_mask_test_epi64_mask(_mm512_test_epi64_mask(P8, M), mO, _mm512_set1_epi64(NEIGHBOUR[pos]))) {	// pass (16%)
+			// n_flips = last_flip(pos, ~P);
+			t = _cvtmask32_u32(_mm256_cmpneq_epi8_mask(_mm512_castsi512_si256(mO), _mm512_extracti64x4_epi64(mO, 1)));	// eq only if l = r = 0
+
+  #elif defined(__AVX512VL__) || defined(__AVX10_1__)	// 256bit AVX512 (2.61s on skylake, 2.37 on icelake, 2.16s on Zen4)
+		__m256i P4 = _mm256_broadcastq_epi64(OP);
+		__m256i M = lrmask[pos].v4[0];
+		__m256i F = _mm256_maskz_andnot_epi64(_mm256_test_epi64_mask(P4, M), P4, M);	// clear if all O
+		M = lrmask[pos].v4[1];
+		// F = _mm256_mask_or_epi64(F, _mm256_test_epi64_mask(P4, M), F, _mm256_andnot_si256(P4, M));
+		F = _mm256_mask_ternarylogic_epi64(F, _mm256_test_epi64_mask(P4, M), P4, M, 0xF2);
+		if (_mm256_testz_si256(F, _mm256_set1_epi64x(NEIGHBOUR[pos]))) {	// pass (16%)
+			// n_flips = last_flip(pos, ~P);
+			// t = _cvtmask32_u32(_mm256_cmpneq_epi8_mask(_mm256_andnot_si256(P4, lM), _mm256_andnot_si256(P4, rM)));
+			t = _cvtmask32_u32(_mm256_test_epi8_mask(F, F));	// all O = all P = 0 flip
+
+  #else	// AVX2
+		__m256i P4 = _mm256_broadcastq_epi64(OP);
+		__m256i M = lrmask[pos].v4[0];
+		__m256i lmO = _mm256_andnot_si256(P4, M);
+		__m256i F = _mm256_andnot_si256(_mm256_cmpeq_epi64(lmO, M), lmO);	// clear if all O
+		M = lrmask[pos].v4[1];
+		__m256i rmO = _mm256_andnot_si256(P4, M);
+		F = _mm256_or_si256(F, _mm256_andnot_si256(_mm256_cmpeq_epi64(rmO, M), rmO));
+		if (_mm256_testz_si256(F, _mm256_set1_epi64x(NEIGHBOUR[pos]))) {	// pass (16%)
+			// n_flips = last_flip(pos, ~P);
+			t = ~_mm256_movemask_epi8(_mm256_cmpeq_epi8(lmO, rmO));	// eq only if l = r = 0
+  #endif
+			const uint8_t *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+
+			n_flips = -COUNT_FLIP[pos & 7][(~P >> (pos & 0x38)) & 0xFF];	// h
+			n_flips -= COUNT_FLIP_Y[(t >> 8) & 0xFF];	// v
+			n_flips -= COUNT_FLIP_Y[(t >> 16) & 0xFF];	// d
+			n_flips -= COUNT_FLIP_Y[t >> 24];	// d
+				// last square for O if O can move or score <= 0
+			score += n_flips - (int)((n_flips | (score - 1)) < 0) * 2;
+		} else	score += 2;	// min flip
+
+	} else {	// if player cannot move, low cut-off will occur whether opponent can move.
+		const uint8_t *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+
+		// n_flips = last_flip(pos, P);
+		t = TEST_EPI8_MASK32(_mm256_broadcastq_epi64(OP), mask_dvhd[pos].v4);
+		n_flips  = COUNT_FLIP[pos & 7][(P >> (pos & 0x38)) & 0xFF];	// h
+		n_flips += COUNT_FLIP_Y[t & 0xFF];	// d
+		n_flips += COUNT_FLIP_Y[(t >> 16) & 0xFF];	// v
+		n_flips += COUNT_FLIP_Y[t >> 24];	// d
+		score += n_flips;
+
+		// if n_flips == 0, score <= alpha so lazy low cut-off
+	}
+
+	return score;
+}
+
+#else	// COUNT_LAST_FLIP_SSE - reasonably fast on all platforms (2.61s on skylake, 2.16s on Zen4)
+static inline int vectorcall board_score_sse_1(__m128i OP, const int alpha, const int pos)
+{
+	uint_fast8_t	n_flips;
+	unsigned int	t;
+	int	score, score2;
+	const uint8_t *COUNT_FLIP_X = COUNT_FLIP[pos & 7];
+	const uint8_t *COUNT_FLIP_Y = COUNT_FLIP[pos >> 3];
+
+	// n_flips = last_flip(pos, P);
+  #ifdef AVXLASTFLIP	// no gain
+	__m256i M = mask_dvhd[pos].v4;
+	__m256i P4 = _mm256_broadcastq_epi64(OP);
+	unsigned int h = (_mm_cvtsi128_si64(OP) >> (pos & 0x38)) & 0xFF;
+
+	t = TEST_EPI8_MASK32(P4, M);
+	n_flips  = COUNT_FLIP_X[h];
+	n_flips += COUNT_FLIP_Y[t & 0xFF];
+	t >>= 16;
+
+  #else
+	__m128i M0 = mask_dvhd[pos].v2[0];
+	__m128i M1 = mask_dvhd[pos].v2[1];
+	__m128i P2 = _mm_unpacklo_epi64(OP, OP);
+	__m128i II = _mm_sad_epu8(_mm_and_si128(P2, M0), _mm_setzero_si128());
+
+	n_flips  = COUNT_FLIP_X[_mm_extract_epi16(II, 4)];
+	n_flips += COUNT_FLIP_X[_mm_cvtsi128_si32(II)];
+	t = TEST_EPI8_MASK16(P2, M1);
+  #endif
+	n_flips += COUNT_FLIP_Y[t >> 8];
+	n_flips += COUNT_FLIP_Y[t & 0xFF];
+
+	score = 2 * bit_count_si64(OP) - SCORE_MAX + 2;	// = (bit_count(P) + 1) - (SCORE_MAX - 1 - bit_count(P))
+	score += n_flips;
+
+	if (n_flips == 0) {
+		score2 = score - 2;	// empty for player
+		if (score <= 0)
+			score = score2;
+
+		if (score > alpha) {	// lazy cut-off
+			// n_flips = last_flip(pos, ~P);
+  #ifdef AVXLASTFLIP
+			t = TEST1_EPI8_MASK32(_mm256_andnot_si256(P4, M));
+			n_flips  = COUNT_FLIP_X[h ^ 0xFF];
+			n_flips += COUNT_FLIP_Y[t & 0xFF];
+			t >>= 16;
+  #else
+			II = _mm_sad_epu8(_mm_andnot_si128(P2, M0), _mm_setzero_si128());
+			n_flips  = COUNT_FLIP_X[_mm_extract_epi16(II, 4)];
+			n_flips += COUNT_FLIP_X[_mm_cvtsi128_si32(II)];
+			t = _mm_movemask_epi8(_mm_sub_epi8(_mm_setzero_si128(), _mm_andnot_si128(P2, M1)));
+  #endif
+			n_flips += COUNT_FLIP_Y[t >> 8];
+			n_flips += COUNT_FLIP_Y[t & 0xFF];
+
+			if (n_flips != 0)
+				score = score2 - n_flips;
+		}
+	}
+
+	return score;
+}
+#endif
+
+// from bench.c
+int board_score_1(const unsigned long long player, const int alpha, const int x)
+{
+	return board_score_sse_1(_mm_cvtsi64_si128(player), alpha, x);
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final min score, when 2 empty squares remain.
+ *
+ * @param OP The board to evaluate.
+ * @param alpha Alpha bound.
+ * @param n_nodes Node counter.
+ * @param empties Packed empty square coordinates.
+ * @return The final min score, as a disc difference.
+ */
+static int vectorcall board_solve_2(__m128i OP, int alpha, volatile unsigned long long *n_nodes, __m128i empties)
+{
+	__m128i flipped;
+	int score, bestscore, nodes;
+	int x1 = _mm_extract_epi16(empties, 1);
+	int x2 = _mm_extract_epi16(empties, 0);
+	unsigned long long opponent;
+	// const int beta = alpha + 1;
+
+	SEARCH_STATS(++statistics.n_board_solve_2);
+
+	opponent = EXTRACT_O(OP);
+	if ((NEIGHBOUR[x1] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x1))) {
+		bestscore = board_score_sse_1(_mm_xor_si128(_mm_shuffle_epi32(OP, SWAP64), reduce_vflip(flipped)), alpha, x2);
+
+		if ((bestscore > alpha) && (NEIGHBOUR[x2] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+			score = board_score_sse_1(_mm_xor_si128(_mm_shuffle_epi32(OP, SWAP64), reduce_vflip(flipped)), alpha, x1);
+			if (score < bestscore)
+				bestscore = score;
+			nodes = 3;
+		} else	nodes = 2;
+
+	} else if ((NEIGHBOUR[x2] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+		bestscore = board_score_sse_1(_mm_xor_si128(_mm_shuffle_epi32(OP, SWAP64), reduce_vflip(flipped)), alpha, x1);
+		nodes = 2;
+
+	} else {	// pass - NEIGHBOUR test is almost 100% true
+		alpha = ~alpha;	// = -alpha - 1
+		if (!TESTZ_FLIP(flipped = mm_Flip(_mm_shuffle_epi32(OP, SWAP64), x1))) {
+			bestscore = board_score_sse_1(_mm_xor_si128(OP, reduce_vflip(flipped)), alpha, x2);
+
+			if ((bestscore > alpha) && !TESTZ_FLIP(flipped = mm_Flip(_mm_shuffle_epi32(OP, SWAP64), x2))) {
+				score = board_score_sse_1(_mm_xor_si128(OP, reduce_vflip(flipped)), alpha, x1);
+				if (score < bestscore)
+					bestscore = score;
+				nodes = 3;
+			} else	nodes = 2;
+
+		} else if (!TESTZ_FLIP(flipped = mm_Flip(_mm_shuffle_epi32(OP, SWAP64), x2))) {
+			bestscore = board_score_sse_1(_mm_xor_si128(OP, reduce_vflip(flipped)), alpha, x1);
+			nodes = 2;
+
+		} else {	// gameover
+			bestscore = board_solve(_mm_cvtsi128_si64(OP), 2);
+			nodes = 1;
+		}
+		bestscore = -bestscore;
+	}
+
+	SEARCH_UPDATE_2EMPTIES_NODES(*n_nodes += nodes;)
+	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+	assert((bestscore & 1) == 0);
+	return bestscore;
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final max score, when 3 empty squares remain.
+ *
+ * @param OP The board to evaluate.
+ * @param alpha Alpha bound.
+ * @param n_nodes Node counter.
+ * @param empties Packed empty square coordinates.
+ * @return The final max score, as a disc difference.
+ */
+static int vectorcall search_solve_3(__m128i OP, int alpha, volatile unsigned long long *n_nodes, __m128i empties)
+{
+	__m128i flipped;
+	int score, bestscore, x, pol;
+	unsigned long long opponent;
+
+	SEARCH_STATS(++statistics.n_search_solve_3);
+	SEARCH_UPDATE_INTERNAL_NODES(*n_nodes);
+
+#ifdef __AVX__
+	empties = _mm_cvtepu8_epi16(empties);
+#elif defined(__SSSE3__)
+	empties = _mm_unpacklo_epi8((empties), _mm_setzero_si128());
+#endif
+	bestscore = -SCORE_INF;
+	pol = 1;
+	do {
+		// best move alphabeta search
+		opponent = EXTRACT_O(OP);
+		x = _mm_extract_epi16(empties, 2);
+		if ((NEIGHBOUR[x] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x))) {
+			bestscore = board_solve_2(board_flip_next(OP, x, flipped), alpha, n_nodes, empties);
+			if (bestscore > alpha) return bestscore * pol;
+		}
+
+		x = _mm_extract_epi16(empties, 1);
+		if (/* (NEIGHBOUR[x] & opponent) && */ !TESTZ_FLIP(flipped = mm_Flip(OP, x))) {
+			score = board_solve_2(board_flip_next(OP, x, flipped), alpha, n_nodes, _mm_shufflelo_epi16(empties, 0xd8));	// (d3d1)d2d0
+			if (score > alpha) return score * pol;
+			else if (score > bestscore) bestscore = score;
+		}
+
+		x = _mm_extract_epi16(empties, 0);
+		if (/* (NEIGHBOUR[x] & opponent) && */ !TESTZ_FLIP(flipped = mm_Flip(OP, x))) {
+			score = board_solve_2(board_flip_next(OP, x, flipped), alpha, n_nodes, _mm_shufflelo_epi16(empties, 0xc9));	// (d3d0)d2d1
+			if (score > bestscore) bestscore = score;
+			return bestscore * pol;
+		}
+
+		if (bestscore > -SCORE_INF)
+			return bestscore * pol;
+
+		OP = _mm_shuffle_epi32(OP, SWAP64);	// pass
+		alpha = ~alpha;	// = -(alpha + 1)
+	} while ((pol = -pol) < 0);
+
+	return board_solve(_mm_cvtsi128_si64(OP), 3);	// gameover
+}
+
+/**
+ * @brief Get the final score.
+ *
+ * Get the final min score, when 4 empty squares remain.
+ *
+ * @param search Search position.
+ * @param alpha Upper score value.
+ * @return The final min score, as a disc difference.
+ */
+
+// pick the move for this ply and pass the rest as packed 3 x 8 bit (AVX/SSSE3) or 3 x 16 bit (SSE), in search order.
+#if defined(__SSSE3__) || defined(__AVX__)
+  #ifdef __AVX__
+	#define	EXTRACT_MOVE(X,i)	_mm_extract_epi8((X), (i) * 4 + 3)
+  #else
+	#define	EXTRACT_MOVE(X,i)	(_mm_extract_epi16((X), (i) * 2 + 1) >> 8)
+  #endif
+	#define	v3_empties_0(empties,sort3)	(empties)
+	#define	v3_empties(empties,i,shuf,sort3)	_mm_srli_si128((empties), (i) * 4)
+#else
+	#define	EXTRACT_MOVE(X,i)	_mm_extract_epi16((X), 3 - (i))
+	static inline __m128i vectorcall v3_empties_0(__m128i empties, int sort3) {
+		// parity based move sorting
+		// if (sort3 == 3) empties = _mm_shufflelo_epi16(empties, 0xe1); // swap x2, x3
+		if (sort3 & 2)	empties = _mm_shufflelo_epi16(empties, 0xc9); // case 1(x3) 2(x1 x2): x3->x1->x2->x3
+		if (sort3 & 1)	empties = _mm_shufflelo_epi16(empties, 0xd8); // case 1(x2) 2(x1 x3): swap x1, x2
+		return empties;
+	}
+	#define	v3_empties(empties,i,shuf,sort3)	v3_empties_0(_mm_shufflelo_epi16((empties), (shuf)), (sort3))
+#endif
+
+static int search_solve_4(Search *search, int alpha)
+{
+	__m128i	OP, flipped;
+	__m128i	empties_series;	// (AVX) B15:4th, B11:3rd, B7:2nd, B3:1st, lower 3 bytes for 3 empties
+				// (SSE) W3:1st, W2:2nd, W1:3rd, W0:4th
+	int x1, x2, x3, x4, paritysort, score, bestscore, pol;
+	unsigned long long opponent;
+	// const int beta = alpha + 1;
+	static const unsigned char parity_case[64] = {	/* x4x3x2x1 = */
+		/*0000*/  0, /*0001*/  0, /*0010*/  1, /*0011*/  9, /*0100*/  2, /*0101*/ 10, /*0110*/ 11, /*0111*/  3,
+		/*0002*/  0, /*0003*/  0, /*0012*/  0, /*0013*/  0, /*0102*/  4, /*0103*/  4, /*0112*/  5, /*0113*/  5,
+		/*0020*/  1, /*0021*/  0, /*0030*/  1, /*0031*/  0, /*0120*/  6, /*0121*/  7, /*0130*/  6, /*0131*/  7,
+		/*0022*/  9, /*0023*/  0, /*0032*/  0, /*0033*/  9, /*0122*/  8, /*0123*/  0, /*0132*/  0, /*0133*/  8,
+		/*0200*/  2, /*0201*/  4, /*0210*/  6, /*0211*/  8, /*0300*/  2, /*0301*/  4, /*0310*/  6, /*0311*/  8,
+		/*0202*/ 10, /*0203*/  4, /*0212*/  7, /*0213*/  0, /*0302*/  4, /*0303*/ 10, /*0312*/  0, /*0313*/  7,
+		/*0220*/ 11, /*0221*/  5, /*0230*/  6, /*0231*/  0, /*0320*/  6, /*0321*/  0, /*0330*/ 11, /*0331*/  5,
+		/*0222*/  3, /*0223*/  5, /*0232*/  7, /*0233*/  8, /*0322*/  8, /*0323*/  7, /*0332*/  5, /*0333*/  3
+	};
+#if defined(__SSSE3__) || defined(__AVX__)
+	union V4SI {
+		unsigned int	ui[4];
+		__m128i	v4;
+	};
+	static const union V4SI shuf_mask[] = {	// make search order identical to 4.4.0
+		{{ 0x03020100, 0x02030100, 0x01030200, 0x00030201 }},	//  0: 1(x1) 3(x2 x3 x4), 1(x1) 1(x2) 2(x3 x4), 1 1 1 1, 4
+		{{ 0x03020100, 0x02030100, 0x01020300, 0x00020301 }},	//  1: 1(x2) 3(x1 x3 x4)
+		{{ 0x03010200, 0x02010300, 0x01030200, 0x00010302 }},	//  2: 1(x3) 3(x1 x2 x4)
+		{{ 0x03000201, 0x02000301, 0x01000302, 0x00030201 }},	//  3: 1(x4) 3(x1 x2 x3)
+		{{ 0x03010200, 0x01030200, 0x02030100, 0x00030201 }},	//  4: 1(x1) 1(x3) 2(x2 x4)
+		{{ 0x03000201, 0x00030201, 0x02030100, 0x01030200 }},	//  5: 1(x1) 1(x4) 2(x2 x3)
+		{{ 0x02010300, 0x01020300, 0x03020100, 0x00030201 }},	//  6: 1(x2) 1(x3) 2(x1 x4)
+		{{ 0x02000301, 0x00020301, 0x03020100, 0x01030200 }},	//  7: 1(x2) 1(x4) 2(x1 x3)
+		{{ 0x01000302, 0x00010302, 0x03020100, 0x02030100 }},	//  8: 1(x3) 1(x4) 2(x1 x2)
+		{{ 0x03020100, 0x02030100, 0x01000302, 0x00010302 }},	//  9: 2(x1 x2) 2(x3 x4)
+		{{ 0x03010200, 0x02000301, 0x01030200, 0x00020301 }},	// 10: 2(x1 x3) 2(x2 x4)
+		{{ 0x03000201, 0x02010300, 0x01020300, 0x00030201 }}	// 11: 2(x1 x4) 2(x2 x3)
+	};
+	enum { sort3 = 0 };	// sort is done on 4 empties
+#else
+	int sort3;	// for move sorting on 3 empties
+	static const short sort3_shuf[] = {
+		0x0000,	//  0: 1(x1) 3(x2 x3 x4), 1(x1) 1(x2) 2(x3 x4), 1 1 1 1, 4		x4x1x2x3-x3x1x2x4-x2x1x3x4-x1x2x3x4
+		0x1100,	//  1: 1(x2) 3(x1 x3 x4)	x4x2x1x3-x3x2x1x4-x2x1x3x4-x1x2x3x4
+		0x2011,	//  2: 1(x3) 3(x1 x2 x4)	x4x3x1x2-x3x1x2x4-x2x3x1x4-x1x3x2x4
+		0x0222,	//  3: 1(x4) 3(x1 x2 x3)	x4x1x2x3-x3x4x1x2-x2x4x1x3-x1x4x2x3
+		0x3000,	//  4: 1(x1) 1(x3) 2(x2 x4)	x4x1x2x3-x2x1x3x4-x3x1x2x4-x1x3x2x4 <- x4x1x3x2-x2x1x3x4-x3x1x2x4-x1x3x2x4
+		0x3300,	//  5: 1(x1) 1(x4) 2(x2 x3)	x3x1x2x4-x2x1x3x4-x4x1x2x3-x1x4x2x3 <- x3x1x4x2-x2x1x4x3-x4x1x2x3-x1x4x2x3
+		0x2000,	//  6: 1(x2) 1(x3) 2(x1 x4)	x4x1x2x3-x1x2x3x4-x3x2x1x4-x2x3x1x4 <- x4x2x3x1-x1x2x3x4-x3x2x1x4-x2x3x1x4
+		0x2300,	//  7: 1(x2) 1(x4) 2(x1 x3)	x3x1x2x4-x1x2x3x4-x4x2x1x3-x2x4x1x3 <- x3x2x4x1-x1x2x4x3-x4x2x1x3-x2x4x1x3
+		0x2200,	//  8: 1(x3) 1(x4) 2(x1 x2)	x2x1x3x4-x1x2x3x4-x4x3x1x2-x3x4x1x2 <- x2x3x4x1-x1x3x4x2-x4x3x1x2-x3x4x1x2
+		0x2200,	//  9: 2(x1 x2) 2(x3 x4)	x4x3x1x2-x3x4x1x2-x2x1x3x4-x1x2x3x4
+		0x1021,	// 10: 2(x1 x3) 2(x2 x4)	x4x2x1x3-x3x1x2x4-x2x4x1x3-x1x3x2x4
+		0x0112	// 11: 2(x1 x4) 2(x2 x3)	x4x1x2x3-x3x2x1x4-x2x3x1x4-x1x4x2x3
+	};
+#endif
+
+	SEARCH_STATS(++statistics.n_search_solve_4);
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
+
+	// stability cutoff (try 12%, cut 7%)
+	if (search_SC_NWS_4(search, alpha, &score)) return score;
+
+	OP = _mm_loadu_si128((__m128i *) &search->board);
+	x1 = search->empties[NOMOVE].next;
+	x2 = search->empties[x1].next;
+	x3 = search->empties[x2].next;
+	x4 = search->empties[x3].next;
+
+	// parity based move sorting.
+	// The following hole sizes are possible:
+	//    4 - 1 3 - 2 2 - 1 1 2 - 1 1 1 1
+	// Only the 1 1 2 case needs move sorting on this ply.
+	paritysort = parity_case[((x3 ^ x4) & 0x24) + ((((x2 ^ x4) & 0x24) * 2 + ((x1 ^ x4) & 0x24)) >> 2)];
+#if defined(__SSSE3__) || defined(__AVX__)
+	empties_series = _mm_cvtsi32_si128((x1 << 24) | (x2 << 16) | (x3 << 8) | x4);
+	empties_series = _mm_shuffle_epi8(empties_series, shuf_mask[paritysort].v4);
+
+#else // SSE
+	empties_series = _mm_cvtsi32_si128((x3 << 16) | x4);
+	empties_series = _mm_insert_epi16(empties_series, x2, 2);
+	empties_series = _mm_insert_epi16(empties_series, x1, 3);
+	switch (paritysort) {
+		case 4: // case 1(x1) 1(x3) 2(x2 x4)
+			empties_series = _mm_shufflelo_epi16(empties_series, 0xd8);	// x1x3x2x4
+			break;
+		case 5: // case 1(x1) 1(x4) 2(x2 x3)
+			empties_series = _mm_shufflelo_epi16(empties_series, 0xc9);	// x1x4x2x3
+			break;
+		case 6:	// case 1(x2) 1(x3) 2(x1 x4)
+			empties_series = _mm_shufflelo_epi16(empties_series, 0x9c);	// x2x3x1x4
+			break;
+		case 7: // case 1(x2) 1(x4) 2(x1 x3)
+			empties_series = _mm_shufflelo_epi16(empties_series, 0x8d);	// x2x4x1x3
+			break;
+		case 8:	// case 1(x3) 1(x4) 2(x1 x2)
+			empties_series = _mm_shufflelo_epi16(empties_series, 0x4e);	// x3x4x1x2
+			break;
+	}
+	sort3 = sort3_shuf[paritysort];
+#endif
+
+	bestscore = SCORE_INF;	// min stage
+	pol = 1;
+	do {
+		// best move alphabeta search
+		opponent = EXTRACT_O(OP);
+		x1 = EXTRACT_MOVE(empties_series, 0);
+		if ((NEIGHBOUR[x1] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x1))) {
+			bestscore = search_solve_3(board_flip_next(OP, x1, flipped), alpha, &search->n_nodes,
+				v3_empties_0(empties_series, sort3));
+			if (bestscore <= alpha) return bestscore * pol;
+		}
+
+		x2 = EXTRACT_MOVE(empties_series, 1);
+		if ((NEIGHBOUR[x2] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x2))) {
+			score = search_solve_3(board_flip_next(OP, x2, flipped), alpha, &search->n_nodes,
+				v3_empties(empties_series, 1, 0xb4, sort3 >> 4));	// (SSE) x2x1x3x4
+			if (score <= alpha) return score * pol;
+			else if (score < bestscore) bestscore = score;
+		}
+
+		x3 = EXTRACT_MOVE(empties_series, 2);
+		if ((NEIGHBOUR[x3] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x3))) {
+			score = search_solve_3(board_flip_next(OP, x3, flipped), alpha, &search->n_nodes,
+				v3_empties(empties_series, 2, 0x78, sort3 >> 8));	// (SSE) x3x1x2x4
+			if (score <= alpha) return score * pol;
+			else if (score < bestscore) bestscore = score;
+		}
+
+		x4 = EXTRACT_MOVE(empties_series, 3);
+		if ((NEIGHBOUR[x4] & opponent) && !TESTZ_FLIP(flipped = mm_Flip(OP, x4))) {
+			score = search_solve_3(board_flip_next(OP, x4, flipped), alpha, &search->n_nodes,
+				v3_empties(empties_series, 3, 0x39, sort3 >> 12));	// (SSE) x4x1x2x3
+			if (score <= bestscore) bestscore = score;
+			return bestscore * pol;
+		}
+
+		if (bestscore < SCORE_INF)
+			return bestscore * pol;
+
+		OP = _mm_shuffle_epi32(OP, SWAP64);	// pass
+		alpha = ~alpha;	// = -(alpha + 1)
+	} while ((pol = -pol) < 0);
+
+	return board_solve(EXTRACT_O(OP), 4);	// gameover
+}
diff --git a/src/eval.c b/src/eval.c
index 8b1d2801..500d4e2c 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3,9 +3,10 @@
  *
  * Evaluation function.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @author Toshihiko Okuhara
+ * @version 4.5
  */
 
 #include "eval.h"
@@ -19,19 +20,21 @@
 #include <stdlib.h>
 #include <assert.h>
 
+#if !defined(VECTOR_EVAL_UPDATE) && !defined(hasSSE2) && !defined(__ARM_NEON)
+
 /** coordinate to feature conversion */
 typedef struct CoordinateToFeature {
 	int n_feature;
 	struct {
-		int i;
-		int x;
-	} feature[16];
+		unsigned short i;
+		unsigned short x;
+	} feature[7];
 } CoordinateToFeature;
 
 /** feature to coordinates conversion */
 typedef struct FeatureToCoordinate {
 	int n_square;
-	int x[16];
+	unsigned char x[12];
 } FeatureToCoordinate;
 
 /** array to convert features into coordinates */
@@ -99,157 +102,454 @@ static const FeatureToCoordinate EVAL_F2X[] = {
 
 /** array to convert coordinates into feature */
 static const CoordinateToFeature EVAL_X2F[] = {
-	{7, {{ 0,    6561}, { 4,     243}, { 8,    6561}, {10,    6561}, {12,   19683}, {14,   19683}, {28,    2187}}},  /* a1 */
-	{5, {{ 0,    2187}, { 4,      27}, { 8,    2187}, {18,    2187}, {30,     729}}},                                /* b1 */
-	{6, {{ 0,      81}, { 4,       9}, { 8,     729}, {12,    6561}, {22,    2187}, {34,     243}}},                 /* c1 */
-	{7, {{ 4,       3}, { 5,       1}, { 8,     243}, {12,    2187}, {26,    2187}, {38,      81}, {42,      27}}},  /* d1 */
-	{7, {{ 4,       1}, { 5,       3}, { 8,      81}, {12,       9}, {27,    2187}, {40,      81}, {44,      27}}},  /* e1 */
-	{6, {{ 1,      81}, { 5,       9}, { 8,      27}, {12,       3}, {23,    2187}, {36,     243}}},                 /* f1 */
-	{5, {{ 1,    2187}, { 5,      27}, { 8,       9}, {19,    2187}, {33,     729}}},                                /* g1 */
-	{7, {{ 1,    6561}, { 5,     243}, { 8,       3}, {11,    6561}, {12,       1}, {15,   19683}, {29,       1}}},  /* h1 */
-	{5, {{ 0,     729}, { 4,     729}, {10,    2187}, {16,    2187}, {32,     729}}},                                /* a2 */
-	{7, {{ 0,     243}, { 4,      81}, { 8,   19683}, {10,   19683}, {16,     729}, {18,     729}, {28,     729}}},  /* b2 */
-	{6, {{ 0,       9}, {12,     729}, {16,     243}, {22,     729}, {30,     243}, {42,       9}}},                 /* c2 */
-	{5, {{12,     243}, {16,      81}, {26,     729}, {34,      81}, {40,      27}}},                                /* d2 */
-	{5, {{12,      81}, {16,      27}, {27,     729}, {36,      81}, {38,      27}}},                                /* e2 */
-	{6, {{ 1,       9}, {12,      27}, {16,       9}, {23,     729}, {33,     243}, {44,       9}}},                 /* f2 */
-	{7, {{ 1,     243}, { 5,      81}, { 8,       1}, {11,   19683}, {16,       3}, {19,     729}, {29,       3}}},  /* g2 */
-	{5, {{ 1,     729}, { 5,     729}, {11,    2187}, {16,       1}, {31,     729}}},                                /* h2 */
-	{6, {{ 0,      27}, { 4,    2187}, {10,     729}, {14,    6561}, {20,    2187}, {35,     243}}},                 /* a3 */
-	{6, {{ 0,       3}, {14,     729}, {18,     243}, {20,     729}, {32,     243}, {42,       3}}},                 /* b3 */
-	{5, {{ 0,       1}, {20,     243}, {22,     243}, {28,     243}, {40,       9}}},                                /* c3 */
-	{4, {{20,      81}, {26,     243}, {30,      81}, {36,      27}}},                                               /* d3 */
-	{4, {{20,      27}, {27,     243}, {33,      81}, {34,      27}}},                                               /* e3 */
-	{5, {{ 1,       1}, {20,       9}, {23,     243}, {29,       9}, {38,       9}}},                                /* f3 */
-	{6, {{ 1,       3}, {15,     729}, {19,     243}, {20,       3}, {31,     243}, {44,       3}}},                 /* g3 */
-	{6, {{ 1,      27}, { 5,    2187}, {11,     729}, {15,    6561}, {20,       1}, {37,     243}}},                 /* h3 */
-	{7, {{ 4,    6561}, { 6,   19683}, {10,     243}, {14,    2187}, {24,    2187}, {39,      81}, {42,       1}}},  /* a4 */
-	{5, {{14,     243}, {18,      81}, {24,     729}, {35,      81}, {40,       3}}},                                /* b4 */
-	{4, {{22,      81}, {24,     243}, {32,      81}, {36,       9}}},                                               /* c4 */
-	{4, {{24,      81}, {26,      81}, {28,      81}, {33,      27}}},                                               /* d4 */
-	{4, {{24,      27}, {27,      81}, {29,      27}, {30,      27}}},                                               /* e4 */
-	{4, {{23,      81}, {24,       9}, {31,      81}, {34,       9}}},                                               /* f4 */
-	{5, {{15,     243}, {19,      81}, {24,       3}, {37,      81}, {38,       3}}},                                /* g4 */
-	{7, {{ 5,    6561}, { 7,   19683}, {11,     243}, {15,    2187}, {24,       1}, {41,      81}, {44,       1}}},  /* h4 */
-	{7, {{ 4,   19683}, { 6,    6561}, {10,      81}, {14,       9}, {25,    2187}, {40,       1}, {43,      27}}},  /* a5 */
-	{5, {{14,      81}, {18,      27}, {25,     729}, {36,       3}, {39,      27}}},                                /* b5 */
-	{4, {{22,      27}, {25,     243}, {33,       9}, {35,      27}}},                                               /* c5 */
-	{4, {{25,      81}, {26,      27}, {29,      81}, {32,      27}}},                                               /* d5 */
-	{4, {{25,      27}, {27,      27}, {28,      27}, {31,      27}}},                                               /* e5 */
-	{4, {{23,      27}, {25,       9}, {30,       9}, {37,      27}}},                                               /* f5 */
-	{5, {{15,      81}, {19,      27}, {25,       3}, {34,       3}, {41,      27}}},                                /* g5 */
-	{7, {{ 5,   19683}, { 7,    6561}, {11,      81}, {15,       9}, {25,       1}, {38,       1}, {45,      27}}},  /* h5 */
-	{6, {{ 2,      81}, { 6,    2187}, {10,      27}, {14,       3}, {21,    2187}, {36,       1}}},                 /* a6 */
-	{6, {{ 2,       9}, {14,      27}, {18,       9}, {21,     729}, {33,       3}, {43,       9}}},                 /* b6 */
-	{5, {{ 2,       1}, {21,     243}, {22,       9}, {29,     243}, {39,       9}}},                                /* c6 */
-	{4, {{21,      81}, {26,       9}, {31,       9}, {35,       9}}},                                               /* d6 */
-	{4, {{21,      27}, {27,       9}, {32,       9}, {37,       9}}},                                               /* e6 */
-	{5, {{ 3,       1}, {21,       9}, {23,       9}, {28,       9}, {41,       9}}},                                /* f6 */
-	{6, {{ 3,       9}, {15,      27}, {19,       9}, {21,       3}, {30,       3}, {45,       9}}},                 /* g6 */
-	{6, {{ 3,      81}, { 7,    2187}, {11,      27}, {15,       3}, {21,       1}, {34,       1}}},                 /* h6 */
-	{5, {{ 2,    2187}, { 6,     729}, {10,       9}, {17,    2187}, {33,       1}}},                                /* a7 */
-	{7, {{ 2,     243}, { 6,      81}, { 9,   19683}, {10,       1}, {17,     729}, {18,       3}, {29,     729}}},  /* b7 */
-	{6, {{ 2,       3}, {13,     729}, {17,     243}, {22,       3}, {31,       3}, {43,       3}}},                 /* c7 */
-	{5, {{13,     243}, {17,      81}, {26,       3}, {37,       3}, {39,       3}}},                                /* d7 */
-	{5, {{13,      81}, {17,      27}, {27,       3}, {35,       3}, {41,       3}}},                                /* e7 */
-	{6, {{ 3,       3}, {13,      27}, {17,       9}, {23,       3}, {32,       3}, {45,       3}}},                 /* f7 */
-	{7, {{ 3,     243}, { 7,      81}, { 9,       1}, {11,       1}, {17,       3}, {19,       3}, {28,       3}}},  /* g7 */
-	{5, {{ 3,    2187}, { 7,     729}, {11,       9}, {17,       1}, {30,       1}}},                                /* h7 */
-	{7, {{ 2,    6561}, { 6,     243}, { 9,    6561}, {10,       3}, {13,   19683}, {14,       1}, {29,    2187}}},  /* a8 */
-	{5, {{ 2,     729}, { 6,      27}, { 9,    2187}, {18,       1}, {31,       1}}},                                /* b8 */
-	{6, {{ 2,      27}, { 6,       9}, { 9,     729}, {13,    6561}, {22,       1}, {37,       1}}},                 /* c8 */
-	{7, {{ 6,       3}, { 7,       1}, { 9,     243}, {13,    2187}, {26,       1}, {41,       1}, {43,       1}}},  /* d8 */
-	{7, {{ 6,       1}, { 7,       3}, { 9,      81}, {13,       9}, {27,       1}, {39,       1}, {45,       1}}},  /* e8 */
-	{6, {{ 3,      27}, { 7,       9}, { 9,      27}, {13,       3}, {23,       1}, {35,       1}}},                 /* f8 */
-	{5, {{ 3,     729}, { 7,      27}, { 9,       9}, {19,       1}, {32,       1}}},                                /* g8 */
-	{7, {{ 3,    6561}, { 7,     243}, { 9,       3}, {11,       3}, {13,       1}, {15,       1}, {28,       1}}},  /* h8 */
-	{0, {{ 0, 0}}} // <- PASS
+	{7, {{ 0,  6561}, { 4,   243}, { 8,  6561}, {10,  6561}, {12, 19683}, {14, 19683}, {28,  2187}}},  /* a1 */
+	{5, {{ 0,  2187}, { 4,    27}, { 8,  2187}, {18,  2187}, {30,   729}}},                            /* b1 */
+	{6, {{ 0,    81}, { 4,     9}, { 8,   729}, {12,  6561}, {22,  2187}, {34,   243}}},               /* c1 */
+	{7, {{ 4,     3}, { 5,     1}, { 8,   243}, {12,  2187}, {26,  2187}, {38,    81}, {42,    27}}},  /* d1 */
+	{7, {{ 4,     1}, { 5,     3}, { 8,    81}, {12,     9}, {27,  2187}, {40,    81}, {44,    27}}},  /* e1 */
+	{6, {{ 1,    81}, { 5,     9}, { 8,    27}, {12,     3}, {23,  2187}, {36,   243}}},               /* f1 */
+	{5, {{ 1,  2187}, { 5,    27}, { 8,     9}, {19,  2187}, {33,   729}}},                            /* g1 */
+	{7, {{ 1,  6561}, { 5,   243}, { 8,     3}, {11,  6561}, {12,     1}, {15, 19683}, {29,     1}}},  /* h1 */
+	{5, {{ 0,   729}, { 4,   729}, {10,  2187}, {16,  2187}, {32,   729}}},                            /* a2 */
+	{7, {{ 0,   243}, { 4,    81}, { 8, 19683}, {10, 19683}, {16,   729}, {18,   729}, {28,   729}}},  /* b2 */
+	{6, {{ 0,     9}, {12,   729}, {16,   243}, {22,   729}, {30,   243}, {42,     9}}},               /* c2 */
+	{5, {{12,   243}, {16,    81}, {26,   729}, {34,    81}, {40,    27}}},                            /* d2 */
+	{5, {{12,    81}, {16,    27}, {27,   729}, {36,    81}, {38,    27}}},                            /* e2 */
+	{6, {{ 1,     9}, {12,    27}, {16,     9}, {23,   729}, {33,   243}, {44,     9}}},               /* f2 */
+	{7, {{ 1,   243}, { 5,    81}, { 8,     1}, {11, 19683}, {16,     3}, {19,   729}, {29,     3}}},  /* g2 */
+	{5, {{ 1,   729}, { 5,   729}, {11,  2187}, {16,     1}, {31,   729}}},                            /* h2 */
+	{6, {{ 0,    27}, { 4,  2187}, {10,   729}, {14,  6561}, {20,  2187}, {35,   243}}},               /* a3 */
+	{6, {{ 0,     3}, {14,   729}, {18,   243}, {20,   729}, {32,   243}, {42,     3}}},               /* b3 */
+	{5, {{ 0,     1}, {20,   243}, {22,   243}, {28,   243}, {40,     9}}},                            /* c3 */
+	{4, {{20,    81}, {26,   243}, {30,    81}, {36,    27}}},                                         /* d3 */
+	{4, {{20,    27}, {27,   243}, {33,    81}, {34,    27}}},                                         /* e3 */
+	{5, {{ 1,     1}, {20,     9}, {23,   243}, {29,     9}, {38,     9}}},                            /* f3 */
+	{6, {{ 1,     3}, {15,   729}, {19,   243}, {20,     3}, {31,   243}, {44,     3}}},               /* g3 */
+	{6, {{ 1,    27}, { 5,  2187}, {11,   729}, {15,  6561}, {20,     1}, {37,   243}}},               /* h3 */
+	{7, {{ 4,  6561}, { 6, 19683}, {10,   243}, {14,  2187}, {24,  2187}, {39,    81}, {42,     1}}},  /* a4 */
+	{5, {{14,   243}, {18,    81}, {24,   729}, {35,    81}, {40,     3}}},                            /* b4 */
+	{4, {{22,    81}, {24,   243}, {32,    81}, {36,     9}}},                                         /* c4 */
+	{4, {{24,    81}, {26,    81}, {28,    81}, {33,    27}}},                                         /* d4 */
+	{4, {{24,    27}, {27,    81}, {29,    27}, {30,    27}}},                                         /* e4 */
+	{4, {{23,    81}, {24,     9}, {31,    81}, {34,     9}}},                                         /* f4 */
+	{5, {{15,   243}, {19,    81}, {24,     3}, {37,    81}, {38,     3}}},                            /* g4 */
+	{7, {{ 5,  6561}, { 7, 19683}, {11,   243}, {15,  2187}, {24,     1}, {41,    81}, {44,     1}}},  /* h4 */
+	{7, {{ 4, 19683}, { 6,  6561}, {10,    81}, {14,     9}, {25,  2187}, {40,     1}, {43,    27}}},  /* a5 */
+	{5, {{14,    81}, {18,    27}, {25,   729}, {36,     3}, {39,    27}}},                            /* b5 */
+	{4, {{22,    27}, {25,   243}, {33,     9}, {35,    27}}},                                         /* c5 */
+	{4, {{25,    81}, {26,    27}, {29,    81}, {32,    27}}},                                         /* d5 */
+	{4, {{25,    27}, {27,    27}, {28,    27}, {31,    27}}},                                         /* e5 */
+	{4, {{23,    27}, {25,     9}, {30,     9}, {37,    27}}},                                         /* f5 */
+	{5, {{15,    81}, {19,    27}, {25,     3}, {34,     3}, {41,    27}}},                            /* g5 */
+	{7, {{ 5, 19683}, { 7,  6561}, {11,    81}, {15,     9}, {25,     1}, {38,     1}, {45,    27}}},  /* h5 */
+	{6, {{ 2,    81}, { 6,  2187}, {10,    27}, {14,     3}, {21,  2187}, {36,     1}}},               /* a6 */
+	{6, {{ 2,     9}, {14,    27}, {18,     9}, {21,   729}, {33,     3}, {43,     9}}},               /* b6 */
+	{5, {{ 2,     1}, {21,   243}, {22,     9}, {29,   243}, {39,     9}}},                            /* c6 */
+	{4, {{21,    81}, {26,     9}, {31,     9}, {35,     9}}},                                         /* d6 */
+	{4, {{21,    27}, {27,     9}, {32,     9}, {37,     9}}},                                         /* e6 */
+	{5, {{ 3,     1}, {21,     9}, {23,     9}, {28,     9}, {41,     9}}},                            /* f6 */
+	{6, {{ 3,     9}, {15,    27}, {19,     9}, {21,     3}, {30,     3}, {45,     9}}},               /* g6 */
+	{6, {{ 3,    81}, { 7,  2187}, {11,    27}, {15,     3}, {21,     1}, {34,     1}}},               /* h6 */
+	{5, {{ 2,  2187}, { 6,   729}, {10,     9}, {17,  2187}, {33,     1}}},                            /* a7 */
+	{7, {{ 2,   243}, { 6,    81}, { 9, 19683}, {10,     1}, {17,   729}, {18,     3}, {29,   729}}},  /* b7 */
+	{6, {{ 2,     3}, {13,   729}, {17,   243}, {22,     3}, {31,     3}, {43,     3}}},               /* c7 */
+	{5, {{13,   243}, {17,    81}, {26,     3}, {37,     3}, {39,     3}}},                            /* d7 */
+	{5, {{13,    81}, {17,    27}, {27,     3}, {35,     3}, {41,     3}}},                            /* e7 */
+	{6, {{ 3,     3}, {13,    27}, {17,     9}, {23,     3}, {32,     3}, {45,     3}}},               /* f7 */
+	{7, {{ 3,   243}, { 7,    81}, { 9,     1}, {11,     1}, {17,     3}, {19,     3}, {28,     3}}},  /* g7 */
+	{5, {{ 3,  2187}, { 7,   729}, {11,     9}, {17,     1}, {30,     1}}},                            /* h7 */
+	{7, {{ 2,  6561}, { 6,   243}, { 9,  6561}, {10,     3}, {13, 19683}, {14,     1}, {29,  2187}}},  /* a8 */
+	{5, {{ 2,   729}, { 6,    27}, { 9,  2187}, {18,     1}, {31,     1}}},                            /* b8 */
+	{6, {{ 2,    27}, { 6,     9}, { 9,   729}, {13,  6561}, {22,     1}, {37,     1}}},               /* c8 */
+	{7, {{ 6,     3}, { 7,     1}, { 9,   243}, {13,  2187}, {26,     1}, {41,     1}, {43,     1}}},  /* d8 */
+	{7, {{ 6,     1}, { 7,     3}, { 9,    81}, {13,     9}, {27,     1}, {39,     1}, {45,     1}}},  /* e8 */
+	{6, {{ 3,    27}, { 7,     9}, { 9,    27}, {13,     3}, {23,     1}, {35,     1}}},               /* f8 */
+	{5, {{ 3,   729}, { 7,    27}, { 9,     9}, {19,     1}, {32,     1}}},                            /* g8 */
+	{7, {{ 3,  6561}, { 7,   243}, { 9,     3}, {11,     3}, {13,     1}, {15,     1}, {28,     1}}},  /* h8 */
+	{4, {{ 0,     0}, { 0,     0}, { 0,     0}, { 0,     0}}} // <- PASS
 };
 
-/** feature size */
-static const int EVAL_SIZE[] = {19683, 59049, 59049, 59049, 6561, 6561, 6561, 6561, 2187,729, 243, 81, 1};
-
-/** packed feature size */
-static const int EVAL_PACKED_SIZE[] = {10206, 29889, 29646, 29646, 3321, 3321, 3321, 3321, 1134, 378, 135, 45, 1};
-
-/** feature offset */
-static const int EVAL_OFFSET[] = {
-	     0,      0,      0,      0,
-	 19683,  19683,  19683,  19683,
-	 78732,  78732,  78732,  78732,
-	137781,	137781, 137781, 137781,
-	196830,	196830, 196830, 196830,
-	203391,	203391, 203391, 203391,
-	209952,	209952, 209952, 209952,
-	216513,	216513,
-	223074,	223074,	223074,	223074,
-	225261,	225261,	225261,	225261,
-	225990,	225990, 225990,	225990,
-	226233,	226233, 226233, 226233,
-	226314,
+#endif
+#if defined(VECTOR_EVAL_UPDATE) || defined(hasSSE2) || defined(__ARM_NEON) || defined(DISPATCH_NEON) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+
+const EVAL_FEATURE_V EVAL_FEATURE[65] = {
+	{{ // a1
+		 6561,     0,     0,     0,   243,     0,     0,     0,  6561,     0,  6561,     0, 19683,     0, 19683,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // b1
+		 2187,     0,     0,     0,    27,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // c1
+		   81,     0,     0,     0,     9,     0,     0,     0,   729,     0,     0,     0,  6561,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,   243,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // d1
+		    0,     0,     0,     0,     3,     1,     0,     0,   243,     0,     0,     0,  2187,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,    81,     0,     0,     0,    27,     0,     0,     0,     0,     0
+	}}, {{ // e1
+		    0,     0,     0,     0,     1,     3,     0,     0,    81,     0,     0,     0,     9,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,    81,     0,     0,     0,    27,     0,     0,     0
+	}}, {{ // f1
+		    0,    81,     0,     0,     0,     9,     0,     0,    27,     0,     0,     0,     3,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,   243,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // g1
+		    0,  2187,     0,     0,     0,    27,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,   729,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // h1
+		    0,  6561,     0,     0,     0,   243,     0,     0,     3,     0,     0,  6561,     1,     0,     0, 19683,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // a2
+		  729,     0,     0,     0,   729,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,
+		 2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		  729,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // b2
+		  243,     0,     0,     0,    81,     0,     0,     0, 19683,     0, 19683,     0,     0,     0,     0,     0,
+		  729,     0,   729,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // c2
+		    9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,     0,     0,
+		  243,     0,     0,     0,     0,     0,   729,     0,     0,     0,     0,     0,     0,     0,   243,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0,     0
+	}}, {{ // d2
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   243,     0,     0,     0,
+		   81,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,     0,     0,     0,     0,
+		    0,     0,    81,     0,     0,     0,     0,     0,    27,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // e2
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    81,     0,     0,     0,
+		   27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,     0,     0,     0,
+		    0,     0,     0,     0,    81,     0,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // f2
+		    0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    27,     0,     0,     0,
+		    9,     0,     0,     0,     0,     0,     0,   729,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,   243,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     9,     0,     0,     0
+	}}, {{ // g2
+		    0,   243,     0,     0,     0,    81,     0,     0,     1,     0,     0, 19683,     0,     0,     0,     0,
+		    3,     0,     0,   729,     0,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // h2
+		    0,   729,     0,     0,     0,   729,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,
+		    1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // a3
+		   27,     0,     0,     0,  2187,     0,     0,     0,     0,     0,   729,     0,     0,     0,  6561,     0,
+		    0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,   243,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // b3
+		    3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,
+		    0,     0,   243,     0,   729,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		  243,     0,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0
+	}}, {{ // c3
+		    1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,   243,     0,   243,     0,     0,     0,     0,     0,   243,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // d3
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,    81,     0,     0,     0,     0,     0,   243,     0,     0,     0,    81,     0,
+		    0,     0,     0,     0,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // e3
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,    27,     0,     0,     0,     0,     0,     0,   243,     0,     0,     0,     0,
+		    0,    81,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // f3
+		    0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     9,     0,     0,   243,     0,     0,     0,     0,     0,     9,     0,     0,
+		    0,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // g3
+		    0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,
+		    0,     0,     0,   243,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   243,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,     0
+	}}, {{ // h3
+		    0,    27,     0,     0,     0,  2187,     0,     0,     0,     0,     0,   729,     0,     0,     0,  6561,
+		    0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,   243,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // a4
+		    0,     0,     0,     0,  6561,     0, 19683,     0,     0,     0,   243,     0,     0,     0,  2187,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,    81,     0,     0,     1,     0,     0,     0,     0,     0
+	}}, {{ // b4
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   243,     0,
+		    0,     0,    81,     0,     0,     0,     0,     0,   729,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,    81,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // c4
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,    81,     0,   243,     0,     0,     0,     0,     0,     0,     0,
+		   81,     0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // d4
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,    81,     0,    81,     0,    81,     0,     0,     0,
+		    0,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // e4
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,    27,     0,     0,    81,     0,    27,    27,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // f4
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,    81,     9,     0,     0,     0,     0,     0,     0,    81,
+		    0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // g4
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   243,
+		    0,     0,     0,    81,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,    81,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // h4
+		    0,     0,     0,     0,     0,  6561,     0, 19683,     0,     0,     0,   243,     0,     0,     0,  2187,
+		    0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,    81,     0,     0,     1,     0,     0,     0
+	}}, {{ // a5
+		    0,     0,     0,     0, 19683,     0,  6561,     0,     0,     0,    81,     0,     0,     0,     9,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,    27,     0,     0,     0,     0
+	}}, {{ // b5
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    81,     0,
+		    0,     0,    27,     0,     0,     0,     0,     0,     0,   729,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     3,     0,     0,    27,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // c5
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,    27,     0,     0,   243,     0,     0,     0,     0,     0,     0,
+		    0,     9,     0,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // d5
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,    81,    27,     0,     0,    81,     0,     0,
+		   27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // e5
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,    27,     0,    27,    27,     0,     0,    27,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // f5
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,    27,     0,     9,     0,     0,     0,     0,     9,     0,
+		    0,     0,     0,     0,     0,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // g5
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    81,
+		    0,     0,     0,    27,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,     0,
+		    0,     0,     3,     0,     0,     0,     0,     0,     0,    27,     0,     0,     0,     0,     0,     0
+	}}, {{ // h5
+		    0,     0,     0,     0,     0, 19683,     0,  6561,     0,     0,     0,    81,     0,     0,     0,     9,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,    27,     0,     0
+	}}, {{ // a6
+		    0,     0,    81,     0,     0,     0,  2187,     0,     0,     0,    27,     0,     0,     0,     3,     0,
+		    0,     0,     0,     0,     0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // b6
+		    0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    27,     0,
+		    0,     0,     9,     0,     0,   729,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0
+	}}, {{ // c6
+		    0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,   243,     9,     0,     0,     0,     0,     0,     0,   243,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // d6
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,    81,     0,     0,     0,     0,     9,     0,     0,     0,     0,     9,
+		    0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // e6
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,    27,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0,
+		    9,     0,     0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // f6
+		    0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     9,     0,     9,     0,     0,     0,     0,     9,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     9,     0,     0,     0,     0,     0,     0
+	}}, {{ // g6
+		    0,     0,     0,     9,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    27,
+		    0,     0,     0,     9,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     9,     0,     0
+	}}, {{ // h6
+		    0,     0,     0,    81,     0,     0,     0,  2187,     0,     0,     0,    27,     0,     0,     0,     3,
+		    0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // a7
+		    0,     0,  2187,     0,     0,     0,   729,     0,     0,     0,     9,     0,     0,     0,     0,     0,
+		    0,  2187,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // b7
+		    0,     0,   243,     0,     0,     0,    81,     0,     0, 19683,     1,     0,     0,     0,     0,     0,
+		    0,   729,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // c7
+		    0,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   729,     0,     0,
+		    0,   243,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     3,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0
+	}}, {{ // d7
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,   243,     0,     0,
+		    0,    81,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     3,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // e7
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,    81,     0,     0,
+		    0,    27,     0,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0,
+		    0,     0,     0,     3,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,     0
+	}}, {{ // f7
+		    0,     0,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     0,    27,     0,     0,
+		    0,     9,     0,     0,     0,     0,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0,
+		    3,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0
+	}}, {{ // g7
+		    0,     0,     0,   243,     0,     0,     0,    81,     0,     1,     0,     1,     0,     0,     0,     0,
+		    0,     3,     0,     3,     0,     0,     0,     0,     0,     0,     0,     0,     3,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // h7
+		    0,     0,     0,  2187,     0,     0,     0,   729,     0,     0,     0,     9,     0,     0,     0,     0,
+		    0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // a8
+		    0,     0,  6561,     0,     0,     0,   243,     0,     0,  6561,     3,     0,     0, 19683,     1,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,  2187,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // b8
+		    0,     0,   729,     0,     0,     0,    27,     0,     0,  2187,     0,     0,     0,     0,     0,     0,
+		    0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     1,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // c8
+		    0,     0,    27,     0,     0,     0,     9,     0,     0,   729,     0,     0,     0,  6561,     0,     0,
+		    0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // d8
+		    0,     0,     0,     0,     0,     0,     3,     1,     0,   243,     0,     0,     0,  2187,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     1,     0,     0,     0,     0
+	}}, {{ // e8
+		    0,     0,     0,     0,     0,     0,     1,     3,     0,    81,     0,     0,     0,     9,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     1,     0,     0
+	}}, {{ // f8
+		    0,     0,     0,    27,     0,     0,     0,     9,     0,    27,     0,     0,     0,     3,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // g8
+		    0,     0,     0,   729,     0,     0,     0,    27,     0,     9,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    1,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // h8
+		    0,     0,     0,  6561,     0,     0,     0,   243,     0,     3,     0,     3,     0,     1,     0,     1,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     1,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}, {{ // PASS
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+		    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0
+	}}
 };
 
-static const int EVAL_MAX_VALUE[] = {
-	 19682,  19682,  19682,  19682,
-	 78731,  78731,  78731,  78731,
-	137780,	137780, 137780, 137780,
-	196829,	196829, 196829, 196829,
-	203390,	203390, 203390, 203390,
-	209951,	209951, 209951, 209951,
-	216512,	216512,
-	223073,	223073,	223073,	223073,
-	225260,	225260,	225260,	225260,
-	225989,	225989, 225989,	225989,
-	226232,	226232, 226232, 226232,
-	226313,	226313,	226313,	226313,
-	226314,
-};
+const EVAL_FEATURE_V EVAL_FEATURE_all_opponent = {{
+	 9841,  9841,  9841,  9841, 29524, 29524, 29524, 29524, 29524, 29524, 29524, 29524, 29524, 29524, 29524, 29524,
+//	11111111(3)                 +3^8                       +3^8*2                      +3^8*3         1111111(3)
+	 3280,  3280,  3280,  3280,  9841,  9841,  9841,  9841, 16402, 16402, 16402, 16402, 22963, 22963,  1093,  1093,
+//	              364(=111111(3))+2187        121(=11111(3))+2187+729     40(=1111(3))+2187+729+243
+	 1093,  1093,  2551,  2551,  2551,  2551,  3037,  3037,  3037,  3037,  3199,  3199,  3199,  3199,     0,     0
+}};
 
-/** feature symetry packing */
-static int EVAL_C10[2][59049];
-static int EVAL_S10[2][59049];
-static int EVAL_C9[2][19683];
-static int EVAL_S8[2][6561];
-static int EVAL_S7[2][2187];
-static int EVAL_S6[2][729];
-static int EVAL_S5[2][243];
-static int EVAL_S4[2][81];
+#endif
 
-/** number of (unpacked) weights */
-static const int EVAL_N_WEIGHT = 226315;
+/** feature offset/size */
+// static const int EVAL_OFS[] = { 0, 19683, 78732, 137781, 196830, 203391, 209952, 216513, 223074, 225261, 225990, 226233, 226314 };
+// static const int EVAL_SIZE[] = {19683, 59049, 59049, 59049, 6561, 6561, 6561, 6561, 2187, 729, 243, 81, 1};
+static const unsigned short EVAL_OFFSET[] = {
+	    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+	    0,     0,     0,     0,  6561,  6561,  6561,  6561, 13122, 13122, 13122, 13122, 19683, 19683,     0,     0,
+	    0,     0,  2187,  2187,  2187,  2187,  2916,  2916,  2916,  2916,  3159,  3159,  3159,  3159,     0,     0
+};
 
-/** number of plies */
-static const int EVAL_N_PLY = 61;
+/** packed feature offset/size */
+static const int EVAL_PACKED_OFS[] = { 0, 10206, 40095, 69741, 99387, 102708, 106029, 109350, 112671, 113805, 114183, 114318, 114363 };
+// static const int EVAL_PACKED_SIZE[] = {10206, 29889, 29646, 29646, 3321, 3321, 3321, 3321, 1134, 378, 135, 45, 1};
 
-/** number of features */
-static const int EVAL_N_FEATURE = 47;
+/** feature symetry packing */
+typedef struct {
+	short EVAL_C10[59049];
+	short EVAL_S10[59049];
+	short EVAL_C9[19683];
+	short EVAL_S8[6561];
+	short EVAL_S7[2187];
+	short EVAL_S6[729];
+	short EVAL_S5[243];
+	short EVAL_S4[81];
+} SymetryPacking;
 
 /** eval weight load status */
 static int EVAL_LOADED = 0;
 
 /** eval weights */
-short ***EVAL_WEIGHT;
+Eval_weight (*EVAL_WEIGHT)[EVAL_N_PLY - 2];	// for 2..53
+
+/** opponent feature */
+static unsigned short *OPPONENT_FEATURE;
 
 /** evaluation function error coefficient parameters */
 static double EVAL_A, EVAL_B, EVAL_C, EVAL_a, EVAL_b, EVAL_c;
 
-
 /**
  * @brief Opponent feature.
  *
  * Compute a feature from the opponent point of view.
- * @param l feature.
+ * @param p opponent feature pointer.
+ * @param o opponent feature base to next depth.
  * @param d feature size.
- * @return opponent feature.
+ * @return updated opponent feature pointer
  */
-static int opponent_feature(int l, int d)
+// #define OPPONENT(x)	((9 >> (x)) & 3)	// (0, 1, 2) to (1, 0, 2)
+static unsigned short *set_opponent_feature(unsigned short *p, int o, int d)
 {
-	static const int o[] = {1, 0, 2};
-	int f = o[l % 3];
-
-	if (d > 1) f += opponent_feature(l / 3, d - 1) * 3;
+	if (--d) {
+		p = set_opponent_feature(p, (o + 1) * 3, d);
+		p = set_opponent_feature(p, o * 3, d);
+		p = set_opponent_feature(p, (o + 2) * 3, d);
+	} else {
+		*p++ = o + 1;
+		*p++ = o;
+		*p++ = o + 2;
+	}
+	return p;
+}
 
-	return f;
+/**
+ * @brief Create eval packing index.
+ *
+ * Create an index array to reduce mirror positions.
+ * @param pe pointer to array to set result.
+ * @param T internally used array to check mirror positions.
+ * @param kd feature increment at each depth for the mirror position.
+ * @param l feature index.
+ * @param k feature index for the mirror position.
+ * @param n packed count so far.
+ * @param d feature size, >= 4.
+ * @return updated packed count.
+ */
+static int set_eval_packing(short *pe, int *T, const int *kd, int l, int k, int n, int d)
+{
+	int	i, q0, q1, q2, q3;
+
+	if (--d > 3) {
+		l *= 3;
+		n = set_eval_packing(pe, T, kd, l, k, n, d);
+		k += kd[d];
+		n = set_eval_packing(pe, T, kd, l + 3, k, n, d);
+		k += kd[d];
+		n = set_eval_packing(pe, T, kd, l + 6, k, n, d);
+	} else {
+		l *= 27;
+		for (q3 = 0; q3 < 3; ++q3) {
+			for (q2 = 0; q2 < 3; ++q2) {
+				for (q1 = 0; q1 < 3; ++q1) {
+					for (q0 = 0; q0 < 3; ++q0) {
+						if (k < l) i = T[k];
+						else T[l] = i = n++;
+						pe[l++] = i;
+						k += kd[0];
+					}
+					k += (kd[1] - kd[0] * 3);
+				}
+				k += (kd[2] - kd[1] * 3);
+			}
+			k += (kd[3] - kd[2] * 3);
+		}
+	}
+	return n;
 }
 
 /**
@@ -269,11 +569,16 @@ void eval_open(const char* file)
 	double date;
 	const int n_w = 114364;
 	int *T;
-	int ply, i, j, k, l, n;
+	int ply, i, j, k;
 	int r;
-	int offset;
 	FILE* f;
-	short *w = NULL;
+	short *w;
+	Eval_weight *pe;
+	SymetryPacking (*P)[2];
+	SymetryPacking *pp;
+	static const int kd_S10[] = { 19683, 6561, 2187, 729, 243, 81, 27, 9, 3, 1 };
+	static const int kd_C10[] = { 19683, 6561, 2187, 729, 81, 243, 27, 9, 3, 1 };
+	static const int kd_C9[] = { 1, 9, 3, 81, 27, 243, 2187, 729, 6561 };
 
 	if (EVAL_LOADED++) return;
 
@@ -284,94 +589,50 @@ void eval_open(const char* file)
 	if (sizeof (short) != 2) fatal_error("short size is not compatible with Edax.\n");
 
 	// create unpacking tables
-	T = (int*) malloc(59049 * sizeof (*T));
-	if (T == NULL) fatal_error("Cannot allocate temporary table variable.\n");
-
-	for (l = n = 0; l < 6561; l++){ /* 8 squares : 6561 -> 3321 */
-		k=((l / 2187) % 3) + ((l / 729) % 3) * 3 + ((l / 243) % 3) * 9 +
-		((l / 81) % 3) * 27 + ((l / 27) % 3) * 81 + ((l / 9) % 3) * 243 +
-		((l / 3) % 3) * 729 + (l % 3) * 2187;
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_S8[0][l] = T[l];
-		EVAL_S8[1][opponent_feature(l, 8)] = T[l];
-	}
-	for (l = n = 0; l < 2187; l++){ /* 7 squares : 2187 -> 1134 */
-		k=((l / 729) % 3) + ((l / 243) % 3) * 3 + ((l / 81) % 3) * 9 +
-		 ((l / 27) % 3) * 27 + ((l / 9) % 3) * 81 + ((l / 3) % 3) * 243 +
-		 (l % 3) * 729;
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_S7[0][l] = T[l];
-		EVAL_S7[1][opponent_feature(l, 7)] = T[l];
-	}
-	for (l = n = 0; l < 729; l++){ /* 6 squares : 729 -> 378 */
-		k=((l / 243) % 3) + ((l / 81) % 3) * 3 + ((l / 27) % 3) * 9 +
-		 ((l / 9) % 3) * 27 + ((l / 3) % 3) * 81 + (l % 3) * 243;
-		if (k < l) T[l]=T[k];
-		else T[l] = n++;
-		EVAL_S6[0][l] = T[l];
-		EVAL_S6[1][opponent_feature(l, 6)] = T[l];
-	}
-	for (l = n = 0; l < 243; l++) { /* 5 squares : 243 -> 135 */
-		k=((l / 81) % 3)+((l / 27) % 3) * 3 + ((l / 9) % 3) * 9+
-		((l / 3) % 3) * 27 + (l % 3) * 81;
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_S5[0][l] = T[l];
-		EVAL_S5[1][opponent_feature(l, 5)] = T[l];
-	}
-	for (l = n = 0; l < 81; l++) { /* 4 squares : 81 -> 45 */
-		k=((l / 27) % 3) + ((l / 9) % 3) * 3 + ((l / 3) % 3) * 9 + (l % 3) * 27;
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_S4[0][l] = T[l];
-		EVAL_S4[1][opponent_feature(l, 4)] = T[l];
-	}
-	for (l = n = 0;l < 19683; l++) { /* 9 corner squares : 19683 -> 10206 */
-		k = ((l / 6561) % 3) * 6561 + ((l / 729) % 3) * 2187 +
-		((l / 2187) % 3) * 729 + ((l / 243) % 3) * 243 +((l / 27) % 3) * 81 +
-		((l / 81) % 3) * 27 + ((l / 3) % 3) * 9 + ((l / 9) % 3) * 3 + (l % 3);
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_C9[0][l] = T[l];
-		EVAL_C9[1][opponent_feature(l, 9)] = T[l];
-	}
-	for (l = n = 0; l < 59049; l++) { /* 10 squares (edge +X ) : 59049 -> 29646 */
-		k=((l / 19683) % 3) + ((l / 6561) % 3) * 3+((l / 2187) % 3) * 9 +
-		  ((l / 729) % 3) * 27 + ((l / 243) % 3) * 81 + ((l / 81) % 3) * 243 +
-		  ((l / 27) % 3) * 729 + ((l / 9) % 3) * 2187 + ((l / 3) % 3) * 6561 +
-		  (l % 3) * 19683;
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_S10[0][l] = T[l];
-		EVAL_S10[1][opponent_feature(l, 10)] = T[l];
-	}
-	for (l = n = 0; l < 59049; l++) { /* 10 squares (angle + X) : 59049 -> 29889 */
-		k=((l / 19683) % 3) + ((l / 6561) % 3) * 3+((l / 2187) % 3) * 9 +
-		  ((l / 729) % 3) * 27 + ((l / 243) % 3) * 243 + ((l / 81) % 3) * 81 +
-		  ((l / 27) % 3) * 729 + ((l / 9) % 3) * 2187 + ((l / 3) % 3) * 6561 +
-		  (l % 3) * 19683;
-		if (k < l) T[l] = T[k];
-		else T[l] = n++;
-		EVAL_C10[0][l] = T[l];
-		EVAL_C10[1][opponent_feature(l, 10)] = T[l];
+	OPPONENT_FEATURE = (unsigned short *) malloc(59049 * sizeof(unsigned short));	// 3^10
+	P = (SymetryPacking (*)[2]) malloc(2 * sizeof(*P));
+	T = (int *) malloc(2 * 59049 * sizeof(*T));
+	if ((OPPONENT_FEATURE == NULL) || (P == NULL) || (T == NULL))
+		fatal_error("Cannot allocate temporary table variable.\n");
+
+	set_opponent_feature(OPPONENT_FEATURE, 0, 10);
+
+	set_eval_packing((*P)[0].EVAL_S8, T, kd_S10 + 2, 0, 0, 0, 8);	/* 8 squares : 6561 -> 3321 */
+	for (j = 0; j < 6561; ++j)
+		(*P)[1].EVAL_S8[j] = (*P)[0].EVAL_S8[OPPONENT_FEATURE[j + 26244]];	// 1100000000(3)
+
+	set_eval_packing((*P)[0].EVAL_S7, T, kd_S10 + 3, 0, 0, 0, 7);	/* 7 squares : 2187 -> 1134 */
+	for (j = 0; j < 2187; ++j)
+		(*P)[1].EVAL_S7[j] = (*P)[0].EVAL_S7[OPPONENT_FEATURE[j + 28431]];	// 1110000000(3)
+
+	set_eval_packing((*P)[0].EVAL_S6, T, kd_S10 + 4, 0, 0, 0, 6);	/* 6 squares : 729 -> 378 */
+	for (j = 0; j < 729; ++j)
+		(*P)[1].EVAL_S6[j] = (*P)[0].EVAL_S6[OPPONENT_FEATURE[j + 29160]];	// 1111000000(3)
+
+	set_eval_packing((*P)[0].EVAL_S5, T, kd_S10 + 5, 0, 0, 0, 5);	/* 5 squares : 243 -> 135 */
+	for (j = 0; j < 243; ++j)
+		(*P)[1].EVAL_S5[j] = (*P)[0].EVAL_S5[OPPONENT_FEATURE[j + 29403]];	// 1111100000(3)
+
+	set_eval_packing((*P)[0].EVAL_S4, T, kd_S10 + 6, 0, 0, 0, 4);	/* 4 squares : 81 -> 45 */
+	for (j = 0; j < 81; ++j)
+		(*P)[1].EVAL_S4[j] = (*P)[0].EVAL_S4[OPPONENT_FEATURE[j + 29484]];	// 1111110000(3)
+
+	set_eval_packing((*P)[0].EVAL_C9, T, kd_C9, 0, 0, 0, 9);	/* 9 corner squares : 19683 -> 10206 */
+	for (j = 0; j < 19683; ++j)
+		(*P)[1].EVAL_C9[j] = (*P)[0].EVAL_C9[OPPONENT_FEATURE[j + 19683]];	// 1000000000(3)
+
+	set_eval_packing((*P)[0].EVAL_S10, T, kd_S10, 0, 0, 0, 10);	/* 10 squares (edge + X) : 59049 -> 29646 */
+	set_eval_packing((*P)[0].EVAL_C10, T, kd_C10, 0, 0, 0, 10);	/* 10 squares (angle + X) : 59049 -> 29889 */
+	for (j = 0; j < 59049; ++j) {
+		(*P)[1].EVAL_S10[j] = (*P)[0].EVAL_S10[OPPONENT_FEATURE[j]];
+		(*P)[1].EVAL_C10[j] = (*P)[0].EVAL_C10[OPPONENT_FEATURE[j]];
 	}
+
 	free(T);
 
 	// allocation
-	EVAL_WEIGHT = (short***) malloc(2 * sizeof (*EVAL_WEIGHT));
-	if (EVAL_WEIGHT == NULL) fatal_error("Cannot evaluation weights.\n");
-	EVAL_WEIGHT[0] = (short**) malloc(2 * EVAL_N_PLY * sizeof (**EVAL_WEIGHT));
-	if (EVAL_WEIGHT[0] == NULL) fatal_error("Cannot evaluation weights.\n");
-	EVAL_WEIGHT[1] = EVAL_WEIGHT[0] + EVAL_N_PLY;
-	EVAL_WEIGHT[0][0] = (short*) malloc(2 * EVAL_N_PLY * EVAL_N_WEIGHT * sizeof (***EVAL_WEIGHT));
-	if (EVAL_WEIGHT[0][0] == NULL) fatal_error("Cannot evaluation weights.\n");
-	EVAL_WEIGHT[1][0] = EVAL_WEIGHT[0][0] + EVAL_N_PLY * EVAL_N_WEIGHT;
-	for (ply = 1; ply < EVAL_N_PLY; ply++) {
-		EVAL_WEIGHT[0][ply] = EVAL_WEIGHT[0][ply - 1] + EVAL_N_WEIGHT;
-		EVAL_WEIGHT[1][ply] = EVAL_WEIGHT[1][ply - 1] + EVAL_N_WEIGHT;
-	}
+	EVAL_WEIGHT = (Eval_weight(*)[EVAL_N_PLY - 2]) malloc(sizeof(*EVAL_WEIGHT));
+	if (EVAL_WEIGHT == NULL) fatal_error("Cannot allocate evaluation weights.\n");
 
 	// data reading
 	w = (short*) malloc(n_w * sizeof (*w)); // a temporary to read packed weights
@@ -399,86 +660,46 @@ void eval_open(const char* file)
 	for (ply = 0; ply < EVAL_N_PLY; ply++) {
 		r = fread(w, sizeof (short), n_w, f);
 		if (r != n_w) fatal_error("Cannot read evaluation weight from %s\n", file);
+		if (ply < 2) continue;	// skip ply 1 & 2
+
 		if (edax_header == XADE) for (i = 0; i < n_w; ++i) w[i] = bswap_short(w[i]);
-		i = j = offset = 0;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_C9[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_C9[1][k] + offset];
-		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_C10[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_C10[1][k] + offset];
-		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S10[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S10[1][k] + offset];
-		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S10[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S10[1][k] + offset];
-		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S8[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S8[1][k] + offset];
-		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S8[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S8[1][k] + offset];
+
+		pe = *EVAL_WEIGHT + ply - 2;
+		pp = *P + (ply & 1);
+		for (k = 0; k < 19683; k++) {
+			pe->C9[k] = w[pp->EVAL_C9[k] + EVAL_PACKED_OFS[0]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S8[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S8[1][k] + offset];
+		for (k = 0; k < 59049; k++) {
+			pe->C10[k] = w[pp->EVAL_C10[k] + EVAL_PACKED_OFS[1]];
+			i = pp->EVAL_S10[k];
+			pe->S100[k] = w[i + EVAL_PACKED_OFS[2]];
+			pe->S101[k] = w[i + EVAL_PACKED_OFS[3]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S8[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S8[1][k] + offset];
+		for (k = 0; k < 6561; k++) {
+			i = pp->EVAL_S8[k];
+			pe->S8x4[k] = w[i + EVAL_PACKED_OFS[4]];
+			pe->S8x4[k + 6561] = w[i + EVAL_PACKED_OFS[5]];
+			pe->S8x4[k + 13122] = w[i + EVAL_PACKED_OFS[6]];
+			pe->S8x4[k + 19683] = w[i + EVAL_PACKED_OFS[7]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S7[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S7[1][k] + offset];
+		for (k = 0; k < 2187; k++) {
+			pe->S7654[k] = w[pp->EVAL_S7[k] + EVAL_PACKED_OFS[8]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S6[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S6[1][k] + offset];
+		for (k = 0; k < 729; k++) {
+			pe->S7654[k + 2187] = w[pp->EVAL_S6[k] + EVAL_PACKED_OFS[9]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S5[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S5[1][k] + offset];
+		for (k = 0; k < 243; k++) {
+			pe->S7654[k + 2916] = w[pp->EVAL_S5[k] + EVAL_PACKED_OFS[10]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		for (k = 0; k < EVAL_SIZE[i]; k++,j++) {
-			EVAL_WEIGHT[0][ply][j] = w[EVAL_S4[0][k] + offset];
-			EVAL_WEIGHT[1][ply][j] = w[EVAL_S4[1][k] + offset];
+		for (k = 0; k < 81; k++) {
+			pe->S7654[k + 3159] = w[pp->EVAL_S4[k] + EVAL_PACKED_OFS[11]];
 		}
-		offset += EVAL_PACKED_SIZE[i];
-		i++;
-		EVAL_WEIGHT[0][ply][j] = w[offset];
-		EVAL_WEIGHT[1][ply][j] = w[offset];
+		pe->S0 = w[EVAL_PACKED_OFS[12]];
 	}
 
 	fclose(f);
 	free(w);
+	free(P);
 
 	/*if (version == 3 && release == 2 && build == 5)*/ {
 		EVAL_A = -0.10026799, EVAL_B = 0.31027733, EVAL_C = -0.57772603;
@@ -486,6 +707,10 @@ void eval_open(const char* file)
 	}
 
 	info("<Evaluation function weights version %u.%u.%u loaded>\n", version, release, build);
+
+	// f = fopen("eval.bin", "wb");
+	// fwrite(*EVAL_WEIGHT, sizeof(Eval_weight), EVAL_N_PLY, f);
+	// fclose(f);
 }
 
 /**
@@ -493,33 +718,18 @@ void eval_open(const char* file)
  */
 void eval_close(void)
 {
-	free(EVAL_WEIGHT[0][0]);
-	free(EVAL_WEIGHT[0]);
+	free(OPPONENT_FEATURE);
 	free(EVAL_WEIGHT);
 	EVAL_WEIGHT = NULL;
 }
 
-/**
- * @brief Initialize a new evaluation function.
- *
- * Allocate space to store the state of the evaluation function.
- *
- * @param eval Evaluation function.
- */
-void eval_init(Eval *eval)
-{
-	eval->feature = (int*) malloc(EVAL_N_FEATURE * sizeof (*eval->feature));
-}
+#ifdef ANDROID
+extern void eval_update_sse(int x, unsigned long long f, Eval *eval_out, const Eval *eval_in);
+#elif defined(hasSSE2) || defined(__ARM_NEON) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+#include "eval_sse.c"
+#endif
 
-/**
- * @brief Free resources used by the evaluation function.
- *
- * @param eval Evaluation function.
- */
-void eval_free(Eval *eval)
-{
-	free(eval->feature);
-}
+#if !defined(hasSSE2) && !defined(__ARM_NEON)
 
 /**
  * @brief Set up evaluation features from a board.
@@ -529,292 +739,173 @@ void eval_free(Eval *eval)
  */
 void eval_set(Eval *eval, const Board *board)
 {
-	int i, j, c;
+	int	i, x;
+  #ifdef VECTOR_EVAL_UPDATE
+	unsigned long long b = (eval->n_empties & 1) ? board->opponent : board->player;
+
+	eval->feature = EVAL_FEATURE_all_opponent;
+	foreach_bit (x, b)
+		for (i = 0; i < 12; ++i)
+			eval->feature.ull[i] -= EVAL_FEATURE[x].ull[i];
+
+	b = ~(board->opponent | board->player);
+	foreach_bit (x, b)
+		for (i = 0; i < 12; ++i)
+			eval->feature.ull[i] += EVAL_FEATURE[x].ull[i];
+
+  #else
+	int	j;
+	Board	b;
+
+	if (eval->n_empties & 1) {
+		b.player = board->opponent;
+		b.opponent = board->player;
+	} else	b = *board;
 
 	for (i = 0; i < EVAL_N_FEATURE; ++i) {
-		eval->feature[i] = 0;
+		x = 0;
 		for (j = 0; j < EVAL_F2X[i].n_square; j++) {
-			c = board_get_square_color(board, EVAL_F2X[i].x[j]);
-			eval->feature[i] = eval->feature[i] * 3 + c;
+			x = x * 3 + board_get_square_color(&b, EVAL_F2X[i].x[j]);
 		}
-		eval->feature[i] += EVAL_OFFSET[i];
+		eval->feature.us[i] = x + EVAL_OFFSET[i];
 	}
-	eval->player = 0;
-}
-
-/**
- * @brief Swap player's feature.
- *
- * @param eval  Evaluation function.
- */
-static void eval_swap(Eval *eval)
-{
-	eval->player ^= 1;
+  #endif
 }
 
-
 /**
  * @brief Update the features after a player's move.
  *
+ * @param x     Move position.
+ * @param f     Flipped bitboard.
  * @param eval  Evaluation function.
- * @param move  Move.
  */
-static void eval_update_0(Eval *eval, const Move *move)
+static void eval_update_0(int x, unsigned long long f, Eval *eval)
 {
-	const CoordinateToFeature *s = EVAL_X2F + move->x;
-	register int x;
-	int *feature = eval->feature;
-	unsigned long long f = move->flipped;
-	
-#ifdef DEBUG
-
-	int i, j;
-	for (i = 0; i < s->n_feature; ++i) {
-		j = s->feature[i].i;
-		assert(0 <= j && j < EVAL_N_FEATURE);
-		feature[j] -= 2 * s->feature[i].x;
-		assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
-	}
+  #ifdef VECTOR_EVAL_UPDATE
+	int	i;
 
-	foreach_bit (x, f) {
-		s = EVAL_X2F + x;
-		for (i = 0; i < s->n_feature; ++i) {
-			j = s->feature[i].i;
-			assert(0 <= j && j < EVAL_N_FEATURE);
-			feature[j] -= s->feature[i].x;
-			assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
-		}
-	}
+	for (i = 0; i < 12; ++i)
+		eval->feature.ull[i] -= EVAL_FEATURE[x].ull[i] << 1;
+
+	foreach_bit (x, f)
+		for (i = 0; i < 12; ++i)
+			eval->feature.ull[i] -= EVAL_FEATURE[x].ull[i];
 
-#else
+  #else
+	const CoordinateToFeature *s = EVAL_X2F + x;
 
 	switch (s->n_feature) {
-	case 7:	feature[s->feature[6].i] -= 2 * s->feature[6].x;
-	case 6:	feature[s->feature[5].i] -= 2 * s->feature[5].x;
-	case 5:	feature[s->feature[4].i] -= 2 * s->feature[4].x;
-	case 4:	feature[s->feature[3].i] -= 2 * s->feature[3].x;
-	case 3:	feature[s->feature[2].i] -= 2 * s->feature[2].x;
-	case 2:	feature[s->feature[1].i] -= 2 * s->feature[1].x;
-	case 1:	feature[s->feature[0].i] -= 2 * s->feature[0].x;
-	case 0: break;
+	default:
+		eval->feature.us[s->feature[6].i] -= 2 * s->feature[6].x;	// FALLTHRU
+	case 6:	eval->feature.us[s->feature[5].i] -= 2 * s->feature[5].x;	// FALLTHRU
+	case 5:	eval->feature.us[s->feature[4].i] -= 2 * s->feature[4].x;	// FALLTHRU
+	case 4:	eval->feature.us[s->feature[3].i] -= 2 * s->feature[3].x;
+		eval->feature.us[s->feature[2].i] -= 2 * s->feature[2].x;
+		eval->feature.us[s->feature[1].i] -= 2 * s->feature[1].x;
+		eval->feature.us[s->feature[0].i] -= 2 * s->feature[0].x;
+		break;
 	}
+
 	foreach_bit (x, f) {
 		s = EVAL_X2F + x;
 		switch (s->n_feature) {
-		case 7:	feature[s->feature[6].i] -= s->feature[6].x;
-		case 6:	feature[s->feature[5].i] -= s->feature[5].x;
-		case 5:	feature[s->feature[4].i] -= s->feature[4].x;
-		case 4:	feature[s->feature[3].i] -= s->feature[3].x;
-		case 3:	feature[s->feature[2].i] -= s->feature[2].x;
-		case 2:	feature[s->feature[1].i] -= s->feature[1].x;
-		case 1:	feature[s->feature[0].i] -= s->feature[0].x;
-		case 0: break;
+		default:
+			eval->feature.us[s->feature[6].i] -= s->feature[6].x;	// FALLTHRU
+		case 6:	eval->feature.us[s->feature[5].i] -= s->feature[5].x;	// FALLTHRU
+		case 5:	eval->feature.us[s->feature[4].i] -= s->feature[4].x;	// FALLTHRU
+		case 4:	eval->feature.us[s->feature[3].i] -= s->feature[3].x;
+			eval->feature.us[s->feature[2].i] -= s->feature[2].x;
+			eval->feature.us[s->feature[1].i] -= s->feature[1].x;
+			eval->feature.us[s->feature[0].i] -= s->feature[0].x;
+			break;
 		}
 	}
-	
-#endif
-	
+  #endif
 }
 
 /**
  * @brief Update the features after a player's move.
  *
+ * @param x     Move position.
+ * @param f     Flipped bitboard.
  * @param eval  Evaluation function.
- * @param move  Move.
  */
-static void eval_update_1(Eval *eval, const Move *move)
+static void eval_update_1(int x, unsigned long long f, Eval *eval)
 {
-	const CoordinateToFeature *s = EVAL_X2F + move->x;
-	register int x;
-	int *feature = eval->feature;
-	unsigned long long f = move->flipped;
-
-#ifdef DEBUG
-
-	int i, j;
-	for (i = 0; i < s->n_feature; ++i) {
-		j = s->feature[i].i;
-		assert(0 <= j && j < EVAL_N_FEATURE);
-		feature[j] -= s->feature[i].x;
-		assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
-	}
+  #ifdef VECTOR_EVAL_UPDATE
+	int	i;
 
-	foreach_bit (x, f) {
-		s = EVAL_X2F + x;
-		for (i = 0; i < s->n_feature; ++i) {
-			j = s->feature[i].i;
-			assert(0 <= j && j < EVAL_N_FEATURE);
-			feature[j] += s->feature[i].x;
-			assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
-		}
-	}
+	for (i = 0; i < 12; ++i)
+		eval->feature.ull[i] -= EVAL_FEATURE[x].ull[i];
+
+	foreach_bit (x, f)
+		for (i = 0; i < 12; ++i)
+			eval->feature.ull[i] += EVAL_FEATURE[x].ull[i];
 
-#else
+  #else
+	const CoordinateToFeature *s = EVAL_X2F + x;
 
 	switch (s->n_feature) {
-	case 7:	feature[s->feature[6].i] -= s->feature[6].x;
-	case 6:	feature[s->feature[5].i] -= s->feature[5].x;
-	case 5:	feature[s->feature[4].i] -= s->feature[4].x;
-	case 4:	feature[s->feature[3].i] -= s->feature[3].x;
-	case 3:	feature[s->feature[2].i] -= s->feature[2].x;
-	case 2:	feature[s->feature[1].i] -= s->feature[1].x;
-	case 1:	feature[s->feature[0].i] -= s->feature[0].x;
-	case 0: break;
+	default:
+	       	eval->feature.us[s->feature[6].i] -= s->feature[6].x;	// FALLTHRU
+	case 6:	eval->feature.us[s->feature[5].i] -= s->feature[5].x;	// FALLTHRU
+	case 5:	eval->feature.us[s->feature[4].i] -= s->feature[4].x;	// FALLTHRU
+	case 4:	eval->feature.us[s->feature[3].i] -= s->feature[3].x;
+	       	eval->feature.us[s->feature[2].i] -= s->feature[2].x;
+	       	eval->feature.us[s->feature[1].i] -= s->feature[1].x;
+	       	eval->feature.us[s->feature[0].i] -= s->feature[0].x;
+	       	break;
 	}
+
 	foreach_bit (x, f) {
 		s = EVAL_X2F + x;
 		switch (s->n_feature) {
-		case 7:	feature[s->feature[6].i] += s->feature[6].x;
-		case 6:	feature[s->feature[5].i] += s->feature[5].x;
-		case 5:	feature[s->feature[4].i] += s->feature[4].x;
-		case 4:	feature[s->feature[3].i] += s->feature[3].x;
-		case 3:	feature[s->feature[2].i] += s->feature[2].x;
-		case 2:	feature[s->feature[1].i] += s->feature[1].x;
-		case 1:	feature[s->feature[0].i] += s->feature[0].x;
-		case 0: break;
+		default:
+		       	eval->feature.us[s->feature[6].i] += s->feature[6].x;	// FALLTHRU
+		case 6:	eval->feature.us[s->feature[5].i] += s->feature[5].x;	// FALLTHRU
+		case 5:	eval->feature.us[s->feature[4].i] += s->feature[4].x;	// FALLTHRU
+		case 4:	eval->feature.us[s->feature[3].i] += s->feature[3].x;
+		       	eval->feature.us[s->feature[2].i] += s->feature[2].x;
+		       	eval->feature.us[s->feature[1].i] += s->feature[1].x;
+		       	eval->feature.us[s->feature[0].i] += s->feature[0].x;
+		       	break;
 		}
 	}
-#endif
-	
+  #endif
 }
 
-void eval_update(Eval *eval, const Move *move)
+void eval_update(int x, unsigned long long f, Eval *eval)
 {
-	static void (*eval_update_f[])(Eval*, const Move*) = {eval_update_0, eval_update_1};
-	assert(move->flipped);
-	assert(WHITE == eval->player || BLACK == eval->player);
-	eval_update_f[eval->player](eval, move);
-	eval_swap(eval);
-}
+	assert(f);
 
-/**
- * @brief Restore the features as before a player's move.
- *
- * @param eval  Evaluation function.
- * @param move  Move.
- */
-static void eval_restore_0(Eval *eval, const Move *move)
-{
-	const CoordinateToFeature *s = EVAL_X2F + move->x;
-	register int x;
-	int *feature = eval->feature;
-	unsigned long long f = move->flipped;
-
-#ifdef DEBUG
-
-	int i, j;
-	for (i = 0; i < s->n_feature; ++i) {
-		j = s->feature[i].i;
-		assert(0 <= j && j < EVAL_N_FEATURE);
-		feature[j] += 2 * s->feature[i].x;
-		assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
+  #if defined(USE_GAS_MMX) || defined(USE_MSVC_X86) || defined(DISPATCH_NEON)
+	if (hasSSE2) {
+		eval_update_sse(x, f, eval, eval);
+		return;
 	}
-
-	foreach_bit (x, f) {
-		s = EVAL_X2F + x;
-		for (i = 0; i < s->n_feature; ++i) {
-			j = s->feature[i].i;
-			assert(0 <= j && j < EVAL_N_FEATURE);
-			feature[j] += s->feature[i].x;
-			assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
-		}
-	}
-
-#else
-
-	switch (s->n_feature) {
-	case 7:	feature[s->feature[6].i] += 2 * s->feature[6].x;
-	case 6:	feature[s->feature[5].i] += 2 * s->feature[5].x;
-	case 5:	feature[s->feature[4].i] += 2 * s->feature[4].x;
-	case 4:	feature[s->feature[3].i] += 2 * s->feature[3].x;
-	case 3:	feature[s->feature[2].i] += 2 * s->feature[2].x;
-	case 2:	feature[s->feature[1].i] += 2 * s->feature[1].x;
-	case 1:	feature[s->feature[0].i] += 2 * s->feature[0].x;
-	case 0: break;
-	}
-	foreach_bit (x, f) {
-		s = EVAL_X2F + x;
-		switch (s->n_feature) {
-		case 7:	feature[s->feature[6].i] += s->feature[6].x;
-		case 6:	feature[s->feature[5].i] += s->feature[5].x;
-		case 5:	feature[s->feature[4].i] += s->feature[4].x;
-		case 4:	feature[s->feature[3].i] += s->feature[3].x;
-		case 3:	feature[s->feature[2].i] += s->feature[2].x;
-		case 2:	feature[s->feature[1].i] += s->feature[1].x;
-		case 1:	feature[s->feature[0].i] += s->feature[0].x;
-		case 0: break;
-		}
-	}
-	
-#endif
-
+  #endif
+	if (eval->n_empties & 1)
+		eval_update_1(x, f, eval);
+	else
+		eval_update_0(x, f, eval);
 }
 
-static void eval_restore_1(Eval *eval, const Move *move)
+void eval_update_leaf(int x, unsigned long long f, Eval *eval_out, const Eval *eval_in)
 {
-	const CoordinateToFeature *s = EVAL_X2F + move->x;
-	register int x;
-	int *feature = eval->feature;
-	unsigned long long f = move->flipped;
-
-#ifdef DEBUG
-
-	int i, j;
-	for (i = 0; i < s->n_feature; ++i) {
-		j = s->feature[i].i;
-		assert(0 <= j && j < EVAL_N_FEATURE);
-		feature[j] += s->feature[i].x;
-		assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
+  #if defined(USE_GAS_MMX) || defined(USE_MSVC_X86) || defined(DISPATCH_NEON)
+	if (hasSSE2) {
+		eval_update_sse(x, f, eval_out, eval_in);
+		return;
 	}
-
-	foreach_bit (x, f) {
-		s = EVAL_X2F + x;
-		for (i = 0; i < s->n_feature; ++i) {
-			j = s->feature[i].i;
-			assert(0 <= j && j < EVAL_N_FEATURE);
-			feature[j] -= s->feature[i].x;
-			assert(EVAL_OFFSET[j] <= feature[j] && feature[j] <= EVAL_MAX_VALUE[j]);
-		}
-	}
-
-#else
-
-	switch (s->n_feature) {
-	case 7:	feature[s->feature[6].i] += s->feature[6].x;
-	case 6:	feature[s->feature[5].i] += s->feature[5].x;
-	case 5:	feature[s->feature[4].i] += s->feature[4].x;
-	case 4:	feature[s->feature[3].i] += s->feature[3].x;
-	case 3:	feature[s->feature[2].i] += s->feature[2].x;
-	case 2:	feature[s->feature[1].i] += s->feature[1].x;
-	case 1:	feature[s->feature[0].i] += s->feature[0].x;
-	case 0: break;
-	}
-	foreach_bit (x, f) {
-		s = EVAL_X2F + x;
-		switch (s->n_feature) {
-		case 7:	feature[s->feature[6].i] -= s->feature[6].x;
-		case 6:	feature[s->feature[5].i] -= s->feature[5].x;
-		case 5:	feature[s->feature[4].i] -= s->feature[4].x;
-		case 4:	feature[s->feature[3].i] -= s->feature[3].x;
-		case 3:	feature[s->feature[2].i] -= s->feature[2].x;
-		case 2:	feature[s->feature[1].i] -= s->feature[1].x;
-		case 1:	feature[s->feature[0].i] -= s->feature[0].x;
-		case 0: break;
-		}
-	}
-
-#endif
-
+  #endif
+	eval_out->feature = eval_in->feature;
+	if (eval_in->n_empties & 1)
+		eval_update_1(x, f, eval_out);
+	else
+		eval_update_0(x, f, eval_out);
 }
 
-void eval_restore(Eval *eval, const Move *move)
-{
-	static void (*eval_restore_f[])(Eval*, const Move*) = {eval_restore_0, eval_restore_1};
-	assert(move->flipped);
-	eval_swap(eval);
-	assert(WHITE == eval->player || BLACK == eval->player);
-	eval_restore_f[eval->player](eval, move);
-}
+#endif // !defined(hasSSE2) && !defined(__ARM_NEON)
 
 /**
  * @brief Update/Restore the features after a passing move.
@@ -823,10 +914,24 @@ void eval_restore(Eval *eval, const Move *move)
  */
 void eval_pass(Eval *eval)
 {
-	eval_swap(eval);
+	int i;
+
+	for (i =  0; i <  4; ++i)	// 9
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i] + 19683];
+	for (i =  4; i < 16; ++i)	// 10
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i]];
+	for (i = 16; i < 30; ++i)	// 8
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i] - EVAL_OFFSET[i] + 26244] + EVAL_OFFSET[i];
+	for (i = 30; i < 34; ++i)	// 7
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i] + 28431];
+	for (i = 34; i < 38; ++i)	// 6
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i] - 2187 + 29160] + 2187;
+	for (i = 38; i < 42; ++i)	// 5
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i] - 2916 + 29403] + 2916;
+	for (i = 42; i < 46; ++i)	// 4
+		eval->feature.us[i] = OPPONENT_FEATURE[eval->feature.us[i] - 3159 + 29484] + 3159;
 }
 
-
 /**
  * @brief Compute the error-type of the evaluation function according to the
  * depths.
@@ -849,4 +954,3 @@ double eval_sigma(const int n_empty, const int depth, const int probcut_depth)
 
 	return sigma;
 }
-
diff --git a/src/eval.h b/src/eval.h
index d45faab7..babee2a4 100644
--- a/src/eval.h
+++ b/src/eval.h
@@ -3,39 +3,82 @@
  *
  * Evaluation function's header.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_EVAL_H
 #define EDAX_EVAL_H
 
+#include "bit.h"
+
+/** number of features */
+enum { EVAL_N_FEATURE = 47 };
+
 /**
  * struct Eval
  * @brief evaluation function
  */
+typedef union {
+	unsigned short us[48];
+	unsigned long long ull[12];	// SWAR
+#ifdef __ARM_NEON
+	int16x8_t v8[6];
+#elif defined(hasSSE2) || defined(USE_MSVC_X86)
+	__m128i	v8[6];
+#endif
+#ifdef __AVX2__
+	__m256i	v16[3];
+#endif
+} EVAL_FEATURE_V;
+
 typedef struct Eval {
-	int *feature;         /**!< discs' features */
-	int player;
+	EVAL_FEATURE_V feature;                       /**!< discs' features (96) */
+	int n_empties;                                /**< number of empty squares (4) */
+	unsigned int parity;                          /**< parity (4) */
 } Eval;
 
 struct Board;
 struct Move;
 
-extern short ***EVAL_WEIGHT;
+/** unpacked weights */
+// enum { EVAL_N_WEIGHT = 226315 };
+typedef struct Eval_weight {
+	short	S0;		// also acts as guard for VGATHERDD access
+	short	C9[19683];
+	short	C10[59049];
+	short	S100[59049];
+	short	S101[59049];
+	short	S8x4[6561*4];
+	short	S7654[2187+729+243+81];
+} Eval_weight;
 
+/** number of plies */
+enum { EVAL_N_PLY = 54 };	// decreased from 60 in 4.5.1
+
+extern Eval_weight (*EVAL_WEIGHT)[EVAL_N_PLY - 2];	// for 2..53
 
 /* function declaration */
 void eval_open(const char*);
 void eval_close(void);
-void eval_init(Eval*);
-void eval_free(Eval*);
+// void eval_init(Eval*);
+// void eval_free(Eval*);
 void eval_set(Eval*, const struct Board*);
-void eval_update(Eval*, const struct Move*);
 void eval_restore(Eval*, const struct Move*);
 void eval_pass(Eval*);
 double eval_sigma(const int, const int, const int);
 
+#if defined(hasSSE2) || defined(__ARM_NEON) || defined(USE_MSVC_X86) || defined(ANDROID)
+void eval_update_sse(int, unsigned long long, Eval *, const Eval *);
+#endif
+#if defined(hasSSE2) || defined(__ARM_NEON)
+#define	eval_update(x, f, eval)	eval_update_sse(x, f, eval, eval)
+#define	eval_update_leaf(x, f, eval_out, eval_in)	eval_update_sse(x, f, eval_out, eval_in)
+#else
+void eval_update(int, unsigned long long, Eval*);
+void eval_update_leaf(int, unsigned long long, Eval*, const Eval*);
+#endif
+
 #endif
 
diff --git a/src/eval_builder.c b/src/eval_builder.c
index bb9aa28a..ee75925e 100644
--- a/src/eval_builder.c
+++ b/src/eval_builder.c
@@ -6,46 +6,58 @@
  * This or similar code has been used to build current evaluation function.
  * It will be reused to build a new evaluation function for Edax version 5.0
  *
- * @date 1998 - 201?
+ * @date 1998 - 2023
  * @author Richard Delorme
+ * @author Toshihiko Okuhara
  * @version 5.0
  */
- 
-#include "const.h"
-#include "clock.h"
-#include "gamebase.h"
-#include "eval.h"
-#include "stat.h"
+
+enum { MAX_N_GAMES = 3200000 };
+
+#define _CRT_SECURE_NO_WARNINGS
+
+ // #include "const.h"
+ // #include "clock.h"
+ // #include "gamebase.h"
+ // #include "eval.h"
+ // #include "stat.h"
 #include <assert.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
 #include <math.h>
 #include <float.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <time.h>
 
 #define EDAX_BUILDER_REGULAR
 
+#define EDAX 0x45444158
 #define EVAL 0x4556414c
 #define LAVE 0x4c415645
 
 /** minimization algorithm */
-enum{
+enum {
 	EVAL_STEEPEST_DESCENT, /* steepest_descent (with momentum) */
 	EVAL_FLETCHER_REEVES,  /* Fletcher-Reeves' conjugate gradient */
 	EVAL_POLAK_RIBIERE     /* Polak-Ribiere's conjugate gradient */
 };
 
 /** filter */
-enum{
+enum {
 	FILTER_NONE,
 	FILTER_SPATIAL,
 	FILTER_TEMPORAL
 };
 
 /** evaluation function */
-enum{
-	EVAL_EDAX_v3,
-	EVAL_EDAX_v5,
+enum {
+	// EVAL_EDAX_v3,
+	// EVAL_EDAX_v5,
+	EVAL_EDAX_3c,
+	EVAL_AJAX,
+
 	EVAL_LOGISTELLO,
 	EVAL_CORNER3x3,
 	EVAL_CORNER3x3_B,
@@ -65,7 +77,9 @@ enum{
 	EVAL_D6,
 	EVAL_D5,
 	EVAL_D4,
-	EVAL_D3
+	EVAL_D3,
+	EVAL_ANGLE_X,
+	EVAL_CORNER_BLOCK
 };
 
 /* error function */
@@ -77,23 +91,23 @@ enum {
 };
 
 /* EvalBuilder struct */
-typedef struct EvalBuilder{
-	int edax_header,eval_header; /* recognition header */
-	int version,release,build;   /* version, release & build numbers*/
+typedef struct EvalBuilder {
+	int edax_header, eval_header; /* recognition header */
+	int version, release, build;  /* version, release & build numbers*/
 	double date;                 /* date of creation */
 	int type;                    /* type of function : */
-	int n_ply,n_vectors;         /* plys * vectors */
+	int n_ply, n_vectors;        /* plys * vectors */
 	int n_features;              /* features */
 	int n_data;                  /* data */
 	int n_games;                 /* games */
-	int *vector_size;            /* vectors size */
-	int *vector_squares;         /* vectors size in bits */
-	int *vector_offset;          /* vectors offset */
-	int *vector_times;
-	short **data;                /* data[ply][config] */
-	short **coeff;               /* coeff[vector][subconfig] -> data */
-	int **feature;               /* feature[game][feature] */
-	char *score;			     /* score[game] */
+	int* vector_size;            /* vectors size */
+	int* vector_squares;         /* vectors size in bits */
+	int* vector_offset;          /* vectors offset */
+	int* vector_times;
+	short** data;                /* data[ply][config] */
+	short** coeff;               /* coeff[vector][subconfig] -> data */
+	int** feature;               /* feature[game][feature] */
+	char* score;			     /* score[game] */
 } EvalBuilder;
 
 typedef struct EvalOption {
@@ -108,119 +122,870 @@ typedef struct EvalOption {
 	int minimization_algorithm;
 	int error_type;
 	double alpha, beta;
+	int minimax_ply;
 } EvalOption;
 
-extern int s12[2][531441],s12[2][531441],s10[2][59049],c10[2][59049],i10[2][59049],c9[2][19683],s8[2][6561],s7[2][2187],s6[2][729],s5[2][243],s4[2][81],s3[2][27];
+/** feature symetry packing */
+/* extern */ int s12[2][531441], s10[2][59049], c10[2][59049], i10[2][59049], c9[2][19683], s8[2][6561], s7[2][2187], s6[2][729], s5[2][243], s4[2][81], s3[2][27];
+
+/* Original eval_builder lacks supporting routines to build, so here are ad hoc restore by T.Okuhara */
+
+/** constants for square coordinates */
+enum {
+	A1, B1, C1, D1, E1, F1, G1, H1,
+	A2, B2, C2, D2, E2, F2, G2, H2,
+	A3, B3, C3, D3, E3, F3, G3, H3,
+	A4, B4, C4, D4, E4, F4, G4, H4,
+	A5, B5, C5, D5, E5, F5, G5, H5,
+	A6, B6, C6, D6, E6, F6, G6, H6,
+	A7, B7, C7, D7, E7, F7, G7, H7,
+	A8, B8, C8, D8, E8, F8, G8, H8,
+	PASS, NOMOVE
+};
+
+enum { EDAX_VERSION = 3, EDAX_RELEASE = 2 };
+
+/** constants for colors */
+enum {
+	PBLACK = 0,
+	PWHITE,
+	PEMPTY,
+	OFF_SIDE
+};
+
+typedef struct Board {
+	char	square[64];
+	int	player;
+	int	BWTotal;
+	int	ScoreDiff;
+} Board;
+
+/** Constrain a variable to a range of values. */
+#define BOUND(var, min, max)	(((var) < (min)) ? (min) : (((var) > (max)) ? (max) : (var)))
+
+void (*eval_builder_set_features)(const Board* b, int* feature);
+
+static unsigned int *OPPONENT_FEATURE;
+
+/**
+ * @brief Opponent feature.
+ *
+ * Compute a feature from the opponent point of view.
+ * @param p opponent feature pointer.
+ * @param o opponent feature base to next depth.
+ * @param d feature size.
+ * @return updated opponent feature pointer
+ */
+ // #define OPPONENT(x)	((9 >> (x)) & 3)	// (0, 1, 2) to (1, 0, 2)
+static unsigned int* set_opponent_feature(unsigned int* p, int o, int d)
+{
+	if (--d) {
+		p = set_opponent_feature(p, (o + 1) * 3, d);
+		p = set_opponent_feature(p, o * 3, d);
+		p = set_opponent_feature(p, (o + 2) * 3, d);
+	}
+	else {
+		*p++ = o + 1;
+		*p++ = o;
+		*p++ = o + 2;
+	}
+	return p;
+}
+
+/**
+ * @brief Create eval packing index.
+ *
+ * Create an index array to reduce mirror positions.
+ * @param pe pointer to array to set result.
+ * @param T internally used array to check mirror positions.
+ * @param kd feature increment at each depth for the mirror position.
+ * @param l feature index.
+ * @param k feature index for the mirror position.
+ * @param n packed count so far.
+ * @param d feature size, >= 3.
+ * @return updated packed count.
+ */
+static int set_eval_packing(int* pe, int* T, const int* kd, int l, int k, int n, int d)
+{
+	int	i, q0, q1, q2;
+
+	if (--d > 2) {
+		l *= 3;
+		n = set_eval_packing(pe, T, kd, l, k, n, d);
+		k += kd[d];
+		n = set_eval_packing(pe, T, kd, l + 3, k, n, d);
+		k += kd[d];
+		n = set_eval_packing(pe, T, kd, l + 6, k, n, d);
+	}
+	else {
+		l *= 9;
+		for (q2 = 0; q2 < 3; ++q2) {
+			for (q1 = 0; q1 < 3; ++q1) {
+				for (q0 = 0; q0 < 3; ++q0) {
+					if (k < l) i = T[k];
+					else T[l] = i = n++;
+					pe[l++] = i;
+					k += kd[0];
+				}
+				k += (kd[1] - kd[0] * 3);
+			}
+			k += (kd[2] - kd[1] * 3);
+		}
+	}
+	return n;
+}
+
+static void init_eval_packing(void)
+{
+	int	j;
+	int* T = (int *) malloc(2 * 531441 * sizeof(*T));
+	static const int kd_S12[] = { 177147, 59049, 19683, 6561, 2187, 729, 243, 81, 27, 9, 3, 1 };
+	static const int kd_C10[] = { 19683, 6561, 2187, 729, 81, 243, 27, 9, 3, 1 };
+	static const int kd_C9[] = { 1, 9, 3, 81, 27, 243, 2187, 729, 6561 };
+
+	assert(T);
+	OPPONENT_FEATURE = (unsigned int *) malloc(531441 * sizeof(*OPPONENT_FEATURE));
+	assert(OPPONENT_FEATURE);
+
+	set_opponent_feature(OPPONENT_FEATURE, 0, 12);
+
+	set_eval_packing(s8[0], T, kd_S12 + 4, 0, 0, 0, 8);	/* 8 squares : 6561 -> 3321 */
+	for (j = 0; j < 6561; ++j)
+		s8[1][j] = s8[0][OPPONENT_FEATURE[j + 262440]];	// 111100000000(3)
+	set_eval_packing(s7[0], T, kd_S12 + 5, 0, 0, 0, 7);	/* 7 squares : 2187 -> 1134 */
+	for (j = 0; j < 2187; ++j)
+		s7[1][j] = s7[0][OPPONENT_FEATURE[j + 264627]];	// 111110000000(3)
+	set_eval_packing(s6[0], T, kd_S12 + 6, 0, 0, 0, 6);	/* 6 squares : 729 -> 378 */
+	for (j = 0; j < 729; ++j)
+		s6[1][j] = s6[0][OPPONENT_FEATURE[j + 265356]];	// 111111000000(3)
+	set_eval_packing(s5[0], T, kd_S12 + 7, 0, 0, 0, 5);	/* 5 squares : 243 -> 135 */
+	for (j = 0; j < 243; ++j)
+		s5[1][j] = s5[0][OPPONENT_FEATURE[j + 265599]];	// 111111100000(3)
+	set_eval_packing(s4[0], T, kd_S12 + 8, 0, 0, 0, 4);	/* 4 squares : 81 -> 45 */
+	for (j = 0; j < 81; ++j)
+		s4[1][j] = s4[0][OPPONENT_FEATURE[j + 265680]];	// 111111110000(3)
+	set_eval_packing(s3[0], T, kd_S12 + 9, 0, 0, 0, 3);	/* 3 squares : 27 -> 18 */
+	for (j = 0; j < 27; ++j)
+		s3[1][j] = s3[0][OPPONENT_FEATURE[j + 265707]];	// 111111111000(3)
+	set_eval_packing(c9[0], T, kd_C9, 0, 0, 0, 9);		/* 9 corner squares : 19683 -> 10206 */
+	for (j = 0; j < 19683; ++j)
+		c9[1][j] = c9[0][OPPONENT_FEATURE[j + 255879]];	// 111000000000(3)
+	set_eval_packing(s10[0], T, kd_S12 + 2, 0, 0, 0, 10);	/* 10 squares (edge + X) : 59049 -> 29646 */
+	set_eval_packing(c10[0], T, kd_C10, 0, 0, 0, 10);	/* 10 squares (angle + X) : 59049 -> 29889 */
+	for (j = 0; j < 59049; ++j)				/* 5x2 corner rects : 59049 -> 59049 */
+		i10[0][j] = j;
+	for (j = 0; j < 59049; ++j) {
+		s10[1][j] = s10[0][OPPONENT_FEATURE[j + 236196]];	// 110000000000(3)
+		c10[1][j] = c10[0][OPPONENT_FEATURE[j + 236196]];
+		i10[1][j] = i10[0][OPPONENT_FEATURE[j + 236196]];
+	}
+	set_eval_packing(s12[0], T, kd_S12, 0, 0, 0, 12);	/* 12 squares : 531441 -> 145341 */
+	for (j = 0; j < 531441; ++j)
+		s12[1][j] = s12[0][OPPONENT_FEATURE[j]];
+}
+
+/* no sentinel array board */
+static const signed char TurnVect[] = {
+	97, 97, 73, 73, 73, 73, 101, 101,
+	97, 97, 73, 73, 73, 73, 101, 101,
+	79, 79, 64, 64, 64, 64, 85, 85,
+	79, 79, 64, 64, 64, 64, 85, 85,
+	79, 79, 64, 64, 64, 64, 85, 85,
+	79, 79, 64, 64, 64, 64, 85, 85,
+	105, 105, 91, 91, 91, 91, 109, 109,
+	105, 105, 91, 91, 91, 91, 109, 109,
+
+	-9, -8, -7, -1, 1, 7, 8, 9, 0,
+	-1, 1, 7, 8, 9, 0,
+	-8, -7, 1, 8, 9, 0,
+	-9, -8, -1, 7, 8, 0,
+	-9, -8, -7, -1, 1, 0,
+	1, 8, 9, 0,
+	-1, 7, 8, 0,
+	-8, -7, 1, 0,
+	-9, -8, -1, 0
+};
+
+void InitBoard(Board *b)
+{
+	int	i;
+
+	for (i = 0; i < 64; ++i)
+		b->square[i] = PEMPTY;
+	b->square[E4] = b->square[D5] = PBLACK;
+	b->square[D4] = b->square[E5] = PWHITE;
+	b->player = PBLACK;
+	b->BWTotal = 4;
+	b->ScoreDiff = 0;
+}
+
+int MPerform(Board* b, int Mv)
+{
+	int	TurnCnt, vect, i, m, dx;
+	signed char	c1, c2;
+	const signed char* Tvp;
+
+	c2 = b->player;
+	c1 = c2 ^ (PBLACK ^ PWHITE);
+	TurnCnt = 0;
+
+	if (Mv < PASS) {
+		Tvp = TurnVect + TurnVect[Mv];
+		vect = *Tvp++;
+		do {
+			m = Mv + vect;
+			if (b->square[m] == c1) {
+				i = 0;
+				do {
+					++i;
+					m += vect;
+					dx = ((m + vect) & 7) - (m & 7);
+				} while ((b->square[m] == c1) && ((unsigned int)(m + vect) < 64) && (dx >= -1) && (dx <= 1));
+				if (b->square[m] == c2) {
+					TurnCnt += i;
+					do {
+						m -= vect;
+						b->square[m] = c2;
+					} while (--i != 0);
+				}
+			}
+		} while ((vect = *Tvp++) != 0);
+
+		if (TurnCnt == 0)
+			return (TurnCnt);
+
+		b->square[Mv] = c2;
+		b->ScoreDiff += (TurnCnt * 2 + 1);
+		++(b->BWTotal);
+	} /* if (Mv) */
+
+	b->ScoreDiff = -(b->ScoreDiff);
+	b->player = c1;
+	return (TurnCnt);
+}
+
+int MExamine(Board* b, int Mv, int color)	/* Returns turn count as if Mv performed */
+{
+	int	TurnCnt, vect, i, m, dx;
+	signed char	c1;
+	const signed char* Tvp;
+
+	c1 = color ^ (PBLACK ^ PWHITE);
+	TurnCnt = 0;
+	Tvp = TurnVect + TurnVect[Mv];
+	vect = *Tvp++;
+	do {
+		m = Mv + vect;
+		if (b->square[m] == c1) {
+			i = 0;
+			do {
+				++i;
+				m += vect;
+				dx = ((m + vect) & 7) - (m & 7);
+			} while ((b->square[m] == c1) && ((unsigned int)(m + vect) < 64) && (dx >= -1) && (dx <= 1));
+			if (b->square[m] == color)
+				TurnCnt += i;
+		}
+	} while ((vect = *Tvp++) != 0);
+	return (TurnCnt);
+}
+
+bool board_is_game_over(Board* b)
+{
+	int	i;
+	for (i = 0; i < 64; ++i)
+		if (b->square[i] == PEMPTY)
+			if (MExamine(b, i, PBLACK) || MExamine(b, i, PWHITE))
+				return false;
+	return true;
+}
+
+/* edax3c eval */
+void eval_edax_v3_get_packed_features(const Board* b, int* X)
+{
+	int p = b->player;
+	const char* x = b->square;
+
+	X[0] = c9[p][x[A1] * 6561 + x[B1] * 2187 + x[A2] * 729 + x[B2] * 243 + x[C1] * 81 + x[A3] * 27 + x[C2] * 9 + x[B3] * 3 + x[C3]];
+	X[1] = c9[p][x[H1] * 6561 + x[G1] * 2187 + x[H2] * 729 + x[G2] * 243 + x[F1] * 81 + x[H3] * 27 + x[F2] * 9 + x[G3] * 3 + x[F3]];
+	X[2] = c9[p][x[A8] * 6561 + x[A7] * 2187 + x[B8] * 729 + x[B7] * 243 + x[A6] * 81 + x[C8] * 27 + x[B6] * 9 + x[C7] * 3 + x[C6]];
+	X[3] = c9[p][x[H8] * 6561 + x[H7] * 2187 + x[G8] * 729 + x[G7] * 243 + x[H6] * 81 + x[F8] * 27 + x[G6] * 9 + x[F7] * 3 + x[F6]];
+
+	X[4] = c10[p][x[A5] * 19683 + x[A4] * 6561 + x[A3] * 2187 + x[A2] * 729 + x[A1] * 243 + x[B2] * 81 + x[B1] * 27 + x[C1] * 9 + x[D1] * 3 + x[E1]] + 10206;
+	X[5] = c10[p][x[H5] * 19683 + x[H4] * 6561 + x[H3] * 2187 + x[H2] * 729 + x[H1] * 243 + x[G2] * 81 + x[G1] * 27 + x[F1] * 9 + x[E1] * 3 + x[D1]] + 10206;
+	X[6] = c10[p][x[A4] * 19683 + x[A5] * 6561 + x[A6] * 2187 + x[A7] * 729 + x[A8] * 243 + x[B7] * 81 + x[B8] * 27 + x[C8] * 9 + x[D8] * 3 + x[E8]] + 10206;
+	X[7] = c10[p][x[H4] * 19683 + x[H5] * 6561 + x[H6] * 2187 + x[H7] * 729 + x[H8] * 243 + x[G7] * 81 + x[G8] * 27 + x[F8] * 9 + x[E8] * 3 + x[D8]] + 10206;
+
+	X[8] = s10[p][x[B2] * 19683 + x[A1] * 6561 + x[B1] * 2187 + x[C1] * 729 + x[D1] * 243 + x[E1] * 81 + x[F1] * 27 + x[G1] * 9 + x[H1] * 3 + x[G2]] + 40095;
+	X[9] = s10[p][x[B7] * 19683 + x[A8] * 6561 + x[B8] * 2187 + x[C8] * 729 + x[D8] * 243 + x[E8] * 81 + x[F8] * 27 + x[G8] * 9 + x[H8] * 3 + x[G7]] + 40095;
+	X[10] = s10[p][x[B2] * 19683 + x[A1] * 6561 + x[A2] * 2187 + x[A3] * 729 + x[A4] * 243 + x[A5] * 81 + x[A6] * 27 + x[A7] * 9 + x[A8] * 3 + x[B7]] + 40095;
+	X[11] = s10[p][x[G2] * 19683 + x[H1] * 6561 + x[H2] * 2187 + x[H3] * 729 + x[H4] * 243 + x[H5] * 81 + x[H6] * 27 + x[H7] * 9 + x[H8] * 3 + x[G7]] + 40095;
+
+	X[12] = s10[p][x[A1] * 19683 + x[C1] * 6561 + x[D1] * 2187 + x[C2] * 729 + x[D2] * 243 + x[E2] * 81 + x[F2] * 27 + x[E1] * 9 + x[F1] * 3 + x[H1]] + 69741;
+	X[13] = s10[p][x[A8] * 19683 + x[C8] * 6561 + x[D8] * 2187 + x[C7] * 729 + x[D7] * 243 + x[E7] * 81 + x[F7] * 27 + x[E8] * 9 + x[F8] * 3 + x[H8]] + 69741;
+	X[14] = s10[p][x[A1] * 19683 + x[A3] * 6561 + x[A4] * 2187 + x[B3] * 729 + x[B4] * 243 + x[B5] * 81 + x[B6] * 27 + x[A5] * 9 + x[A6] * 3 + x[A8]] + 69741;
+	X[15] = s10[p][x[H1] * 19683 + x[H3] * 6561 + x[H4] * 2187 + x[G3] * 729 + x[G4] * 243 + x[G5] * 81 + x[G6] * 27 + x[H5] * 9 + x[H6] * 3 + x[H8]] + 69741;
+
+	X[16] = s8[p][x[A2] * 2187 + x[B2] * 729 + x[C2] * 243 + x[D2] * 81 + x[E2] * 27 + x[F2] * 9 + x[G2] * 3 + x[H2]] + 99387;
+	X[17] = s8[p][x[A7] * 2187 + x[B7] * 729 + x[C7] * 243 + x[D7] * 81 + x[E7] * 27 + x[F7] * 9 + x[G7] * 3 + x[H7]] + 99387;
+	X[18] = s8[p][x[B1] * 2187 + x[B2] * 729 + x[B3] * 243 + x[B4] * 81 + x[B5] * 27 + x[B6] * 9 + x[B7] * 3 + x[B8]] + 99387;
+	X[19] = s8[p][x[G1] * 2187 + x[G2] * 729 + x[G3] * 243 + x[G4] * 81 + x[G5] * 27 + x[G6] * 9 + x[G7] * 3 + x[G8]] + 99387;
+
+	X[20] = s8[p][x[A3] * 2187 + x[B3] * 729 + x[C3] * 243 + x[D3] * 81 + x[E3] * 27 + x[F3] * 9 + x[G3] * 3 + x[H3]] + 102708;
+	X[21] = s8[p][x[A6] * 2187 + x[B6] * 729 + x[C6] * 243 + x[D6] * 81 + x[E6] * 27 + x[F6] * 9 + x[G6] * 3 + x[H6]] + 102708;
+	X[22] = s8[p][x[C1] * 2187 + x[C2] * 729 + x[C3] * 243 + x[C4] * 81 + x[C5] * 27 + x[C6] * 9 + x[C7] * 3 + x[C8]] + 102708;
+	X[23] = s8[p][x[F1] * 2187 + x[F2] * 729 + x[F3] * 243 + x[F4] * 81 + x[F5] * 27 + x[F6] * 9 + x[F7] * 3 + x[F8]] + 102708;
+
+	X[24] = s8[p][x[A4] * 2187 + x[B4] * 729 + x[C4] * 243 + x[D4] * 81 + x[E4] * 27 + x[F4] * 9 + x[G4] * 3 + x[H4]] + 106029;
+	X[25] = s8[p][x[A5] * 2187 + x[B5] * 729 + x[C5] * 243 + x[D5] * 81 + x[E5] * 27 + x[F5] * 9 + x[G5] * 3 + x[H5]] + 106029;
+	X[26] = s8[p][x[D1] * 2187 + x[D2] * 729 + x[D3] * 243 + x[D4] * 81 + x[D5] * 27 + x[D6] * 9 + x[D7] * 3 + x[D8]] + 106029;
+	X[27] = s8[p][x[E1] * 2187 + x[E2] * 729 + x[E3] * 243 + x[E4] * 81 + x[E5] * 27 + x[E6] * 9 + x[E7] * 3 + x[E8]] + 106029;
+
+	X[28] = s8[p][x[A1] * 2187 + x[B2] * 729 + x[C3] * 243 + x[D4] * 81 + x[E5] * 27 + x[F6] * 9 + x[G7] * 3 + x[H8]] + 109350;
+	X[29] = s8[p][x[A8] * 2187 + x[B7] * 729 + x[C6] * 243 + x[D5] * 81 + x[E4] * 27 + x[F3] * 9 + x[G2] * 3 + x[H1]] + 109350;
+
+	X[30] = s7[p][x[B1] * 729 + x[C2] * 243 + x[D3] * 81 + x[E4] * 27 + x[F5] * 9 + x[G6] * 3 + x[H7]] + 112671;
+	X[31] = s7[p][x[H2] * 729 + x[G3] * 243 + x[F4] * 81 + x[E5] * 27 + x[D6] * 9 + x[C7] * 3 + x[B8]] + 112671;
+	X[32] = s7[p][x[A2] * 729 + x[B3] * 243 + x[C4] * 81 + x[D5] * 27 + x[E6] * 9 + x[F7] * 3 + x[G8]] + 112671;
+	X[33] = s7[p][x[G1] * 729 + x[F2] * 243 + x[E3] * 81 + x[D4] * 27 + x[C5] * 9 + x[B6] * 3 + x[A7]] + 112671;
+
+	X[34] = s6[p][x[C1] * 243 + x[D2] * 81 + x[E3] * 27 + x[F4] * 9 + x[G5] * 3 + x[H6]] + 113805;
+	X[35] = s6[p][x[A3] * 243 + x[B4] * 81 + x[C5] * 27 + x[D6] * 9 + x[E7] * 3 + x[F8]] + 113805;
+	X[36] = s6[p][x[F1] * 243 + x[E2] * 81 + x[D3] * 27 + x[C4] * 9 + x[B5] * 3 + x[A6]] + 113805;
+	X[37] = s6[p][x[H3] * 243 + x[G4] * 81 + x[F5] * 27 + x[E6] * 9 + x[D7] * 3 + x[C8]] + 113805;
+
+	X[38] = s5[p][x[D1] * 81 + x[E2] * 27 + x[F3] * 9 + x[G4] * 3 + x[H5]] + 114183;
+	X[39] = s5[p][x[A4] * 81 + x[B5] * 27 + x[C6] * 9 + x[D7] * 3 + x[E8]] + 114183;
+	X[40] = s5[p][x[E1] * 81 + x[D2] * 27 + x[C3] * 9 + x[B4] * 3 + x[A5]] + 114183;
+	X[41] = s5[p][x[H4] * 81 + x[G5] * 27 + x[F6] * 9 + x[E7] * 3 + x[D8]] + 114183;
+
+	X[42] = s4[p][x[D1] * 27 + x[C2] * 9 + x[B3] * 3 + x[A4]] + 114318;
+	X[43] = s4[p][x[A5] * 27 + x[B6] * 9 + x[C7] * 3 + x[D8]] + 114318;
+	X[44] = s4[p][x[E1] * 27 + x[F2] * 9 + x[G3] * 3 + x[H4]] + 114318;
+	X[45] = s4[p][x[H5] * 27 + x[G6] * 9 + x[F7] * 3 + x[E8]] + 114318;
+
+	X[46] = 114363;
+}
+
+// *****...
+// **......
+void eval_builder_get_angle_X_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = c10[p][x[A5] * 19683 + x[A4] * 6561 + x[A3] * 2187 + x[A2] * 729 + x[A1] * 243 + x[B2] * 81 + x[B1] * 27 + x[C1] * 9 + x[D1] * 3 + x[E1]];
+	X[1] = c10[p][x[H5] * 19683 + x[H4] * 6561 + x[H3] * 2187 + x[H2] * 729 + x[H1] * 243 + x[G2] * 81 + x[G1] * 27 + x[F1] * 9 + x[E1] * 3 + x[D1]];
+	X[2] = c10[p][x[A4] * 19683 + x[A5] * 6561 + x[A6] * 2187 + x[A7] * 729 + x[A8] * 243 + x[B7] * 81 + x[B8] * 27 + x[C8] * 9 + x[D8] * 3 + x[E8]];
+	X[3] = c10[p][x[H4] * 19683 + x[H5] * 6561 + x[H6] * 2187 + x[H7] * 729 + x[H8] * 243 + x[G7] * 81 + x[G8] * 27 + x[F8] * 9 + x[E8] * 3 + x[D8]];
+	X[4] = 29889;
+}
+
+// *.****.*
+// ..****..
+void eval_builder_get_corner_block_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s10[p][x[A1] * 19683 + x[C1] * 6561 + x[D1] * 2187 + x[C2] * 729 + x[D2] * 243 + x[E2] * 81 + x[F2] * 27 + x[E1] * 9 + x[F1] * 3 + x[H1]];
+	X[1] = s10[p][x[A8] * 19683 + x[C8] * 6561 + x[D8] * 2187 + x[C7] * 729 + x[D7] * 243 + x[E7] * 81 + x[F7] * 27 + x[E8] * 9 + x[F8] * 3 + x[H8]];
+	X[2] = s10[p][x[A1] * 19683 + x[A3] * 6561 + x[A4] * 2187 + x[B3] * 729 + x[B4] * 243 + x[B5] * 81 + x[B6] * 27 + x[A5] * 9 + x[A6] * 3 + x[A8]];
+	X[3] = s10[p][x[H1] * 19683 + x[H3] * 6561 + x[H4] * 2187 + x[G3] * 729 + x[G4] * 243 + x[G5] * 81 + x[G6] * 27 + x[H5] * 9 + x[H6] * 3 + x[H8]];
+	X[4] = 29646;
+}
+
+/* gamebase */
+
+typedef struct Game {
+	char	move[60];	// MSB = 1: same player's move after opponent's pass
+	int	score;		// black - white
+	int	suboptimal_ply;
+} Game;
+
+
+typedef struct Gamebase {
+	int	n_games;
+	Game	games[];
+} Gamebase;
+
+Gamebase* gamebase_create(int i)
+{
+	Gamebase* base = (Gamebase*) malloc(sizeof(int) + sizeof(Game) * MAX_N_GAMES);
+	assert(base);
+	base->n_games = i;
+	return base;
+}
+
+static int compare_moves(const void* a, const void* b)
+{
+	return memcmp((*(Game **)a)->move, (*(Game **)b)->move, 60);
+}
+
+void gamebase_minimax(Gamebase *base, int ply)
+{
+	Game	**ga = (Game **) malloc(base->n_games * sizeof(Game *));
+	int	i, j, mxi, mxv, sgn;
+
+	assert(ga);
+	for (i = 0; i < base->n_games; ++i)
+		ga[i] = base->games + i;
+	qsort(ga, base->n_games, sizeof(Game *), compare_moves);
+
+	while (--ply > 0) {
+		for (i = 0; i < base->n_games; ++i) {
+			if (ply < ga[i]->suboptimal_ply)
+				continue;
+			sgn = 1;
+			for (j = 0; j < ply; ++j)
+				if (!(ga[i]->move[j] & 0x80))
+					sgn = -sgn;
+			mxi = i;
+			mxv = ga[i]->score * sgn;
+			while (i + 1 < base->n_games) {
+				if (memcmp(ga[i + 1]->move, ga[mxi]->move, ply))
+					break;
+				++i;
+				if (ply < ga[i]->suboptimal_ply)
+					continue;
+				if (ga[i]->score * sgn > mxv) {
+					mxv = ga[i]->score * sgn;
+					ga[mxi]->suboptimal_ply = ply;
+					mxi = i;
+				} else {
+					ga[i]->suboptimal_ply = ply;
+				}
+			}
+		}
+	}
+
+	/* for (i = 0; i < base->n_games; ++i)
+		if (base->games[i].suboptimal_ply < 5) {
+			for (mxi = 0; mxi < 6; ++mxi)
+				printf("%c%c", (base->games[i].move[mxi] & 7) + 'a', (base->games[i].move[mxi] >> 3) + '1');
+			printf(" %d\n", base->games[i].score);
+		}
+	*/
+	free(ga);
+}
+
+/* f5d6c3d3c4.. */
+void gamebase_import(Gamebase* base, const char* file_1, int minimax_ply)
+{
+	int	i, j, m;
+	char	s[130], *p;
+	Board	b;
+	Game	*g;
+	FILE	*f = fopen(file_1, "r");
+
+	if (f == NULL) {
+		fprintf(stderr, "gamebase_import : can't open %s\n", file_1);
+		exit(EXIT_FAILURE);
+	}
+
+	i = 0;
+	g = base->games;
+	while (i < MAX_N_GAMES) {
+		if (fgets(s, sizeof(s), f) == NULL)
+			break;	// EOF or error
+		InitBoard(&b);
+		j = 0; p = s;
+		while ((((*p >= 'A') && (*p <= 'H')) || ((*p >= 'a') && (*p <= 'h'))) && *(p + 1)) {
+			m = ((*p - 'A') & 7) + ((*(p + 1) - '1') & 7) * 8;
+			assert(b.square[m] == PEMPTY);
+			if (!MPerform(&b, m)) {
+				b.player ^= (PBLACK ^ PWHITE);
+				b.ScoreDiff = -b.ScoreDiff;
+				if (!MPerform(&b, m)) {
+					fprintf(stderr, "gamebase_import : illegal move in line %d\n", i);
+					exit(EXIT_FAILURE);
+				}
+				m |= 0x80;	// opponent pass
+			}
+			g->move[j++] = m;
+			p += 2;
+		}
+		while (j < 60)
+			g->move[j++] = NOMOVE;
+		m = b.ScoreDiff;
+		if (b.player != PBLACK)
+			m = -m;
+		if (m > 0)
+			m += 64 - b.BWTotal;
+		else if (m < 0)
+			m -= 64 - b.BWTotal;
+		g->score = m;
+		g->suboptimal_ply = -1;
+		++i;
+		++g;
+	}
+	fclose(f);
+	base->n_games = i;
+	printf("eval_builder : read %d games\n", i);
+
+	if (minimax_ply)
+		gamebase_minimax(base, minimax_ply);
+}
+
+bool game_get_board(Game* g, int ply, Board* b)
+{
+	int	i, m, t;
+
+	InitBoard(b);
+	for (i = 0; i < ply; ++i) {
+		m = g->move[i];
+		if (m == NOMOVE)
+			return false;
+		if (m & 0x80) {	// same player
+			b->player ^= (PBLACK ^ PWHITE);
+			b->ScoreDiff = -b->ScoreDiff;
+		}
+		t = MPerform(b, m & 0x7f);
+		assert(t);
+	}
+	return true;
+}
+
+/* --- stat ---*/
+
+typedef struct sl_Point {
+	int	x, y;
+} sl_Point;
+
+typedef struct sl_Plot {
+	FILE* f;
+} sl_Plot;
+
+double sl_min(double* x, int n)
+{
+	int	i;
+	double	y = x[0];
+	for (i = 1; i < n; ++i)
+		if (x[i] < y)
+			y = x[i];
+	return y;
+}
+
+double sl_max(double* x, int n)
+{
+	int	i;
+	double	y = x[0];
+	for (i = 1; i < n; ++i)
+		if (x[i] > y)
+			y = x[i];
+	return y;
+}
+
+double sl_mean(double* x, int n)
+{
+	int	i;
+	double	s = x[0];
+	for (i = 1; i < n; ++i)
+		s += x[i];
+	return s / n;
+}
+
+static int compare_double(const void* a, const void* b)
+{
+	if (*(double*)a < *(double*)b)	return -1;
+	return (*(double*)a > *(double*)b);
+}
+
+double sl_median(double* x, int n)
+{
+	double	y;
+	double* buf = (double*)malloc(sizeof(double) * n);
+	assert(buf);
+	memcpy(buf, x, sizeof(double) * n);
+	qsort(buf, n, sizeof(double), compare_double);
+	y = (buf[(n - 1) / 2] + buf[n / 2]) * 0.5;
+	free(buf);
+	return y;
+}
+
+double sl_variance(double* x, int n)
+{
+	int	i;
+	double	y = 0.0;
+	double	m = sl_mean(x, n);
+	for (i = 0; i < n; ++i)
+		y += (x[i] - m) * (x[i] - m);
+	return y / n;
+}
+
+double sl_standard_deviation(double* x, int n)
+{
+	return sqrt(sl_variance(x, n));
+}
+
+double sl_regression_a(double* x, double* y, int n)
+{
+	int	i;
+	double	sx = 0.0, sx2 = 0.0, sy = 0.0, sxy = 0.0;
+	for (i = 0; i < n; ++i) {
+		sx += x[i];
+		sx2 += x[i] * x[i];
+		sy += y[i];
+		sxy += x[i] * y[i];
+	}
+	return (n * sxy - sx * sy) / (n * sx2 - sx * sx);
+}
+
+double sl_regression_b(double* x, double* y, int n)
+{
+	int	i;
+	double	sx = 0.0, sx2 = 0.0, sy = 0.0, sxy = 0.0;
+	for (i = 0; i < n; ++i) {
+		sx += x[i];
+		sx2 += x[i] * x[i];
+		sy += y[i];
+		sxy += x[i] * y[i];
+	}
+	return (sx2 * sy - sxy * sx) / (n * sx2 - sx * sx);
+}
+
+double sl_correlation_r(double* x, double* y, int n)
+{
+	int	i;
+	double	cov = 0.0, varx = 0.0, vary = 0.0;
+	double	mx = sl_mean(x, n);
+	double	my = sl_mean(y, n);
+	for (i = 0; i < n; ++i) {
+		cov += (x[i] - mx) * (y[i] - my);
+		varx += (x[i] - mx) * (x[i] - mx);
+		vary += (y[i] - my) * (y[i] - my);
+	}
+	return cov / (sqrt(varx) * sqrt(vary));
+}
+
+int* sl_histogram1(double* x, int n, double y, double z, int m)
+{
+	int* p = (int*)calloc(m, sizeof(int));
+	int	i, t;
+
+	if (p)
+		for (i = 0; i < n; ++i) {
+			t = (int)((x[i] - y) / (z - y) * m);
+			if ((t >= 0) && (t < m))
+				++p[t];
+		}
+	return p;
+}
+
+sl_Plot* sl_plot_open(char* file_1)
+{
+	time_t t = time(NULL);
+	struct tm *date = localtime(&t);
+	sl_Plot	*plot = (sl_Plot *) malloc(sizeof(sl_Plot));
+
+	assert(plot);
+	plot->f = fopen(file_1, "w");
+	assert(plot->f);
+
+	fputs(	"%!PS-Adobe-3.0 EPSF-3.0\n"
+		"%%Creator: Edax-3.0\n", plot->f);
+	fprintf(plot->f, "%%%%CreationDate:  %d/%d/%d %d:%d:%d\n", date->tm_year + 1900, date->tm_mon + 1, date->tm_mday, date->tm_hour, date->tm_min, date->tm_sec);
+	fputs(	"%%BoundingBox: 0 0 150 150\n\n"
+		// "%%BeginProlog\n\n"
+		// "%%EndProlog\n\n"
+		"% do the drawing\n"
+		"gsave\n", plot->f);
+	return plot;
+}
+
+void sl_plot_titles(sl_Plot* plot, const char* s1, const char* s2, const char* title)
+{
+	fprintf(plot->f, "\t/Helvetica findfont 8 scalefont setfont\n"
+		"\t125 61 moveto\n"
+		"\t(%s) show\n"
+		"\t73 117 moveto\n"
+		"\t90 rotate\n"
+		"\t(%s) show\n"
+		"\t-90 rotate\n"
+		"\t11 140 moveto\n"
+		"\t(%s) show\n\n", s1, s2, title);
+}
+
+void sl_plot_axis(sl_Plot* plot, sl_Point* A, sl_Point* B, sl_Point* O)
+{
+	fprintf(plot->f, "\t11 68 moveto\n"
+		"\t139 68 lineto\n"
+		"\tstroke\n"
+		"\t75 4 moveto\n"
+		"\t75 133 lineto\n"
+		"\tstroke\n"
+		"\t11 70 moveto\n"
+		"\t(%d) show\n"
+		"\t76 4 moveto\n"
+		"\t(%d) show\n"
+		"\t130 70 moveto\n"
+		"\t(%d) show\n"
+		"\t76 128 moveto\n"
+		"\t(%d) show\n"
+		"\t76 70 moveto\n"
+		"\t(\\(%d, %d\\)) show\n"
+		"\tnewpath\n\n", A->x, A->y, B->x, B->y, O->x, O->y);
+}
+
+void sl_plot_scatter(sl_Plot* plot, sl_Point* X, int I)
+{
+	int	(*sc)[129][129] = (int(*)[129][129]) calloc(129 * 129, sizeof(int));
+	int	i, x, y, t, mx;
+	double	gray;
+
+	assert(sc);
+	mx = 1;
+	for (i = 0; i < I; ++i) {
+		x = X[i].x;
+		y = X[i].y;
+		if ((x >= -64) && (x <= 64) && (y >= -64) && (y <= 64)) {
+			t = ++(*sc)[x + 64][y + 64];
+			if ((x | y) && (t > mx))
+				mx = t;
+		}
+	}
+	for (y = -64; y <= 64; ++y)
+		for (x = -64; x <= 64; ++x) {
+			t = (*sc)[x + 64][y + 64];
+			if (t) {
+				gray = 0.8 - (double) t / mx;
+				if (gray < 0.0)
+					gray = 0.0;
+				fprintf(plot->f, "\t%f setgray\n", gray);
+				fprintf(plot->f, "\t%d %d 0.75 0 360 arc fill\n", x + 75, y + 68);
+			}
+		}
+	free(sc);
+}
+
+void sl_plot_close(sl_Plot* plot)
+{
+	fputs("\ngrestore\n", plot->f);
+	fclose(plot->f);
+	free(plot);
+}
+
+/* --- clock ---*/
+
+#include <time.h>
+
+double ul_clock_get_date(void)
+{
+	return (double) time(NULL);
+}
+
+void ul_clock_print_time(time_t tm, FILE* f)
+{
+	fprintf(f, "%d:%02d:%02d\n", (int)(tm / 3600), (int)((tm % 3600) / 60), (int)(tm % 60));
+}
+
+/* --- end of patch ---*/
 
 /* create a new EvalBuilder structure */
-EvalBuilder *eval_builder_create(int n_vectors,int *vector_size,int *vector_times,int n_features,int n_games){
-	EvalBuilder *eval;
+EvalBuilder* eval_builder_create(int n_vectors, int* vector_size, int* vector_times, int n_features, int n_games) {
+	EvalBuilder* eval;
 	int i;
 
-	eval=(EvalBuilder*)malloc(sizeof (EvalBuilder));
-
-	eval->edax_header=EDAX;
-	eval->eval_header=EVAL;
-	eval->version=EDAX_VERSION;
-	eval->release=EDAX_RELEASE;
-	eval->build=0;
-	eval->date=ul_clock_get_date();
-	eval->n_ply=61;
-	eval->n_vectors=n_vectors;
-	eval->n_data=0;
-	eval->vector_size=(int *)malloc(n_vectors*sizeof (int));
-	assert(eval->vector_size!=NULL);
-	eval->vector_squares=(int *)malloc(n_vectors*sizeof (int));
-	assert(eval->vector_squares!=NULL);
-	eval->vector_offset=(int *)malloc(n_vectors*sizeof (int));
-	assert(eval->vector_offset!=NULL);
-	eval->vector_times=(int *)malloc(n_vectors*sizeof (int));
-	assert(eval->vector_times!=NULL);
-	eval->coeff=(short **)malloc(n_vectors*sizeof (short *));
-	assert(eval->coeff!=NULL);
-	for (i=0;i<n_vectors;i++){
-		eval->vector_size[i]=vector_size[i];
-		eval->vector_times[i]=vector_times[i];
-		eval->vector_offset[i]=(i==0?0:(eval->vector_offset[i-1]+vector_size[i-1]));
-		eval->n_data+=eval->vector_size[i];
-		switch(vector_size[i]){
+	eval = (EvalBuilder*)malloc(sizeof(EvalBuilder));
+
+	eval->edax_header = EDAX;
+	eval->eval_header = EVAL;
+	eval->version = EDAX_VERSION;
+	eval->release = EDAX_RELEASE;
+	eval->build = 0;
+	eval->date = ul_clock_get_date();
+	eval->n_ply = 61;
+	eval->n_vectors = n_vectors;
+	eval->n_data = 0;
+	eval->vector_size = (int*)malloc(n_vectors * sizeof(int));
+	assert(eval->vector_size != NULL);
+	eval->vector_squares = (int*)malloc(n_vectors * sizeof(int));
+	assert(eval->vector_squares != NULL);
+	eval->vector_offset = (int*)malloc(n_vectors * sizeof(int));
+	assert(eval->vector_offset != NULL);
+	eval->vector_times = (int*)malloc(n_vectors * sizeof(int));
+	assert(eval->vector_times != NULL);
+	eval->coeff = (short**)malloc(n_vectors * sizeof(short*));
+	assert(eval->coeff != NULL);
+	for (i = 0; i < n_vectors; i++) {
+		eval->vector_size[i] = vector_size[i];
+		eval->vector_times[i] = vector_times[i];
+		eval->vector_offset[i] = (i == 0 ? 0 : (eval->vector_offset[i - 1] + vector_size[i - 1]));
+		eval->n_data += eval->vector_size[i];
+		switch (vector_size[i]) {
 		case 1:
-			eval->vector_squares[i]=0;
+			eval->vector_squares[i] = 0;
 			break;
 		case 3:
-			eval->vector_squares[i]=1;
+			eval->vector_squares[i] = 1;
 			break;
 		case 6:
 		case 9:
-			eval->vector_squares[i]=2;
+			eval->vector_squares[i] = 2;
 			break;
 		case 27:
 		case 18:
-			eval->vector_squares[i]=3;
+			eval->vector_squares[i] = 3;
 			break;
 		case 81:
 		case 45:
-			eval->vector_squares[i]=4;
+			eval->vector_squares[i] = 4;
 			break;
 		case 243:
 		case 135:
-			eval->vector_squares[i]=5;
+			eval->vector_squares[i] = 5;
 			break;
 		case 729:
 		case 378:
-			eval->vector_squares[i]=6;
+			eval->vector_squares[i] = 6;
 			break;
 		case 2187:
 		case 1134:
-			eval->vector_squares[i]=7;
+			eval->vector_squares[i] = 7;
 			break;
 		case 6561:
 		case 3321:
-			eval->vector_squares[i]=8;
+			eval->vector_squares[i] = 8;
 			break;
 		case 19683:
 		case 10206:
-			eval->vector_squares[i]=9;
+			eval->vector_squares[i] = 9;
 			break;
 		case 59049:
 		case 29646:
 		case 29889:
-			eval->vector_squares[i]=10;
+			eval->vector_squares[i] = 10;
 			break;
 		case 531441:
 		case 266814:
 		case 266085:
-			eval->vector_squares[i]=12;
+			eval->vector_squares[i] = 12;
 			break;
 		default:
-			eval->vector_squares[i]=0;
+			eval->vector_squares[i] = 0;
 		}
 	}
-	eval->data=(short**)malloc(eval->n_ply*sizeof (short*));
-	assert(eval->data!=NULL);
-	eval->data[0]=(short*)calloc(eval->n_ply*eval->n_data,sizeof (short));
-	assert(eval->data[0]!=NULL);
-	for (i=1;i<eval->n_ply;i++){
-		eval->data[i]=eval->data[i-1]+eval->n_data;
+	eval->data = (short**)malloc(eval->n_ply * sizeof(short*));
+	assert(eval->data != NULL);
+	eval->data[0] = (short*)calloc(eval->n_ply * eval->n_data, sizeof(short));
+	assert(eval->data[0] != NULL);
+	for (i = 1; i < eval->n_ply; i++) {
+		eval->data[i] = eval->data[i - 1] + eval->n_data;
 	}
-	eval->n_features=n_features;
-	eval->n_games=n_games;
-	eval->feature=(int**)malloc(n_games*sizeof (int*));
-	assert(eval->feature!=NULL);
-	eval->feature[0]=(int*)malloc(n_games*eval->n_features*sizeof (int));
-	assert(eval->feature[0]!=NULL);
-	for (i=1;i<n_games;i++){
-		eval->feature[i]=eval->feature[i-1]+eval->n_features;
+	eval->n_features = n_features;
+	eval->n_games = n_games;
+	eval->feature = (int**)malloc(n_games * sizeof(int*));
+	assert(eval->feature != NULL);
+	eval->feature[0] = (int*)malloc(n_games * eval->n_features * sizeof(int));
+	assert(eval->feature[0] != NULL);
+	for (i = 1; i < n_games; i++) {
+		eval->feature[i] = eval->feature[i - 1] + eval->n_features;
 	}
-	eval->score=(char *)malloc(n_games*sizeof (char));
-	assert(eval->score!=NULL);
+	eval->score = (char*)malloc(n_games * sizeof(char));
+	assert(eval->score != NULL);
 
 	return eval;
 }
 
 /* destroy an EvalBuilder structure */
-void eval_builder_destroy(EvalBuilder *eval){
-	if (eval!=NULL){
+void eval_builder_destroy(EvalBuilder* eval) {
+	if (eval != NULL) {
 		free(eval->feature[0]);
 		free(eval->feature);
 		free(eval->data[0]);
@@ -233,328 +998,333 @@ void eval_builder_destroy(EvalBuilder *eval){
 }
 
 /* set EvalBuilder items for 'ply' */
-void eval_builder_set_ply(EvalBuilder* eval,int ply){
+void eval_builder_set_ply(EvalBuilder* eval, int ply) {
 	int i;
-	short **x=eval->coeff;
+	short** x = eval->coeff;
 
-	x[0]=eval->data[ply];
-	for (i=1;i<eval->n_vectors;i++){
-		x[i]=x[i-1]+eval->vector_size[i-1];
+	x[0] = eval->data[ply];
+	for (i = 1; i < eval->n_vectors; i++) {
+		x[i] = x[i - 1] + eval->vector_size[i - 1];
 	}
 }
 
 /* read an EvalBuilder structure */
-void eval_builder_read(EvalBuilder* eval,const char *file){
-	FILE *f;
+void eval_builder_read(EvalBuilder* eval, const char* file) {
+	FILE* f;
 	int r;
 
-	f=fopen(file,"rb");
-	if (f==NULL){
-		fprintf(stderr,"eval_builder_read : can't open %s\n",file);
+	f = fopen(file, "rb");
+	if (f == NULL) {
+		fprintf(stderr, "eval_builder_read : can't open %s\n", file);
 		exit(EXIT_FAILURE);
 	}
 
-	r = fread(&(eval->edax_header),sizeof (int),1,f);
-	r += fread(&(eval->eval_header),sizeof (int),1,f);
-	r += fread(&(eval->version),sizeof (int),1,f);
-	r += fread(&(eval->release),sizeof (int),1,f);
-	r += fread(&(eval->build),sizeof (int),1,f);
-	r += fread(&(eval->date),sizeof (double),1,f);
-	r += fread(eval->data[0],sizeof (short),eval->n_data*eval->n_ply,f);
+	r = fread(&(eval->edax_header), sizeof(int), 1, f);
+	r += fread(&(eval->eval_header), sizeof(int), 1, f);
+	r += fread(&(eval->version), sizeof(int), 1, f);
+	r += fread(&(eval->release), sizeof(int), 1, f);
+	r += fread(&(eval->build), sizeof(int), 1, f);
+	r += fread(&(eval->date), sizeof(double), 1, f);
+	r += fread(eval->data[0], sizeof(short), eval->n_data * eval->n_ply, f);
 
-	if (r != 6 + eval->n_data*eval->n_ply) {
-		fprintf(stderr,"eval_builder_read : can't read %s\n",file);
+	if (r != 6 + eval->n_data * eval->n_ply) {
+		fprintf(stderr, "eval_builder_read : can't read %s\n", file);
 		exit(EXIT_FAILURE);
 	}
 }
 
 /* write an EvalBuilder structure */
-void eval_builder_write(EvalBuilder* eval,const char *file){
-	FILE *f;
-	
-	f=fopen(file,"wb");
-	if (f==NULL){
-		fprintf(stderr,"eval_builder_write : can't open %s\n",file);
+void eval_builder_write(EvalBuilder* eval, const char* file) {
+	FILE* f;
+
+	f = fopen(file, "wb");
+	if (f == NULL) {
+		fprintf(stderr, "eval_builder_write : can't open %s\n", file);
 		exit(EXIT_FAILURE);
 	}
 
-	fwrite(&(eval->edax_header),sizeof (int),1,f);
-	fwrite(&(eval->eval_header),sizeof (int),1,f);
-	fwrite(&(eval->version),sizeof (int),1,f);
-	fwrite(&(eval->release),sizeof (int),1,f);
-	fwrite(&(eval->build),sizeof (int),1,f);
-	fwrite(&(eval->date),sizeof (double),1,f);
-	fwrite(eval->data[0],sizeof (short),eval->n_data*eval->n_ply,f);
+	fwrite(&(eval->edax_header), sizeof(int), 1, f);
+	fwrite(&(eval->eval_header), sizeof(int), 1, f);
+	fwrite(&(eval->version), sizeof(int), 1, f);
+	fwrite(&(eval->release), sizeof(int), 1, f);
+	fwrite(&(eval->build), sizeof(int), 1, f);
+	fwrite(&(eval->date), sizeof(double), 1, f);
+	fwrite(eval->data[0], sizeof(short), eval->n_data * eval->n_ply, f);
 }
 
 /* init eval_builder_edax features for a board */
-void eval_builder_logistello_get_features(const Board *b, int *X){
-	int p=b->player;
-	const char *x=b->square;
-
-	X[0]=c9[p][x[A1]*6561+x[B1]*2187+x[A2]*729+x[B2]*243+x[C1]*81+x[A3]*27+x[C2]*9+x[B3]*3+x[C3]];
-	X[1]=c9[p][x[H1]*6561+x[G1]*2187+x[H2]*729+x[G2]*243+x[F1]*81+x[H3]*27+x[F2]*9+x[G3]*3+x[F3]];
-	X[2]=c9[p][x[A8]*6561+x[A7]*2187+x[B8]*729+x[B7]*243+x[A6]*81+x[C8]*27+x[B6]*9+x[C7]*3+x[C6]];
-	X[3]=c9[p][x[H8]*6561+x[H7]*2187+x[G8]*729+x[G7]*243+x[H6]*81+x[F8]*27+x[G6]*9+x[F7]*3+x[F6]];
-
-	X[4]=s10[p][x[B2]*19683+x[A1]*6561+x[B1]*2187+x[C1]*729+x[D1]*243+x[E1]*81+x[F1]*27+x[G1]*9+x[H1]*3+x[G2]]+10206; 
-	X[5]=s10[p][x[B7]*19683+x[A8]*6561+x[B8]*2187+x[C8]*729+x[D8]*243+x[E8]*81+x[F8]*27+x[G8]*9+x[H8]*3+x[G7]]+10206;
-	X[6]=s10[p][x[B2]*19683+x[A1]*6561+x[A2]*2187+x[A3]*729+x[A4]*243+x[A5]*81+x[A6]*27+x[A7]*9+x[A8]*3+x[B7]]+10206;
-	X[7]=s10[p][x[G2]*19683+x[H1]*6561+x[H2]*2187+x[H3]*729+x[H4]*243+x[H5]*81+x[H6]*27+x[H7]*9+x[H8]*3+x[G7]]+10206;
-
-	X[8]=i10[p][x[A1]*19683+x[B1]*6561+x[C1]*2187+x[D1]*729+x[E1]*243+x[A2]*81+x[B2]*27+x[C2]*9+x[D2]*3+x[E2]]+39852;
-	X[9]=i10[p][x[H1]*19683+x[G1]*6561+x[F1]*2187+x[E1]*729+x[D1]*243+x[H2]*81+x[G2]*27+x[F2]*9+x[E2]*3+x[D2]]+39852;
-	X[10]=i10[p][x[A8]*19683+x[B8]*6561+x[C8]*2187+x[D8]*729+x[E8]*243+x[A2]*81+x[B2]*27+x[C2]*9+x[D2]*3+x[E2]]+39852;
-	X[11]=i10[p][x[H8]*19683+x[G8]*6561+x[F8]*2187+x[E8]*729+x[D8]*243+x[H2]*81+x[G2]*27+x[F2]*9+x[E2]*3+x[D2]]+39852;
-	X[12]=i10[p][x[A1]*19683+x[A2]*6561+x[A3]*2187+x[A4]*729+x[A5]*243+x[B1]*81+x[B2]*27+x[B3]*9+x[B4]*3+x[B5]]+39852;
-	X[13]=i10[p][x[A8]*19683+x[A7]*6561+x[A6]*2187+x[A5]*729+x[A4]*243+x[B8]*81+x[B7]*27+x[B6]*9+x[B5]*3+x[B4]]+39852;
-	X[14]=i10[p][x[H1]*19683+x[H2]*6561+x[H3]*2187+x[H4]*729+x[H5]*243+x[G1]*81+x[G2]*27+x[G3]*9+x[G4]*3+x[G5]]+39852;
-	X[15]=i10[p][x[H8]*19683+x[H7]*6561+x[H6]*2187+x[H5]*729+x[H4]*243+x[G8]*81+x[G7]*27+x[G6]*9+x[G5]*3+x[G4]]+39852;
-
-	X[16]=s8[p][x[A2]*2187+x[B2]*729+x[C2]*243+x[D2]*81+x[E2]*27+x[F2]*9+x[G2]*3+x[H2]]+98901;
-	X[17]=s8[p][x[A7]*2187+x[B7]*729+x[C7]*243+x[D7]*81+x[E7]*27+x[F7]*9+x[G7]*3+x[H7]]+98901;
-	X[18]=s8[p][x[B1]*2187+x[B2]*729+x[B3]*243+x[B4]*81+x[B5]*27+x[B6]*9+x[B7]*3+x[B8]]+98901;
-	X[19]=s8[p][x[G1]*2187+x[G2]*729+x[G3]*243+x[G4]*81+x[G5]*27+x[G6]*9+x[G7]*3+x[G8]]+98901;
-
-	X[20]=s8[p][x[A3]*2187+x[B3]*729+x[C3]*243+x[D3]*81+x[E3]*27+x[F3]*9+x[G3]*3+x[H3]]+102222;
-	X[21]=s8[p][x[A6]*2187+x[B6]*729+x[C6]*243+x[D6]*81+x[E6]*27+x[F6]*9+x[G6]*3+x[H6]]+102222;
-	X[22]=s8[p][x[C1]*2187+x[C2]*729+x[C3]*243+x[C4]*81+x[C5]*27+x[C6]*9+x[C7]*3+x[C8]]+102222;
-	X[23]=s8[p][x[F1]*2187+x[F2]*729+x[F3]*243+x[F4]*81+x[F5]*27+x[F6]*9+x[F7]*3+x[F8]]+102222;
-
-	X[24]=s8[p][x[A4]*2187+x[B4]*729+x[C4]*243+x[D4]*81+x[E4]*27+x[F4]*9+x[G4]*3+x[H4]]+105543;
-	X[25]=s8[p][x[A5]*2187+x[B5]*729+x[C5]*243+x[D5]*81+x[E5]*27+x[F5]*9+x[G5]*3+x[H5]]+105543;
-	X[26]=s8[p][x[D1]*2187+x[D2]*729+x[D3]*243+x[D4]*81+x[D5]*27+x[D6]*9+x[D7]*3+x[D8]]+105543;
-	X[27]=s8[p][x[E1]*2187+x[E2]*729+x[E3]*243+x[E4]*81+x[E5]*27+x[E6]*9+x[E7]*3+x[E8]]+105543;
-
-	X[28]=s8[p][x[A1]*2187+x[B2]*729+x[C3]*243+x[D4]*81+x[E5]*27+x[F6]*9+x[G7]*3+x[H8]]+108864;
-	X[29]=s8[p][x[A8]*2187+x[B7]*729+x[C6]*243+x[D5]*81+x[E4]*27+x[F3]*9+x[G2]*3+x[H1]]+108864;
-
-	X[30]=s7[p][x[B1]*729+x[C2]*243+x[D3]*81+x[E4]*27+x[F5]*9+x[G6]*3+x[H7]]+112185;
-	X[31]=s7[p][x[H2]*729+x[G3]*243+x[F4]*81+x[E5]*27+x[D6]*9+x[C7]*3+x[B8]]+112185;
-	X[32]=s7[p][x[A2]*729+x[B3]*243+x[C4]*81+x[D5]*27+x[E6]*9+x[F7]*3+x[G8]]+112185;
-	X[33]=s7[p][x[G1]*729+x[F2]*243+x[E3]*81+x[D4]*27+x[C5]*9+x[B6]*3+x[A7]]+112185;
-
-	X[34]=s6[p][x[C1]*243+x[D2]*81+x[E3]*27+x[F4]*9+x[G5]*3+x[H6]]+113319;
-	X[35]=s6[p][x[A3]*243+x[B4]*81+x[C5]*27+x[D6]*9+x[E7]*3+x[F8]]+113319;
-	X[36]=s6[p][x[F1]*243+x[E2]*81+x[D3]*27+x[C4]*9+x[B5]*3+x[A6]]+113319;
-	X[37]=s6[p][x[H3]*243+x[G4]*81+x[F5]*27+x[E6]*9+x[D7]*3+x[C8]]+113319;
-
-	X[38]=s5[p][x[D1]*81+x[E2]*27+x[F3]*9+x[G4]*3+x[H5]]+113697;
-	X[39]=s5[p][x[A4]*81+x[B5]*27+x[C6]*9+x[D7]*3+x[E8]]+113697;
-	X[40]=s5[p][x[E1]*81+x[D2]*27+x[C3]*9+x[B4]*3+x[A5]]+113697;
-	X[41]=s5[p][x[H4]*81+x[G5]*27+x[F6]*9+x[E7]*3+x[D8]]+113697;
-
-	X[42]=s4[p][x[D1]*27+x[C2]*9+x[B3]*3+x[A4]]+113832;
-	X[43]=s4[p][x[A5]*27+x[B6]*9+x[C7]*3+x[D8]]+113832;
-	X[44]=s4[p][x[E1]*27+x[F2]*9+x[G3]*3+x[H4]]+113832;
-	X[45]=s4[p][x[H5]*27+x[G6]*9+x[F7]*3+x[E8]]+113832;
-	
-	X[46]=113877;
+void eval_builder_logistello_get_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+
+	X[0] = c9[p][x[A1] * 6561 + x[B1] * 2187 + x[A2] * 729 + x[B2] * 243 + x[C1] * 81 + x[A3] * 27 + x[C2] * 9 + x[B3] * 3 + x[C3]];
+	X[1] = c9[p][x[H1] * 6561 + x[G1] * 2187 + x[H2] * 729 + x[G2] * 243 + x[F1] * 81 + x[H3] * 27 + x[F2] * 9 + x[G3] * 3 + x[F3]];
+	X[2] = c9[p][x[A8] * 6561 + x[A7] * 2187 + x[B8] * 729 + x[B7] * 243 + x[A6] * 81 + x[C8] * 27 + x[B6] * 9 + x[C7] * 3 + x[C6]];
+	X[3] = c9[p][x[H8] * 6561 + x[H7] * 2187 + x[G8] * 729 + x[G7] * 243 + x[H6] * 81 + x[F8] * 27 + x[G6] * 9 + x[F7] * 3 + x[F6]];
+
+	X[4] = s10[p][x[B2] * 19683 + x[A1] * 6561 + x[B1] * 2187 + x[C1] * 729 + x[D1] * 243 + x[E1] * 81 + x[F1] * 27 + x[G1] * 9 + x[H1] * 3 + x[G2]] + 10206;
+	X[5] = s10[p][x[B7] * 19683 + x[A8] * 6561 + x[B8] * 2187 + x[C8] * 729 + x[D8] * 243 + x[E8] * 81 + x[F8] * 27 + x[G8] * 9 + x[H8] * 3 + x[G7]] + 10206;
+	X[6] = s10[p][x[B2] * 19683 + x[A1] * 6561 + x[A2] * 2187 + x[A3] * 729 + x[A4] * 243 + x[A5] * 81 + x[A6] * 27 + x[A7] * 9 + x[A8] * 3 + x[B7]] + 10206;
+	X[7] = s10[p][x[G2] * 19683 + x[H1] * 6561 + x[H2] * 2187 + x[H3] * 729 + x[H4] * 243 + x[H5] * 81 + x[H6] * 27 + x[H7] * 9 + x[H8] * 3 + x[G7]] + 10206;
+
+	X[8] = i10[p][x[A1] * 19683 + x[B1] * 6561 + x[C1] * 2187 + x[D1] * 729 + x[E1] * 243 + x[A2] * 81 + x[B2] * 27 + x[C2] * 9 + x[D2] * 3 + x[E2]] + 39852;
+	X[9] = i10[p][x[H1] * 19683 + x[G1] * 6561 + x[F1] * 2187 + x[E1] * 729 + x[D1] * 243 + x[H2] * 81 + x[G2] * 27 + x[F2] * 9 + x[E2] * 3 + x[D2]] + 39852;
+	X[10] = i10[p][x[A8] * 19683 + x[B8] * 6561 + x[C8] * 2187 + x[D8] * 729 + x[E8] * 243 + x[A2] * 81 + x[B2] * 27 + x[C2] * 9 + x[D2] * 3 + x[E2]] + 39852;
+	X[11] = i10[p][x[H8] * 19683 + x[G8] * 6561 + x[F8] * 2187 + x[E8] * 729 + x[D8] * 243 + x[H2] * 81 + x[G2] * 27 + x[F2] * 9 + x[E2] * 3 + x[D2]] + 39852;
+	X[12] = i10[p][x[A1] * 19683 + x[A2] * 6561 + x[A3] * 2187 + x[A4] * 729 + x[A5] * 243 + x[B1] * 81 + x[B2] * 27 + x[B3] * 9 + x[B4] * 3 + x[B5]] + 39852;
+	X[13] = i10[p][x[A8] * 19683 + x[A7] * 6561 + x[A6] * 2187 + x[A5] * 729 + x[A4] * 243 + x[B8] * 81 + x[B7] * 27 + x[B6] * 9 + x[B5] * 3 + x[B4]] + 39852;
+	X[14] = i10[p][x[H1] * 19683 + x[H2] * 6561 + x[H3] * 2187 + x[H4] * 729 + x[H5] * 243 + x[G1] * 81 + x[G2] * 27 + x[G3] * 9 + x[G4] * 3 + x[G5]] + 39852;
+	X[15] = i10[p][x[H8] * 19683 + x[H7] * 6561 + x[H6] * 2187 + x[H5] * 729 + x[H4] * 243 + x[G8] * 81 + x[G7] * 27 + x[G6] * 9 + x[G5] * 3 + x[G4]] + 39852;
+
+	X[16] = s8[p][x[A2] * 2187 + x[B2] * 729 + x[C2] * 243 + x[D2] * 81 + x[E2] * 27 + x[F2] * 9 + x[G2] * 3 + x[H2]] + 98901;
+	X[17] = s8[p][x[A7] * 2187 + x[B7] * 729 + x[C7] * 243 + x[D7] * 81 + x[E7] * 27 + x[F7] * 9 + x[G7] * 3 + x[H7]] + 98901;
+	X[18] = s8[p][x[B1] * 2187 + x[B2] * 729 + x[B3] * 243 + x[B4] * 81 + x[B5] * 27 + x[B6] * 9 + x[B7] * 3 + x[B8]] + 98901;
+	X[19] = s8[p][x[G1] * 2187 + x[G2] * 729 + x[G3] * 243 + x[G4] * 81 + x[G5] * 27 + x[G6] * 9 + x[G7] * 3 + x[G8]] + 98901;
+
+	X[20] = s8[p][x[A3] * 2187 + x[B3] * 729 + x[C3] * 243 + x[D3] * 81 + x[E3] * 27 + x[F3] * 9 + x[G3] * 3 + x[H3]] + 102222;
+	X[21] = s8[p][x[A6] * 2187 + x[B6] * 729 + x[C6] * 243 + x[D6] * 81 + x[E6] * 27 + x[F6] * 9 + x[G6] * 3 + x[H6]] + 102222;
+	X[22] = s8[p][x[C1] * 2187 + x[C2] * 729 + x[C3] * 243 + x[C4] * 81 + x[C5] * 27 + x[C6] * 9 + x[C7] * 3 + x[C8]] + 102222;
+	X[23] = s8[p][x[F1] * 2187 + x[F2] * 729 + x[F3] * 243 + x[F4] * 81 + x[F5] * 27 + x[F6] * 9 + x[F7] * 3 + x[F8]] + 102222;
+
+	X[24] = s8[p][x[A4] * 2187 + x[B4] * 729 + x[C4] * 243 + x[D4] * 81 + x[E4] * 27 + x[F4] * 9 + x[G4] * 3 + x[H4]] + 105543;
+	X[25] = s8[p][x[A5] * 2187 + x[B5] * 729 + x[C5] * 243 + x[D5] * 81 + x[E5] * 27 + x[F5] * 9 + x[G5] * 3 + x[H5]] + 105543;
+	X[26] = s8[p][x[D1] * 2187 + x[D2] * 729 + x[D3] * 243 + x[D4] * 81 + x[D5] * 27 + x[D6] * 9 + x[D7] * 3 + x[D8]] + 105543;
+	X[27] = s8[p][x[E1] * 2187 + x[E2] * 729 + x[E3] * 243 + x[E4] * 81 + x[E5] * 27 + x[E6] * 9 + x[E7] * 3 + x[E8]] + 105543;
+
+	X[28] = s8[p][x[A1] * 2187 + x[B2] * 729 + x[C3] * 243 + x[D4] * 81 + x[E5] * 27 + x[F6] * 9 + x[G7] * 3 + x[H8]] + 108864;
+	X[29] = s8[p][x[A8] * 2187 + x[B7] * 729 + x[C6] * 243 + x[D5] * 81 + x[E4] * 27 + x[F3] * 9 + x[G2] * 3 + x[H1]] + 108864;
+
+	X[30] = s7[p][x[B1] * 729 + x[C2] * 243 + x[D3] * 81 + x[E4] * 27 + x[F5] * 9 + x[G6] * 3 + x[H7]] + 112185;
+	X[31] = s7[p][x[H2] * 729 + x[G3] * 243 + x[F4] * 81 + x[E5] * 27 + x[D6] * 9 + x[C7] * 3 + x[B8]] + 112185;
+	X[32] = s7[p][x[A2] * 729 + x[B3] * 243 + x[C4] * 81 + x[D5] * 27 + x[E6] * 9 + x[F7] * 3 + x[G8]] + 112185;
+	X[33] = s7[p][x[G1] * 729 + x[F2] * 243 + x[E3] * 81 + x[D4] * 27 + x[C5] * 9 + x[B6] * 3 + x[A7]] + 112185;
+
+	X[34] = s6[p][x[C1] * 243 + x[D2] * 81 + x[E3] * 27 + x[F4] * 9 + x[G5] * 3 + x[H6]] + 113319;
+	X[35] = s6[p][x[A3] * 243 + x[B4] * 81 + x[C5] * 27 + x[D6] * 9 + x[E7] * 3 + x[F8]] + 113319;
+	X[36] = s6[p][x[F1] * 243 + x[E2] * 81 + x[D3] * 27 + x[C4] * 9 + x[B5] * 3 + x[A6]] + 113319;
+	X[37] = s6[p][x[H3] * 243 + x[G4] * 81 + x[F5] * 27 + x[E6] * 9 + x[D7] * 3 + x[C8]] + 113319;
+
+	X[38] = s5[p][x[D1] * 81 + x[E2] * 27 + x[F3] * 9 + x[G4] * 3 + x[H5]] + 113697;
+	X[39] = s5[p][x[A4] * 81 + x[B5] * 27 + x[C6] * 9 + x[D7] * 3 + x[E8]] + 113697;
+	X[40] = s5[p][x[E1] * 81 + x[D2] * 27 + x[C3] * 9 + x[B4] * 3 + x[A5]] + 113697;
+	X[41] = s5[p][x[H4] * 81 + x[G5] * 27 + x[F6] * 9 + x[E7] * 3 + x[D8]] + 113697;
+
+	X[42] = s4[p][x[D1] * 27 + x[C2] * 9 + x[B3] * 3 + x[A4]] + 113832;
+	X[43] = s4[p][x[A5] * 27 + x[B6] * 9 + x[C7] * 3 + x[D8]] + 113832;
+	X[44] = s4[p][x[E1] * 27 + x[F2] * 9 + x[G3] * 3 + x[H4]] + 113832;
+	X[45] = s4[p][x[H5] * 27 + x[G6] * 9 + x[F7] * 3 + x[E8]] + 113832;
+
+	X[46] = 113877;
 }
 
 /* init eval_builder corner 5x2 feature for a board */
-void eval_builder_get_corner5x2_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
+void eval_builder_get_corner5x2_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
 
-	X[0]=i10[p][x[A1]*19683+x[B1]*6561+x[C1]*2187+x[D1]*729+x[E1]*243+x[A2]*81+x[B2]*27+x[C2]*9+x[D2]*3+x[E2]];
-	X[1]=i10[p][x[H1]*19683+x[G1]*6561+x[F1]*2187+x[E1]*729+x[D1]*243+x[H2]*81+x[G2]*27+x[F2]*9+x[E2]*3+x[D2]];
-	X[2]=i10[p][x[A8]*19683+x[B8]*6561+x[C8]*2187+x[D8]*729+x[E8]*243+x[A2]*81+x[B2]*27+x[C2]*9+x[D2]*3+x[E2]];
-	X[3]=i10[p][x[H8]*19683+x[G8]*6561+x[F8]*2187+x[E8]*729+x[D8]*243+x[H2]*81+x[G2]*27+x[F2]*9+x[E2]*3+x[D2]];
-	X[4]=i10[p][x[A1]*19683+x[A2]*6561+x[A3]*2187+x[A4]*729+x[A5]*243+x[B1]*81+x[B2]*27+x[B3]*9+x[B4]*3+x[B5]];
-	X[5]=i10[p][x[A8]*19683+x[A7]*6561+x[A6]*2187+x[A5]*729+x[A4]*243+x[B8]*81+x[B7]*27+x[B6]*9+x[B5]*3+x[B4]];
-	X[6]=i10[p][x[H1]*19683+x[H2]*6561+x[H3]*2187+x[H4]*729+x[H5]*243+x[G1]*81+x[G2]*27+x[G3]*9+x[G4]*3+x[G5]];
-	X[7]=i10[p][x[H8]*19683+x[H7]*6561+x[H6]*2187+x[H5]*729+x[H4]*243+x[G8]*81+x[G7]*27+x[G6]*9+x[G5]*3+x[G4]];
-	X[8]=59049;
+	X[0] = i10[p][x[A1] * 19683 + x[B1] * 6561 + x[C1] * 2187 + x[D1] * 729 + x[E1] * 243 + x[A2] * 81 + x[B2] * 27 + x[C2] * 9 + x[D2] * 3 + x[E2]];
+	X[1] = i10[p][x[H1] * 19683 + x[G1] * 6561 + x[F1] * 2187 + x[E1] * 729 + x[D1] * 243 + x[H2] * 81 + x[G2] * 27 + x[F2] * 9 + x[E2] * 3 + x[D2]];
+	X[2] = i10[p][x[A8] * 19683 + x[B8] * 6561 + x[C8] * 2187 + x[D8] * 729 + x[E8] * 243 + x[A2] * 81 + x[B2] * 27 + x[C2] * 9 + x[D2] * 3 + x[E2]];
+	X[3] = i10[p][x[H8] * 19683 + x[G8] * 6561 + x[F8] * 2187 + x[E8] * 729 + x[D8] * 243 + x[H2] * 81 + x[G2] * 27 + x[F2] * 9 + x[E2] * 3 + x[D2]];
+	X[4] = i10[p][x[A1] * 19683 + x[A2] * 6561 + x[A3] * 2187 + x[A4] * 729 + x[A5] * 243 + x[B1] * 81 + x[B2] * 27 + x[B3] * 9 + x[B4] * 3 + x[B5]];
+	X[5] = i10[p][x[A8] * 19683 + x[A7] * 6561 + x[A6] * 2187 + x[A5] * 729 + x[A4] * 243 + x[B8] * 81 + x[B7] * 27 + x[B6] * 9 + x[B5] * 3 + x[B4]];
+	X[6] = i10[p][x[H1] * 19683 + x[H2] * 6561 + x[H3] * 2187 + x[H4] * 729 + x[H5] * 243 + x[G1] * 81 + x[G2] * 27 + x[G3] * 9 + x[G4] * 3 + x[G5]];
+	X[7] = i10[p][x[H8] * 19683 + x[H7] * 6561 + x[H6] * 2187 + x[H5] * 729 + x[H4] * 243 + x[G8] * 81 + x[G7] * 27 + x[G6] * 9 + x[G5] * 3 + x[G4]];
+	X[8] = 59049;
 }
 
 
 /* init eval_builder corner 3x3 feature for a board */
-void eval_builder_get_corner3x3_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-
-	X[0]=c9[p][x[A1]*6561+x[B1]*2187+x[A2]*729+x[B2]*243+x[C1]*81+x[A3]*27+x[C2]*9+x[B3]*3+x[C3]];
-	X[1]=c9[p][x[H1]*6561+x[G1]*2187+x[H2]*729+x[G2]*243+x[F1]*81+x[H3]*27+x[F2]*9+x[G3]*3+x[F3]];
-	X[2]=c9[p][x[A8]*6561+x[A7]*2187+x[B8]*729+x[B7]*243+x[A6]*81+x[C8]*27+x[B6]*9+x[C7]*3+x[C6]];
-	X[3]=c9[p][x[H8]*6561+x[H7]*2187+x[G8]*729+x[G7]*243+x[H6]*81+x[F8]*27+x[G6]*9+x[F7]*3+x[F6]];
-	X[4]=10206;
-}
-
-/* init eval_builder edge feature for a board */
-void eval_builder_get_edge_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-
-	X[0]=s8[p][x[A1]*2187+x[B1]*729+x[C1]*243+x[D1]*81+x[E1]*27+x[F1]*9+x[G1]*3+x[H1]];
-	X[1]=s8[p][x[A8]*2187+x[B8]*729+x[C8]*243+x[D8]*81+x[E8]*27+x[F8]*9+x[G8]*3+x[H8]];
-	X[2]=s8[p][x[A1]*2187+x[A2]*729+x[A3]*243+x[A4]*81+x[A5]*27+x[A6]*9+x[A7]*3+x[A8]];
-	X[3]=s8[p][x[H1]*2187+x[H2]*729+x[H3]*243+x[H4]*81+x[H5]*27+x[H6]*9+x[H7]*3+x[H8]];
-	X[4]=3321;
-}
-
-/* init eval_builder edge feature for a board */
-void eval_builder_get_edge_X_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
+void eval_builder_get_corner3x3_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
 
-	X[0]=s10[p][x[B2]*19683+x[A1]*6561+x[B1]*2187+x[C1]*729+x[D1]*243+x[E1]*81+x[F1]*27+x[G1]*9+x[H1]*3+x[G2]];
-	X[1]=s10[p][x[B7]*19683+x[A8]*6561+x[B8]*2187+x[C8]*729+x[D8]*243+x[E8]*81+x[F8]*27+x[G8]*9+x[H8]*3+x[G7]];
-	X[2]=s10[p][x[B2]*19683+x[A1]*6561+x[A2]*2187+x[A3]*729+x[A4]*243+x[A5]*81+x[A6]*27+x[A7]*9+x[A8]*3+x[B7]];
-	X[3]=s10[p][x[G2]*19683+x[H1]*6561+x[H2]*2187+x[H3]*729+x[H4]*243+x[H5]*81+x[H6]*27+x[H7]*9+x[H8]*3+x[G7]];
-	X[4]=29646;
+	X[0] = c9[p][x[A1] * 6561 + x[B1] * 2187 + x[A2] * 729 + x[B2] * 243 + x[C1] * 81 + x[A3] * 27 + x[C2] * 9 + x[B3] * 3 + x[C3]];
+	X[1] = c9[p][x[H1] * 6561 + x[G1] * 2187 + x[H2] * 729 + x[G2] * 243 + x[F1] * 81 + x[H3] * 27 + x[F2] * 9 + x[G3] * 3 + x[F3]];
+	X[2] = c9[p][x[A8] * 6561 + x[A7] * 2187 + x[B8] * 729 + x[B7] * 243 + x[A6] * 81 + x[C8] * 27 + x[B6] * 9 + x[C7] * 3 + x[C6]];
+	X[3] = c9[p][x[H8] * 6561 + x[H7] * 2187 + x[G8] * 729 + x[G7] * 243 + x[H6] * 81 + x[F8] * 27 + x[G6] * 9 + x[F7] * 3 + x[F6]];
+	X[4] = 10206;
 }
 
 /* init eval_builder edge feature for a board */
-void eval_builder_get_edge_C_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-
-	X[0]=s10[p][x[A2]*19683+x[A1]*6561+x[B1]*2187+x[C1]*729+x[D1]*243+x[E1]*81+x[F1]*27+x[G1]*9+x[H1]*3+x[H2]];
-	X[1]=s10[p][x[A7]*19683+x[A8]*6561+x[B8]*2187+x[C8]*729+x[D8]*243+x[E8]*81+x[F8]*27+x[G8]*9+x[H8]*3+x[H7]];
-	X[2]=s10[p][x[B1]*19683+x[A1]*6561+x[A2]*2187+x[A3]*729+x[A4]*243+x[A5]*81+x[A6]*27+x[A7]*9+x[A8]*3+x[B8]];
-	X[3]=s10[p][x[G1]*19683+x[H1]*6561+x[H2]*2187+x[H3]*729+x[H4]*243+x[H5]*81+x[H6]*27+x[H7]*9+x[H8]*3+x[G8]];
-	X[4]=29646;
-}
-
-
-/* init eval_builder edge feature for a board */
-void eval_builder_get_edge_CX_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-
-	X[0]=s12[p][x[B2]*177147+x[A2]*59049+x[A1]*19683+x[B1]*6561+x[C1]*2187+x[D1]*729+x[E1]*243+x[F1]*81+x[G1]*27+x[H1]*9+x[H2]*3+x[G2]];
-	X[1]=s12[p][x[B7]*177147+x[A7]*59049+x[A8]*19683+x[B8]*6561+x[C8]*2187+x[D8]*729+x[E8]*243+x[F8]*81+x[G8]*27+x[H8]*9+x[H7]*3+x[G7]];
-	X[2]=s12[p][x[B2]*177147+x[B1]*59049+x[A1]*19683+x[A2]*6561+x[A3]*2187+x[A4]*729+x[A5]*243+x[A6]*81+x[A7]*27+x[A8]*9+x[B8]*3+x[B7]];
-	X[3]=s12[p][x[G2]*177147+x[G1]*59049+x[H1]*19683+x[H2]*6561+x[H3]*2187+x[H4]*729+x[H5]*243+x[H6]*81+x[H7]*27+x[H8]*9+x[G8]*3+x[G7]];
-	X[4]=266085;
-}
-
-/* ABFG */
-void eval_builder_get_ABFG_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s8[p][x[C1]*2187+x[D1]*729+x[C2]*243+x[D2]*81+x[E2]*27+x[F2]*9+x[E1]*3+x[F1]];
-	X[1]=s8[p][x[C8]*2187+x[D8]*729+x[C7]*243+x[D7]*81+x[E7]*27+x[F7]*9+x[E8]*3+x[F8]];
-	X[2]=s8[p][x[A3]*2187+x[A4]*729+x[B3]*243+x[B4]*81+x[B5]*27+x[B6]*9+x[A5]*3+x[A6]];
-	X[3]=s8[p][x[H3]*2187+x[H4]*729+x[G3]*243+x[G4]*81+x[G5]*27+x[G6]*9+x[H5]*3+x[H6]];
-	X[4]=3321;
-}
-
-void eval_builder_get_edge_FG_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s12[p][x[D2]*177147+x[C2]*59049+x[A1]*19683+x[B1]*6561+x[C1]*2187+x[D1]*729+x[E1]*243+x[F1]*81+x[G1]*27+x[H1]*9+x[F2]*3+x[E2]];
-	X[1]=s12[p][x[D7]*177147+x[C7]*59049+x[A8]*19683+x[B8]*6561+x[C8]*2187+x[D8]*729+x[E8]*243+x[F8]*81+x[G8]*27+x[H8]*9+x[F7]*3+x[E7]];
-	X[2]=s12[p][x[B4]*177147+x[B3]*59049+x[A1]*19683+x[A2]*6561+x[A3]*2187+x[A4]*729+x[A5]*243+x[A6]*81+x[A7]*27+x[A8]*9+x[B6]*3+x[B5]];
-	X[3]=s12[p][x[G4]*177147+x[G3]*59049+x[H1]*19683+x[H2]*6561+x[H3]*2187+x[H4]*729+x[H5]*243+x[H6]*81+x[H7]*27+x[H8]*9+x[G6]*3+x[G5]];
-	X[4]=266085;
+void eval_builder_get_edge_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+
+	X[0] = s8[p][x[A1] * 2187 + x[B1] * 729 + x[C1] * 243 + x[D1] * 81 + x[E1] * 27 + x[F1] * 9 + x[G1] * 3 + x[H1]];
+	X[1] = s8[p][x[A8] * 2187 + x[B8] * 729 + x[C8] * 243 + x[D8] * 81 + x[E8] * 27 + x[F8] * 9 + x[G8] * 3 + x[H8]];
+	X[2] = s8[p][x[A1] * 2187 + x[A2] * 729 + x[A3] * 243 + x[A4] * 81 + x[A5] * 27 + x[A6] * 9 + x[A7] * 3 + x[A8]];
+	X[3] = s8[p][x[H1] * 2187 + x[H2] * 729 + x[H3] * 243 + x[H4] * 81 + x[H5] * 27 + x[H6] * 9 + x[H7] * 3 + x[H8]];
+	X[4] = 3321;
+}
+
+// ********
+// .*....*.
+void eval_builder_get_edge_X_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+
+	X[0] = s10[p][x[B2] * 19683 + x[A1] * 6561 + x[B1] * 2187 + x[C1] * 729 + x[D1] * 243 + x[E1] * 81 + x[F1] * 27 + x[G1] * 9 + x[H1] * 3 + x[G2]];
+	X[1] = s10[p][x[B7] * 19683 + x[A8] * 6561 + x[B8] * 2187 + x[C8] * 729 + x[D8] * 243 + x[E8] * 81 + x[F8] * 27 + x[G8] * 9 + x[H8] * 3 + x[G7]];
+	X[2] = s10[p][x[B2] * 19683 + x[A1] * 6561 + x[A2] * 2187 + x[A3] * 729 + x[A4] * 243 + x[A5] * 81 + x[A6] * 27 + x[A7] * 9 + x[A8] * 3 + x[B7]];
+	X[3] = s10[p][x[G2] * 19683 + x[H1] * 6561 + x[H2] * 2187 + x[H3] * 729 + x[H4] * 243 + x[H5] * 81 + x[H6] * 27 + x[H7] * 9 + x[H8] * 3 + x[G7]];
+	X[4] = 29646;
+}
+
+// ********
+// *......*
+void eval_builder_get_edge_C_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+
+	X[0] = s10[p][x[A2] * 19683 + x[A1] * 6561 + x[B1] * 2187 + x[C1] * 729 + x[D1] * 243 + x[E1] * 81 + x[F1] * 27 + x[G1] * 9 + x[H1] * 3 + x[H2]];
+	X[1] = s10[p][x[A7] * 19683 + x[A8] * 6561 + x[B8] * 2187 + x[C8] * 729 + x[D8] * 243 + x[E8] * 81 + x[F8] * 27 + x[G8] * 9 + x[H8] * 3 + x[H7]];
+	X[2] = s10[p][x[B1] * 19683 + x[A1] * 6561 + x[A2] * 2187 + x[A3] * 729 + x[A4] * 243 + x[A5] * 81 + x[A6] * 27 + x[A7] * 9 + x[A8] * 3 + x[B8]];
+	X[3] = s10[p][x[G1] * 19683 + x[H1] * 6561 + x[H2] * 2187 + x[H3] * 729 + x[H4] * 243 + x[H5] * 81 + x[H6] * 27 + x[H7] * 9 + x[H8] * 3 + x[G8]];
+	X[4] = 29646;
+}
+
+// ********
+// **....**
+void eval_builder_get_edge_CX_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+
+	X[0] = s12[p][x[B2] * 177147 + x[A2] * 59049 + x[A1] * 19683 + x[B1] * 6561 + x[C1] * 2187 + x[D1] * 729 + x[E1] * 243 + x[F1] * 81 + x[G1] * 27 + x[H1] * 9 + x[H2] * 3 + x[G2]];
+	X[1] = s12[p][x[B7] * 177147 + x[A7] * 59049 + x[A8] * 19683 + x[B8] * 6561 + x[C8] * 2187 + x[D8] * 729 + x[E8] * 243 + x[F8] * 81 + x[G8] * 27 + x[H8] * 9 + x[H7] * 3 + x[G7]];
+	X[2] = s12[p][x[B2] * 177147 + x[B1] * 59049 + x[A1] * 19683 + x[A2] * 6561 + x[A3] * 2187 + x[A4] * 729 + x[A5] * 243 + x[A6] * 81 + x[A7] * 27 + x[A8] * 9 + x[B8] * 3 + x[B7]];
+	X[3] = s12[p][x[G2] * 177147 + x[G1] * 59049 + x[H1] * 19683 + x[H2] * 6561 + x[H3] * 2187 + x[H4] * 729 + x[H5] * 243 + x[H6] * 81 + x[H7] * 27 + x[H8] * 9 + x[G8] * 3 + x[G7]];
+	X[4] = 266085;
+}
+
+// ..****..
+// ..****..
+void eval_builder_get_ABFG_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s8[p][x[C1] * 2187 + x[D1] * 729 + x[C2] * 243 + x[D2] * 81 + x[E2] * 27 + x[F2] * 9 + x[E1] * 3 + x[F1]];
+	X[1] = s8[p][x[C8] * 2187 + x[D8] * 729 + x[C7] * 243 + x[D7] * 81 + x[E7] * 27 + x[F7] * 9 + x[E8] * 3 + x[F8]];
+	X[2] = s8[p][x[A3] * 2187 + x[A4] * 729 + x[B3] * 243 + x[B4] * 81 + x[B5] * 27 + x[B6] * 9 + x[A5] * 3 + x[A6]];
+	X[3] = s8[p][x[H3] * 2187 + x[H4] * 729 + x[G3] * 243 + x[G4] * 81 + x[G5] * 27 + x[G6] * 9 + x[H5] * 3 + x[H6]];
+	X[4] = 3321;
+}
+
+// ********
+// ..****..
+void eval_builder_get_edge_FG_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s12[p][x[D2] * 177147 + x[C2] * 59049 + x[A1] * 19683 + x[B1] * 6561 + x[C1] * 2187 + x[D1] * 729 + x[E1] * 243 + x[F1] * 81 + x[G1] * 27 + x[H1] * 9 + x[F2] * 3 + x[E2]];
+	X[1] = s12[p][x[D7] * 177147 + x[C7] * 59049 + x[A8] * 19683 + x[B8] * 6561 + x[C8] * 2187 + x[D8] * 729 + x[E8] * 243 + x[F8] * 81 + x[G8] * 27 + x[H8] * 9 + x[F7] * 3 + x[E7]];
+	X[2] = s12[p][x[B4] * 177147 + x[B3] * 59049 + x[A1] * 19683 + x[A2] * 6561 + x[A3] * 2187 + x[A4] * 729 + x[A5] * 243 + x[A6] * 81 + x[A7] * 27 + x[A8] * 9 + x[B6] * 3 + x[B5]];
+	X[3] = s12[p][x[G4] * 177147 + x[G3] * 59049 + x[H1] * 19683 + x[H2] * 6561 + x[H3] * 2187 + x[H4] * 729 + x[H5] * 243 + x[H6] * 81 + x[H7] * 27 + x[H8] * 9 + x[G6] * 3 + x[G5]];
+	X[4] = 266085;
 }
 
 /* CC */
-void eval_builder_get_CC_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s8[p][x[A2]*2187+x[B2]*729+x[C2]*243+x[D2]*81+x[E2]*27+x[F2]*9+x[G2]*3+x[H2]];
-	X[1]=s8[p][x[A7]*2187+x[B7]*729+x[C7]*243+x[D7]*81+x[E7]*27+x[F7]*9+x[G7]*3+x[H7]];
-	X[2]=s8[p][x[B1]*2187+x[B2]*729+x[B3]*243+x[B4]*81+x[B5]*27+x[B6]*9+x[B7]*3+x[B8]];
-	X[3]=s8[p][x[G1]*2187+x[G2]*729+x[G3]*243+x[G4]*81+x[G5]*27+x[G6]*9+x[G7]*3+x[G8]];
-	X[4]=3321;
+void eval_builder_get_CC_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s8[p][x[A2] * 2187 + x[B2] * 729 + x[C2] * 243 + x[D2] * 81 + x[E2] * 27 + x[F2] * 9 + x[G2] * 3 + x[H2]];
+	X[1] = s8[p][x[A7] * 2187 + x[B7] * 729 + x[C7] * 243 + x[D7] * 81 + x[E7] * 27 + x[F7] * 9 + x[G7] * 3 + x[H7]];
+	X[2] = s8[p][x[B1] * 2187 + x[B2] * 729 + x[B3] * 243 + x[B4] * 81 + x[B5] * 27 + x[B6] * 9 + x[B7] * 3 + x[B8]];
+	X[3] = s8[p][x[G1] * 2187 + x[G2] * 729 + x[G3] * 243 + x[G4] * 81 + x[G5] * 27 + x[G6] * 9 + x[G7] * 3 + x[G8]];
+	X[4] = 3321;
 }
 
 /* AA */
-void eval_builder_get_AA_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s8[p][x[A3]*2187+x[B3]*729+x[C3]*243+x[D3]*81+x[E3]*27+x[F3]*9+x[G3]*3+x[H3]];
-	X[1]=s8[p][x[A6]*2187+x[B6]*729+x[C6]*243+x[D6]*81+x[E6]*27+x[F6]*9+x[G6]*3+x[H6]];
-	X[2]=s8[p][x[C1]*2187+x[C2]*729+x[C3]*243+x[C4]*81+x[C5]*27+x[C6]*9+x[C7]*3+x[C8]];
-	X[3]=s8[p][x[F1]*2187+x[F2]*729+x[F3]*243+x[F4]*81+x[F5]*27+x[F6]*9+x[F7]*3+x[F8]];
-	X[4]=3321;
+void eval_builder_get_AA_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s8[p][x[A3] * 2187 + x[B3] * 729 + x[C3] * 243 + x[D3] * 81 + x[E3] * 27 + x[F3] * 9 + x[G3] * 3 + x[H3]];
+	X[1] = s8[p][x[A6] * 2187 + x[B6] * 729 + x[C6] * 243 + x[D6] * 81 + x[E6] * 27 + x[F6] * 9 + x[G6] * 3 + x[H6]];
+	X[2] = s8[p][x[C1] * 2187 + x[C2] * 729 + x[C3] * 243 + x[C4] * 81 + x[C5] * 27 + x[C6] * 9 + x[C7] * 3 + x[C8]];
+	X[3] = s8[p][x[F1] * 2187 + x[F2] * 729 + x[F3] * 243 + x[F4] * 81 + x[F5] * 27 + x[F6] * 9 + x[F7] * 3 + x[F8]];
+	X[4] = 3321;
 }
 
 /* BB */
-void eval_builder_get_BB_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s8[p][x[A4]*2187+x[B4]*729+x[C4]*243+x[D4]*81+x[E4]*27+x[F4]*9+x[G4]*3+x[H4]];
-	X[1]=s8[p][x[A5]*2187+x[B5]*729+x[C5]*243+x[D5]*81+x[E5]*27+x[F5]*9+x[G5]*3+x[H5]];
-	X[2]=s8[p][x[D1]*2187+x[D2]*729+x[D3]*243+x[D4]*81+x[D5]*27+x[D6]*9+x[D7]*3+x[D8]];
-	X[3]=s8[p][x[E1]*2187+x[E2]*729+x[E3]*243+x[E4]*81+x[E5]*27+x[E6]*9+x[E7]*3+x[E8]];
-	X[4]=3321;
+void eval_builder_get_BB_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s8[p][x[A4] * 2187 + x[B4] * 729 + x[C4] * 243 + x[D4] * 81 + x[E4] * 27 + x[F4] * 9 + x[G4] * 3 + x[H4]];
+	X[1] = s8[p][x[A5] * 2187 + x[B5] * 729 + x[C5] * 243 + x[D5] * 81 + x[E5] * 27 + x[F5] * 9 + x[G5] * 3 + x[H5]];
+	X[2] = s8[p][x[D1] * 2187 + x[D2] * 729 + x[D3] * 243 + x[D4] * 81 + x[D5] * 27 + x[D6] * 9 + x[D7] * 3 + x[D8]];
+	X[3] = s8[p][x[E1] * 2187 + x[E2] * 729 + x[E3] * 243 + x[E4] * 81 + x[E5] * 27 + x[E6] * 9 + x[E7] * 3 + x[E8]];
+	X[4] = 3321;
 }
 
 /* d8 */
-void eval_builder_get_d8_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s8[p][x[A1]*2187+x[B2]*729+x[C3]*243+x[D4]*81+x[E5]*27+x[F6]*9+x[G7]*3+x[H8]];
-	X[1]=s8[p][x[A8]*2187+x[B7]*729+x[C6]*243+x[D5]*81+x[E4]*27+x[F3]*9+x[G2]*3+x[H1]];
-	X[2]=3321;
+void eval_builder_get_d8_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s8[p][x[A1] * 2187 + x[B2] * 729 + x[C3] * 243 + x[D4] * 81 + x[E5] * 27 + x[F6] * 9 + x[G7] * 3 + x[H8]];
+	X[1] = s8[p][x[A8] * 2187 + x[B7] * 729 + x[C6] * 243 + x[D5] * 81 + x[E4] * 27 + x[F3] * 9 + x[G2] * 3 + x[H1]];
+	X[2] = 3321;
 }
 
 /* d7 */
-void eval_builder_get_d7_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s7[p][x[B1]*729+x[C2]*243+x[D3]*81+x[E4]*27+x[F5]*9+x[G6]*3+x[H7]];
-	X[1]=s7[p][x[H2]*729+x[G3]*243+x[F4]*81+x[E5]*27+x[D6]*9+x[C7]*3+x[B8]];
-	X[2]=s7[p][x[A2]*729+x[B3]*243+x[C4]*81+x[D5]*27+x[E6]*9+x[F7]*3+x[G8]];
-	X[3]=s7[p][x[G1]*729+x[F2]*243+x[E3]*81+x[D4]*27+x[C5]*9+x[B6]*3+x[A7]];
-	X[4]=1134;
+void eval_builder_get_d7_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s7[p][x[B1] * 729 + x[C2] * 243 + x[D3] * 81 + x[E4] * 27 + x[F5] * 9 + x[G6] * 3 + x[H7]];
+	X[1] = s7[p][x[H2] * 729 + x[G3] * 243 + x[F4] * 81 + x[E5] * 27 + x[D6] * 9 + x[C7] * 3 + x[B8]];
+	X[2] = s7[p][x[A2] * 729 + x[B3] * 243 + x[C4] * 81 + x[D5] * 27 + x[E6] * 9 + x[F7] * 3 + x[G8]];
+	X[3] = s7[p][x[G1] * 729 + x[F2] * 243 + x[E3] * 81 + x[D4] * 27 + x[C5] * 9 + x[B6] * 3 + x[A7]];
+	X[4] = 1134;
 }
 
 /* d6 */
-void eval_builder_get_d6_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s6[p][x[C1]*243+x[D2]*81+x[E3]*27+x[F4]*9+x[G5]*3+x[H6]];
-	X[1]=s6[p][x[A3]*243+x[B4]*81+x[C5]*27+x[D6]*9+x[E7]*3+x[F8]];
-	X[2]=s6[p][x[F1]*243+x[E2]*81+x[D3]*27+x[C4]*9+x[B5]*3+x[A6]];
-	X[3]=s6[p][x[H3]*243+x[G4]*81+x[F5]*27+x[E6]*9+x[D7]*3+x[C8]];
-	X[4]=378;
+void eval_builder_get_d6_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s6[p][x[C1] * 243 + x[D2] * 81 + x[E3] * 27 + x[F4] * 9 + x[G5] * 3 + x[H6]];
+	X[1] = s6[p][x[A3] * 243 + x[B4] * 81 + x[C5] * 27 + x[D6] * 9 + x[E7] * 3 + x[F8]];
+	X[2] = s6[p][x[F1] * 243 + x[E2] * 81 + x[D3] * 27 + x[C4] * 9 + x[B5] * 3 + x[A6]];
+	X[3] = s6[p][x[H3] * 243 + x[G4] * 81 + x[F5] * 27 + x[E6] * 9 + x[D7] * 3 + x[C8]];
+	X[4] = 378;
 }
 
 /* d5 */
-void eval_builder_get_d5_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s5[p][x[D1]*81+x[E2]*27+x[F3]*9+x[G4]*3+x[H5]];
-	X[1]=s5[p][x[A4]*81+x[B5]*27+x[C6]*9+x[D7]*3+x[E8]];
-	X[2]=s5[p][x[E1]*81+x[D2]*27+x[C3]*9+x[B4]*3+x[A5]];
-	X[3]=s5[p][x[H4]*81+x[G5]*27+x[F6]*9+x[E7]*3+x[D8]];
-	X[4]=135;
+void eval_builder_get_d5_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s5[p][x[D1] * 81 + x[E2] * 27 + x[F3] * 9 + x[G4] * 3 + x[H5]];
+	X[1] = s5[p][x[A4] * 81 + x[B5] * 27 + x[C6] * 9 + x[D7] * 3 + x[E8]];
+	X[2] = s5[p][x[E1] * 81 + x[D2] * 27 + x[C3] * 9 + x[B4] * 3 + x[A5]];
+	X[3] = s5[p][x[H4] * 81 + x[G5] * 27 + x[F6] * 9 + x[E7] * 3 + x[D8]];
+	X[4] = 135;
 }
 
 /* d4 */
-void eval_builder_get_d4_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s4[p][x[D1]*27+x[C2]*9+x[B3]*3+x[A4]];
-	X[1]=s4[p][x[A5]*27+x[B6]*9+x[C7]*3+x[D8]];
-	X[2]=s4[p][x[E1]*27+x[F2]*9+x[G3]*3+x[H4]];
-	X[3]=s4[p][x[H5]*27+x[G6]*9+x[F7]*3+x[E8]];
-	X[4]=45;
+void eval_builder_get_d4_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s4[p][x[D1] * 27 + x[C2] * 9 + x[B3] * 3 + x[A4]];
+	X[1] = s4[p][x[A5] * 27 + x[B6] * 9 + x[C7] * 3 + x[D8]];
+	X[2] = s4[p][x[E1] * 27 + x[F2] * 9 + x[G3] * 3 + x[H4]];
+	X[3] = s4[p][x[H5] * 27 + x[G6] * 9 + x[F7] * 3 + x[E8]];
+	X[4] = 45;
 }
 
 /* d3 */
-void eval_builder_get_d3_features(const Board *b,int *X){
-	int p=b->player;
-	const char *x=b->square;
-	X[0]=s3[p][x[G2]*9+x[B3]*3+x[A4]];
-	X[1]=s3[p][x[B6]*9+x[C7]*3+x[D8]];
-	X[2]=s3[p][x[F2]*9+x[G3]*3+x[H4]];
-	X[3]=s3[p][x[G6]*9+x[F7]*3+x[E8]];
-	X[4]=18;
+void eval_builder_get_d3_features(const Board* b, int* X) {
+	int p = b->player;
+	const char* x = b->square;
+	X[0] = s3[p][x[G2] * 9 + x[B3] * 3 + x[A4]];
+	X[1] = s3[p][x[B6] * 9 + x[C7] * 3 + x[D8]];
+	X[2] = s3[p][x[F2] * 9 + x[G3] * 3 + x[H4]];
+	X[3] = s3[p][x[G6] * 9 + x[F7] * 3 + x[E8]];
+	X[4] = 18;
 }
 
 /* create a new EvalBuilder structure for 'edax' EvalBuilder */
 /*EvalBuilder *eval_builder_create_edax_v2(int n_games){
 	int vector_size[]={10206,3321,3321,3321,3321,3321,3321,1134,378,135,45,1};
 	int vector_times[]={4,4,4,4,4,4,2,4,4,4,4,1};
-	
+
 	eval_init();
-	eval_builder_set_features=eval_builder_edax_v2_get_features;	
+	eval_builder_set_features=eval_builder_edax_v2_get_features;
 	return eval_builder_create(12,vector_size,vector_times,43,n_games);
 }
 */
@@ -564,7 +1334,7 @@ void eval_builder_get_d3_features(const Board *b,int *X){
 /*EvalBuilder *eval_builder_create_edax(int n_games){
 	int vector_size[]={10206,29646,3321,3321,3321,3321,3321,1134,378,135,45,1};
 	int vector_times[]={4,4,4,4,4,4,2,4,4,4,4,1};
-	
+
 	eval_init();
 	eval_builder_set_features = eval_edax_get_packed_features;
 	return eval_builder_create(12, vector_size, vector_times, 43, n_games);
@@ -572,9 +1342,9 @@ void eval_builder_get_d3_features(const Board *b,int *X){
 */
 /* create a new EvalBuilder structure for 'edax' EvalBuilder */
 #if 0
-EvalBuilder *eval_builder_create_edax3b(int n_games){
-	int vector_size[]={10206,29646,29646,3321,3321,3321,3321,1134,378,135,45,1};
-	int vector_times[]={4,4,4,4,4,4,2,4,4,4,4,1};
+EvalBuilder* eval_builder_create_edax3b(int n_games) {
+	int vector_size[] = { 10206,29646,29646,3321,3321,3321,3321,1134,378,135,45,1 };
+	int vector_times[] = { 4,4,4,4,4,4,2,4,4,4,4,1 };
 
 	eval_init();
 	eval_builder_set_features = eval_edax3b_get_packed_features;
@@ -583,23 +1353,23 @@ EvalBuilder *eval_builder_create_edax3b(int n_games){
 #endif
 
 /* create a new EvalBuilder structure for 'edax' EvalBuilder */
-EvalBuilder *eval_builder_create_edax3c(int n_games){
-	int vector_size[]={10206,29889,29646,29646,3321,3321,3321,3321,1134,378,135,45,1};
-	int vector_times[]={4,4,4,4,4,4,4,2,4,4,4,4,1};
+EvalBuilder* eval_builder_create_edax3c(int n_games) {
+	int vector_size[] = { 10206,29889,29646,29646,3321,3321,3321,3321,1134,378,135,45,1 };
+	int vector_times[] = { 4,4,4,4,4,4,4,2,4,4,4,4,1 };
 
-	eval_init();
-	eval_builder_set_features = eval_edax_v3r1_get_packed_features;
+	// eval_init();
+	eval_builder_set_features = eval_edax_v3_get_packed_features;
 	return eval_builder_create(13, vector_size, vector_times, 47, n_games);
 }
 
-#if 1
+#if 0
 /* create a new EvalBuilder structure for 'edax' EvalBuilder */
 
-EvalBuilder *eval_builder_create_edax3d(int n_games){
-	int vector_size[]={10206,266814,266085,266085,3321,3321,3321,3321,1134,378,135,45,1};
-	int vector_times[]={4,4,4,4,4,4,4,2,4,4,4,4,1};
+EvalBuilder* eval_builder_create_edax3d(int n_games) {
+	int vector_size[] = { 10206,266814,266085,266085,3321,3321,3321,3321,1134,378,135,45,1 };
+	int vector_times[] = { 4,4,4,4,4,4,4,2,4,4,4,4,1 };
 
-	eval_init();
+	// eval_init();
 	eval_builder_set_features = eval_edax_v3r2_get_packed_features;
 	return eval_builder_create(13, vector_size, vector_times, 47, n_games);
 }
@@ -607,121 +1377,152 @@ EvalBuilder *eval_builder_create_edax3d(int n_games){
 
 /* create a new EvalBuilder structure for 'edax' EvalBuilder */
 #if 0
-EvalBuilder *eval_builder_create_edax3d(int n_games){
-	int vector_size[]={10206,266814,266085,3321,3321,3321,3321,1134,378,135,45,1};
-	int vector_times[]={4,4,4,4,4,4,2,4,4,4,4,1};
+EvalBuilder* eval_builder_create_edax3d(int n_games) {
+	int vector_size[] = { 10206,266814,266085,3321,3321,3321,3321,1134,378,135,45,1 };
+	int vector_times[] = { 4,4,4,4,4,4,2,4,4,4,4,1 };
 
-	eval_init();
+	// eval_init();
 	eval_builder_set_features = eval_edax_v3r3_get_packed_features;
 	return eval_builder_create(12, vector_size, vector_times, 43, n_games);
 }
 #endif
 
 /* create a new EvalBuilder structure for 'edax' EvalBuilder */
-EvalBuilder *eval_builder_create_logistello(int n_games){
-	int vector_size[]={10206,29646,59049,3321,3321,3321,3321,1134,378,135,45,1};
-	int vector_times[]={4,4,8,4,4,4,2,4,4,4,4,1};
+EvalBuilder* eval_builder_create_logistello(int n_games) {
+	int vector_size[] = { 10206,29646,59049,3321,3321,3321,3321,1134,378,135,45,1 };
+	int vector_times[] = { 4,4,8,4,4,4,2,4,4,4,4,1 };
 
-	eval_init();
-	eval_builder_set_features=eval_builder_logistello_get_features;
-	return eval_builder_create(12,vector_size,vector_times,47,n_games);
+	// eval_init();
+	eval_builder_set_features = eval_builder_logistello_get_features;
+	return eval_builder_create(12, vector_size, vector_times, 47, n_games);
 }
 
 /* create a new EvalBuilder structure for a single feature */
-EvalBuilder *eval_builder_create_feature(int n_games, int feature){
-	int vector_size[2]={3321,1};
-	int vector_times[]={4,1};
+EvalBuilder* eval_builder_create_feature(int n_games, int feature) {
+	int vector_size[2] = { 3321,1 };
+	int vector_times[] = { 4,1 };
 
-	eval_init();
-	switch(feature){
+	// eval_init();
+	switch (feature) {
 	case EVAL_CORNER3x3:
-		eval_builder_set_features=eval_builder_get_corner3x3_features;
-		vector_size[0]=10206;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_corner3x3_features;
+		vector_size[0] = 10206;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_CORNER5x2:
-		eval_builder_set_features=eval_builder_get_corner5x2_features;
-		vector_size[0]=59049;
-		vector_times[0]=8;
-		return eval_builder_create(2,vector_size,vector_times,9,n_games);
+		eval_builder_set_features = eval_builder_get_corner5x2_features;
+		vector_size[0] = 59049;
+		vector_times[0] = 8;
+		return eval_builder_create(2, vector_size, vector_times, 9, n_games);
 	case EVAL_EDGE:
-		eval_builder_set_features=eval_builder_get_edge_features;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_edge_features;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_EDGE_X:
-		eval_builder_set_features=eval_builder_get_edge_X_features;
-		vector_size[0]=29646;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_edge_X_features;
+		vector_size[0] = 29646;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_EDGE_C:
-		eval_builder_set_features=eval_builder_get_edge_C_features;
-		vector_size[0]=29646;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_edge_C_features;
+		vector_size[0] = 29646;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_EDGE_CX:
-		eval_builder_set_features=eval_builder_get_edge_CX_features;
-		vector_size[0]=266085;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_edge_CX_features;
+		vector_size[0] = 266085;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_EDGE_FG:
-		eval_builder_set_features=eval_builder_get_edge_FG_features;
-		vector_size[0]=266085;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_edge_FG_features;
+		vector_size[0] = 266085;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_ABFG:
-		eval_builder_set_features=eval_builder_get_ABFG_features;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_ABFG_features;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_CC:
-		eval_builder_set_features=eval_builder_get_CC_features;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_CC_features;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_AA:
-		eval_builder_set_features=eval_builder_get_AA_features;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_AA_features;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_BB:
-		eval_builder_set_features=eval_builder_get_BB_features;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_BB_features;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_D8:
-		eval_builder_set_features=eval_builder_get_d8_features;
-		vector_times[0]=2;
-		return eval_builder_create(2,vector_size,vector_times,3,n_games);
+		eval_builder_set_features = eval_builder_get_d8_features;
+		vector_times[0] = 2;
+		return eval_builder_create(2, vector_size, vector_times, 3, n_games);
 	case EVAL_D7:
-		eval_builder_set_features=eval_builder_get_d7_features;
-		vector_size[0]=1134;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_d7_features;
+		vector_size[0] = 1134;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_D6:
-		eval_builder_set_features=eval_builder_get_d6_features;
-		vector_size[0]=378;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_d6_features;
+		vector_size[0] = 378;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_D5:
-		eval_builder_set_features=eval_builder_get_d5_features;
-		vector_size[0]=135;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_d5_features;
+		vector_size[0] = 135;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_D4:
-		eval_builder_set_features=eval_builder_get_d4_features;
-		vector_size[0]=45;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_d4_features;
+		vector_size[0] = 45;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	case EVAL_D3:
-		eval_builder_set_features=eval_builder_get_d3_features;
-		vector_size[0]=18;
-		return eval_builder_create(2,vector_size,vector_times,5,n_games);
+		eval_builder_set_features = eval_builder_get_d3_features;
+		vector_size[0] = 18;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
+	case EVAL_ANGLE_X:
+		eval_builder_set_features = eval_builder_get_angle_X_features;
+		vector_size[0] = 29889;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
+	case EVAL_CORNER_BLOCK:
+		eval_builder_set_features = eval_builder_get_corner_block_features;
+		vector_size[0] = 29646;
+		return eval_builder_create(2, vector_size, vector_times, 5, n_games);
 	default:
-		/* oups... */
-		fprintf(stderr,"invalid feature %d !\n",feature);
+		/* oops... */
+		fprintf(stderr, "invalid feature %d !\n", feature);
 		exit(EXIT_FAILURE);
 	}
 }
 
+/* select feature type and create */
+EvalBuilder* eval_builder_select_feature(int n_games, int eval) {
+	switch (eval) {
+		/* case EVAL_EDAX:
+			return eval_builder_create_edax(n_games);
+		case EVAL_EDAX_3b:
+			return eval_builder_create_edax3b(n_games);  */
+		case EVAL_EDAX_3c:
+			return eval_builder_create_edax3c(n_games);
+		/* case EVAL_EDAX_3d:
+			return eval_builder_create_edax3d(n_games); */
+		case EVAL_AJAX:
+			fprintf(stderr, "NOT IMPLEMENTED YET\n");
+			exit(EXIT_FAILURE);
+		case EVAL_LOGISTELLO:
+			return eval_builder_create_logistello(n_games);
+		default:
+			return eval_builder_create_feature(n_games, eval);
+	}
+}
+
 /* build the features */
-void eval_builder_build_features(EvalBuilder *eval,Gamebase *base,int ply){
-	int n=base->n_games,i,I;
+void eval_builder_build_features(EvalBuilder* eval, Gamebase* base, int ply) {
+	int n = base->n_games, i, I;
 	Board b;
-	Game *g;
-
-	eval_builder_set_ply(eval,ply);
-	for (i=I=0;i<n;i++){
-		g=base->games+i;
-		if (game_get_board(g,ply,&b) && (!board_is_game_over(&b) || ply==60)){
-			if (b.player==BLACK) eval->score[I]=g->score*2-64;
-			else eval->score[I]=64-2*g->score;
-			eval_builder_set_features(&b,eval->feature[I]);
-			I++;
-		}
+	Game* g;
+
+	eval_builder_set_ply(eval, ply);
+	g = base->games;
+	for (i = I = 0; i < n; i++) {
+		if (ply > g->suboptimal_ply)
+			if (game_get_board(g, ply, &b) && (!board_is_game_over(&b) || ply == 60)) {
+				if (b.player == PBLACK) eval->score[I] = g->score;	// b - w
+				else eval->score[I] = -(g->score);	// w - b
+				eval_builder_set_features(&b, eval->feature[I]);
+				I++;
+			}
+		++g;
 	}
-	eval->n_games=I;
+	eval->n_games = I;
 }
 
 /* equalize */
@@ -741,43 +1542,41 @@ void eval_builder_equalize(EvalBuilder *eval,double *w){
 	}
 }
 
-/* count the features */
-void eval_builder_zero(EvalBuilder *eval, double *w, int *N, int N_min){
+/* zero frequency */
+void eval_builder_zero(EvalBuilder* eval, double* w, int* N, int N_min) {
 	int k;
-	const int K=eval->n_data;
-	
+	const int K = eval->n_data;
+
 	for (k = 0; k < K; k++) if (N[k] < N_min) w[k] = 0.0;
 }
 
 
 /* eval */
-void eval_builder_eval(EvalBuilder *eval, int ply, double *x, double *y){
-	const int I = eval->n_games, J=eval->n_features;
-	int i, j;
-	short *c = eval->data[ply];
-	int *f;
-	double score;
-	
-	for (i=0;i<I;i++){
-		f=eval->feature[i];
+void eval_builder_eval(EvalBuilder* eval, int ply, double* x, double* y) {
+	const int I = eval->n_games, J = eval->n_features;
+	int i, j, score;
+	short* c = eval->data[ply];
+	int* f;
+
+	for (i = 0; i < I; i++) {
+		f = eval->feature[i];
 		for (score = j = 0; j < J; j++) score += c[f[j]];
-		score = BOUND(score, -8191, 8191) / 128.0;
-		
-		x[i] = score;
+
+		x[i] = BOUND(score, -8191, 8191) / 128.0;
 		y[i] = eval->score[i];
 	}
 }
 
 /* count non zero coefficients */
-int eval_builder_count_features(EvalBuilder *eval,int ply){
+int eval_builder_count_features(EvalBuilder* eval, int ply) {
 	int i, j, k, n;
-	int I = eval->n_games, J = eval->n_features, K = eval->n_data;
-	int **x = eval->feature;
-	int *h = calloc(K, sizeof (int));
+	int* h = (int*)calloc(eval->n_data, sizeof(int));
 
-	for (i = 0; i < I; i++)
-	for (j = 0; j < J; j++) h[x[i][j]]++;
-	for (k = n = 0; k < K; k++) if (h[k]>0) n++;
+	for (i = 0; i < eval->n_games; i++)
+		for (j = 0; j < eval->n_features; j++)
+			h[eval->feature[i][j]]++;
+	for (k = n = 0; k < eval->n_data; k++)
+		if (h[k] > 0) n++;
 
 	free(h);
 
@@ -785,38 +1584,38 @@ int eval_builder_count_features(EvalBuilder *eval,int ply){
 }
 
 /* count non zero coefficients */
-int eval_builder_count_significant_coefficients(EvalBuilder *eval,int ply){
+int eval_builder_count_significant_coefficients(EvalBuilder* eval, int ply) {
 	int k, n;
 	int K = eval->n_data;
-	short *c = eval->data[ply];
-	
+	short* c = eval->data[ply];
+
 	for (k = n = 0; k < K; k++) if (c[k] != 0) n++;
 
 	return n;
 }
 
 /* count the features */
-void eval_builder_get_feature_frequency(EvalBuilder *eval, int *N){
+void eval_builder_get_feature_frequency(EvalBuilder* eval, int* N) {
 	int i, j, k;
-	const int I = eval->n_games, J = eval->n_features, K = eval->n_data;
-	int **x = eval->feature;
 
-	for (k = 0; k < K; k++) N[k] = 0;
-	for (i = 0; i < I; i++)
-	for (j = 0; j < J; j++) N[x[i][j]]++;
+	for (k = 0; k < eval->n_data; k++)
+		N[k] = 0;
+	for (i = 0; i < eval->n_games; i++)
+		for (j = 0; j < eval->n_features; j++)
+			N[eval->feature[i][j]]++;
 }
 
 /* get the weight coefficients */
-void eval_builder_get_coefficient(EvalBuilder *eval,double *w){
+void eval_builder_get_coefficient(EvalBuilder* eval, double* w) {
 	int k;
 	const int K = eval->n_data;
-	short *a = eval->coeff[0];
+	short* a = eval->coeff[0];
 
 	for (k = 0; k < K; k++) w[k] = a[k] / 128.0;
 }
 
 /* get the game scores */
-void eval_builder_get_score(EvalBuilder *eval, double *y){
+void eval_builder_get_score(EvalBuilder* eval, double* y) {
 	int i;
 	const int I = eval->n_games;
 
@@ -825,104 +1624,105 @@ void eval_builder_get_score(EvalBuilder *eval, double *y){
 }
 
 /* set the weight coefficients */
-void eval_builder_set_coefficient(EvalBuilder *eval,double *w){
+void eval_builder_set_coefficient(EvalBuilder* eval, double* w) {
 	int k;
-	const int K=eval->n_data;
-	short *a=eval->coeff[0];
+	const int K = eval->n_data;
+	short* a = eval->coeff[0];
 
-	for (k=0;k<K;k++) a[k]=(short)(128.0*w[k] + 0.5);
+	for (k = 0; k < K; k++) a[k] = (short)(128.0 * w[k] + 0.5);
 }
 
-/* compute error */
-double eval_builder_get_abs_error(EvalBuilder *eval, double *w, double *e){
+/* compute abs error */
+double eval_builder_get_abs_error(EvalBuilder* eval, double* w, double* e) {
 	int i, j, I = eval->n_games, J = eval->n_features;
 	double E = 0.0, score;
-	int **x = eval->feature;
-	char *y = eval->score;
-	
-	for (i = 0; i < I; i++){
+	int** x = eval->feature;
+	char* y = eval->score;
+
+	for (i = 0; i < I; i++) {
 		score = 0.0; for (j = 0; j < J; j++) score += w[x[i][j]];
 		e[i] = y[i] - BOUND(score, -64.0, 64.0);
 		E += fabs(e[i]);
 	}
 	E /= I;
-	
+
 	return E;
 }
 
-/* compute error gradient */
-void eval_builder_get_abs_error_gradient(EvalBuilder *eval,double *e,double *g,int *N,int N_min){
-	int i,j,k;
-	const int I=eval->n_games,J=eval->n_features,K=eval->n_data;
-	int **x=eval->feature;
-	
-	for (k = 0; k < K; k++) g[k]=0.0;
-	for (i = 0; i < I; i++){
-		if (e[i] < 0.0) for (j = 0; j < J; j++) g[x[i][j]] ++;
-		else if (e[i]>0.0) for (j = 0; j < J; j++) g[x[i][j]] --;
+/* compute abs error gradient */
+void eval_builder_get_abs_error_gradient(EvalBuilder* eval, double* e, double* g, int* N, int N_min) {
+	int i, j, k;
+	const int I = eval->n_games, J = eval->n_features, K = eval->n_data;
+	int** x = eval->feature;
+
+	for (k = 0; k < K; k++) g[k] = 0.0;
+	for (i = 0; i < I; i++) {
+		if (e[i] < 0.0) for (j = 0; j < J; j++) g[x[i][j]]++;
+		else if (e[i] > 0.0) for (j = 0; j < J; j++) g[x[i][j]]--;
 	}
-	if (N == NULL) for (k = 0; k < K; k++) g[k] *= 1.0 / I;
-	else 
+	if (N == NULL)
+		for (k = 0; k < K; k++) g[k] *= 1.0 / I;
+	else
 		for (k = 0; k < K; k++)
-			g[k] *= (N[k] < N_min ? 0.0 : (N[k] < 20 ? 0.05 : 1.0 / N[k]))/J;
+			g[k] *= (N[k] < N_min ? 0.0 : (N[k] < 20 ? 0.05 : 1.0 / N[k])) / J;
 }
 
-/* compute error */
-double eval_builder_get_squared_error(EvalBuilder *eval, double *w, double *e){
+/* compute squared error */
+double eval_builder_get_squared_error(EvalBuilder* eval, double* w, double* e) {
 	int i, j, I = eval->n_games, J = eval->n_features;
 	double E = 0.0, score;
-	int **x = eval->feature;
-	char *y = eval->score;
-	
-	for (i=0;i<I;i++){
+	int** x = eval->feature;
+	char* y = eval->score;
+
+	for (i = 0; i < I; i++) {
 		score = 0.0; for (j = 0; j < J; j++) score += w[x[i][j]];
 		e[i] = y[i] - BOUND(score, -64.0, 64.0);
 		E += e[i] * e[i];
 	}
 	E /= I;
-	
+
 	return E;
 }
 
-/* compute error gradient */
-void eval_builder_get_squared_error_gradient(EvalBuilder *eval, double *e, double *g, int *N, int N_min){
+/* compute squared error gradient */
+void eval_builder_get_squared_error_gradient(EvalBuilder* eval, double* e, double* g, int* N, int N_min) {
 	int i, j, k;
 	const int I = eval->n_games, J = eval->n_features, K = eval->n_data;
-	int **x = eval->feature;
+	int** x = eval->feature;
 
-	for (k = 0; k < K; k++) g[k]=0.0;
+	for (k = 0; k < K; k++) g[k] = 0.0;
 	for (i = 0; i < I; i++)
-	for (j = 0; j < J; j++) g[x[i][j]] -= e[i];
-	if (N==NULL) for (k=0;k<K;k++) g[k] *= 2.0/I;
-	else for (k=0;k<K;k++) g[k] *= (N[k]<N_min?0.0:(N[k]<20?0.1:2.0/N[k]))/J;
-}
-
-/* get the error for the weight w[k] + l *d[k] */
-double eval_builder_get_dir_squared_error(EvalBuilder *eval, double *w, double *d, double l){
-	int i,j,I=eval->n_games,J=eval->n_features;
-	double E=0.0, e;
-	int **x=eval->feature;
-	char *y=eval->score;
-	
-	for (i=0;i<I;i++){
+		for (j = 0; j < J; j++) g[x[i][j]] -= e[i];
+	if (N == NULL) for (k = 0; k < K; k++) g[k] *= 2.0 / I;
+	else for (k = 0; k < K; k++) g[k] *= (N[k] < N_min ? 0.0 : (N[k] < 20 ? 0.1 : 2.0 / N[k])) / J;
+}
+
+/* get the error for the weight w[k] + l * d[k] */
+double eval_builder_get_dir_squared_error(EvalBuilder* eval, double* w, double* d, double l) {
+	int i, j, I = eval->n_games, J = eval->n_features;
+	double E = 0.0, e;
+	int** x = eval->feature;
+	char* y = eval->score;
+
+	for (i = 0; i < I; i++) {
 		e = y[i];
 		for (j = 0; j < J; j++) e -= w[x[i][j]] + l * d[x[i][j]];
 		E += e * e;
 	}
 	E /= I;
-	
+
 	return E;
 }
 
 /* minimize the absolute error along the gradient direction */
-double eval_builder_minimize_dir_abs_error(EvalBuilder *eval,double *w, double *d){
-	const int I=eval->n_games, J=eval->n_features;
-	double *v = (double*)malloc(I*sizeof (double));   /* a vector */
-	int *x;
+double eval_builder_minimize_dir_abs_error(EvalBuilder* eval, double* w, double* d) {
+	const int I = eval->n_games, J = eval->n_features;
+	double* v = (double*)malloc(I * sizeof(double));   /* a vector */
+	int* x;
 	double a, b, l, s;
 	int i, j, n;
-	
-	for (i=n=0;i<I;i++){
+
+	for (i = n = 0; i < I; i++) {
 		x = eval->feature[i];
 		s = 0.0; for (j = 0; j < J; j++)	s += w[x[j]];
 		a = eval->score[i] - BOUND(s, -64.0, 64.0);
@@ -931,36 +1731,36 @@ double eval_builder_minimize_dir_abs_error(EvalBuilder *eval,double *w, double *
 	}
 	l = sl_median(v, n);
 	if (l <= 0.0) l = DBL_EPSILON; /* otherwise the algo is trapped */
-	
+
 	free(v);
-	
+
 	return l;
 }
 
-/* minimize the absolute error along the gradient direction */
-double eval_builder_minimize_dir_squared_error(EvalBuilder *eval,double *w, double *d){
-	const int I=eval->n_games, J=eval->n_features;
-	int *x;
+/* minimize the squared error along the gradient direction */
+double eval_builder_minimize_dir_squared_error(EvalBuilder* eval, double* w, double* d) {
+	const int I = eval->n_games, J = eval->n_features;
+	int* x;
 	double a, b, lambda, A, B, s;
 	int i, j, n;
-	
+
 	A = B = lambda = 0.0;
-	for (i = n = 0; i < I; i++){
+	for (i = n = 0; i < I; i++) {
 		x = eval->feature[i];
 		s = 0.0; for (j = 0; j < J; j++)	s += w[x[j]];
 		a = eval->score[i] - BOUND(s, -64.0, 64.0);
-		b = 0.0; for (j = 0; j < J; j++) b += d[x[j]];
+		b = 0.0; for (j = 0; j < J; j++)	b += d[x[j]];
 		A += a * b;
 		B += b * b;
 	}
 	if (B > 0.0)	lambda = A / B;
 	if (lambda <= 0.0) lambda = DBL_EPSILON; /* never 0 */
-	
+
 	return lambda;
 }
 
 /* minimize the error */
-double eval_builder_minimize_dir_squared_error_using_brent(EvalBuilder *eval,double *w, double *d, double accuracy){
+double eval_builder_minimize_dir_squared_error_using_brent(EvalBuilder* eval, double* w, double* d, double accuracy) {
 	int k, iter;
 	const int K = eval->n_data;
 	double e, e_u, e_v, e_w;
@@ -971,11 +1771,11 @@ double eval_builder_minimize_dir_squared_error_using_brent(EvalBuilder *eval,dou
 	int can_fail = 1;
 
 	/* check direction */
-	for (k = 0; k > K; k++){
+	for (k = 0; k > K; k++) {
 		if (d[k] != 0.0) break;
 	}
 	if (k == K) return 0.0;
-	
+
 	/* bracketting lambda (='l') */
 	l_a = 0.0; l_b = +10.0;
 
@@ -984,15 +1784,15 @@ double eval_builder_minimize_dir_squared_error_using_brent(EvalBuilder *eval,dou
 	e = e_w = e_v = eval_builder_get_dir_squared_error(eval, w, d, l);
 
 brent_start:
-	
+
 	f = g = 0.0;
-	for (iter = 0; iter<= MAX_ITER; iter++){
+	for (iter = 0; iter <= MAX_ITER; iter++) {
 		l_m = (l_a + l_b) * 0.5;
 		tolerance = accuracy * fabs(l) + 1e-10;
-		if (fabs(l - l_m) <= 2.0 * tolerance - 0.5 * (l_b - l_a)){
-			if (can_fail){
+		if (fabs(l - l_m) <= 2.0 * tolerance - 0.5 * (l_b - l_a)) {
+			if (can_fail) {
 				can_fail = 0;
-				if (l >= (10.0 - 4.0 * tolerance)){
+				if (l >= (10.0 - 4.0 * tolerance)) {
 					l_a = l - 2.0 * tolerance; l_b = 100.0;
 					l_w = l_v = l;
 					e_w = e_v = e;
@@ -1001,7 +1801,7 @@ double eval_builder_minimize_dir_squared_error_using_brent(EvalBuilder *eval,dou
 			}
 			break;
 		}
-		if (fabs(f) > tolerance){
+		if (fabs(f) > tolerance) {
 			r = (l - l_w) * (e - e_v);
 			q = (l - l_v) * (e - e_w);
 			p = (l - l_v) * q - (l - l_w) * r;
@@ -1009,126 +1809,137 @@ double eval_builder_minimize_dir_squared_error_using_brent(EvalBuilder *eval,dou
 			if (q > 0.0) p = -p; else q = -q;
 			r = f;
 			f = g;
-			if (fabs(p) > fabs( 0.5 *q * r) || p <= q * (l_a - l) || p >= q * (l_b - l)){
-				g = (f = (l >= l_m ? l_a - l : l_b - l))* N_GOLD;
-			} else {
+			if (fabs(p) > fabs(0.5 * q * r) || p <= q * (l_a - l) || p >= q * (l_b - l)) {
+				g = (f = (l >= l_m ? l_a - l : l_b - l)) * N_GOLD;
+			}
+			else {
 				g = p / q;
 				l_u = l + g;
-				if (l_u - l_a < 2.0 * tolerance || l_b - l_u < 2.0 * tolerance){
+				if (l_u - l_a < 2.0 * tolerance || l_b - l_u < 2.0 * tolerance) {
 					g = (l < l_m) ? tolerance : -tolerance;
 				}
 			}
-		} else {
+		}
+		else {
 			f = (l >= l_m) ? l_a - l : l_b - l;
 			g = f * N_GOLD;
 		}
-		if (fabs(g) >= tolerance){
+		if (fabs(g) >= tolerance) {
 			l_u = l + g;
-		} else { 
-			l_u = l + ((g > 0.0) ? tolerance : - tolerance);
+		}
+		else {
+			l_u = l + ((g > 0.0) ? tolerance : -tolerance);
 		}
 		e_u = eval_builder_get_dir_squared_error(eval, w, d, l_u);
-		if (e_u <= e){
-			if ( l_u >= l) l_a = l; else l_b = l;
+		if (e_u <= e) {
+			if (l_u >= l) l_a = l; else l_b = l;
 			l_v = l_w; l_w = l; l = l_u;
 			e_v = e_w; e_w = e; e = e_u;
-		} else {
+		}
+		else {
 			if (l_u < l)  l_a = l_u; else l_b = l_u;
-			if ( e_u <= e_w || l_w == l){
+			if (e_u <= e_w || l_w == l) {
 				l_v = l_w; l_w = l_u;
 				e_v = e_w; e_w = e_u;
-			} else if (e_u <= e_v || l_v == l || l_v == l_w){
+			}
+			else if (e_u <= e_v || l_v == l || l_v == l_w) {
 				l_v = l_u;
 				e_v = e_u;
 			}
 		}
 	}
-	
+
 	return l;
 }
 
 /* compute coefficient through conjugate_gradient */
-int eval_builder_conjugate_gradient(EvalBuilder *eval,int ply,EvalOption *option){
+int eval_builder_conjugate_gradient(EvalBuilder* eval, int ply, EvalOption* option) {
 	int k, iter, i;
-	const int I = eval->n_games,K = eval->n_data;
+	const int I = eval->n_games, K = eval->n_data;
 	double r1, r2, err1, err2, v, m;
 	double delta, max_delta = 0.0, mean_delta = 0.0; /* weights change */
 	double d_gamma, n_gamma, gamma, lambda;
-	double *w = (double*)malloc((K)*sizeof (double)); /* weights */
-	double *d = (double*)calloc((K),sizeof (double)); /* delta weights = xi*/
-	double *g = (double*)malloc((K)*sizeof (double)); /* g_i*/
-	double *h = (double*)malloc((K)*sizeof (double)); /* h_i*/
-	double *e = (double*)malloc(I*sizeof (double));   /* errors */
-	int *N = (int*)malloc((K)*sizeof (int));          /* frequencies */
+	double* w = (double*)calloc(K, sizeof(double)); /* weights */
+	double* d = (double*)calloc(K, sizeof(double)); /* delta weights = xi*/
+	double* g = (double*)calloc(K, sizeof(double)); /* g_i*/
+	double* h = (double*)calloc(K, sizeof(double)); /* h_i*/
+	double* e = (double*)malloc(I * sizeof(double));   /* errors */
+	int* N = (int*)malloc(K * sizeof(int));          /* frequencies */
 
 	eval_builder_get_coefficient(eval, w);
 	eval_builder_get_feature_frequency(eval, N);
-	
+
 	/* score variance */
 	eval_builder_get_score(eval, e);
-	if (option->error_type == EVAL_ABS_ERROR){
+	if (option->error_type == EVAL_ABS_ERROR) {
 		m = sl_median(e, I);
-		v = 0.0;	
-		for (i = 0; i < I; i++) 
+		v = 0.0;
+		for (i = 0; i < I; i++)
 			v += fabs(e[i] - m);
 		v /= I;
 		v *= v;
 		err1 = eval_builder_get_abs_error(eval, w, e);
-	} else{
+	}
+	else {
 		v = sl_variance(e, I);
 		err1 = sqrt(eval_builder_get_squared_error(eval, w, e));
 	}
 	r1 = 1.0 - (err1 * err1) / (v);
-	printf("%2d %4d %6.2f %6.3f %8.4f %12.8f %9.5f %9.5f\r", ply, 0, 0.0, 0.0, err1, r1, 0.0, 0.0);
+	printf("%2d %4d %6.2f %6.3f %8.4f %12.8f\r", ply, 0, 0.0, 0.0, err1, r1);
 	fflush(stdout);
 
-	for (iter = 1; iter <= option->max_iter; iter++){
+	for (iter = 1; iter <= option->max_iter; iter++) {
 		/* compute gradient */
-		if (option->error_type == EVAL_ABS_ERROR){
+		if (option->error_type == EVAL_ABS_ERROR) {
 			eval_builder_get_abs_error_gradient(eval, e, d, N, 3);
-		}else{
+		}
+		else {
 			eval_builder_get_squared_error_gradient(eval, e, d, N, 3);
 		}
 
 		/* compute conjugate direction */
-		if (iter == 1 || (option->restart_frequency && (iter % option->restart_frequency == 1))){
+		if (iter == 1 || (option->restart_frequency && (iter % option->restart_frequency == 1))) {
 			gamma = 0.0;
-		} else {
+		}
+		else {
 			n_gamma = d_gamma = 0.0;
-			if (option->minimization_algorithm == EVAL_POLAK_RIBIERE){
-				for (k = 0; k < K; k++){
+			if (option->minimization_algorithm == EVAL_POLAK_RIBIERE) {
+				for (k = 0; k < K; k++) {
 					d_gamma += g[k] * g[k];
 					n_gamma += (d[k] + g[k]) * d[k]; /* Polak Ribiere */
 				}
-			}else if (option->minimization_algorithm == EVAL_FLETCHER_REEVES){
-				for (k = 0; k < K; k++){
+			}
+			else if (option->minimization_algorithm == EVAL_FLETCHER_REEVES) {
+				for (k = 0; k < K; k++) {
 					d_gamma += g[k] * g[k];
 					n_gamma += d[k] * d[k]; /* Fletcher Reeves */
 				}
 			}
-			if (option->minimization_algorithm != EVAL_STEEPEST_DESCENT){
+			if (option->minimization_algorithm != EVAL_STEEPEST_DESCENT) {
 				if (d_gamma < DBL_EPSILON) break;
 				gamma = n_gamma / d_gamma;
-			}else {
+			}
+			else {
 				gamma = 0.0;
 			}
 		}
 
 		/* minimize along direction */
-		if (option->minimization_algorithm == EVAL_STEEPEST_DESCENT){
-			for (k = 0; k < K; k++){
+		if (option->minimization_algorithm == EVAL_STEEPEST_DESCENT) {
+			for (k = 0; k < K; k++) {
 				g[k] = -d[k] + option->beta * h[k];
 				d[k] = h[k] = option->alpha * g[k];
 			}
 			lambda = 1.0;
-		}else{
-			for (k = 0; k < K; k++){
+		}
+		else {
+			for (k = 0; k < K; k++) {
 				g[k] = -d[k];
 				d[k] = h[k] = g[k] + gamma * h[k];
 			}
-			if (option->error_type == EVAL_ABS_ERROR){
+			if (option->error_type == EVAL_ABS_ERROR) {
 				lambda = eval_builder_minimize_dir_abs_error(eval, w, d);
-			}else{
+			} else {
 				lambda = eval_builder_minimize_dir_squared_error(eval, w, d);
 			}
 		}
@@ -1136,7 +1947,7 @@ int eval_builder_conjugate_gradient(EvalBuilder *eval,int ply,EvalOption *option
 		/* update weights */
 		mean_delta = 0.0;
 		max_delta = 0.0;
-		for (k = 0; k < K; k++){
+		for (k = 0; k < K; k++) {
 			delta = d[k] * lambda;
 			w[k] += delta;
 			delta = fabs(delta);
@@ -1146,37 +1957,37 @@ int eval_builder_conjugate_gradient(EvalBuilder *eval,int ply,EvalOption *option
 		mean_delta /= K;
 
 		/* apply various regularisation methods */
-		if (option->equalize_frequency && (iter % option->equalize_frequency == 0)){
+		if (option->equalize_frequency && (iter % option->equalize_frequency == 0)) {
 			eval_builder_equalize(eval, w);
 		}
-		
-		if (option->zero_frequency && (iter % option->zero_frequency == 0)){
+
+		if (option->zero_frequency && (iter % option->zero_frequency == 0)) {
 			eval_builder_zero(eval, w, N, 3);
 		}
 
-		if (option->unbias_frequency && (iter % option->unbias_frequency == 0)){
-			if (option->error_type == EVAL_ABS_ERROR){
+		if (option->unbias_frequency && (iter % option->unbias_frequency == 0)) {
+			if (option->error_type == EVAL_ABS_ERROR) {
 				eval_builder_get_abs_error(eval, w, e);
-				w[K-1] += (m = sl_median(e,I));
-			}else{
-				eval_builder_get_abs_error(eval, w, e);
-				w[K-1] += (m = sl_mean(e,I));
+				w[K - 1] += sl_median(e, I);
+			} else {
+				eval_builder_get_squared_error(eval, w, e);
+				w[K - 1] += sl_mean(e, I);
 			}
 		}
-		
-		if (option->round_frequency && (iter % option->round_frequency == 0)){
+
+		if (option->round_frequency && (iter % option->round_frequency == 0)) {
 			eval_builder_set_coefficient(eval, w);
 			eval_builder_get_coefficient(eval, w);
 		}
 
 		/* compute and show error */
-		if (option->error_type == EVAL_ABS_ERROR){
+		if (option->error_type == EVAL_ABS_ERROR) {
 			err2 = eval_builder_get_abs_error(eval, w, e);
-		}else{
+		} else {
 			err2 = sqrt(eval_builder_get_squared_error(eval, w, e));
 		}
-		r2 = 1.0 - err2 * err2/ v;
-		printf("%2d  %4d %6.2f %6.3f %8.4f %12.8f %9.7f %9.7f   %10.8f \r", ply, iter, lambda, gamma, err2, r2, max_delta, mean_delta, fabs(err2-err1));
+		r2 = 1.0 - err2 * err2 / v;
+		printf("%2d %4d %6.2f %6.3f %8.4f %12.8f %9.7f %9.7f %11.8f\r", ply, iter, lambda, gamma, err2, r2, max_delta, mean_delta, fabs(err2 - err1));
 		fflush(stdout);
 		if ((iter > option->min_iter || ply < 2) && (fabs(err2 - err1) <= option->accuracy && fabs(max_delta) < 1000 * option->accuracy && fabs(mean_delta) <= 10 * option->accuracy))
 			break;
@@ -1185,21 +1996,22 @@ int eval_builder_conjugate_gradient(EvalBuilder *eval,int ply,EvalOption *option
 	putchar('\n');
 
 	/* apply various regularisation methods */
-	if (option->equalize_frequency){
+	if (option->equalize_frequency) {
 		eval_builder_equalize(eval, w);
 	}
-		
-	if (option->zero_frequency){
+
+	if (option->zero_frequency) {
 		eval_builder_zero(eval, w, N, 3);
 	}
 
-	if (option->unbias_frequency){
-		if (option->error_type == EVAL_ABS_ERROR){
-			eval_builder_get_abs_error(eval, w, e);
-			w[K-1] += (m = sl_median(e,I));
-		}else{
+	if (option->unbias_frequency) {
+		if (option->error_type == EVAL_ABS_ERROR) {
 			eval_builder_get_abs_error(eval, w, e);
-			w[K-1] += (m = sl_mean(e,I));
+			w[K - 1] += sl_median(e, I);
+		}
+		else {
+			eval_builder_get_squared_error(eval, w, e);
+			w[K - 1] += sl_mean(e, I);
 		}
 	}
 
@@ -1211,17 +2023,17 @@ int eval_builder_conjugate_gradient(EvalBuilder *eval,int ply,EvalOption *option
 	free(g);
 	free(d);
 	free(w);
-	
+
 	return iter;
 }
 
 /* compute the coefficients */
-void eval_builder_build(EvalBuilder *eval,Gamebase *base, EvalOption *option){
+void eval_builder_build(EvalBuilder* eval, Gamebase* base, EvalOption* option) {
 	int ply;
-	double t=-ul_clock_get_time();
+	time_t t = -time(NULL);
 
 	eval->build++;
-	eval->date=ul_clock_get_date();
+	eval->date = ul_clock_get_date();
 
 	printf("Settings:\n");
 	printf("accuracy = %g\n", option->accuracy);
@@ -1235,195 +2047,198 @@ void eval_builder_build(EvalBuilder *eval,Gamebase *base, EvalOption *option){
 	printf("error    = %d\n", option->error_type);
 	printf("algo     = %d\n", option->minimization_algorithm);
 
-	printf("ply iter  lambda gamma  error     r2           max_delta mean_delta err_delta\n");
-	for (ply=0;ply<=60;ply++){
-		eval_builder_build_features(eval,base,ply);
-		eval_builder_conjugate_gradient(eval,ply,option);
+	printf("ply iter lambda gamma  error     r2         max_delta mean_delta err_delta\n");
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_build_features(eval, base, ply);
+		eval_builder_conjugate_gradient(eval, ply, option);
 	}
-	t+=ul_clock_get_time();
-	printf("time = ");ul_clock_print_time(t,stdout);putchar('\n');
+	t += time(NULL);
+	printf("time = "); ul_clock_print_time(t, stdout); putchar('\n');
 }
 
 /* filter temporally (between plies) the coefficients */
-void eval_builder_temporal_filter(EvalBuilder *eval,Gamebase *base,int max_iter,double accuracy){
-	int i,j,k,n,iter;
-	int I=eval->n_games,J=eval->n_features,K=eval->n_data,N=eval->n_ply;
-	double *a,*a0,*aN,r;
-	int **x=eval->feature;
-	int **f,*F;
+void eval_builder_temporal_filter(EvalBuilder* eval, Gamebase* base, int max_iter, double accuracy) {
+	int i, j, k, n, iter;
+	int I = eval->n_games, J = eval->n_features, K = eval->n_data, N = eval->n_ply;
+	double* a, * a0, * aN, r;
+	int** x = eval->feature;
+	int** f, * F;
 	double c;
-	
+
 	eval->build++;
-	eval->date=ul_clock_get_date();
-	
+	eval->date = ul_clock_get_date();
+
 	/* frequencies */
 	printf("computing feature frequencies\n");
-	f=(int**)malloc(N*sizeof (int*));
-	F=(int*)calloc(K,sizeof (int));
-	for (n=0;n<N;n++){
-		printf("%5d/%d\r",n,N);fflush(stdout);
-		f[n]=(int*)calloc(K,sizeof (int));
-		eval_builder_build_features(eval,base,n);
-		for (i=0;i<I;i++)
-		for (j=0;j<J;j++) f[n][x[i][j]]++;
-		for (k=0;k<K;k++) F[k]+=f[n][k];
-	}
-	
+	f = (int**)malloc(N * sizeof(int*));
+	F = (int*)calloc(K, sizeof(int));
+	for (n = 0; n < N; n++) {
+		printf("%5d/%d\r", n, N); fflush(stdout);
+		f[n] = (int*)calloc(K, sizeof(int));
+		eval_builder_build_features(eval, base, n);
+		for (i = 0; i < I; i++)
+			for (j = 0; j < J; j++) f[n][x[i][j]]++;
+		for (k = 0; k < K; k++) F[k] += f[n][k];
+	}
+
 	/* filtering */
 	printf("filtering the data\n");
-	a=(double*)malloc(N*sizeof (double));
-	a0=(double*)malloc(N*sizeof (double));
-	aN=(double*)malloc(N*sizeof (double));
-	for (k=0;k<K-1;k++){
-		for (n=0;n<N;n++) a0[n]=aN[n]=(eval->data[n][k])/128.0;
-		if (F[k]==0) continue;
-		for (iter=0;iter<max_iter;iter++){
-			for (n=0;n<N;n++) a[n]=aN[n];
-			r=0.0;
-			for (n=1;n<N-1;n++){
-				c=sqrt((double)f[n][k]/F[k]);
-				aN[n]=c*a0[n]+(1.0-c)*(a[n-1]+a[n+1])*0.5;
-				r+=(aN[n]-a[n])*(aN[n]-a[n]);
+	a = (double*)malloc(N * sizeof(double));
+	a0 = (double*)malloc(N * sizeof(double));
+	aN = (double*)malloc(N * sizeof(double));
+	for (k = 0; k < K - 1; k++) {
+		for (n = 0; n < N; n++) a0[n] = aN[n] = (eval->data[n][k]) / 128.0;
+		if (F[k] == 0) continue;
+		for (iter = 0; iter < max_iter; iter++) {
+			for (n = 0; n < N; n++) a[n] = aN[n];
+			r = 0.0;
+			for (n = 1; n < N - 1; n++) {
+				c = sqrt((double)f[n][k] / F[k]);
+				aN[n] = c * a0[n] + (1.0 - c) * (a[n - 1] + a[n + 1]) * 0.5;
+				r += (aN[n] - a[n]) * (aN[n] - a[n]);
 			}
-			if (r<accuracy) break;
+			if (r < accuracy) break;
+		}
+		if (k % 100 == 0) {
+			printf("%8d/%d\r", k, K);
+			fflush(stdout);
 		}
-		if (k%100==0) printf("%8d/%d\r",k,K);fflush(stdout);
-		for (n=0;n<N;n++) eval->data[n][k]=(short)(aN[n]*128.0);
+		for (n = 0; n < N; n++) eval->data[n][k] = (short)(aN[n] * 128.0);
 	}
 	printf("\n\n");
 	free(a);
 	free(a0);
 	free(aN);
 	free(F);
-	for (n=0;n<N;n++) free(f[n]);
+	for (n = 0; n < N; n++) free(f[n]);
 	free(f);
 }
 
-void print_feature(int n,int i){
+void print_feature(int n, int i) {
 	int k;
-	char x[]="xo.";
-	
-	for (k=0;k<n;k++){
-		putchar(x[i%3]);
-		i/=3;
+	char x[] = "xo.";
+
+	for (k = 0; k < n; k++) {
+		putchar(x[i % 3]);
+		i /= 3;
 	}
 }
 
 /* compress a feature */
-void eval_builder_get_feature(int n,int offset,int *feature){
-	int *compress[]={NULL,NULL,NULL,s3[0],s4[0],s5[0],s6[0],s7[0],s8[0],c9[0],s10[0],c10[0],s12[0],s12[0]};
-	*feature=compress[n][*feature]+offset;
+void eval_builder_get_feature(int n, int offset, int* feature) {
+	int* compress[] = { NULL,NULL,NULL,s3[0],s4[0],s5[0],s6[0],s7[0],s8[0],c9[0],s10[0],c10[0],s12[0],s12[0] };
+	*feature = compress[n][*feature] + offset;
 }
 
 /* from one feature get 'n' sub features differing by a single disc */
-int MAX_P=3,MAX_L=12,MIN_SQUARE=3;
-void eval_builder_get_sub_features(int n,int offset,int feature,int **subfeature,int *P,int *L){
-	int k,p,l;
+int MAX_P = 3, MAX_L = 12, MIN_SQUARE = 3;
+void eval_builder_get_sub_features(int n, int offset, int feature, int** subfeature, int* P, int* L) {
+	int k, p, l;
 	int x[20];
-	int *compress[]={NULL,NULL,NULL,s3[0],s4[0],s5[0],s6[0],s7[0],s8[0],c9[0],s10[0],c10[0],s12[0],s12[0]};
+	int* compress[] = { NULL,NULL,NULL,s3[0],s4[0],s5[0],s6[0],s7[0],s8[0],c9[0],s10[0],c10[0],s12[0],s12[0] };
 
-	for (k=0;k<n;k++){
-		x[k]=feature%3;
-		feature/=3;
+	for (k = 0; k < n; k++) {
+		x[k] = feature % 3;
+		feature /= 3;
 	}
-	
-	*P=3;
-	*L=n;
-	for (l=0;l<*L;l++)
-	for (p=0;p<*P;p++){
-		subfeature[p][l]=0;
-		for (k=n-1;k>=0;k--){
-			subfeature[p][l]*=3;
-			subfeature[p][l]+=(k==l? p : x[k]);
+
+	*P = 3;
+	*L = n;
+	for (l = 0; l < *L; l++)
+		for (p = 0; p < *P; p++) {
+			subfeature[p][l] = 0;
+			for (k = n - 1; k >= 0; k--) {
+				subfeature[p][l] *= 3;
+				subfeature[p][l] += (k == l ? p : x[k]);
+			}
+			subfeature[p][l] = compress[n][subfeature[p][l]] + offset;
 		}
-		subfeature[p][l]=compress[n][subfeature[p][l]]+offset;
-	}
 }
 
-/*  filter temporally (between plies) the coefficients */
-void eval_builder_spatial_filter(EvalBuilder *eval,Gamebase *base,int max_iter,double accuracy){
-	int power_3[]={1,3,9,27,81,243,729,2187,6561,19683,59049,177147,531441};
-	int i,j,k,p,n,l,iter;
-	int I=eval->n_games,J=eval->n_features,K=eval->n_data,N=eval->n_ply;
-	int **x=eval->feature,***X;
-	int *f,*L,*P,*todo;
-	double W,*w,F,w0,w1,r,a;
+/*  filter spatially (between patterns) the coefficients */
+void eval_builder_spatial_filter(EvalBuilder* eval, Gamebase* base, int max_iter, double accuracy) {
+	int power_3[] = { 1,3,9,27,81,243,729,2187,6561,19683,59049,177147,531441 };
+	int i, j, k, p, n, l, iter;
+	int I = eval->n_games, J = eval->n_features, K = eval->n_data, N = eval->n_ply;
+	int** x = eval->feature, *** X;
+	int* f, * L, * P, * todo;
+	double W, * w, F, w0, w1, r, a;
 
 	eval->build++;
-	eval->date=ul_clock_get_date();
+	eval->date = ul_clock_get_date();
 
 	printf("computing parent features\n");
-	L=(int*)calloc(K,sizeof (int));
-	P=(int*)calloc(K,sizeof (int));
-	todo=(int*)calloc(K,sizeof (int));
-	f=(int*)malloc(K*sizeof (int));
-	w=(double*)malloc(K*sizeof (double));
-	X=(int***)malloc(K*sizeof (int**));
-	for (k=0;k<K;k++){
-		X[k]=(int**)malloc(MAX_P*sizeof (int*));
-		for (p=0;p<MAX_P;p++){
-			X[k][p]=(int*)malloc(MAX_L*sizeof (int));
-			for (l=0;l<MAX_L;l++) X[k][p][l]=0xffff;
+	L = (int*)calloc(K, sizeof(int));
+	P = (int*)calloc(K, sizeof(int));
+	todo = (int*)calloc(K, sizeof(int));
+	f = (int*)malloc(K * sizeof(int));
+	w = (double*)malloc(K * sizeof(double));
+	X = (int***)malloc(K * sizeof(int**));
+	for (k = 0; k < K; k++) {
+		X[k] = (int**)malloc(MAX_P * sizeof(int*));
+		for (p = 0; p < MAX_P; p++) {
+			X[k][p] = (int*)malloc(MAX_L * sizeof(int));
+			for (l = 0; l < MAX_L; l++) X[k][p][l] = 0xffff;
 		}
 	}
 
 	/* parent features */
-	for (i=0;i<eval->n_vectors;i++){
-		n=eval->vector_squares[i];
-		if (n<MIN_SQUARE) continue;
-		for (j=0;j<power_3[n];j++){
-			k=j;
-			eval_builder_get_feature(n,eval->vector_offset[i],&k);
-			eval_builder_get_sub_features(n,eval->vector_offset[i],j,X[k],P+k,L+k);
-			todo[k]=1;
+	for (i = 0; i < eval->n_vectors; i++) {
+		n = eval->vector_squares[i];
+		if (n < MIN_SQUARE) continue;
+		for (j = 0; j < power_3[n]; j++) {
+			k = j;
+			eval_builder_get_feature(n, eval->vector_offset[i], &k);
+			eval_builder_get_sub_features(n, eval->vector_offset[i], j, X[k], P + k, L + k);
+			todo[k] = 1;
 		}
 	}
 
 	/* filter */
 	printf("filtering\n");
-	for (n=0;n<N;n++){
-		printf("%5d/%d frequencies      \r",n,N);fflush(stdout);
-		eval_builder_build_features(eval,base,n);
-		for (k=0;k<K;k++) f[k] = 0;
-		for (i=0;i<I;i++)
-		for (j=0;j<J;j++) f[x[i][j]]++;
+	for (n = 0; n < N; n++) {
+		printf("%5d/%d frequencies      \r", n, N); fflush(stdout);
+		eval_builder_build_features(eval, base, n);
+		for (k = 0; k < K; k++) f[k] = 0;
+		for (i = 0; i < I; i++)
+			for (j = 0; j < J; j++) f[x[i][j]]++;
 
-		printf("%5d/%d weights          \r",n,N);fflush(stdout);
-		for (k=0;k<K;k++) w[k]=eval->data[n][k]/128.0;
+		printf("%5d/%d weights          \r", n, N); fflush(stdout);
+		for (k = 0; k < K; k++) w[k] = eval->data[n][k] / 128.0;
 
-		printf("%5d/%d filtering         \r",n,N);fflush(stdout);
-		for (iter=0;iter<max_iter;iter++){
-			r=0.0;
+		printf("%5d/%d filtering         \r", n, N); fflush(stdout);
+		for (iter = 0; iter < max_iter; iter++) {
+			r = 0.0;
 
-			for (k=0;k<K;k++){
+			for (k = 0; k < K; k++) {
 				if (!todo[k]) continue;
-				w0=eval->data[n][k]/128.0;
-
-				w1=0.0;
-				for (l=0;l<L[k];l++){
-					F=f[k];
-					W=w0*f[k];
-					for (p=0;p<P[k];p++){
-						if (X[k][p][l]!=k){
-							F+=f[X[k][p][l]];
-							W+=w[X[k][p][l]]*f[X[k][p][l]];
+				w0 = eval->data[n][k] / 128.0;
+
+				w1 = 0.0;
+				for (l = 0; l < L[k]; l++) {
+					F = f[k];
+					W = w0 * f[k];
+					for (p = 0; p < P[k]; p++) {
+						if (X[k][p][l] != k) {
+							F += f[X[k][p][l]];
+							W += w[X[k][p][l]] * f[X[k][p][l]];
 						}
 					}
-					if (F>0.0) w1+=W/(F*L[k]); else w1+=w0/L[k];
+					if (F > 0.0) w1 += W / (F * L[k]); else w1 += w0 / L[k];
 				}
-				a=f[k]/100.0;if (a>0.5) a=0.5;
-				w1=a*w0+(1.0-a)*w1;
-				r+=(w1-w[k])*(w1-w[k]);
-				w[k]=w1;
+				a = f[k] / 100.0; if (a > 0.5) a = 0.5;
+				w1 = a * w0 + (1.0 - a) * w1;
+				r += (w1 - w[k]) * (w1 - w[k]);
+				w[k] = w1;
 			}
-			printf("%5d/%d %3d %12.4f\r",n,N,iter,r);fflush(stdout);
-			if (r<accuracy) break;
+			printf("%5d/%d %3d %12.4f\r", n, N, iter, r); fflush(stdout);
+			if (r < accuracy) break;
 		}
-		for (k=0;k<K;k++) eval->data[n][k]=128.0*w[k];
+		for (k = 0; k < K; k++) eval->data[n][k] = 128.0 * w[k];
 	}
 
-	for (k=0;k<K;k++){
-		for (p=0;p<P[k];p++) free(X[k][p]);
+	for (k = 0; k < K; k++) {
+		for (p = 0; p < P[k]; p++) free(X[k][p]);
 		free(X[k]);
 	}
 	free(X);
@@ -1435,40 +2250,40 @@ void eval_builder_spatial_filter(EvalBuilder *eval,Gamebase *base,int max_iter,d
 }
 
 /* equalize */
-void eval_builder_equalize_all(EvalBuilder *eval){
+void eval_builder_equalize_all(EvalBuilder* eval) {
 	int ply;
-	const int K=eval->n_data;
-	double *w=(double*)malloc((K)*sizeof (double));	/* weights */
+	const int K = eval->n_data;
+	double* w = (double*)malloc((K) * sizeof(double));	/* weights */
 
 	printf("equalize\n");
-	for (ply=0;ply<=60;ply++){
-		eval_builder_set_ply(eval,ply);
-		eval_builder_get_coefficient(eval,w);
-		eval_builder_equalize(eval,w);
-		eval_builder_set_coefficient(eval,w);
-		printf("%5d/61\r",ply);
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_set_ply(eval, ply);
+		eval_builder_get_coefficient(eval, w);
+		eval_builder_equalize(eval, w);
+		eval_builder_set_coefficient(eval, w);
+		printf("%5d/61\r", ply);
 		fflush(stdout);
 	}
 
 	free(w);
 }
 
-/* equalize */
-void eval_builder_zero_rare_features(EvalBuilder *eval,Gamebase *base){
+/* zero */
+void eval_builder_zero_rare_features(EvalBuilder* eval, Gamebase* base) {
 	int ply;
-	const int K=eval->n_data;
-	double *w=(double*)malloc((K)*sizeof (double));	/* weights */
-	int *N=(int*)malloc((K)*sizeof (int));			/* frequencies */
+	const int K = eval->n_data;
+	double* w = (double*)malloc((K) * sizeof(double));	/* weights */
+	int* N = (int*)malloc((K) * sizeof(int));			/* frequencies */
 
 	printf("zero rare features\n");
-	for (ply=0;ply<=60;ply++){
-		eval_builder_set_ply(eval,ply);
-		eval_builder_build_features(eval,base,ply);
-		eval_builder_get_coefficient(eval,w);
-		eval_builder_get_feature_frequency(eval,N);
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_set_ply(eval, ply);
+		eval_builder_build_features(eval, base, ply);
+		eval_builder_get_coefficient(eval, w);
+		eval_builder_get_feature_frequency(eval, N);
 		eval_builder_zero(eval, w, N, 3);
-		eval_builder_set_coefficient(eval,w);
-		printf("%5d/61\r",ply);
+		eval_builder_set_coefficient(eval, w);
+		printf("%5d/61\r", ply);
 		fflush(stdout);
 	}
 
@@ -1477,30 +2292,38 @@ void eval_builder_zero_rare_features(EvalBuilder *eval,Gamebase *base){
 }
 
 /* merge */
-void eval_builder_merge(EvalBuilder *eval_1, EvalBuilder *eval_2, int split){
+void eval_builder_merge(EvalBuilder* eval_1, EvalBuilder* eval_2, int split0, int split1) {
 	int ply, k;
-	const int K=eval_1->n_data;
-	double *w1=(double*)malloc((K)*sizeof (double));	/* weights */
-	double *w2=(double*)malloc((K)*sizeof (double));	/* weights */
-
-	if (split == 0){
-		for (ply=0;ply<=60;ply++){
-			eval_builder_set_ply(eval_1,ply);
-			eval_builder_set_ply(eval_2,ply);
-			eval_builder_get_coefficient(eval_1,w1);
-			eval_builder_get_coefficient(eval_2,w2);
-			for (k = 0; k < K; k++) w1[k] = (w1[k] + w2[k])*0.5;
-			eval_builder_set_coefficient(eval_1,w1);
-			printf("%5d/60\r",ply);
+	double mix;
+	const int K = eval_1->n_data;
+	double* w1 = (double*)malloc((K) * sizeof(double));	/* weights */
+	double* w2 = (double*)malloc((K) * sizeof(double));	/* weights */
+
+	if (split0 == 0) {
+		for (ply = 0; ply <= 60; ply++) {
+			eval_builder_set_ply(eval_1, ply);
+			eval_builder_set_ply(eval_2, ply);
+			eval_builder_get_coefficient(eval_1, w1);
+			eval_builder_get_coefficient(eval_2, w2);
+			for (k = 0; k < K; k++) w1[k] = (w1[k] + w2[k]) * 0.5;
+			eval_builder_set_coefficient(eval_1, w1);
+			printf("%5d/60\r", ply);
 			fflush(stdout);
 		}
-	} else {
-		for (ply=split;ply<=60;ply++){
-			eval_builder_set_ply(eval_1,ply);		
-			eval_builder_set_ply(eval_2,ply);		
-			eval_builder_get_coefficient(eval_2,w2);
-			eval_builder_set_coefficient(eval_1,w2);
-			printf("%5d/60\r",ply);
+	}
+	else {
+		for (ply = split0; ply <= 60; ply++) {
+			eval_builder_set_ply(eval_1, ply);
+			eval_builder_set_ply(eval_2, ply);
+			eval_builder_get_coefficient(eval_2, w2);
+			if (ply < split1) {
+				eval_builder_get_coefficient(eval_1, w1);
+				mix = (double)(split1 - ply) / (double)(split1 - split0);
+				for (k = 0; k < K; k++)
+					w2[k] -= mix * (w2[k] - w1[k]);
+			}
+			eval_builder_set_coefficient(eval_1, w2);
+			printf("%5d/60\r", ply);
 			fflush(stdout);
 		}
 	}
@@ -1510,97 +2333,128 @@ void eval_builder_merge(EvalBuilder *eval_1, EvalBuilder *eval_2, int split){
 }
 
 /* remove the bias */
-void eval_builder_unbias(EvalBuilder *eval, Gamebase *base, int error_type){
-	double *e,*w=NULL,bias;
-	int ply,I,K=0;
-	
-	e=(double *)malloc(base->n_games*sizeof (double));
-	
+void eval_builder_unbias(EvalBuilder* eval, Gamebase* base, int error_type) {
+	double* e, * w = NULL, bias;
+	int ply, I, K = 0;
+
+	e = (double*)malloc(base->n_games * sizeof(double));
+
 	printf("correcting weight bias\n");
-	for (ply=0;ply<=60;ply++){
-		eval_builder_build_features(eval,base,ply);
-		I=eval->n_games;
-		if (w==NULL){
-			K=eval->n_data;
-			w=(double *)malloc(K*sizeof (double));
-		}
-		eval_builder_get_coefficient(eval,w);
-		if (error_type == EVAL_ABS_ERROR){
-			eval_builder_get_abs_error(eval,w,e);
-			w[K-1]+=(bias=sl_median(e,I));
-		} else {
-			eval_builder_get_squared_error(eval,w,e);
-			w[K-1]+=(bias=sl_mean(e,I));
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_build_features(eval, base, ply);
+		I = eval->n_games;
+		if (w == NULL) {
+			K = eval->n_data;
+			w = (double*)malloc(K * sizeof(double));
+		}
+		eval_builder_get_coefficient(eval, w);
+		if (error_type == EVAL_ABS_ERROR) {
+			eval_builder_get_abs_error(eval, w, e);
+			w[K - 1] += (bias = sl_median(e, I));
 		}
-		eval_builder_set_coefficient(eval,w);
-		printf("%5d/61 parity = %+6.2f (correction = %+6.2f)\r",ply,w[K-1],bias);
+		else {
+			eval_builder_get_squared_error(eval, w, e);
+			w[K - 1] += (bias = sl_mean(e, I));
+		}
+		eval_builder_set_coefficient(eval, w);
+		printf("%5d/61 parity = %+6.2f (correction = %+6.2f)\r", ply, w[K - 1], bias);
 		fflush(stdout);
-	}	
+	}
 	free(w);
 	free(e);
 }
 
 /* print some statisitics */
-void eval_builder_stat(EvalBuilder *eval,Gamebase *base){
-	double *x,*y,*e;
-	int i,ply,n;
-	
-	x=(double *)malloc(base->n_games*sizeof (double));
-	y=(double *)malloc(base->n_games*sizeof (double));
-	e=(double *)malloc(base->n_games*sizeof (double));
-
-	printf("n coeffs\teval mean\teval sdev\teval min\teval max\tscore mean\tscore sdev\tscore min\tscore max\ta\tb\tr\terror bias\terror sdev\terror min\terror max\n");
-	
-	for (ply=0;ply<=60;ply++){
-		eval_builder_build_features(eval,base,ply);		
-		eval_builder_eval(eval,ply,x,y);
-		n=eval->n_games;
-		for (i=0;i<n;i++) e[i]=y[i]-x[i];
-		printf("%6d\t",eval_builder_count_features(eval,ply));
-		printf("%6d\t",eval_builder_count_significant_coefficients(eval,ply));
-		printf("%5.2f\t",sl_mean(x,n));
-		printf("%5.2f\t",sl_standard_deviation(x,n));
-		printf("%5.2f\t",sl_min(x,n));
-		printf("%5.2f\t",sl_max(x,n));
-		printf("%5.2f\t",sl_mean(y,n));
-		printf("%5.2f\t",sl_standard_deviation(y,n));
-		printf("%3.0f\t",sl_min(y,n));
-		printf("%3.0f\t",sl_max(y,n));
-		printf("%7.4f\t",sl_regression_a(x,y,n));
-		printf("%7.4f\t",sl_regression_b(x,y,n));
-		printf("%7.4f\t",sl_correlation_r(x,y,n));
-		printf("%5.2f\t",sl_mean(e,n));
-		printf("%5.2f\t",sl_standard_deviation(e,n));
-		printf("%5.2f\t",sl_min(e,n));
-		printf("%5.2f\n",sl_max(e,n));
+void eval_builder_stat(EvalBuilder* eval, Gamebase* base) {
+	double* x, * y, * e;
+	int i, ply, n;
+
+	x = (double*)malloc(base->n_games * sizeof(double));
+	y = (double*)malloc(base->n_games * sizeof(double));
+	e = (double*)malloc(base->n_games * sizeof(double));
+
+	printf("  feat coeffs evmean evsdev  evmin  evmax scmean scsdev smin smax    a       b       r    erbias ersdev ermin  ermax\n");
+
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_build_features(eval, base, ply);
+		eval_builder_eval(eval, ply, x, y);
+		n = eval->n_games;
+		for (i = 0; i < n; i++) e[i] = y[i] - x[i];
+		printf("%6d", eval_builder_count_features(eval, ply));
+		printf("%7d", eval_builder_count_significant_coefficients(eval, ply));
+		printf("%7.2f", sl_mean(x, n));
+		printf("%7.2f", sl_standard_deviation(x, n));
+		printf("%7.2f", sl_min(x, n));
+		printf("%7.2f", sl_max(x, n));
+		printf("%7.2f", sl_mean(y, n));
+		printf("%7.2f", sl_standard_deviation(y, n));
+		printf("%5.0f", sl_min(y, n));
+		printf("%5.0f", sl_max(y, n));
+		printf("%8.4f", sl_regression_a(x, y, n));
+		printf("%8.4f", sl_regression_b(x, y, n));
+		printf("%8.4f", sl_correlation_r(x, y, n));
+		printf("%7.2f", sl_mean(e, n));
+		printf("%7.2f", sl_standard_deviation(e, n));
+		printf("%7.2f", sl_min(e, n));
+		printf("%7.2f\n", sl_max(e, n));
 		fflush(stdout);
-	}	
+	}
 	free(e);
 	free(y);
 	free(x);
 }
 
+/* print some statisitics */
+void eval_builder_evalgame(EvalBuilder* eval, Gamebase* base) {
+	int i, ply, n, s, v;
+	Board b;
+	Game *g = base->games;
+
+	printf("\nply");
+	for (n = 0; n < eval->n_features; n++)	printf("%6d", n);
+	printf("\n");
+	for (i = 0; i < base->n_games; i++) {
+		for (ply = 0; ply <= 60; ply++) {
+			eval_builder_set_ply(eval, ply);
+			if (ply > g->suboptimal_ply)
+				if (game_get_board(g, ply, &b) && (!board_is_game_over(&b) || ply == 60)) {
+					eval_builder_set_features(&b, eval->feature[i]);
+					printf("%3d", ply);
+					s = 0;
+					for (n = 0; n < eval->n_features; n++) {
+						v = eval->data[ply][eval->feature[i][n]];
+						s += v;
+						printf("%6.2f", v / 128.0);
+					}
+					printf("%6.2f\n", s / 128.0);
+				}
+		}
+		printf("\n");
+		++g;
+	}
+}
+
 /* diff */
-void eval_builder_diff(EvalBuilder *eval_1, EvalBuilder *eval_2){
+void eval_builder_diff(EvalBuilder* eval_1, EvalBuilder* eval_2) {
 	int ply, k, n;
-	const int K=eval_1->n_data;
-	double *w1=(double*)malloc((K)*sizeof (double));	/* weights */
-	double *w2=(double*)malloc((K)*sizeof (double));	/* weights */
-	double *d=(double*)malloc((K)*sizeof (double));	/* diff */
+	const int K = eval_1->n_data;
+	double* w1 = (double*)malloc((K) * sizeof(double));	/* weights */
+	double* w2 = (double*)malloc((K) * sizeof(double));	/* weights */
+	double* d = (double*)malloc((K) * sizeof(double));	/* diff */
 	double max_diff, min_diff, abs_diff, dev_diff, avg_diff, eps_diff;
 	double t_max_diff, t_min_diff, t_abs_diff, t_dev_diff, t_avg_diff, t_eps_diff;
-	int *histo,*t_histo = NULL;
+	int* histo, * t_histo = NULL;
 
 	t_avg_diff = t_abs_diff = t_dev_diff = t_min_diff = t_max_diff = t_eps_diff = 0;;
 
-	printf("ply\tmean\tabsmean\tdeviation\tmin\tmax\tabsmin\n");
-	for (ply=0;ply<=60;ply++){
-		eval_builder_set_ply(eval_1,ply);		
-		eval_builder_set_ply(eval_2,ply);		
-		eval_builder_get_coefficient(eval_1,w1);
-		eval_builder_get_coefficient(eval_2,w2);
-		for (k = n = 0; k < K; k++){
-		 	if (w1[k] != 0.0 && w2[k]!= 0.0) d[n++] = (w1[k] - w2[k]);
+	printf("ply\tmean\tabsmean\tdeviati\tmin\tmax\tabsmin\n");
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_set_ply(eval_1, ply);
+		eval_builder_set_ply(eval_2, ply);
+		eval_builder_get_coefficient(eval_1, w1);
+		eval_builder_get_coefficient(eval_2, w2);
+		for (k = n = 0; k < K; k++) {
+			if (w1[k] != 0.0 && w2[k] != 0.0) d[n++] = (w1[k] - w2[k]);
 		}
 		max_diff = sl_max(d, n);
 		min_diff = sl_min(d, n);
@@ -1609,21 +2463,22 @@ void eval_builder_diff(EvalBuilder *eval_1, EvalBuilder *eval_2){
 		for (k = 0; k < n; k++) d[k] = fabs(d[k]);
 		abs_diff = sl_mean(d, n);
 		eps_diff = sl_min(d, n);
-		printf("%3d\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\n",
-			ply,avg_diff,abs_diff,dev_diff,min_diff,max_diff,eps_diff);
+		printf("%3d\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\n",
+			ply, avg_diff, abs_diff, dev_diff, min_diff, max_diff, eps_diff);
 		fflush(stdout);
-		
+
 		t_avg_diff += avg_diff;
 		t_dev_diff += dev_diff;
 		t_abs_diff += abs_diff;
-		if (ply == 0){
+		if (ply == 0) {
 			t_histo = sl_histogram1(d, n, 0.0, 10.0, 100);
 			t_max_diff = max_diff;
 			t_min_diff = min_diff;
 			t_eps_diff = eps_diff;
-		}else{
+		}
+		else {
 			histo = sl_histogram1(d, n, 0.0, 10.0, 100);
-			for (k = 0; k < 100; k++) t_histo[k] += histo[k]; 
+			for (k = 0; k < 100; k++) t_histo[k] += histo[k];
 			free(histo);
 			if (eps_diff < t_eps_diff) t_eps_diff = eps_diff;
 			if (max_diff > t_max_diff) t_max_diff = max_diff;
@@ -1635,13 +2490,13 @@ void eval_builder_diff(EvalBuilder *eval_1, EvalBuilder *eval_2){
 	t_dev_diff /= ply;
 	t_abs_diff /= ply;
 	printf("------------------------------------------------------------\n");
-	printf("total\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\n",
-		t_avg_diff,t_abs_diff,t_dev_diff,t_min_diff,t_max_diff,t_eps_diff);
-		
-	if (t_histo != NULL){
+	printf("total\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\n",
+		t_avg_diff, t_abs_diff, t_dev_diff, t_min_diff, t_max_diff, t_eps_diff);
+
+	if (t_histo != NULL) {
 		printf("\na\tb\tn_diff\n");
-		for (k = 0; k < 100; k++){
-			printf("%4.1f\t%4.1f\t%8d\n", 0.1 * k, 0.1 * (k+1), t_histo[k]);
+		for (k = 0; k < 100; k++) {
+			printf("%4.1f\t%4.1f\t%7d\n", 0.1 * k, 0.1 * (k + 1), t_histo[k]);
 		}
 		free(t_histo);
 	}
@@ -1651,61 +2506,62 @@ void eval_builder_diff(EvalBuilder *eval_1, EvalBuilder *eval_2){
 	free(d);
 }
 
-/* diff */
-void eval_builder_plot(EvalBuilder *eval,Gamebase *base,const char *plot_file){
+/* plot */
+void eval_builder_plot(EvalBuilder* eval, Gamebase* base, const char* plot_file) {
 	int ply, i;
-	const int I=base->n_games;
-	double *x=(double*)malloc(I*sizeof (double));	/* score */
-	double *y=(double*)malloc(I*sizeof (double));	/* eval */
-	char file[256],title[64];
-	sl_Plot *plot;
-	sl_Point A={-64,-64},B={64,64},O={0,0};
-	sl_Point *X= (sl_Point *)malloc(I*sizeof (sl_Point));
-
-	for (ply=0;ply<=60;ply++){
-		eval_builder_build_features(eval,base,ply);		
-		eval_builder_eval(eval,ply,x,y);
-		for (i = 0; i < I; i++) X[i].x = x[i], X[i].y=y[i];
-		sprintf(file,"%s-%d.eps",plot_file,ply);
-		sprintf(title,"ply %d.eps",ply);
+	const int I = base->n_games;
+	double* x = (double*)malloc(I * sizeof(double));	/* score */
+	double* y = (double*)malloc(I * sizeof(double));	/* eval */
+	char file[256], title[64];
+	sl_Plot* plot;
+	sl_Point A = { -64,-64 }, B = { 64,64 }, O = { 0,0 };
+	sl_Point* X = (sl_Point*)malloc(I * sizeof(sl_Point));
+
+	for (ply = 0; ply <= 60; ply++) {
+		eval_builder_build_features(eval, base, ply);
+		eval_builder_eval(eval, ply, x, y);
+		for (i = 0; i < eval->n_games; i++) X[i].x = x[i], X[i].y = y[i];
+		sprintf(file, "%s-%d.eps", plot_file, ply);
+		sprintf(title, "ply %d.eps", ply);
 
 		plot = sl_plot_open(file);
-			sl_plot_titles(plot,"eval","score",title);
-			sl_plot_axis(plot,&A,&B,&O);
-			sl_plot_scatter(plot,X,I);
+		sl_plot_titles(plot, "eval", "score", title);
+		sl_plot_axis(plot, &A, &B, &O);
+		sl_plot_scatter(plot, X, eval->n_games);
 		sl_plot_close(plot);
-		
 	}
-	
+
 	free(x);
 	free(y);
 	free(X);
 }
 
-/* show weights of a feature*/
-void eval_builder_show_feature_weights(EvalBuilder *eval, int type, const char *feature){
-	int	i, k, n=eval->vector_squares[type], ply;
-	const int K=eval->n_data;
-	double *w=(double*)malloc((K)*sizeof (double));	/* weights */
+/* show weights of a feature */
+void eval_builder_show_feature_weights(EvalBuilder* eval, int type, const char* feature) {
+	int	i, k, n = eval->vector_squares[type], ply;
+	const int K = eval->n_data;
+	double* w = (double*)malloc((K) * sizeof(double));	/* weights */
 	double sum;
-	
-	printf("ply\t%s\n",feature);
-	if (strcmp(feature, "sum") == 0){
-		for (ply = 0; ply <= 60; ply++){
-			eval_builder_set_ply(eval,ply);
-			eval_builder_get_coefficient(eval,w);
+
+	printf("ply\t%s\n", feature);
+	if (strcmp(feature, "sum") == 0) {
+		for (ply = 0; ply <= 60; ply++) {
+			eval_builder_set_ply(eval, ply);
+			eval_builder_get_coefficient(eval, w);
 			sum = 0.0;
-			for (k = eval->vector_offset[type]; k < eval->vector_offset[type + 1]; k++){
+			for (k = eval->vector_offset[type]; k < eval->vector_offset[type + 1]; k++) {
 				sum += w[k];
 			}
-			printf("%3d\t%.4f\n",ply,sum/eval->vector_size[type]);
-		 }
-	}else{
-		if (n == 0 || strcmp(feature,"bias")==0){
+			printf("%3d\t%.4f\n", ply, sum / eval->vector_size[type]);
+		}
+	}
+	else {
+		if (n == 0 || strcmp(feature, "bias") == 0) {
 			k = K - 1;
-		} else {
-			for (i = k = 0; i < n; i++){
-				switch(tolower(feature[i])){
+		}
+		else {
+			for (i = k = 0; i < n; i++) {
+				switch (tolower(feature[i])) {
 				case 'o':
 					k = k * 3 + 0;
 					break;
@@ -1713,225 +2569,224 @@ void eval_builder_show_feature_weights(EvalBuilder *eval, int type, const char *
 					k = k * 3 + 1;
 					break;
 				default:
-					k = k * 3 + 2;		 
+					k = k * 3 + 2;
 					break;
 				}
 			}
 			eval_builder_get_feature(n, eval->vector_offset[type], &k);
 		}
-		for (ply = 0; ply <= 60; ply++){
-			eval_builder_set_ply(eval,ply);		
-			eval_builder_get_coefficient(eval,w);		
-			printf("%3d\t%.4f\n",ply,w[k]);
+		for (ply = 0; ply <= 60; ply++) {
+			eval_builder_set_ply(eval, ply);
+			eval_builder_get_coefficient(eval, w);
+			printf("%3d\t%.4f\n", ply, w[k]);
 		}
 	}
-	
-	
+
+
 	free(w);
 }
 
 /* print version */
-void print_version(void){
-	printf("eval_builder %d.%d %s\n",EDAX_VERSION,EDAX_RELEASE,__DATE__);
-	printf("Copyright (c) 1998-2000 Richard A. Delorme.\n");
-	printf("All Rights Reserved.\n\n");
+void print_version(void) {
+	printf(	"eval_builder %d.%d %s\n"
+		"Copyright (c) 1998-2000 Richard A. Delorme, 2023 Toshihiko Okuhara\n"
+		"All Rights Reserved.\n\n", EDAX_VERSION, EDAX_RELEASE, __DATE__);
 }
 
 /* print usage */
-void print_usage(void){
-	fprintf(stderr,"usage : eval_builder <command> <option> <parameters>\n");
-	fprintf(stderr,"options:\n");
-	fprintf(stderr,"  -tol <float>     set tolerated accuracy.\n");
-	fprintf(stderr,"  -max_iter <int>  set maximum tolerated iterations.\n");
-	fprintf(stderr,"  -min_iter <int>  set minimum tolerated iterations.\n");
-	fprintf(stderr,"  -algo <string>   set algorithm for minimisation:\n");
-	fprintf(stderr,"    simple         steepest descent (default)\n");
-	fprintf(stderr,"    fletcher       Fletcher-reeves conjugate gradient\n");
-	fprintf(stderr,"    polak          Polak-ribiere conjugate gradient\n");
-	fprintf(stderr,"  -error <string>  set error type for minimisation:\n");
-	fprintf(stderr,"    abs            absolute error\n");
-	fprintf(stderr,"    squared        squared_error\n");
-	fprintf(stderr,"  -eval <string>   evaluation function to compute\n");
-	fprintf(stderr,"    edax           edax evaluation function (default)\n");
-	fprintf(stderr,"    ajax           ajax evaluation function\n");
-	fprintf(stderr,"    logistello     logistello/zebra evaluation function\n");
-	fprintf(stderr,"    <feature>      a single feature, like corner3x3\n");
-	fprintf(stderr,"  -unbias <int>    unbias the evaluation function\n");
-	fprintf(stderr,"  -equalize <int>  equalize the evaluation function weight\n");
-	fprintf(stderr,"  -restart <int>   restart frequency\n");
-	fprintf(stderr,"  -round <int>     round frequency\n");
-	fprintf(stderr,"  -filter <string> filter the evaluation function weight first\n");
-	fprintf(stderr,"    spatial        filter from sub-configuration\n");
-	fprintf(stderr,"    temporal       filter through all plies\n");
-	fprintf(stderr,"  -split <int>     ply to split file before merging them\n");
-
-	fprintf(stderr,"commands:\n");
-	fprintf(stderr,"build <option> game_file [eval_file_in] eval_file_out\n");
-	fprintf(stderr,"process <option> game_file [eval_file_in] eval_file_out\n");
-	fprintf(stderr,"merge <option> eval_file1 eval_file2 eval_file_out\n");
-	fprintf(stderr,"stat <option> game_file eval_file\n");
-	fprintf(stderr,"diff <option> game_file eval_file\n");
-	fprintf(stderr,"plot <option> game_file eval_file plot_file\n");
-	fprintf(stderr,"show eval_file feature_type feature\n");
-	
+#ifdef _MSC_VER
+__declspec(noreturn)
+#endif
+void print_usage(void) {
+	fprintf(stderr,
+		"usage : eval_builder <command> <option> <parameters>\n"
+		"options:\n"
+		"  -tol <float>     set tolerated accuracy.\n"
+		"  -max_iter <int>  set maximum tolerated iterations.\n"
+		"  -min_iter <int>  set minimum tolerated iterations.\n"
+		"  -algo <string>   set algorithm for minimisation:\n"
+		"    simple         steepest descent (default)\n"
+		"    fletcher       Fletcher-reeves conjugate gradient\n"
+		"    polak          Polak-ribiere conjugate gradient\n"
+		"  -error <string>  set error type for minimisation:\n"
+		"    abs            absolute error\n"
+		"    squared        squared_error\n"
+		"  -eval <string>   evaluation function to compute\n"
+		"    edax           edax evaluation function (default)\n"
+		"    ajax           ajax evaluation function\n"
+		"    logistello     logistello/zebra evaluation function\n"
+		"  -feature <string>   a single feature\n"
+		"    corner3x3 corner5x2 edge edgeX edgeC edgeCX edgeFG\n"
+		"    ABFG CC BB AA D8 D7 D6 D5 D4 D3 angle+X corner+block\n"
+		"  -unbias <int>    unbias the evaluation function\n"
+		"  -equalize <int>  equalize the evaluation function weight\n"
+		"  -zero <int>      zero out rare features frequency\n"
+		"  -restart <int>   restart frequency\n"
+		"  -round <int>     round frequency\n"
+		"  -filter <string> filter the evaluation function weight first\n"
+		"    spatial        filter from sub-configuration\n"
+		"    temporal       filter through all plies\n"
+		"  -split <int>[,<int>]  ply to split file before merging them\n"
+		"  -minimax <int>   minimax game score up to n-th move\n"
+		"commands:\n"
+		"build <option> game_file [eval_file_in] eval_file_out\n"
+		"process <option> game_file [eval_file_in] eval_file_out\n"
+		"merge <option> eval_file1 eval_file2 eval_file_out\n"
+		"stat <option> game_file eval_file\n"
+		"diff <option> game_file eval_file\n"
+		"plot <option> game_file eval_file plot_file\n"
+		"show eval_file feature_type feature\n");
+
 	exit(EXIT_FAILURE);
 }
 
+/* parameter for eval/feature option */
+int get_eval_feature_option(const char *s) {
+	if (strcmp(s, "corner3x3") == 0) return EVAL_CORNER3x3;
+	else if (strcmp(s, "corner5x2") == 0) return EVAL_CORNER5x2;
+	else if (strcmp(s, "edge") == 0) return EVAL_EDGE;
+	else if (strcmp(s, "edgeX") == 0) return EVAL_EDGE_X;
+	else if (strcmp(s, "edgeC") == 0) return EVAL_EDGE_C;
+	else if (strcmp(s, "edgeCX") == 0) return EVAL_EDGE_CX;
+	else if (strcmp(s, "edgeFG") == 0) return EVAL_EDGE_FG;
+	else if (strcmp(s, "ABFG") == 0) return EVAL_ABFG;
+	else if (strcmp(s, "CC") == 0) return EVAL_CC;
+	else if (strcmp(s, "BB") == 0) return EVAL_BB;
+	else if (strcmp(s, "AA") == 0) return EVAL_AA;
+	else if (strcmp(s, "D8") == 0) return EVAL_D8;
+	else if (strcmp(s, "D7") == 0) return EVAL_D7;
+	else if (strcmp(s, "D6") == 0) return EVAL_D6;
+	else if (strcmp(s, "D5") == 0) return EVAL_D5;
+	else if (strcmp(s, "D4") == 0) return EVAL_D4;
+	else if (strcmp(s, "D3") == 0) return EVAL_D3;
+	else if (strcmp(s, "angle+X") == 0) return EVAL_ANGLE_X;
+	else if (strcmp(s, "corner+block") == 0) return EVAL_CORNER_BLOCK;
+	else print_usage();
+}
+
 /* main */
-int main(int argc,char **argv){
-	Gamebase *base;
-	EvalBuilder *eval_data, *eval_data_1, *eval_data_2;
-	EvalOption option= {
-		0,
-		1000,
-		0.0001,
-		0,
-		0,
-		0,
-		0,
-		50,
-		EVAL_STEEPEST_DESCENT,
-		EVAL_SQUARED_ERROR,
-		1.0,
-		0.1
+int main(int argc, char** argv) {
+	Gamebase* base;
+	EvalBuilder* eval_data, * eval_data_1, * eval_data_2;
+	EvalOption option = {
+		0,			// min_iter
+		1000,			// max_iter
+		0.0001,			// tol		accuracy
+		0,			// round	round_frequency
+		0,			// zero		zero_frequency
+		0,			// equalize	equalize_frequency
+		0,			// unbias	unbias_frequency
+		50,			// restart	restart_frequency
+		EVAL_STEEPEST_DESCENT,	// algo		minimization_algorithm
+		EVAL_SQUARED_ERROR,	// error	error_type
+		1.0,			// alpha
+		0.1,			// beta
+		0			// minimax	minimax_ply
 	};
 
 	int filter, eval;
-	int split;
+	int split0, split1;
 	int feature;
-	char *file_1, *file_2, *file_3;
+	char* file_1, * file_2, * file_3, *p;
 	int i;
-		
+
 	print_version();
-	if (argc < 4) print_usage();
-	
+	if (argc < 3) print_usage();
+	init_eval_packing();
+
 	filter = FILTER_NONE;
-	eval = EVAL_EDAX;
+	eval = EVAL_EDAX_3c;
 	file_1 = file_2 = file_3 = NULL;
-	split = feature = 0;
-	
-	for (i = 2; i < argc; i++){
-		if (strcmp(argv[i],"-tol")==0){
+	split0 = feature = 0;
+
+	for (i = 2; i < argc; i++) {
+		if (strcmp(argv[i], "-tol") == 0) {
 			option.accuracy = atof(argv[++i]);
-		}else if (strcmp(argv[i],"-max_iter")==0){
+		}
+		else if (strcmp(argv[i], "-max_iter") == 0) {
 			option.max_iter = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-min_iter")==0){
+		}
+		else if (strcmp(argv[i], "-min_iter") == 0) {
 			option.min_iter = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-round")==0){
+		}
+		else if (strcmp(argv[i], "-round") == 0) {
 			option.round_frequency = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-equalize")==0){
+		}
+		else if (strcmp(argv[i], "-equalize") == 0) {
 			option.equalize_frequency = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-zero")==0){
+		}
+		else if (strcmp(argv[i], "-zero") == 0) {
 			option.zero_frequency = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-unbias")==0){
+		}
+		else if (strcmp(argv[i], "-unbias") == 0) {
 			option.unbias_frequency = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-restart")==0){
+		}
+		else if (strcmp(argv[i], "-restart") == 0) {
 			option.restart_frequency = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-error")==0){
-			option.error_type = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-alpha")==0){
+		}
+		else if (strcmp(argv[i], "-alpha") == 0) {
 			option.alpha = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-beta")==0){
+		}
+		else if (strcmp(argv[i], "-beta") == 0) {
 			option.beta = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-algo")==0){
-			if (strcmp(argv[++i],"simple")==0) option.minimization_algorithm = EVAL_STEEPEST_DESCENT;
-			else if (strcmp(argv[i],"fletcher")==0) option.minimization_algorithm = EVAL_FLETCHER_REEVES;
-			else if (strcmp(argv[i],"polak")==0) option.minimization_algorithm = EVAL_POLAK_RIBIERE;
-			else print_usage();
-		}else if (strcmp(argv[i],"-error")==0){
-			if (strcmp(argv[++i],"abs")==0) option.error_type = EVAL_ABS_ERROR;
-			else if (strcmp(argv[i],"squared")==0) option.error_type = EVAL_SQUARED_ERROR;
+		}
+		else if (strcmp(argv[i], "-algo") == 0) {
+			if (strcmp(argv[++i], "simple") == 0) option.minimization_algorithm = EVAL_STEEPEST_DESCENT;
+			else if (strcmp(argv[i], "fletcher") == 0) option.minimization_algorithm = EVAL_FLETCHER_REEVES;
+			else if (strcmp(argv[i], "polak") == 0) option.minimization_algorithm = EVAL_POLAK_RIBIERE;
 			else print_usage();
-		}else if (strcmp(argv[i],"-eval")==0){
-			if (strcmp(argv[++i],"edax")==0) eval = EVAL_EDAX;
+		}
+		else if (strcmp(argv[i], "-error") == 0) {
+			if (strcmp(argv[++i], "abs") == 0) option.error_type = EVAL_ABS_ERROR;
+			else if (strcmp(argv[i], "squared") == 0) option.error_type = EVAL_SQUARED_ERROR;
+			else option.error_type = atoi(argv[i]);
+		}
+		else if (strcmp(argv[i], "-eval") == 0) {
+			/* if (strcmp(argv[++i], "edax") == 0) eval = EVAL_EDAX;
 			else if (strcmp(argv[i],"edax3b")==0) eval = EVAL_EDAX_3b;
-			else if (strcmp(argv[i],"edax3c")==0) eval = EVAL_EDAX_3c;
-			else if (strcmp(argv[i],"edax3d")==0) eval = EVAL_EDAX_3d;
-			else if (strcmp(argv[i],"ajax")==0) eval = EVAL_AJAX;
-			else if (strcmp(argv[i],"logistello")==0) eval = EVAL_LOGISTELLO;
-			else if (strcmp(argv[i],"corner3x3")==0) eval = EVAL_CORNER3x3;
-			else if (strcmp(argv[i],"corner5x2")==0) eval = EVAL_CORNER5x2;
-			else if (strcmp(argv[i],"edge")==0) eval = EVAL_EDGE;
-			else if (strcmp(argv[i],"edgeX")==0) eval = EVAL_EDGE_X;
-			else if (strcmp(argv[i],"edgeC")==0) eval = EVAL_EDGE_C;
-			else if (strcmp(argv[i],"edgeCX")==0) eval = EVAL_EDGE_CX;
-			else if (strcmp(argv[i],"edgeFG")==0) eval = EVAL_EDGE_FG;
-			else if (strcmp(argv[i],"ABFG")==0) eval = EVAL_ABFG;
-			else if (strcmp(argv[i],"CC")==0) eval = EVAL_CC;
-			else if (strcmp(argv[i],"BB")==0) eval = EVAL_BB;
-			else if (strcmp(argv[i],"AA")==0) eval = EVAL_AA;
-			else if (strcmp(argv[i],"D8")==0) eval = EVAL_D8;
-			else if (strcmp(argv[i],"D7")==0) eval = EVAL_D7;
-			else if (strcmp(argv[i],"D6")==0) eval = EVAL_D6;
-			else if (strcmp(argv[i],"D5")==0) eval = EVAL_D5;
-			else if (strcmp(argv[i],"D4")==0) eval = EVAL_D4;
-			else if (strcmp(argv[i],"D3")==0) eval = EVAL_D3;
-			else print_usage();
-		}else if (strcmp(argv[i],"-feature")==0){
-			if (strcmp(argv[++i],"corner3x3")==0) feature = EVAL_CORNER3x3;
-			else if (strcmp(argv[i],"corner5x2")==0) feature = EVAL_CORNER5x2;
-			else if (strcmp(argv[i],"edge")==0) feature = EVAL_EDGE;
-			else if (strcmp(argv[i],"edgeX")==0) feature = EVAL_EDGE_X;
-			else if (strcmp(argv[i],"edgeC")==0) feature = EVAL_EDGE_C;
-			else if (strcmp(argv[i],"edgeCX")==0) feature = EVAL_EDGE_CX;
-			else if (strcmp(argv[i],"edgeFG")==0) feature = EVAL_EDGE_FG;
-			else if (strcmp(argv[i],"ABFG")==0) feature = EVAL_ABFG;
-			else if (strcmp(argv[i],"CC")==0) feature = EVAL_CC;
-			else if (strcmp(argv[i],"BB")==0) feature = EVAL_BB;
-			else if (strcmp(argv[i],"AA")==0) feature = EVAL_AA;
-			else if (strcmp(argv[i],"D8")==0) feature = EVAL_D8;
-			else if (strcmp(argv[i],"D7")==0) feature = EVAL_D7;
-			else if (strcmp(argv[i],"D6")==0) feature = EVAL_D6;
-			else if (strcmp(argv[i],"D5")==0) feature = EVAL_D5;
-			else if (strcmp(argv[i],"D4")==0) feature = EVAL_D4;
-			else if (strcmp(argv[i],"D3")==0) feature = EVAL_D3;
-			else print_usage();
-		}else if (strcmp(argv[i],"-split")==0){
-			split = atoi(argv[++i]);
-		}else if (strcmp(argv[i],"-filter")==0){
-			if (strcmp(argv[++i],"spatial")==0) filter = FILTER_SPATIAL;
-			else if (strcmp(argv[i],"temporal")==0) filter = FILTER_TEMPORAL;
+			else */ if (strcmp(argv[i], "edax3c") == 0) eval = EVAL_EDAX_3c;
+			// else if (strcmp(argv[i],"edax3d")==0) eval = EVAL_EDAX_3d;
+			else if (strcmp(argv[i], "ajax") == 0) eval = EVAL_AJAX;
+			else if (strcmp(argv[i], "logistello") == 0) eval = EVAL_LOGISTELLO;
+			else eval = get_eval_feature_option(argv[i]);
+		}
+		else if (strcmp(argv[i], "-feature") == 0) {
+			feature = get_eval_feature_option(argv[++i]);
+		}
+		else if (strcmp(argv[i], "-split") == 0) {
+			split0 = split1 = atoi(argv[++i]);
+			if ((p = strchr(argv[i], ',')))
+				split1 = atoi(p + 1);
+		}
+		else if (strcmp(argv[i], "-filter") == 0) {
+			if (strcmp(argv[++i], "spatial") == 0) filter = FILTER_SPATIAL;
+			else if (strcmp(argv[i], "temporal") == 0) filter = FILTER_TEMPORAL;
 			else print_usage();
-		}else if (file_1 == NULL){
+		}
+		else if (strcmp(argv[i], "-minimax") == 0) {
+			option.minimax_ply = atoi(argv[++i]);
+		}
+		else if (file_1 == NULL) {
 			file_1 = argv[i];
-		}else if (file_2 == NULL){
+		}
+		else if (file_2 == NULL) {
 			file_2 = argv[i];
-		}else if (file_3 == NULL){
+		}
+		else if (file_3 == NULL) {
 			file_3 = argv[i];
-		}else print_usage();
+		}
+		else print_usage();
 	}
 
 	/* build the evaluation function */
-	if (strcmp(argv[1],"build")==0){
+	if (strcmp(argv[1], "build") == 0) {
 		if (file_1 == NULL || file_2 == NULL) print_usage();
 
 		base = gamebase_create(0);
-		gamebase_import(base, file_1);
-		printf("eval_builder : read %d games\n", base->n_games);
+		gamebase_import(base, file_1, option.minimax_ply);
+
+		eval_data = eval_builder_select_feature(base->n_games, eval);
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data = eval_builder_create_edax(base->n_games);
-			break;
-		case EVAL_EDAX_3b:
-			eval_data = eval_builder_create_edax3b(base->n_games);
-			break;
-*/		case EVAL_EDAX_3c:
-			eval_data = eval_builder_create_edax3c(base->n_games);
-			break;
-		case EVAL_EDAX_3d:
-			eval_data = eval_builder_create_edax3d(base->n_games);
-			break;
-		case EVAL_AJAX:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-		case EVAL_LOGISTELLO:
-			eval_data = eval_builder_create_logistello(base->n_games);
-			break;
-		default:
-			eval_data = eval_builder_create_feature(base->n_games, eval);
-			break;
-		}
 		if (file_3 != NULL)
 			eval_builder_read(eval_data, file_2);
 
@@ -1944,38 +2799,16 @@ int main(int argc,char **argv){
 	}
 
 	/* process */
-	else if (strcmp(argv[1],"process")==0){
+	else if (strcmp(argv[1], "process") == 0) {
 		if (file_1 == NULL || file_2 == NULL) print_usage();
 
 		base = gamebase_create(0);
-		gamebase_import(base, file_1);
-		printf("eval_builder : read %d games\n", base->n_games);
+		gamebase_import(base, file_1, option.minimax_ply);
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data = eval_builder_create_edax(base->n_games);
-			break;
-		case EVAL_EDAX_3b:
-			eval_data = eval_builder_create_edax3b(base->n_games);
-			break;
-*/		case EVAL_EDAX_3c:
-			eval_data = eval_builder_create_edax3c(base->n_games);
-			break;
-		case EVAL_EDAX_3d:
-			eval_data = eval_builder_create_edax3d(base->n_games);
-			break;
-		case EVAL_AJAX:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-		case EVAL_LOGISTELLO:
-			eval_data = eval_builder_create_logistello(base->n_games);
-			break;
-		default:
-			eval_data = eval_builder_create_feature(base->n_games, eval);
-			break;
-		}
-		if (file_3 != NULL)
-			eval_builder_read(eval_data, file_2);
+		eval_data = eval_builder_select_feature(base->n_games, eval);
+
+		// if (file_3 != NULL)
+		eval_builder_read(eval_data, file_2);
 
 		if (filter == FILTER_SPATIAL)
 			eval_builder_spatial_filter(eval_data, base, option.max_iter, option.accuracy);
@@ -1995,215 +2828,179 @@ int main(int argc,char **argv){
 	}
 
 	/* statistics */
-	else if (strcmp(argv[1],"stat")==0){
+	else if (strcmp(argv[1], "stat") == 0) {
 		if (file_1 == NULL || file_2 == NULL) print_usage();
 
 		base = gamebase_create(0);
-		gamebase_import(base, file_1);
-		printf("eval_builder : read %d games\n", base->n_games);
+		gamebase_import(base, file_1, option.minimax_ply);
+
+		eval_data = eval_builder_select_feature(base->n_games, eval);
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data = eval_builder_create_edax(base->n_games);
-			break;
-		case EVAL_EDAX_3b:
-			eval_data = eval_builder_create_edax3b(base->n_games);
-			break;
-*/		case EVAL_EDAX_3c:
-			eval_data = eval_builder_create_edax3c(base->n_games);
-			break;
-		case EVAL_EDAX_3d:
-			eval_data = eval_builder_create_edax3d(base->n_games);
-			break;
-		case EVAL_AJAX:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-		case EVAL_LOGISTELLO:
-			eval_data = eval_builder_create_logistello(base->n_games);
-			break;
-		default:
-			eval_data = eval_builder_create_feature(base->n_games, eval);
-			break;
-		}
 		eval_builder_read(eval_data, file_2);
 		eval_builder_stat(eval_data, base);
+	}
 
 	/* merge */
-	}else if (strcmp(argv[1],"merge")==0){
+	else if (strcmp(argv[1], "merge") == 0) {
 		if (file_1 == NULL || file_2 == NULL || file_3 == NULL) print_usage();
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data_1 = eval_builder_create_edax(1);
-			eval_data_2 = eval_builder_create_edax(1);
-			break;
-		case EVAL_EDAX_3b:
-			eval_data_1 = eval_builder_create_edax3b(1);
-			eval_data_2 = eval_builder_create_edax3b(1);
-			break;
-*/		case EVAL_EDAX_3c:
-			eval_data_1 = eval_builder_create_edax3c(1);
-			eval_data_2 = eval_builder_create_edax3c(1);
-			break;
-		case EVAL_EDAX_3d:
-			eval_data_1 = eval_builder_create_edax3d(1);
-			eval_data_2 = eval_builder_create_edax3d(1);
-			break;
-		case EVAL_AJAX:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-		case EVAL_LOGISTELLO:
-			eval_data_1 = eval_builder_create_logistello(1);
-			eval_data_2 = eval_builder_create_logistello(1);
-			break;
-		default:
-			eval_data_1 = eval_builder_create_feature(1, eval);
-			eval_data_2 = eval_builder_create_feature(1, eval);
-			break;
-		}
+		eval_data_1 = eval_builder_select_feature(1, eval);
+		eval_data_2 = eval_builder_select_feature(1, eval);
+
 		eval_builder_read(eval_data_1, file_1);
 		eval_builder_read(eval_data_2, file_2);
 
-		eval_builder_merge(eval_data_1, eval_data_2, split);
-
+		eval_builder_merge(eval_data_1, eval_data_2, split0, split1);
 		eval_builder_write(eval_data_1, file_3);
+	}
 
 	/* diff */
-	}else if (strcmp(argv[1],"diff")==0){
+	else if (strcmp(argv[1], "diff") == 0) {
 		if (file_1 == NULL || file_2 == NULL) print_usage();
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data_1 = eval_builder_create_edax(1);
-			eval_data_2 = eval_builder_create_edax(1);
-			break;
-		case EVAL_EDAX_3b:
-			eval_data_1 = eval_builder_create_edax3b(1);
-			eval_data_2 = eval_builder_create_edax3b(1);
-			break;
-*/		case EVAL_EDAX_3c:
-			eval_data_1 = eval_builder_create_edax3c(1);
-			eval_data_2 = eval_builder_create_edax3c(1);
-			break;
-		case EVAL_EDAX_3d:
-			eval_data_1 = eval_builder_create_edax3d(1);
-			eval_data_2 = eval_builder_create_edax3d(1);
-			break;
-		case EVAL_AJAX:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-		case EVAL_LOGISTELLO:
-			eval_data_1 = eval_builder_create_logistello(1);
-			eval_data_2 = eval_builder_create_logistello(1);
-			break;
-		default:
-			eval_data_1 = eval_builder_create_feature(1, eval);
-			eval_data_2 = eval_builder_create_feature(1, eval);
-			break;
-		}
+		eval_data_1 = eval_builder_select_feature(1, eval);
+		eval_data_2 = eval_builder_select_feature(1, eval);
+
 		eval_builder_read(eval_data_1, file_1);
 		eval_builder_read(eval_data_2, file_2);
 
 		eval_builder_diff(eval_data_1, eval_data_2);
+	}
 
 	/* plot */
-	}else if (strcmp(argv[1],"plot")==0){
+	else if (strcmp(argv[1], "plot") == 0) {
 		if (file_1 == NULL || file_2 == NULL || file_3 == NULL) print_usage();
 
 		base = gamebase_create(0);
-		gamebase_import(base, file_1);
-		printf("eval_builder : read %d games\n", base->n_games);
+		gamebase_import(base, file_1, option.minimax_ply);
+
+		eval_data = eval_builder_select_feature(base->n_games, eval);
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data = eval_builder_create_edax(base->n_games);
-			break;
-		case EVAL_EDAX_3b:
-			eval_data = eval_builder_create_edax3b(base->n_games);
-			break;
-*/		case EVAL_EDAX_3c:
-			eval_data = eval_builder_create_edax3c(base->n_games);
-			break;
-		case EVAL_EDAX_3d:
-			eval_data = eval_builder_create_edax3d(base->n_games);
-			break;
-		case EVAL_AJAX:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-		case EVAL_LOGISTELLO:
-			eval_data = eval_builder_create_logistello(base->n_games);
-			break;
-		default:
-			eval_data = eval_builder_create_feature(base->n_games, eval);
-			break;
-		}
 		eval_builder_read(eval_data, file_2);
 		eval_builder_plot(eval_data, base, file_3);
+	}
 
-	/* plot */
-	}else if (strcmp(argv[1],"show")==0){
+	/* show */
+	else if (strcmp(argv[1], "show") == 0) {
 		if (file_1 == NULL || file_2 == NULL) print_usage();
 
-		switch(eval){
-/*		case EVAL_EDAX:
-			eval_data = eval_builder_create_edax(1);
-			switch(feature){
-			case EVAL_CORNER3x3:
-				feature = 0;
-				break;
-			case EVAL_EDGE_X:
-				feature = 1;
-				break;
-			case EVAL_ABFG:
-				feature = 2;
-				break;
-			case EVAL_CC:
-				feature = 3;
-				break;
-			case EVAL_AA:
-				feature = 4;
-				break;
-			case EVAL_BB:
-				feature = 5;
-				break;
-			case EVAL_D8:
-				feature = 6;
-				break;
-			case EVAL_D7:
-				feature = 7;
-				break;
-			case EVAL_D6:
-				feature = 8;
-				break;
-			case EVAL_D5:
-				feature = 9;
+		switch (eval) {
+			/* case EVAL_EDAX:
+				eval_data = eval_builder_create_edax(1);
+				switch(feature){
+					case EVAL_CORNER3x3:
+						feature = 0;
+						break;
+					case EVAL_EDGE_X:
+						feature = 1;
+						break;
+					case EVAL_ABFG:
+						feature = 2;
+						break;
+					case EVAL_CC:
+						feature = 3;
+						break;
+					case EVAL_AA:
+						feature = 4;
+						break;
+					case EVAL_BB:
+						feature = 5;
+						break;
+					case EVAL_D8:
+						feature = 6;
+						break;
+					case EVAL_D7:
+						feature = 7;
+						break;
+					case EVAL_D6:
+						feature = 8;
+						break;
+					case EVAL_D5:
+						feature = 9;
+						break;
+					case EVAL_D4:
+						feature = 10;
+						break;
+					default:
+						feature = 11;
+						break;
+				}
 				break;
-			case EVAL_D4:
-				feature = 10;
+			case EVAL_EDAX_3b: */
+			case EVAL_EDAX_3c:
+				eval_data = eval_builder_create_edax3c(1);
+				switch(feature){
+					case EVAL_CORNER3x3:
+						feature = 0;
+						break;
+					case EVAL_ANGLE_X:
+						feature = 1;
+						break;
+					case EVAL_EDGE_X:
+						feature = 2;
+						break;
+					case EVAL_CORNER_BLOCK:
+						feature = 3;
+						break;
+					case EVAL_CC:
+						feature = 4;
+						break;
+					case EVAL_AA:
+						feature = 5;
+						break;
+					case EVAL_BB:
+						feature = 6;
+						break;
+					case EVAL_D8:
+						feature = 7;
+						break;
+					case EVAL_D7:
+						feature = 8;
+						break;
+					case EVAL_D6:
+						feature = 9;
+						break;
+					case EVAL_D5:
+						feature = 10;
+						break;
+					case EVAL_D4:
+						feature = 11;
+						break;
+					default:
+						feature = 12;
+						break;
+				}
 				break;
+			// case EVAL_EDAX_3d:
+			case EVAL_AJAX:
+			case EVAL_LOGISTELLO:
 			default:
-				feature = 11;
+				fprintf(stderr, "NOT IMPLEMENTED YET\n");
+				exit(EXIT_FAILURE);
 				break;
-			}
-			break;
-*/		case EVAL_EDAX_3b:
-		case EVAL_EDAX_3c:
-		case EVAL_EDAX_3d:
-		case EVAL_AJAX:
-		case EVAL_LOGISTELLO:
-		default:
-			fprintf(stderr,"NOT IMPLEMENTED YET\n");
-			exit(EXIT_FAILURE);
-			break;
 		}
-		if (eval_data != NULL){
+		if (eval_data != NULL) {
 			eval_builder_read(eval_data, file_1);
 			printf("[%d] : %s\n", feature, file_2);
 			eval_builder_show_feature_weights(eval_data, feature, file_2);
 		}
+	}
+
+	/* evalgame */
+	else if (strcmp(argv[1], "evalgame") == 0) {
+		if (file_1 == NULL || file_2 == NULL) print_usage();
+
+		base = gamebase_create(0);
+		gamebase_import(base, file_1, option.minimax_ply);
+
+		eval_data = eval_builder_select_feature(base->n_games, eval);
+
+		eval_builder_read(eval_data, file_2);
+		eval_builder_evalgame(eval_data, base);
+	}
 
 	/* print usage */
-	}else{
+	else {
 		print_usage();
 	}
 
diff --git a/src/eval_sse.c b/src/eval_sse.c
new file mode 100644
index 00000000..46814361
--- /dev/null
+++ b/src/eval_sse.c
@@ -0,0 +1,262 @@
+/**
+ * @file eval_sse.c
+ *
+ * SSE/AVX translation of some eval.c functions
+ *
+ * @date 2018 - 2023
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include <assert.h>
+
+#include "bit_intrinsics.h"
+#include "board.h"
+#include "move.h"
+#include "eval.h"
+
+extern const EVAL_FEATURE_V EVAL_FEATURE[65];
+extern const EVAL_FEATURE_V EVAL_FEATURE_all_opponent;
+
+#ifdef __ARM_NEON
+#define __m128i		int16x8_t
+#define	_mm_add_epi16	vaddq_s16
+#define _mm_sub_epi16	vsubq_s16
+#define _mm_slli_epi16	vshlq_n_s16
+#endif
+
+#if defined(hasSSE2) || defined(__ARM_NEON) || defined(USE_MSVC_X86)
+
+void eval_update_sse(int x, unsigned long long f, Eval *eval_out, const Eval *eval_in)
+{
+  #ifdef __AVX2__
+	__m256i	f0 = eval_in->feature.v16[0];
+	__m256i	f1 = eval_in->feature.v16[1];
+	__m256i	f2 = eval_in->feature.v16[2];
+
+	if (eval_in->n_empties & 1) {
+		f0 = _mm256_sub_epi16(f0, EVAL_FEATURE[x].v16[0]);
+		f1 = _mm256_sub_epi16(f1, EVAL_FEATURE[x].v16[1]);
+		f2 = _mm256_sub_epi16(f2, EVAL_FEATURE[x].v16[2]);
+
+		foreach_bit (x, f) {
+			f0 = _mm256_add_epi16(f0, EVAL_FEATURE[x].v16[0]);
+			f1 = _mm256_add_epi16(f1, EVAL_FEATURE[x].v16[1]);
+			f2 = _mm256_add_epi16(f2, EVAL_FEATURE[x].v16[2]);
+		}
+
+	} else {
+		f0 = _mm256_sub_epi16(f0, _mm256_slli_epi16(EVAL_FEATURE[x].v16[0], 1));
+		f1 = _mm256_sub_epi16(f1, _mm256_slli_epi16(EVAL_FEATURE[x].v16[1], 1));
+		f2 = _mm256_sub_epi16(f2, _mm256_slli_epi16(EVAL_FEATURE[x].v16[2], 1));
+
+		foreach_bit (x, f) {
+			f0 = _mm256_sub_epi16(f0, EVAL_FEATURE[x].v16[0]);
+			f1 = _mm256_sub_epi16(f1, EVAL_FEATURE[x].v16[1]);
+			f2 = _mm256_sub_epi16(f2, EVAL_FEATURE[x].v16[2]);
+		}
+	}
+
+	eval_out->feature.v16[0] = f0;
+	eval_out->feature.v16[1] = f1;
+	eval_out->feature.v16[2] = f2;
+
+  #else
+	__m128i	f0 = eval_in->feature.v8[0];
+	__m128i	f1 = eval_in->feature.v8[1];
+	__m128i	f2 = eval_in->feature.v8[2];
+	__m128i	f3 = eval_in->feature.v8[3];
+	__m128i	f4 = eval_in->feature.v8[4];
+	__m128i	f5 = eval_in->feature.v8[5];
+
+	if (eval_in->n_empties & 1) {
+		f0 = _mm_sub_epi16(f0, EVAL_FEATURE[x].v8[0]);
+		f1 = _mm_sub_epi16(f1, EVAL_FEATURE[x].v8[1]);
+		f2 = _mm_sub_epi16(f2, EVAL_FEATURE[x].v8[2]);
+		f3 = _mm_sub_epi16(f3, EVAL_FEATURE[x].v8[3]);
+		f4 = _mm_sub_epi16(f4, EVAL_FEATURE[x].v8[4]);
+		f5 = _mm_sub_epi16(f5, EVAL_FEATURE[x].v8[5]);
+
+		foreach_bit (x, f) {
+			f0 = _mm_add_epi16(f0, EVAL_FEATURE[x].v8[0]);
+			f1 = _mm_add_epi16(f1, EVAL_FEATURE[x].v8[1]);
+			f2 = _mm_add_epi16(f2, EVAL_FEATURE[x].v8[2]);
+			f3 = _mm_add_epi16(f3, EVAL_FEATURE[x].v8[3]);
+			f4 = _mm_add_epi16(f4, EVAL_FEATURE[x].v8[4]);
+			f5 = _mm_add_epi16(f5, EVAL_FEATURE[x].v8[5]);
+		}
+
+	} else {
+		f0 = _mm_sub_epi16(f0, _mm_slli_epi16(EVAL_FEATURE[x].v8[0], 1));
+		f1 = _mm_sub_epi16(f1, _mm_slli_epi16(EVAL_FEATURE[x].v8[1], 1));
+		f2 = _mm_sub_epi16(f2, _mm_slli_epi16(EVAL_FEATURE[x].v8[2], 1));
+		f3 = _mm_sub_epi16(f3, _mm_slli_epi16(EVAL_FEATURE[x].v8[3], 1));
+		f4 = _mm_sub_epi16(f4, _mm_slli_epi16(EVAL_FEATURE[x].v8[4], 1));
+		f5 = _mm_sub_epi16(f5, _mm_slli_epi16(EVAL_FEATURE[x].v8[5], 1));
+
+		foreach_bit (x, f) {
+			f0 = _mm_sub_epi16(f0, EVAL_FEATURE[x].v8[0]);
+			f1 = _mm_sub_epi16(f1, EVAL_FEATURE[x].v8[1]);
+			f2 = _mm_sub_epi16(f2, EVAL_FEATURE[x].v8[2]);
+			f3 = _mm_sub_epi16(f3, EVAL_FEATURE[x].v8[3]);
+			f4 = _mm_sub_epi16(f4, EVAL_FEATURE[x].v8[4]);
+			f5 = _mm_sub_epi16(f5, EVAL_FEATURE[x].v8[5]);
+		}
+	}
+
+	eval_out->feature.v8[0] = f0;
+	eval_out->feature.v8[1] = f1;
+	eval_out->feature.v8[2] = f2;
+	eval_out->feature.v8[3] = f3;
+	eval_out->feature.v8[4] = f4;
+	eval_out->feature.v8[5] = f5;
+  #endif
+}
+
+#else	// SSE dispatch (Eval may not be aligned)
+
+void eval_update_sse(int x, unsigned long long f, Eval *eval_out, const Eval *eval_in)
+{
+	__asm__ (
+		"movdqu	%0, %%xmm2\n\t"
+		"movdqu	%1, %%xmm3\n\t"
+		"movdqu	%2, %%xmm4\n\t"
+		"movdqu	%3, %%xmm5\n\t"
+		"movdqu	%4, %%xmm6\n\t"
+		"movdqu	%5, %%xmm7"
+	: :  "m" (eval_in->feature.us[0]), "m" (eval_in->feature.us[8]),  "m" (eval_in->feature.us[16]),
+	"m" (eval_in->feature.us[24]), "m" (eval_in->feature.us[32]), "m" (eval_in->feature.us[40]));
+
+	if (eval_in->n_empties & 1) {
+		__asm__ (
+			"psubw	%0, %%xmm2\n\t"
+			"psubw	%1, %%xmm3\n\t"
+			"psubw	%2, %%xmm4\n\t"
+			"psubw	%3, %%xmm5\n\t"
+			"psubw	%4, %%xmm6\n\t"
+			"psubw	%5, %%xmm7"
+		: :  "m" (EVAL_FEATURE[x].us[0]), "m" (EVAL_FEATURE[x].us[8]), "m" (EVAL_FEATURE[x].us[16]),
+		"m" (EVAL_FEATURE[x].us[24]), "m" (EVAL_FEATURE[x].us[32]), "m" (EVAL_FEATURE[x].us[40]));
+
+		foreach_bit (x, f) {
+			__asm__ (
+				"paddw	%0, %%xmm2\n\t"
+				"paddw	%1, %%xmm3\n\t"
+				"paddw	%2, %%xmm4\n\t"
+				"paddw	%3, %%xmm5\n\t"
+				"paddw	%4, %%xmm6\n\t"
+				"paddw	%5, %%xmm7"
+			: :  "m" (EVAL_FEATURE[x].us[0]), "m" (EVAL_FEATURE[x].us[8]), "m" (EVAL_FEATURE[x].us[16]),
+			"m" (EVAL_FEATURE[x].us[24]), "m" (EVAL_FEATURE[x].us[32]), "m" (EVAL_FEATURE[x].us[40]));
+		}
+
+	} else {
+		__asm__ (
+			"movdqa	%0, %%xmm0\n\t"		"movdqa	%1, %%xmm1\n\t"
+			"psllw	$1, %%xmm0\n\t"		"psllw	$1, %%xmm1\n\t"
+			"psubw	%%xmm0, %%xmm2\n\t"	"psubw	%%xmm1, %%xmm3\n\t"
+			"movdqa	%2, %%xmm0\n\t"		"movdqa	%3, %%xmm1\n\t"
+			"psllw	$1, %%xmm0\n\t"		"psllw	$1, %%xmm1\n\t"
+			"psubw	%%xmm0, %%xmm4\n\t"	"psubw	%%xmm1, %%xmm5\n\t"
+			"movdqa	%4, %%xmm0\n\t"		"movdqa	%5, %%xmm1\n\t"
+			"psllw	$1, %%xmm0\n\t"		"psllw	$1, %%xmm1\n\t"
+			"psubw	%%xmm0, %%xmm6\n\t"	"psubw	%%xmm1, %%xmm7"
+		: :  "m" (EVAL_FEATURE[x].us[0]), "m" (EVAL_FEATURE[x].us[8]), "m" (EVAL_FEATURE[x].us[16]),
+		"m" (EVAL_FEATURE[x].us[24]), "m" (EVAL_FEATURE[x].us[32]), "m" (EVAL_FEATURE[x].us[40]));
+
+		foreach_bit (x, f) {
+			__asm__ (
+				"psubw	%0, %%xmm2\n\t"
+				"psubw	%1, %%xmm3\n\t"
+				"psubw	%2, %%xmm4\n\t"
+				"psubw	%3, %%xmm5\n\t"
+				"psubw	%4, %%xmm6\n\t"
+				"psubw	%5, %%xmm7"
+			: :  "m" (EVAL_FEATURE[x].us[0]), "m" (EVAL_FEATURE[x].us[8]), "m" (EVAL_FEATURE[x].us[16]),
+			"m" (EVAL_FEATURE[x].us[24]), "m" (EVAL_FEATURE[x].us[32]), "m" (EVAL_FEATURE[x].us[40]));
+		}
+	}
+
+	__asm__ (
+		"movdqu	%%xmm2, %0\n\t"
+		"movdqu	%%xmm3, %1\n\t"
+		"movdqu	%%xmm4, %2\n\t"
+		"movdqu	%%xmm5, %3\n\t"
+		"movdqu	%%xmm6, %4\n\t"
+		"movdqu	%%xmm7, %5"
+	: :  "m" (eval_out->feature.us[0]), "m" (eval_out->feature.us[8]), "m" (eval_out->feature.us[16]),
+	"m" (eval_out->feature.us[24]), "m" (eval_out->feature.us[32]), "m" (eval_out->feature.us[40]));
+}
+
+#endif // hasSSE2
+
+#if defined(hasSSE2) || (defined(__ARM_NEON) && !defined(DISPATCH_NEON))
+
+/**
+ * @brief Set up evaluation features from a board.
+ *
+ * @param eval  Evaluation function.
+ * @param board Board to setup features from.
+ */
+void eval_set(Eval *eval, const Board *board)
+{
+	int x;
+	unsigned long long b = (eval->n_empties & 1) ? board->opponent : board->player;
+  #ifdef __AVX2__
+	__m256i	f0 = EVAL_FEATURE_all_opponent.v16[0];
+	__m256i	f1 = EVAL_FEATURE_all_opponent.v16[1];
+	__m256i	f2 = EVAL_FEATURE_all_opponent.v16[2];
+
+	foreach_bit (x, b) {
+		f0 = _mm256_sub_epi16(f0, EVAL_FEATURE[x].v16[0]);
+		f1 = _mm256_sub_epi16(f1, EVAL_FEATURE[x].v16[1]);
+		f2 = _mm256_sub_epi16(f2, EVAL_FEATURE[x].v16[2]);
+	}
+
+	b = ~(board->opponent | board->player);
+	foreach_bit (x, b) {
+		f0 = _mm256_add_epi16(f0, EVAL_FEATURE[x].v16[0]);
+		f1 = _mm256_add_epi16(f1, EVAL_FEATURE[x].v16[1]);
+		f2 = _mm256_add_epi16(f2, EVAL_FEATURE[x].v16[2]);
+	}
+	eval->feature.v16[0] = f0;
+	eval->feature.v16[1] = f1;
+	eval->feature.v16[2] = f2;
+
+  #else
+	__m128i	f0 = EVAL_FEATURE_all_opponent.v8[0];
+	__m128i	f1 = EVAL_FEATURE_all_opponent.v8[1];
+	__m128i	f2 = EVAL_FEATURE_all_opponent.v8[2];
+	__m128i	f3 = EVAL_FEATURE_all_opponent.v8[3];
+	__m128i	f4 = EVAL_FEATURE_all_opponent.v8[4];
+	__m128i	f5 = EVAL_FEATURE_all_opponent.v8[5];
+
+	foreach_bit (x, b) {
+		f0 = _mm_sub_epi16(f0, EVAL_FEATURE[x].v8[0]);
+		f1 = _mm_sub_epi16(f1, EVAL_FEATURE[x].v8[1]);
+		f2 = _mm_sub_epi16(f2, EVAL_FEATURE[x].v8[2]);
+		f3 = _mm_sub_epi16(f3, EVAL_FEATURE[x].v8[3]);
+		f4 = _mm_sub_epi16(f4, EVAL_FEATURE[x].v8[4]);
+		f5 = _mm_sub_epi16(f5, EVAL_FEATURE[x].v8[5]);
+	}
+
+	b = ~(board->opponent | board->player);
+	foreach_bit (x, b) {
+		f0 = _mm_add_epi16(f0, EVAL_FEATURE[x].v8[0]);
+		f1 = _mm_add_epi16(f1, EVAL_FEATURE[x].v8[1]);
+		f2 = _mm_add_epi16(f2, EVAL_FEATURE[x].v8[2]);
+		f3 = _mm_add_epi16(f3, EVAL_FEATURE[x].v8[3]);
+		f4 = _mm_add_epi16(f4, EVAL_FEATURE[x].v8[4]);
+		f5 = _mm_add_epi16(f5, EVAL_FEATURE[x].v8[5]);
+	}
+
+	eval->feature.v8[0] = f0;
+	eval->feature.v8[1] = f1;
+	eval->feature.v8[2] = f2;
+	eval->feature.v8[3] = f3;
+	eval->feature.v8[4] = f4;
+	eval->feature.v8[5] = f5;
+  #endif
+}
+
+#endif // hasSSE2
diff --git a/src/flip_avx512cd.c b/src/flip_avx512cd.c
new file mode 100644
index 00000000..36f8be6c
--- /dev/null
+++ b/src/flip_avx512cd.c
@@ -0,0 +1,143 @@
+/**
+ * @file flip_avx512cd.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, LZCNT is used.
+ *
+ * Optimization ideas by acepck
+ * https://github.com/Nyanyan/Egaroucid/pull/293
+ *
+ * @date 1998 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+
+const V8DI lrmask[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return partially reduced flipped disc pattern.
+ */
+
+__m128i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP = _mm256_broadcastq_epi64(OP);
+	__m256i	OO = _mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP));
+
+		// right: look for player (or edge) bit with lzcnt
+	__m256i	rM = lrmask[pos].v4[1];
+  #if 1 // use prove
+	__m256i t0 = _mm256_lzcnt_epi64(_mm256_andnot_si256(OO, rM));
+	t0 = _mm256_and_si256(_mm256_srlv_epi64(_mm256_set1_epi64x(0x8000000000000000), t0), PP);
+		// clear masked OO lower than outflank
+	// __m256i rF = _mm256_and_si256(_mm256_xor_si256(_mm256_sub_epi64(_mm256_setzero_si256(), tO), tO), rM);
+	__m256i rF = _mm256_ternarylogic_epi64(_mm256_sub_epi64(_mm256_setzero_si256(), t0), t0, rM, 0x28);
+
+  #else // use mask by acepck
+	__m256i	rP = _mm256_and_si256(PP, rM);
+		// shadow mask lower than leftmost P
+	__m256i	t0 = _mm256_srlv_epi64(_mm256_set1_epi64x(-1), _mm256_lzcnt_epi64(rP));
+		// apply flip if leftmost non-opponent is P
+	// __m256i rE = _mm256_andnot_si256(OO, _mm256_andnot_si256(rP, rM));
+	__m256i	rE = _mm256_ternarylogic_epi64(OO, rM, rP, 0x04);	// masked empty
+	__m256i rF = _mm256_maskz_andnot_epi64(_mm256_cmpgt_epi64_mask(rP, rE), t0, rM);
+  #endif
+		// left: look for non-opponent LS1B
+	__m256i	lM = lrmask[pos].v4[0];
+	__m256i	lO = _mm256_andnot_si256(OO, lM);
+  #if 1 // LS1B
+	// lO = _mm256_and_si256(lO, _mm256_sub_epi64(_mm256_setzero_si256(), lO));	// LS1B
+	// lO = _mm256_and_si256(lO, PP);
+	lO = _mm256_ternarylogic_epi64(lO, _mm256_sub_epi64(_mm256_setzero_si256(), lO), PP, 0x80);
+		// set all bits if outflank = 0, otherwise higher bits than outflank
+	__m256i lE = _mm256_sub_epi64(_mm256_cmpeq_epi64(lO, _mm256_setzero_si256()), lO);
+	// __m256i FF = _mm256_or_si256(rF, _mm256_andnot_si256(lE, lM));
+	__m256i FF = _mm256_ternarylogic_epi64(rF, lE, lM, 0xf2);
+
+  #else // BLSMSK
+	// __m256i t2 = _mm256_xor_si256(_mm256_add_epi64(lO, _mm256_set1_epi64x(-1)), lO);	// BLSMSK
+	// t2 = _mm256_and_si256(lM, t2);	// non-opponent LS1B and opponent inbetween
+	__m256i	t2 = _mm256_ternarylogic_epi64(lM, _mm256_add_epi64(lO, _mm256_set1_epi64x(-1)), lO, 0x60);
+		// apply flip if P is in mask, i.e. LS1B is P
+	// __m256i FF = _mm256_mask_or_epi64(rF, _mm256_test_epi64_mask(PP, t2), rF, _mm256_andnot_si256(PP, t2));
+	__m256i FF = _mm256_mask_ternarylogic_epi64(rF, _mm256_test_epi64_mask(PP, t2), PP, t2, 0xf2);
+  #endif
+
+	return _mm_or_si128(_mm256_castsi256_si128(FF), _mm256_extracti128_si256(FF, 1));
+}
diff --git a/src/flip_avx_acepck.c b/src/flip_avx_acepck.c
new file mode 100644
index 00000000..66b741f2
--- /dev/null
+++ b/src/flip_avx_acepck.c
@@ -0,0 +1,126 @@
+/**
+ * @file flip_avx_acepck.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, PCMPGTQ is used to check if leftmost
+ * non-opponent is P.
+ *
+ * Optimization ideas by acepck
+ * https://github.com/Nyanyan/Egaroucid/pull/293
+ *
+ * @date 1998 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+
+const V8DI lrmask[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return partially reduced flipped disc pattern.
+ */
+
+__m128i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP, OO, flip, mask, rP, rS, rE, lO, lF;
+
+	PP = _mm256_broadcastq_epi64(OP);
+	OO = _mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP));
+
+	mask = lrmask[pos].v4[1];
+		// right: shadow mask lower than leftmost P
+	rP = _mm256_and_si256(PP, mask);
+	rS = _mm256_or_si256(rP, _mm256_srlv_epi64(rP, _mm256_set_epi64x(7, 9, 8, 1)));
+	rS = _mm256_or_si256(rS, _mm256_srlv_epi64(rS, _mm256_set_epi64x(14, 18, 16, 2)));
+	rS = _mm256_or_si256(rS, _mm256_srlv_epi64(rS, _mm256_set_epi64x(28, 36, 32, 4)));
+		// apply flip if leftmost non-opponent is P
+	rE = _mm256_xor_si256(_mm256_andnot_si256(OO, mask), rP);	// masked Empty
+	flip = _mm256_and_si256(_mm256_andnot_si256(rS, mask), _mm256_cmpgt_epi64(rP, rE));
+
+	mask = lrmask[pos].v4[0];
+		// left: non-opponent BLSMSK
+	lO = _mm256_andnot_si256(OO, mask);
+	lO = _mm256_and_si256(_mm256_xor_si256(_mm256_add_epi64(lO, _mm256_set1_epi64x(-1)), lO), mask);
+		// clear MSB of BLSMSK if it is P
+	lF = _mm256_andnot_si256(PP, lO);
+		// erase lF if lO = lF (i.e. MSB is not P)
+	flip = _mm256_or_si256(flip, _mm256_andnot_si256(_mm256_cmpeq_epi64(lF, lO), lF));
+
+	return _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+}
diff --git a/src/flip_avx_cvtps.c b/src/flip_avx_cvtps.c
new file mode 100644
index 00000000..8b4f4308
--- /dev/null
+++ b/src/flip_avx_cvtps.c
@@ -0,0 +1,130 @@
+/**
+ * @file flip_avx_cvtps.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, MS1B using floating point conversion is used.
+ *
+ * @date 1998 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+
+const V8DI lrmask[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return partially reduced flipped disc pattern.
+ */
+
+__m128i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP, OO, flip, outflank, mask;
+	const __m256 exp_mask = _mm256_castsi256_ps(_mm256_set1_epi32(0xff800000));
+	const __m256i minusone = _mm256_set1_epi64x(-1);
+
+	PP = _mm256_broadcastq_epi64(OP);
+	OO = _mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP));
+
+	mask = lrmask[pos].v4[1];
+		// look for non-opponent MS1B
+	outflank = _mm256_andnot_si256(OO, mask);
+		// MS1B_31 - clear mantissa to leave implicit MSB alone
+	outflank = _mm256_cvtps_epi32(_mm256_and_ps(_mm256_cvtepi32_ps(outflank), exp_mask));
+		// MS1B_32 - clear except sign bit if negative
+	outflank = _mm256_andnot_si256(_mm256_srli_epi32(_mm256_srai_epi32(outflank, 31), 1), outflank);
+		// MS1B_64 - clear low dword if high != 0
+	outflank = _mm256_and_si256(outflank, _mm256_cmpeq_epi32(_mm256_srli_epi64(outflank, 32), _mm256_setzero_si256()));
+	outflank = _mm256_and_si256(outflank, PP);
+		// set all bits higher than outflank
+	flip = _mm256_and_si256(mask, _mm256_sub_epi64(_mm256_setzero_si256(), _mm256_add_epi64(outflank, outflank)));
+
+	mask = lrmask[pos].v4[0];
+		// look for non-opponent LS1B
+	outflank = _mm256_andnot_si256(OO, mask);
+	outflank = _mm256_andnot_si256(_mm256_add_epi64(outflank, minusone), outflank);	// LS1B
+	outflank = _mm256_and_si256(outflank, PP);
+		// set all bits lower than outflank
+	outflank = _mm256_add_epi64(outflank, minusone);
+		// sign bit becomes 1 only if outflank was 0, if so add back 1
+	outflank = _mm256_add_epi64(outflank, _mm256_srli_epi64(outflank, 63));
+	flip = _mm256_or_si256(flip, _mm256_and_si256(outflank, mask));
+
+	return _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+}
+
diff --git a/src/flip_avx_lzcnt.c b/src/flip_avx_lzcnt.c
new file mode 100644
index 00000000..b08b503c
--- /dev/null
+++ b/src/flip_avx_lzcnt.c
@@ -0,0 +1,134 @@
+/**
+ * @file flip_avx_lzcnt.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For horizontal MSB to LSB, LZCNT is used.
+ * For the other MSB to LSB directions, byteswap then LS1B.
+ *
+ * @date 1998 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+
+const V8DI lrmask[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return partially reduced flipped disc pattern.
+ */
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 7
+#define _mm256_broadcastsi128_si256(x) _mm_broadcastsi128_si256(x)
+#endif
+
+__m128i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP, mOO, flip, outflank, mask, ocontig;
+	__m128i	outflank1;
+	const __m256i mbswapll = _mm256_broadcastsi128_si256(_mm_set_epi64x(0x08090a0b0c0d0e0f, 0x0001020304050607));
+
+	PP = _mm256_broadcastq_epi64(OP);
+	mOO = _mm256_and_si256(_mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP)),
+		_mm256_set_epi64x(0x007e7e7e7e7e7e00, 0x007e7e7e7e7e7e00, 0x00ffffffffffff00, 0x7e7e7e7e7e7e7e7e));	// (sentinel on the edge)
+
+	mask = lrmask[pos].v4[1];
+	ocontig = _mm256_andnot_si256(mOO, mask);
+		// -1 (CPU)
+	outflank1 = _mm_cvtsi64_si128(0x8000000000000000ULL >> lzcnt_u64(_mm_cvtsi128_si64(_mm256_castsi256_si128(ocontig))));
+	// outflank1 = _mm_loadl_epi64((__m128i *) &X_TO_BIT[lzcnt_u64(_mm_cvtsi128_si64(_mm256_castsi256_si128(ocontig))) ^ 63]);
+		// -8/-7/-9 (bswap-LS1B)
+	outflank = _mm256_shuffle_epi8(ocontig, mbswapll);
+	outflank = _mm256_shuffle_epi8(_mm256_and_si256(outflank, _mm256_sub_epi64(_mm256_setzero_si256(), outflank)), mbswapll);	// LS1B
+	outflank = _mm256_blend_epi32(outflank, _mm256_castsi128_si256(outflank1), 0x03);
+	outflank = _mm256_and_si256(outflank, PP);
+		// set all bits higher than outflank
+	flip = _mm256_and_si256(_mm256_sub_epi64(_mm256_setzero_si256(), _mm256_add_epi64(outflank, outflank)), mask);
+
+	mask = lrmask[pos].v4[0];
+		// look for non-opponent (or edge) bit
+	ocontig = _mm256_andnot_si256(mOO, mask);
+	ocontig = _mm256_and_si256(ocontig, _mm256_sub_epi64(_mm256_setzero_si256(), ocontig));	// LS1B
+	outflank = _mm256_and_si256(ocontig, PP);
+		// set all bits lower than outflank (depends on ocontig != 0)
+	outflank = _mm256_add_epi64(outflank, _mm256_cmpeq_epi64(outflank, ocontig));
+	flip = _mm256_or_si256(flip, _mm256_and_si256(outflank, mask));
+
+	return _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+}
+
diff --git a/src/flip_avx_ppfill.c b/src/flip_avx_ppfill.c
new file mode 100644
index 00000000..c5bb1056
--- /dev/null
+++ b/src/flip_avx_ppfill.c
@@ -0,0 +1,136 @@
+/**
+ * @file flip_avx_ppfill.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, parallel prefix fill is used to isolate
+ * MS1B.
+ *
+ * @date 1998 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+
+const V8DI lrmask[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return partially reduced flipped disc pattern.
+ */
+
+__m128i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP, OO, flip, outflank, eraser, mask;
+
+	PP = _mm256_broadcastq_epi64(OP);
+	OO = _mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP));
+
+	mask = lrmask[pos].v4[1];
+		// isolate non-opponent MS1B by clearing lower shadow bits
+	eraser = _mm256_andnot_si256(OO, mask);
+#if 0 // blute force parallel prefix fill
+	outflank = _mm256_and_si256(PP, mask);
+	eraser = _mm256_or_si256(eraser, _mm256_srli_epi64(eraser, 1));
+	eraser = _mm256_or_si256(eraser, _mm256_srli_epi64(eraser, 2));
+	eraser = _mm256_or_si256(eraser, _mm256_srli_epi64(eraser, 4));
+	eraser = _mm256_or_si256(eraser, _mm256_srli_epi64(eraser, 8));
+	eraser = _mm256_or_si256(eraser, _mm256_srli_epi64(eraser, 16));
+	outflank = _mm256_andnot_si256(eraser, _mm256_add_epi64(outflank, outflank));
+	outflank = _mm256_andnot_si256(_mm256_srli_epi64(eraser, 32), outflank);
+#else // clear valid bits only using variable shift
+	outflank = _mm256_sllv_epi64(_mm256_and_si256(PP, mask), _mm256_set_epi64x(7, 9, 8, 1));
+	eraser = _mm256_or_si256(eraser, _mm256_srlv_epi64(eraser, _mm256_set_epi64x(7, 9, 8, 1)));
+	outflank = _mm256_andnot_si256(eraser, outflank);
+	eraser = _mm256_srlv_epi64(eraser, _mm256_set_epi64x(14, 18, 16, 2));
+	outflank = _mm256_andnot_si256(eraser, outflank);
+	outflank = _mm256_andnot_si256(_mm256_srlv_epi64(eraser, _mm256_set_epi64x(14, 18, 16, 2)), outflank);
+#endif
+		// set mask bits higher than outflank
+	flip = _mm256_and_si256(mask, _mm256_sub_epi64(_mm256_setzero_si256(), outflank));
+
+	mask = lrmask[pos].v4[0];
+		// look for non-opponent LS1B
+	outflank = _mm256_andnot_si256(OO, mask);
+	outflank = _mm256_and_si256(outflank, _mm256_sub_epi64(_mm256_setzero_si256(), outflank));	// LS1B
+	outflank = _mm256_and_si256(outflank, PP);
+		// set all bits if outflank = 0, otherwise higher bits than outflank
+	eraser = _mm256_sub_epi64(_mm256_cmpeq_epi64(outflank, _mm256_setzero_si256()), outflank);
+	flip = _mm256_or_si256(flip, _mm256_andnot_si256(eraser, mask));
+
+	return _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+}
diff --git a/src/flip_avx_ppseq.c b/src/flip_avx_ppseq.c
new file mode 100644
index 00000000..00331177
--- /dev/null
+++ b/src/flip_avx_ppseq.c
@@ -0,0 +1,126 @@
+/**
+ * @file flip_avx_ppseq.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, sequencial search with parallel prefix
+ * is used.
+ *
+ * @date 1998 - 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit.h"
+
+const V4DI lmask_v4[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return partially reduced flipped disc pattern.
+ */
+
+__m128i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP, mOO, flip, shift2, pre, outflank, mask, ocontig;
+	const __m256i shift1897 = _mm256_set_epi64x(7, 9, 8, 1);
+
+	PP = _mm256_broadcastq_epi64(OP);
+	mOO = _mm256_and_si256(_mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP)),
+		_mm256_set_epi64x(0x007e7e7e7e7e7e00, 0x007e7e7e7e7e7e00, 0x00ffffffffffff00, 0x7e7e7e7e7e7e7e7e));	// (sentinel on the edge)
+
+	ocontig = _mm256_set1_epi64x(X_TO_BIT[pos]);
+	ocontig = _mm256_and_si256(mOO, _mm256_srlv_epi64(ocontig, shift1897));
+	ocontig = _mm256_or_si256(ocontig, _mm256_and_si256(mOO, _mm256_srlv_epi64(ocontig, shift1897)));
+	pre = _mm256_and_si256(mOO, _mm256_srlv_epi64(mOO, shift1897));	// parallel prefix
+	shift2 = _mm256_add_epi64(shift1897, shift1897);
+	ocontig = _mm256_or_si256(ocontig, _mm256_and_si256(pre, _mm256_srlv_epi64(ocontig, shift2)));
+	ocontig = _mm256_or_si256(ocontig, _mm256_and_si256(pre, _mm256_srlv_epi64(ocontig, shift2)));
+	outflank = _mm256_and_si256(_mm256_srlv_epi64(ocontig, shift1897), PP);
+	flip = _mm256_andnot_si256(_mm256_cmpeq_epi64(outflank, _mm256_setzero_si256()), ocontig);
+
+	mask = lmask_v4[pos].v4;
+		// look for non-opponent (or edge) bit
+	ocontig = _mm256_andnot_si256(mOO, mask);
+	ocontig = _mm256_and_si256(ocontig, _mm256_sub_epi64(_mm256_setzero_si256(), ocontig));	// LS1B
+	outflank = _mm256_and_si256(ocontig, PP);
+		// set all bits lower than outflank (depends on ocontig != 0)
+	outflank = _mm256_add_epi64(outflank, _mm256_cmpeq_epi64(outflank, ocontig));
+	flip = _mm256_or_si256(flip, _mm256_and_si256(outflank, mask));
+
+	return _mm_or_si128(_mm256_castsi256_si128(flip), _mm256_extracti128_si256(flip, 1));
+}
+
diff --git a/src/flip_avx_shuf_max.c b/src/flip_avx_shuf_max.c
new file mode 100644
index 00000000..83976f28
--- /dev/null
+++ b/src/flip_avx_shuf_max.c
@@ -0,0 +1,130 @@
+/**
+ * @file flip_avx_shuf_max.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, isolate MS1B by comparing high and low halves.
+ *
+ * @date 1998 - 2023
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include "bit.h"
+
+const V8DI lrmask[66] = {
+	{{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+
+__m256i vectorcall mm_Flip(const __m128i OP, int pos)
+{
+	__m256i	PP, OO, flip, outflank, eraser, mask;
+	const __m256i mask0F0F = _mm256_set1_epi16(0x0F0F);
+	const __m256i ms1bL = _mm256_broadcastsi128_si256(_mm_set_epi64x(0x0808080808080808, 0x0404040402020100));
+
+	PP = _mm256_broadcastq_epi64(OP);
+	OO = _mm256_broadcastq_epi64(_mm_unpackhi_epi64(OP, OP));
+
+	mask = lrmask[pos].v4[1];
+		// look for non-opponent MS1B
+	outflank = _mm256_andnot_si256(OO, mask);
+		// mask to clear low half if high half != 0 in word/dword/qword
+	eraser = _mm256_and_si256(_mm256_and_si256(
+		_mm256_cmpeq_epi8(_mm256_srli_epi16(outflank, 8), _mm256_setzero_si256()),
+		_mm256_cmpeq_epi16(_mm256_srli_epi32(outflank, 16), _mm256_setzero_si256())),
+		_mm256_cmpeq_epi32(_mm256_srli_epi64(outflank, 32), _mm256_setzero_si256()));
+		// table look up with PSHUFB then take MS1B of a byte with PMAXUB
+	outflank = _mm256_max_epu8(_mm256_shuffle_epi8(ms1bL, _mm256_and_si256(outflank, mask0F0F)),
+		_mm256_shuffle_epi8(_mm256_slli_epi64(ms1bL, 4), _mm256_and_si256(_mm256_srli_epi64(outflank, 4), mask0F0F)));
+	outflank = _mm256_and_si256(_mm256_and_si256(outflank, eraser), PP);
+		// set all bits higher than outflank
+	flip = _mm256_and_si256(_mm256_sub_epi64(_mm256_setzero_si256(), _mm256_add_epi64(outflank, outflank)), mask);
+
+	mask = lrmask[pos].v4[0];
+		// look for non-opponent LS1B
+	outflank = _mm256_andnot_si256(OO, mask);
+	outflank = _mm256_and_si256(outflank, _mm256_sub_epi64(_mm256_setzero_si256(), outflank));	// LS1B
+	outflank = _mm256_and_si256(outflank, PP);
+		// set all bits if outflank = 0, otherwise higher bits than outflank
+	eraser = _mm256_sub_epi64(_mm256_cmpeq_epi64(outflank, _mm256_setzero_si256()), outflank);
+	flip = _mm256_or_si256(flip, _mm256_andnot_si256(eraser, mask));
+
+	return flip;
+}
+
diff --git a/src/flip_bitscan.c b/src/flip_bitscan.c
index eaa2d581..26827efc 100644
--- a/src/flip_bitscan.c
+++ b/src/flip_bitscan.c
@@ -20,10 +20,11 @@
  * with a bit-mask, to gather the masked-bits into a continuous set by a simple
  * multiplication and to right-shift the result to scale it into a number
  * between 0 and 255.
- * Once we get our 8-bits disc patterns,a first array (OUTFLANK) is used to
+ * Once we get our 8-bits disc patterns, a first array (OUTFLANK) is used to
  * get the player's discs that surround the opponent discs:
  *  - outflank = OUTFLANK[x][O] & P
- * (Only inner 6-bits of the P are in interest here.)
+ * Because neighbor-of-x bits in the P are not in interest here, outflank
+ * is stored in bitwise rotated form to reduce the table size.
  * The result is then used as an index to access a second array giving the
  * flipped discs according to the surrounding player's discs:
  *  - flipped = FLIPPED[x][outflank].
@@ -34,221 +35,161 @@
  *
  * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
  * can be used to determine contiguous opponent discs.
- * If the OUTFLANK search is in MSB to LSB direction, GCC's __builtin_clz(ll)
- * is used to determine coutiguous opponent discs.
+ * If the OUTFLANK search is in MSB to LSB direction, lzcnt64 is used if 
+ * available, or __builtin_bswap is used to use carry propagation backwards.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @author Toshihiko Okuhara
  * @version 4.4
  */
 
-/** outflank array (indexed with inner 6 bits) */
-/* static const unsigned char OUTFLANK_0[64] = {
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x40,
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x80
-}; */
-
-/* static const unsigned char OUTFLANK_1[64] = {
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00,
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0x00
-}; */
-
-static const unsigned char OUTFLANK_2[64] = {
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x41, 0x00, 0x00,
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00
-};
+#include "bit_intrinsics.h"
+
+#define LODWORD(l) ((unsigned int)(l))
+#define HIDWORD(l) ((unsigned int)((l)>>32))
 
-static const unsigned char OUTFLANK_3[64] = {
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00
+/** rotated outflank array (indexed with inner 6 bits) */
+static const unsigned char OUTFLANK_2[64] = {	// ...ahgfe
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x12, 0x00, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x12, 0x00, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x18, 0x00, 0x00
 };
 
-static const unsigned char OUTFLANK_4[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x40, 0x40, 0x40, 0x40, 0x44, 0x44, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x80, 0x80, 0x80, 0x84, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+static const unsigned char OUTFLANK_3[64] = {	// ...bahgf
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x12, 0x0a, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x14, 0x0c, 0x00, 0x00, 0x00, 0x00
 };
 
-static const unsigned char OUTFLANK_5[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x88, 0x88, 0x88, 0x88, 0x84, 0x84, 0x82, 0x81,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+static const unsigned char OUTFLANK_4[64] = {	// ...cbahg
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x01, 0x01, 0x01, 0x11, 0x11, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x02, 0x02, 0x02, 0x02, 0x12, 0x12, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
-/* static const unsigned char OUTFLANK_6[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+static const unsigned char OUTFLANK_5[64] = {	// ...dcbah
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x11, 0x11, 0x11, 0x11, 0x09, 0x09, 0x05, 0x03,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-}; */
-
-static const unsigned char OUTFLANK_7[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01
 };
 
-/* (Count of leading 1 from bit 5) * 8 */
-static const unsigned char CONTIG_UP[64] = {
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
-	16, 16, 16, 16, 16, 16, 16, 16, 24, 24, 24, 24, 32, 32, 40, 48
+/** flip array (indexed with rotated outflank) */
+static const unsigned long long FLIPPED_2_H[25] = {	// ...ahgfe
+	0x0000000000000000, 0x0808080808080808, 0x1818181818181818, 0x0000000000000000,
+	0x3838383838383838, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7878787878787878, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0202020202020202, 0x0a0a0a0a0a0a0a0a, 0x1a1a1a1a1a1a1a1a, 0x0000000000000000,
+	0x3a3a3a3a3a3a3a3a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7a7a7a7a7a7a7a7a
 };
 
-/* (Count of leading 1 from bit 5) * 9 */
-static const unsigned char CONTIG_UPLEFT[64] = {
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-	18, 18, 18, 18, 18, 18, 18, 18, 27, 27, 27, 27, 36, 36, 45, 54
+static const unsigned long long FLIPPED_2_V[25] = {
+	0x0000000000000000, 0x00000000ff000000, 0x000000ffff000000, 0x0000000000000000,
+	0x0000ffffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000ff00, 0x00000000ff00ff00, 0x000000ffff00ff00, 0x0000000000000000,
+	0x0000ffffff00ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffffff00ff00
 };
 
-/* (Count of trailing 1) * 7 */
-static const unsigned char CONTIG_UPRIGHT[64] = {
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 28,
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 35,
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 28,
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 42
+static const unsigned long long FLIPPED_3_H[21] = {	// ...bahgf
+	0x0000000000000000, 0x1010101010101010, 0x3030303030303030, 0x0000000000000000,
+	0x7070707070707070, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0606060606060606, 0x1616161616161616, 0x3636363636363636, 0x0000000000000000,
+	0x7676767676767676, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0404040404040404, 0x1414141414141414, 0x3434343434343434, 0x0000000000000000,
+	0x7474747474747474
 };
 
-/** flip array (indexed with outflank, returns inner 6 bits) */
-static const unsigned char FLIPPED_2[130] = {
-	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x0c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x1c, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x3c, 0x3d
+static const unsigned long long FLIPPED_3_V[21] = {
+	0x0000000000000000, 0x000000ff00000000, 0x0000ffff00000000, 0x0000000000000000,
+	0x00ffffff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000ffff00, 0x000000ff00ffff00, 0x0000ffff00ffff00, 0x0000000000000000,
+	0x00ffffff00ffff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000ff0000, 0x000000ff00ff0000, 0x0000ffff00ff0000, 0x0000000000000000, 
+	0x00ffffff00ff0000
 };
 
-static const unsigned long long FLIPPED_3_H[131] = {
-	0x0000000000000000ULL, 0x0606060606060606ULL, 0x0404040404040404ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x1616161616161616ULL, 0x1414141414141414ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3030303030303030ULL, 0x3636363636363636ULL, 0x3434343434343434ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7070707070707070ULL, 0x7676767676767676ULL, 0x7474747474747474ULL
+static const unsigned long long FLIPPED_4_H[19] = {	// ...cbahg
+	0x0000000000000000, 0x2020202020202020, 0x6060606060606060, 0x0000000000000000,
+	0x0e0e0e0e0e0e0e0e, 0x2e2e2e2e2e2e2e2e, 0x6e6e6e6e6e6e6e6e, 0x0000000000000000,
+	0x0c0c0c0c0c0c0c0c, 0x2c2c2c2c2c2c2c2c, 0x6c6c6c6c6c6c6c6c, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0808080808080808, 0x2828282828282828, 0x6868686868686868
 };
 
-static const unsigned long long FLIPPED_4_H[133] = {
-	0x0000000000000000ULL, 0x0e0e0e0e0e0e0e0eULL, 0x0c0c0c0c0c0c0c0cULL, 0x0000000000000000ULL, 0x0808080808080808ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x2020202020202020ULL, 0x2e2e2e2e2e2e2e2eULL, 0x2c2c2c2c2c2c2c2cULL, 0x0000000000000000ULL, 0x2828282828282828ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x6060606060606060ULL, 0x6e6e6e6e6e6e6e6eULL, 0x6c6c6c6c6c6c6c6cULL, 0x0000000000000000ULL, 0x6868686868686868ULL
+static const unsigned long long FLIPPED_4_V[19] = {
+	0x0000000000000000, 0x0000ff0000000000, 0x00ffff0000000000, 0x0000000000000000,
+	0x00000000ffffff00, 0x0000ff00ffffff00, 0x00ffff00ffffff00, 0x0000000000000000,
+	0x00000000ffff0000, 0x0000ff00ffff0000, 0x00ffff00ffff0000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ff000000, 0x0000ff00ff000000, 0x00ffff00ff000000
 };
 
-static const unsigned char FLIPPED_5[137] = {
-	0x00, 0x0f, 0x0e, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x20, 0x2f, 0x2e, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x28
+static const unsigned long long FLIPPED_5_H[18] = {	// ...dcbah
+	0x0000000000000000, 0x4040404040404040, 0x1e1e1e1e1e1e1e1e, 0x5e5e5e5e5e5e5e5e,
+	0x1c1c1c1c1c1c1c1c, 0x5c5c5c5c5c5c5c5c, 0x0000000000000000, 0x0000000000000000,
+	0x1818181818181818, 0x5858585858585858, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x5050505050505050
 };
 
-static const unsigned long long FLIPPED_3_V[131] = {
-	0x0000000000000000ULL, 0x0000000000ffff00ULL, 0x0000000000ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x000000ff00ffff00ULL, 0x000000ff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ffff00000000ULL, 0x0000ffff00ffff00ULL, 0x0000ffff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffffff00000000ULL, 0x00ffffff00ffff00ULL, 0x00ffffff00ff0000ULL
+static const unsigned long long FLIPPED_5_V[18] = {
+	0x0000000000000000, 0x00ff000000000000, 0x000000ffffffff00, 0x00ff00ffffffff00,
+	0x000000ffffff0000, 0x00ff00ffffff0000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ffff000000, 0x00ff00ffff000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x00ff00ff00000000
 };
 
-static const unsigned long long FLIPPED_4_V[133] = {
-	0x0000000000000000ULL, 0x00000000ffffff00ULL, 0x00000000ffff0000ULL, 0x0000000000000000ULL, 0x00000000ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ff0000000000ULL, 0x0000ff00ffffff00ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffff0000000000ULL, 0x00ffff00ffffff00ULL, 0x00ffff00ffff0000ULL, 0x0000000000000000ULL, 0x00ffff00ff000000ULL
-};
 
-
-static const unsigned long long FLIPPED_3_U[131] = {
-	0x0000000000000000ULL, 0x00ffff0000000000ULL, 0x0000ff0000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ff000000ULL, 0x00ffff00ff000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ffff0000ULL, 0x00ffff00ffff0000ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ffffff00ULL, 0x00ffff00ffffff00ULL, 0x0000ff00ffffff00ULL
-};
+/*
+ * Set all bits below the sole outflank bit if outfrank != 0
+ */
+#if __has_builtin(__builtin_subcll)
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned long long flipmask, cy;
+	flipmask = __builtin_subcll(outflank, 1, 0, &cy);
+	return __builtin_addcll(flipmask, 0, cy, &cy);
+}
+#elif (defined(_M_X64) && (_MSC_VER >= 1800)) || (defined(__x86_64__) && defined(__GNUC__) && (__GNUC__ > 7 || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2)))
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned long long flipmask;
+	unsigned char cy = _subborrow_u64(0, outflank, 1, &flipmask);
+	_addcarry_u64(cy, flipmask, 0, &flipmask);
+	return flipmask;
+}
+#else
+	#define OutflankToFlipmask(outflank)	((outflank) - (unsigned int) ((outflank) != 0))
+#endif
+
+#if ((defined(__x86_64__) || defined(USE_GAS_X86)) && defined(__LZCNT__)) || defined(__ARM_FEATURE_CLZ) || defined(_MSC_VER)
+	// Strictly, (long long) >> 64 is undefined in C, but either 0 bit (no change)
+	// or 64 bit (zero out) shift will lead valid result (i.e. flipped == 0).
+	#define	outflank_right(O,maskr)	(0x8000000000000000ULL >> lzcnt_u64(~(O) & (maskr)))
+#elif defined(vertical_mirror)	// bswap to use carry propagation backwards - cannot be used for horizontal right
+	// static inline unsigned long long outflank_right(unsigned long long O, unsigned long long maskr) {
+	//	unsigned long long rOM = vertical_mirror(~(O) & maskr);
+	//	return vertical_mirror(rOM & (-rOM));
+	// }
+	#define	outflank_right(O,maskr)	(vertical_mirror(vertical_mirror((O) | ~(maskr)) + 1) & (maskr))
+#else	// with guardian bit to avoid __builtin_clz(0)
+	#define	outflank_right(O,maskr)	(0x8000000000000000ULL >> __builtin_clzll(((O) & (((maskr) & ((maskr) - 1)))) ^ (maskr)))
+#endif
+
+// in case continuous from MSB
+#if defined(__AVX2__) || defined(__LZCNT__) || defined(_MSC_VER)
+	#define	outflank_right_H(O)	(0x80000000u >> lzcnt_u32(~(O)))
+#else
+	#define	outflank_right_H(O)	(0x80000000u >> __builtin_clz(~(O)))
+#endif
 
 
 /**
@@ -260,16 +201,17 @@ static const unsigned long long FLIPPED_3_U[131] = {
  */
 static unsigned long long flip_A1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101010100ULL) + 0x0000000000000100ULL) & P & 0x0101010101010100ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101010100ULL;
+	outflank_v = ((O | ~0x0101010101010100) + 1) & P & 0x0101010101010100;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010100;
 
-	outflank_h = ((O & 0x000000000000007eULL) + 0x0000000000000002ULL) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x000000000000007eULL;
+	outflank_d9 = ((O | ~0x8040201008040200) + 1) & P & 0x8040201008040200;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040200;
 
-	outflank_d9 = ((O | ~0x8040201008040200ULL) + 0x0000000000000200ULL) & P & 0x8040201008040200ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008040200ULL;
+	outflank_h = (unsigned char) (O + 0x02) & P;
+	flipped |= outflank_h - ((unsigned int) (outflank_h != 0) << 1);
 
 	return flipped;
 }
@@ -283,16 +225,17 @@ static unsigned long long flip_A1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202020200ULL) + 0x0000000000000200ULL) & P & 0x0202020202020200ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202020200ULL;
+	outflank_v = ((O | ~0x0202020202020200) + 1) & P & 0x0202020202020200;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020200;
 
-	outflank_h = ((O & 0x000000000000007cULL) + 0x0000000000000004ULL) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x000000000000007cULL;
+	outflank_d9 = ((O | ~0x0080402010080400) + 1) & P & 0x0080402010080400;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0080402010080400;
 
-	outflank_d9 = ((O | ~0x0080402010080400ULL) + 0x0000000000000400ULL) & P & 0x0080402010080400ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010080400ULL;
+	outflank_h = (unsigned char) (O + 0x04) & P;
+	flipped |= outflank_h - ((unsigned int) (outflank_h != 0) << 2);
 
 	return flipped;
 }
@@ -306,19 +249,18 @@ static unsigned long long flip_B1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = ((O | ~0x0404040404040400ULL) + 0x0000000000000400ULL) & P & 0x0404040404040400ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404040400ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_2[(O >> 1) & 0x3f] & P;
-	flipped |= (FLIPPED_2[outflank_h] << 1);
+	outflank_v = ((O | ~0x0404040404040400) + 1) & P & 0x0404040404040400;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040400;
 
-	flipped |= ((P >> 7) & 0x0000000000000200ULL & O);
+	outflank_d = OUTFLANK_2[(((HIDWORD(O) & 0x00000040) + (LODWORD(O) & 0x20100a04)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000804020110a04) * 0x0101010101010101) >> 52;	// hgfedcb[ahgfe]...
+	flipped |= FLIPPED_2_H[outflank_d] & 0x0000004020100a04;	// A3C1H6
 
-	outflank_d9 = ((O | ~0x0000804020100800ULL) + 0x0000000000000800ULL) & P & 0x0000804020100800ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000804020100800ULL;
+	outflank_h = OUTFLANK_2[(O >> 1) & 0x3f] & rotl8(P, 4);
+	flipped |= (unsigned char) FLIPPED_2_H[outflank_h];
 
 	return flipped;
 }
@@ -332,20 +274,18 @@ static unsigned long long flip_C1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_v = ((O | ~0x0808080808080800ULL) + 0x0000000000000800ULL) & P & 0x0808080808080800ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808080800ULL;
+	outflank_v = ((O | ~0x0808080808080800) + 1) & P & 0x0808080808080800;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080800;
 
-	outflank_h = OUTFLANK_3[(O >> 1) & 0x3f] & P;
-	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
+	outflank_d = OUTFLANK_3[((LODWORD(O) & 0x40221408) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000008041221408) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000000040221408;	// A4D1H5
 
-	outflank_d7 = ((O | ~0x0000000001020400ULL) + 0x0000000000000400ULL) & P & 0x0000000001020400ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000001020400ULL;
-
-	outflank_d9 = ((O | ~0x0000008040201000ULL) + 0x0000000000001000ULL) & P & 0x0000008040201000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000008040201000ULL;
+	outflank_h = OUTFLANK_3[(O >> 1) & 0x3f] & rotl8(P, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
 
 	return flipped;
 }
@@ -359,20 +299,18 @@ static unsigned long long flip_D1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x1010101010101000ULL) + 0x0000000000001000ULL) & P & 0x1010101010101000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010101000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_4[(O >> 1) & 0x3f] & P;
-	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
+	outflank_v = ((O | ~0x1010101010101000) + 1) & P & 0x1010101010101000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010101000;
 
-	outflank_d7 = ((O | ~0x0000000102040800ULL) + 0x0000000000000800ULL) & P & 0x0000000102040800ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000102040800ULL;
+	outflank_d = OUTFLANK_4[((LODWORD(O) & 0x02442810) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000000182442810) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000002442810;	// A5E1H4
 
-	outflank_d9 = ((O | ~0x0000000080402000ULL) + 0x0000000000002000ULL) & P & 0x0000000080402000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000000080402000ULL;
+	outflank_h = OUTFLANK_4[(O >> 1) & 0x3f] & rotl8(P, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
 
 	return flipped;
 }
@@ -386,19 +324,18 @@ static unsigned long long flip_E1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x2020202020202000ULL) + 0x0000000000002000ULL) & P & 0x2020202020202000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020202000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_5[(O >> 1) & 0x3f] & P;
-	flipped |= (FLIPPED_5[outflank_h] << 1);
+	outflank_v = ((O | ~0x2020202020202000) + 1) & P & 0x2020202020202000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020202000;
 
-	outflank_d7 = ((O | ~0x0000010204081000ULL) + 0x0000000000001000ULL) & P & 0x0000010204081000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000010204081000ULL;
+	outflank_d = OUTFLANK_5[(((HIDWORD(O) & 0x00000002) + (LODWORD(O) & 0x04085020)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000010204885020) * 0x0101010101010101) >> 55;	// hgfe[dcbah]...
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0000000204085020;	// A6F1H3
 
-	flipped |= ((P >> 9) & 0x0000000000004000ULL & O);
+	outflank_h = OUTFLANK_5[(O >> 1) & 0x3f] & rotl8(P, 1);
+	flipped |= (unsigned char) FLIPPED_5_H[outflank_h];
 
 	return flipped;
 }
@@ -415,14 +352,14 @@ static unsigned long long flip_G1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040404000ULL) + 0x0000000000004000ULL) & P & 0x4040404040404000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040404000ULL;
+	outflank_v = ((O | ~0x4040404040404000) + 1) & P & 0x4040404040404000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040404000;
 
-	outflank_h = OUTFLANK_7[O & 0x3e] & (P << 1);
-	flipped |= ((-outflank_h) & 0x3e) << 0;
+	outflank_d7 = ((O | ~0x0001020408102000) + 1) & P & 0x0001020408102000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0001020408102000;
 
-	outflank_d7 = ((O | ~0x0001020408102000ULL) + 0x0000000000002000ULL) & P & 0x0001020408102000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408102000ULL;
+	outflank_h = outflank_right_H((unsigned int) O << 26) & ((unsigned int) P << 26);
+	flipped |= (outflank_h * (unsigned int) -2) >> 26;
 
 	return flipped;
 }
@@ -439,14 +376,14 @@ static unsigned long long flip_H1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080808000ULL) + 0x0000000000008000ULL) & P & 0x8080808080808000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080808000ULL;
+	outflank_v = ((O | ~0x8080808080808000) + 1) & P & 0x8080808080808000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080808000;
 
-	outflank_h = OUTFLANK_7[(O >> 1) & 0x3f] & P;
-	flipped |= ((-outflank_h) & 0x3f) << 1;
+	outflank_d7 = ((O | ~0x0102040810204000) + 1) & P & 0x0102040810204000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810204000;
 
-	outflank_d7 = ((O | ~0x0102040810204000ULL) + 0x0000000000004000ULL) & P & 0x0102040810204000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810204000ULL;
+	outflank_h = outflank_right_H((unsigned int) O << 25) & ((unsigned int) P << 25);
+	flipped |= (outflank_h * (unsigned int) -2) >> 25;
 
 	return flipped;
 }
@@ -463,14 +400,14 @@ static unsigned long long flip_A2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101010000ULL) + 0x0000000000010000ULL) & P & 0x0101010101010000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101010000ULL;
+	outflank_v = ((O | ~0x0101010101010000) + 1) & P & 0x0101010101010000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010000;
 
-	outflank_h = ((O & 0x0000000000007e00ULL) + 0x0000000000000200ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000000000007e00ULL;
+	outflank_d9 = ((O | ~0x4020100804020000) + 1) & P & 0x4020100804020000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x4020100804020000;
 
-	outflank_d9 = ((O | ~0x4020100804020000ULL) + 0x0000000000020000ULL) & P & 0x4020100804020000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x4020100804020000ULL;
+	outflank_h = (unsigned short) (O + 0x0200) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00;
 
 	return flipped;
 }
@@ -487,14 +424,14 @@ static unsigned long long flip_B2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202020000ULL) + 0x0000000000020000ULL) & P & 0x0202020202020000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202020000ULL;
+	outflank_v = ((O | ~0x0202020202020000) + 1) & P & 0x0202020202020000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020000;
 
-	outflank_h = ((O & 0x0000000000007c00ULL) + 0x0000000000000400ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000000000007c00ULL;
+	outflank_d9 = ((O | ~0x8040201008040000) + 1) & P & 0x8040201008040000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040000;
 
-	outflank_d9 = ((O | ~0x8040201008040000ULL) + 0x0000000000040000ULL) & P & 0x8040201008040000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008040000ULL;
+	outflank_h = (unsigned short) (O + 0x0400) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00;
 
 	return flipped;
 }
@@ -508,19 +445,18 @@ static unsigned long long flip_B2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = ((O | ~0x0404040404040000ULL) + 0x0000000000040000ULL) & P & 0x0404040404040000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404040000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_2[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= (FLIPPED_2[outflank_h] << 9);
+	outflank_v = ((O | ~0x0404040404040000) + 1) & P & 0x0404040404040000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040000;
 
-	flipped |= ((P >> 7) & 0x0000000000020000ULL & O);
+	outflank_d = OUTFLANK_2[(((HIDWORD(O) & 0x00004020) + (LODWORD(O) & 0x100a0400)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x00804020110a0400) * 0x0101010101010101) >> 52;	// hgfedcb[ahgfe]...
+	flipped |= FLIPPED_2_H[outflank_d] & 0x00004020100a0400;	// A4C2H7
 
-	outflank_d9 = ((O | ~0x0080402010080000ULL) + 0x0000000000080000ULL) & P & 0x0080402010080400ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010080000ULL;
+	outflank_h = OUTFLANK_2[(O >> 9) & 0x3f] & rotl8(P >> 8, 4);
+	flipped |= (unsigned char) FLIPPED_2_H[outflank_h] << 8;
 
 	return flipped;
 }
@@ -534,20 +470,18 @@ static unsigned long long flip_C2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x0808080808080000ULL) + 0x0000000000080000ULL) & P & 0x0808080808080000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808080000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000000000ff00ULL;
+	outflank_v = ((O | ~0x0808080808080000) + 1) & P & 0x0808080808080000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080000;
 
-	outflank_d7 = ((O | ~0x0000000102040000ULL) + 0x0000000000040000ULL) & P & 0x0000000102040000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000102040000ULL;
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 8) & 0x40221408) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000804122140800) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000004022140800;	// A5D2H6
 
-	outflank_d9 = ((O | ~0x0000804020100000ULL) + 0x0000000000100000ULL) & P & 0x0000804020100000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000804020100000ULL;
+	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & rotl8(P >> 8, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h] << 8;
 
 	return flipped;
 }
@@ -561,20 +495,18 @@ static unsigned long long flip_D2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x1010101010100000ULL) + 0x0000000000100000ULL) & P & 0x1010101010100000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010100000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000000000ff00ULL;
+	outflank_v = ((O | ~0x1010101010100000) + 1) & P & 0x1010101010100000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010100000;
 
-	outflank_d7 = ((O | ~0x0000010204080000ULL) + 0x0000000000080000ULL) & P & 0x0000010204080000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000010204080000ULL;
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 8) & 0x02442810) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000018244281000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000244281000;	// A6E2H5
 
-	outflank_d9 = ((O | ~0x0000008040200000ULL) + 0x0000000000200000ULL) & P & 0x0000008040200000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000008040200000ULL;
+	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & rotl8(P >> 8, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h] << 8;
 
 	return flipped;
 }
@@ -588,19 +520,18 @@ static unsigned long long flip_E2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x2020202020200000ULL) + 0x0000000000200000ULL) & P & 0x2020202020200000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020200000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_5[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= (FLIPPED_5[outflank_h] << 9);
+	outflank_v = ((O | ~0x2020202020200000) + 1) & P & 0x2020202020200000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020200000;
 
-	outflank_d7 = ((O | ~0x0001020408100000ULL) + 0x0000000000100000ULL) & P & 0x0001020408100000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408100000ULL;
+	outflank_d = OUTFLANK_5[(((HIDWORD(O) & 0x00000204) + (LODWORD(O) & 0x08502000)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0001020488502000) * 0x0101010101010101) >> 55;	// hgfe[dcbah]...
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0000020408502000;	// A7F2H4
 
-	flipped |= ((P >> 9) & 0x0000000000400000ULL & O);
+	outflank_h = OUTFLANK_5[(O >> 9) & 0x3f] & rotl8(P >> 8, 1);
+	flipped |= (unsigned char) FLIPPED_5_H[outflank_h] << 8;
 
 	return flipped;
 }
@@ -617,14 +548,14 @@ static unsigned long long flip_G2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040400000ULL) + 0x0000000000400000ULL) & P & 0x4040404040400000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040400000ULL;
+	outflank_v = ((O | ~0x4040404040400000) + 1) & P & 0x4040404040400000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040400000;
 
-	outflank_h = OUTFLANK_7[(O >> 8) & 0x3e] & (P >> 7);
-	flipped |= ((-outflank_h) & 0x3e) << 8;
+	outflank_d7 = ((O | ~0x0102040810200000) + 1) & P & 0x0102040810200000;
+	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810200000;
 
-	outflank_d7 = ((O | ~0x0102040810200000ULL) + 0x0000000000200000ULL) & P & 0x0102040810200000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810200000ULL;
+	outflank_h = outflank_right_H(((unsigned int) O >> 9) << 27) & ((unsigned int) P << 18);
+	flipped |= (outflank_h * (unsigned int) -2) >> 18;
 
 	return flipped;
 }
@@ -641,14 +572,14 @@ static unsigned long long flip_H2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080800000ULL) + 0x0000000000800000ULL) & P & 0x8080808080800000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080800000ULL;
+	outflank_v = ((O | ~0x8080808080800000) + 1) & P & 0x8080808080800000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080800000;
 
-	outflank_h = OUTFLANK_7[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= ((-outflank_h) & 0x3f) << 9;
+	outflank_d7 = ((O | ~0x0204081020400000) + 1) & P & 0x0204081020400000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0204081020400000;
 
-	outflank_d7 = ((O | ~0x0204081020400000ULL) + 0x0000000000400000ULL) & P & 0x0204081020400000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0204081020400000ULL;
+	outflank_h = outflank_right_H(((unsigned int) O >> 9) << 26) & ((unsigned int) P << 17);
+	flipped |= (outflank_h * (unsigned int) -2) >> 17;
 
 	return flipped;
 }
@@ -662,18 +593,19 @@ static unsigned long long flip_H2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
-
-	outflank_v = ((O | ~0x0101010101000000ULL) + 0x0000000001000000ULL) & P & 0x0101010101000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101000000ULL;
+	unsigned int outflank_h, outflank_a1a3f8, outflank_a8a3c1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00000000007e0000ULL) + 0x0000000000020000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00000000007e0000ULL;
+	outflank_a1a3f8 = OUTFLANK_2[((O & 0x0010080402010100) * 0x0102040404040404) >> 57];
+	outflank_a1a3f8 &= ((P & 0x2010080402010101) * 0x8000000002020202) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_a1a3f8] & 0x0010080402010100;
 
-	outflank_d9 = ((O | ~0x2010080402000000ULL) + 0x0000000002000000ULL) & P & 0x2010080402000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x2010080402000000ULL;
+	outflank_a8a3c1 = OUTFLANK_5[((O & 0x0001010101010200) * 0x2020201008040201) >> 57];
+	outflank_a8a3c1 &= ((P & 0x0101010101010204) * 0x0200000080402010) >> 59;	// 56781
+	flipped |= vertical_mirror(FLIPPED_5_V[outflank_a8a3c1]) & 0x0001010101010200;
 
-	flipped |= (((P << 8) & 0x0000000000000100ULL) | ((P << 7) & 0x0000000000000200ULL)) & O;
+	outflank_h = ((O & 0x007e0000) + 0x00020000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007e0000;
 
 	return flipped;
 }
@@ -687,18 +619,19 @@ static unsigned long long flip_A3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
-
-	outflank_v = ((O | ~0x0202020202000000ULL) + 0x0000000002000000ULL) & P & 0x0202020202000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202000000ULL;
+	unsigned int outflank_h, outflank_b1b3g8, outflank_b8b3d1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00000000007c0000ULL) + 0x0000000000040000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00000000007c0000ULL;
+	outflank_b1b3g8 = OUTFLANK_2[((O & 0x0020100804020200) * 0x0081020202020202) >> 57];
+	outflank_b1b3g8 &= ((P & 0x4020100804020202) * 0x4000000001010101) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_b1b3g8] & 0x0020100804020200;
 
-	outflank_d9 = ((O | ~0x4020100804000000ULL) + 0x0000000004000000ULL) & P & 0x4020100804000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x4020100804000000ULL;
+	outflank_b8b3d1 = OUTFLANK_5[((O & 0x0002020202020400) * 0x0010100804020100) >> 57];
+	outflank_b8b3d1 &= ((P & 0x0202020202020408) * 0x0100000040201008) >> 59;	// 56781
+	flipped |= vertical_mirror(FLIPPED_5_V[outflank_b8b3d1]) & 0x0002020202020400;
 
-	flipped |= (((P << 8) & 0x0000000000000200ULL) | ((P << 7) & 0x0000000000000400ULL)) & O;
+	outflank_h = ((O & 0x007c0000) + 0x00040000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007c0000;
 
 	return flipped;
 }
@@ -712,19 +645,21 @@ static unsigned long long flip_B3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d9;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x0404040404000000ULL) + 0x0000000004000000ULL) & P & 0x0404040404000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404000000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0004040404040400) * 0x0040810204081020) >> 57];
+	outflank_v &= ((P & 0x0404040404040404) * 0x2000000002040810) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_v] & 0x0004040404040400;
 
-	outflank_h = OUTFLANK_2[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= (FLIPPED_2[outflank_h] << 17);
+	outflank_h = OUTFLANK_2[(O >> 17) & 0x3f] & rotl8(P >> 16, 4);
+	flipped |= (unsigned char) FLIPPED_2_H[outflank_h] << 16;
 
-	outflank_d9 = ((O | ~0x8040201008000000ULL) + 0x0000000008000000ULL) & P & 0x8040201008000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008000000ULL;
+	flipped |= (((P >> 7) | (P << 7)) & 0x000000002000800) & O;
 
-	flipped |= (((P << 8) & 0x0000000000000400ULL) | ((P << 9) & 0x0000000000000200ULL) | (((P >> 7) | (P << 7)) & 0x000000002000800ULL)) & O;
+	outflank_d9 = OUTFLANK_2[(((HIDWORD(O) & 0x00402010) + (LODWORD(O) & 0x08040200)) * 0x01010101) >> 25];
+	outflank_d9 &= rotl8((((HIDWORD(P) & 0x80402010) + (LODWORD(P) & 0x08040201)) * 0x01010101) >> 24, 4);	// (h8)
+	flipped |= FLIPPED_2_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -738,22 +673,21 @@ static unsigned long long flip_C3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x0808080808000000ULL) + 0x0000000008000000ULL) & P & 0x0808080808000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808000000ULL;
+	unsigned int outflank_h, outflank_v, outflank_d;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_3[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000000000ff0000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0008080808080800) * 0x0020408102040810) >> 57];
+	outflank_v &= ((P & 0x0808080808080808) * 0x1020408001020408) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_v] & 0x0008080808080800;
 
-	outflank_d7 = ((O | ~0x0000010204000000ULL) + 0x0000000004000000ULL) & P & 0x0000010204000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 24)) & 0x0000010204000000ULL;
+	outflank_h = OUTFLANK_3[(O >> 17) & 0x3f] & rotl8(P >> 16, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h] << 16;
 
-	outflank_d9 = ((O | ~0x0080402010000000ULL) + 0x0000000010000000ULL) & P & 0x0080402010000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010000000ULL;
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 16) & 0x40221408) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0080412214080000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000402214080000;	// A6D3H7
 
-	flipped |= (((P << 8) & 0x0000000000000800ULL) | ((P << 7) & 0x0000000000001000ULL) | ((P << 9) & 0x000000000000400ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000000001000) | ((P << 9) & 0x000000000000400)) & O;
 
 	return flipped;
 }
@@ -767,22 +701,21 @@ static unsigned long long flip_D3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x1010101010000000ULL) + 0x0000000010000000ULL) & P & 0x1010101010000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010000000ULL;
+	unsigned int outflank_h, outflank_v, outflank_d;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_4[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000000000ff0000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0010101010101000) * 0x0010204081020408) >> 57];
+	outflank_v &= ((P & 0x1010101010101010) * 0x0810204000810204) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_v] & 0x0010101010101000;
 
-	outflank_d7 = ((O | ~0x0001020408000000ULL) + 0x0000000008000000ULL) & P & 0x0001020408000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408000000ULL;
+	outflank_h = OUTFLANK_4[(O >> 17) & 0x3f] & rotl8(P >> 16, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h] << 16;
 
-	outflank_d9 = ((O | ~0x0000804020000000ULL) + 0x0000000020000000ULL) & P & 0x0000804020000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 24)) & 0x0000804020000000ULL;
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 16) & 0x02442810) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0001824428100000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000024428100000;	// A7E3H6
 
-	flipped |= (((P << 8) & 0x0000000000001000ULL) | ((P << 7) & 0x0000000000002000ULL) | ((P << 9) & 0x000000000000800ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000000002000) | ((P << 9) & 0x000000000000800)) & O;
 
 	return flipped;
 }
@@ -796,19 +729,21 @@ static unsigned long long flip_E3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_v, outflank_d7;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x2020202020000000ULL) + 0x0000000020000000ULL) & P & 0x2020202020000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020000000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0020202020202000) * 0x0008102040810204) >> 57];
+	outflank_v &= ((P & 0x2020202020202020) * 0x0408102000408102) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_v] & 0x0020202020202000;
 
-	outflank_h = OUTFLANK_5[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= (FLIPPED_5[outflank_h] << 17);
+	outflank_h = OUTFLANK_5[(O >> 17) & 0x3f] & rotl8(P >> 16, 1);
+	flipped |= (unsigned char) FLIPPED_5_H[outflank_h] << 16;
 
-	outflank_d7 = ((O | ~0x0102040810000000ULL) + 0x0000000010000000ULL) & P & 0x0102040810000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810000000ULL;
+	outflank_d7 = OUTFLANK_5[(((HIDWORD(O) & 0x00020408) + (LODWORD(O) & 0x10204000)) * 0x01010101) >> 25];
+	outflank_d7 &= ((P & 0x0102040810204080) * 0x0010000010101010) >> 59;	// dcbah
+	flipped |= FLIPPED_5_H[outflank_d7] & 0x0002040810204000;
 
-	flipped |= (((P << 8) & 0x0000000000002000ULL) | ((P << 7) & 0x0000000000004000ULL) | (((P >> 9) | (P << 9)) & 0x0000000040001000ULL)) & O;
+	flipped |= (((P >> 9) | (P << 9)) & 0x0000000040001000) & O;
 
 	return flipped;
 }
@@ -822,19 +757,19 @@ static unsigned long long flip_F3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_G3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x4040404040000000ULL) + 0x0000000040000000ULL) & P & 0x4040404040000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040000000ULL;
+	unsigned int outflank_h, outflank_e1g3g8, outflank_b8g3g1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 16) & 0x3e] & (P >> 15);
-	flipped |= ((-outflank_h) & 0x3e) << 16;
+	outflank_e1g3g8 = OUTFLANK_2[((O & 0x0040404040402000) * 0x0010101020408102) >> 57];
+	outflank_e1g3g8 &= ((P & 0x4040404040402010) * 0x0800000000204081) >> 59;	// 18765
+	flipped = FLIPPED_2_V[outflank_e1g3g8] & 0x0040404040402000;
 
-	outflank_d7 = ((O | ~0x0204081020000000ULL) + 0x0000000020000000ULL) & P & 0x0204081020000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0204081020000000ULL;
+	outflank_b8g3g1 = OUTFLANK_5[((O & 0x0004081020404000) * 0x0402010101010101) >> 58];
+	outflank_b8g3g1 &= ((P & 0x0204081020404040) * 0x0020000008080808) >> 59;	// 43218
+	flipped |= vertical_mirror(FLIPPED_5_V[outflank_b8g3g1]) & 0x0004081020404000;
 
-	flipped |= (((P << 8) & 0x0000000000004000ULL) | ((P << 9) & 0x0000000000002000ULL)) & O;
+	outflank_h = outflank_right_H(((unsigned int) O >> 17) << 27) & (unsigned int) (P << 10);
+	flipped |= (outflank_h * (unsigned int) -2) >> 10;
 
 	return flipped;
 }
@@ -848,19 +783,19 @@ static unsigned long long flip_G3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_H3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x8080808080000000ULL) + 0x0000000080000000ULL) & P & 0x8080808080000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080000000ULL;
+	unsigned int outflank_h, outflank_f1h3h8, outflank_c8h3h1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= ((-outflank_h) & 0x3f) << 17;
+	outflank_f1h3h8 = OUTFLANK_2[((O & 0x0080808080804000) * 0x0008080810204081) >> 57];
+	outflank_f1h3h8 &= rotl8(((P & 0x8080808080804020) * 0x0008080810204081) >> 56, 4);	// (h8)
+	flipped = FLIPPED_2_V[outflank_f1h3h8] & 0x0080808080804000;
 
-	outflank_d7 = ((O | ~0x0408102040000000ULL) + 0x0000000040000000ULL) & P & 0x0408102040000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0408102040000000ULL;
+	outflank_c8h3h1 = OUTFLANK_5[((O & 0x0008102040808000) * 0x0000804040404040) >> 57];
+	outflank_c8h3h1 &= ((P & 0x0408102040808080) * 0x0010000004040404) >> 59;	// 43218
+	flipped |= vertical_mirror(FLIPPED_5_V[outflank_c8h3h1]) & 0x0008102040808000;
 
-	flipped |= (((P << 8) & 0x0000000000008000ULL) | ((P << 9) & 0x0000000000004000ULL)) & O;
+	outflank_h = outflank_right_H(((unsigned int) O >> 17) << 26) & (unsigned int) (P << 9);
+	flipped |= (outflank_h * (unsigned int) -2) >> 9;
 
 	return flipped;
 }
@@ -874,21 +809,19 @@ static unsigned long long flip_H3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57] & (((P & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0001010101010100ULL;
+	unsigned int outflank_h, outflank_a1a4e8, outflank_a8a4d1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x000000007e000000ULL) + 0x0000000002000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x000000007e000000ULL;
+	outflank_a1a4e8 = OUTFLANK_3[((O & 0x0008040201010100) * 0x0102040808080808) >> 57];
+	outflank_a1a4e8 &= ((P & 0x1008040201010101) * 0x4080000000020202) >> 59;	// 21876
+	flipped = FLIPPED_3_V[outflank_a1a4e8] & 0x0008040201010100;
 
-	flip_d7 = O & 0x0000000000020000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_a8a4d1 = OUTFLANK_4[((O & 0x0001010101020400) * 0x1010101008040201) >> 57];
+	outflank_a8a4d1 &= ((P & 0x0101010101020408) * 0x0202000000804020) >> 59;	// 67812
+	flipped |= vertical_mirror(FLIPPED_4_V[outflank_a8a4d1]) & 0x0001010101020400;
 
-	outflank_d9 = ((O | ~0x1008040200000000ULL) + 0x0000000200000000ULL) & P & 0x1008040200000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x1008040200000000ULL;
+	outflank_h = ((unsigned int) O + 0x02000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e000000;
 
 	return flipped;
 }
@@ -902,21 +835,19 @@ static unsigned long long flip_A4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57] & (((P & 0x0202020202020202ULL) * 0x0081020408102040ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0002020202020200ULL;
+	unsigned int outflank_h, outflank_b1b4f8, outflank_b8b4e1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x000000007c000000ULL) + 0x0000000004000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x000000007c000000ULL;
+	outflank_b1b4f8 = OUTFLANK_3[((O & 0x0010080402020200) * 0x0081020404040404) >> 57];
+	outflank_b1b4f8 &= ((P & 0x2010080402020202) * 0x2040000000010101) >> 59;	// 21876
+	flipped = FLIPPED_3_V[outflank_b1b4f8] & 0x0010080402020200;
 
-	flip_d7 = O & 0x0000000000040000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_b8b4e1 = OUTFLANK_4[((O & 0x0002020202040800) * 0x1010101008040201) >> 58];
+	outflank_b8b4e1 &= ((P & 0x0202020202040810) * 0x0101000000402010) >> 59;	// 67812
+	flipped |= vertical_mirror(FLIPPED_4_V[outflank_b8b4e1]) & 0x0002020202040800;
 
-	outflank_d9 = ((O | ~0x2010080400000000ULL) + 0x0000000400000000ULL) & P & 0x2010080400000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x2010080400000000ULL;
+	outflank_h = ((unsigned int) O + 0x04000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c000000;
 
 	return flipped;
 }
@@ -930,23 +861,21 @@ static unsigned long long flip_B4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57] & (((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0004040404040400ULL;
+	unsigned int outflank_h, outflank_c1c4g8, outflank_c8c4f1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_2[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= (FLIPPED_2[outflank_h] << 25);
+	outflank_c1c4g8 = OUTFLANK_3[((O & 0x0020100804040400) * 0x0040810202020202) >> 57];
+	outflank_c1c4g8 &= rotl8(((P & 0x4020100804040404) * 0x0040810202020202) >> 56, 3);	// (g8)
+	flipped = FLIPPED_3_V[outflank_c1c4g8] & 0x0020100804040400;
 
-	flip_d7 = O & 0x0000000000080000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_c8c4f1 = OUTFLANK_4[((O & 0x0004040404081000) * 0x0404040402010080) >> 57];
+	outflank_c8c4f1 &= ((P & 0x0404040404081020) * 0x0080800000201008) >> 59;	// 67812
+	flipped |= vertical_mirror(FLIPPED_4_V[outflank_c8c4f1]) & 0x0004040404081000;
 
-	outflank_d9 = ((O | ~0x4020100800000000ULL) + 0x0000000800000000ULL) & P & 0x4020100800000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x4020100800000000ULL;
+	outflank_h = OUTFLANK_2[(O >> 25) & 0x3f] & rotl8(P >> 24, 4);
+	flipped |= (unsigned char) FLIPPED_2_H[outflank_h] << 24;
 
-	flipped |= (((P << 9) & 0x00000000000020000ULL) | ((P >> 7) & 0x00000000200000000ULL)) & O;
+	flipped |= (((P << 9) & 0x00000000000020000) | ((P >> 7) & 0x00000000200000000)) & O;
 
 	return flipped;
 }
@@ -963,17 +892,20 @@ static unsigned long long flip_D4(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_3[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800ULL;
+	outflank_v = OUTFLANK_3[((O & 0x0008080808080800) * 0x0020408102040810) >> 57];
+	outflank_v &= ((P & 0x0808080808080808) * 0x0810000000010204) >> 59;	// 21876
+	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800;
 
-	outflank_h = OUTFLANK_3[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00000000ff000000ULL;
+	outflank_h = OUTFLANK_3[(O >> 25) & 0x3f] & rotl8(P >> 24, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h] << 24;
 
-	outflank_d7 = OUTFLANK_3[((O & 0x0000020408102000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0001020408102040ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000ULL;
+	outflank_d7 = OUTFLANK_3[(((HIDWORD(O) & 0x00000204) + (LODWORD(O) & 0x08102000)) * 0x01010101) >> 25];
+	outflank_d7 &= ((P & 0x0001020408102040) * 0x0040400000404000) >> 59;	// ba0gf
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000;
 
-	outflank_d9 = OUTFLANK_3[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200ULL;
+	outflank_d9 = OUTFLANK_3[(((HIDWORD(O) & 0x00402010) + (LODWORD(O) & 0x08040200)) * 0x01010101) >> 25];
+	outflank_d9 &= rotl8((((HIDWORD(P) & 0x80402010) + (LODWORD(P) & 0x08040201)) * 0x01010101) >> 24, 3);	// (h8)
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -990,17 +922,20 @@ static unsigned long long flip_E4(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_3[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000ULL;
+	outflank_v = OUTFLANK_3[((O & 0x0010101010101000) * 0x0010204081020408) >> 57];
+	outflank_v &= ((P & 0x1010101010101010) * 0x0408000000008102) >> 59;	// 21876
+	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000;
 
-	outflank_h = OUTFLANK_4[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00000000ff000000ULL;
+	outflank_h = OUTFLANK_4[(O >> 25) & 0x3f] & rotl8(P >> 24, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h] << 24;
 
-	outflank_d7 = OUTFLANK_4[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000ULL;
+	outflank_d7 = OUTFLANK_4[(((HIDWORD(O) & 0x00020408) + (LODWORD(O) & 0x10204000)) * 0x01010101) >> 25];
+	outflank_d7 &= ((P & 0x0102040810204080) * 0x0020200000202020) >> 59;	// cbahg
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000;
 
-	outflank_d9 = OUTFLANK_4[((O & 0x0000402010080400ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0080402010080402ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400ULL;
+	outflank_d9 = OUTFLANK_4[(((HIDWORD(O) & 0x00004020) + (LODWORD(O) & 0x10080400)) * 0x01010101) >> 25];
+	outflank_d9 &= ((P & 0x0080402010080402) * 0x0404000000040404) >> 56;	// cbahg
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400;
 
 	return flipped;
 }
@@ -1014,23 +949,21 @@ static unsigned long long flip_E4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57] & (((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0020202020202000ULL;
+	unsigned int outflank_h, outflank_c1f4f8, outflank_b8f4f1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_5[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= (FLIPPED_5[outflank_h] << 25);
+	outflank_c1f4f8 = OUTFLANK_3[((O & 0x0020202020100800) * 0x0040404040810204) >> 57];
+	outflank_c1f4f8 &= ((P & 0x2020202020100804) * 0x1010000000004081) >> 59;	// 21876
+	flipped = FLIPPED_3_V[outflank_c1f4f8] & 0x0020202020100800;
 
-	outflank_d7 = ((O | ~0x0204081000000000ULL) + 0x0000001000000000ULL) & P & 0x0204081000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0204081000000000ULL;
+	outflank_b8f4f1 = OUTFLANK_4[((O & 0x0004081020202000) * 0x0804020101010101) >> 58];
+	outflank_b8f4f1 &= ((P & 0x0204081020202020) * 0x0080400000101010) >> 59;	// 67812
+	flipped |= vertical_mirror(FLIPPED_4_V[outflank_b8f4f1]) & 0x0004081020202000;
 
-	flip_d9 = O & 0x0000000000100000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
+	outflank_h = OUTFLANK_5[(O >> 25) & 0x3f] & rotl8(P >> 24, 1);
+	flipped |= (unsigned char) FLIPPED_5_H[outflank_h] << 24;
 
-	flipped |= (((P << 7) & 0x0000000000400000ULL) | ((P >> 9) & 0x0000004000000000ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000000400000) | ((P >> 9) & 0x0000004000000000)) & O;
 
 	return flipped;
 }
@@ -1044,21 +977,19 @@ static unsigned long long flip_F4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_G4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57] & (((P & 0x4040404040404040ULL) * 0x0004081020408102ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0040404040404000ULL;
+	unsigned int outflank_h, outflank_d1g4g8, outflank_c8g4g1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 24) & 0x3e] & (P >> 23);
-	flipped |= ((-outflank_h) & 0x3e) << 24;
+	outflank_d1g4g8 = OUTFLANK_3[((O & 0x0040404040201000) * 0x0020202020408102) >> 57];
+	outflank_d1g4g8 &= rotl8(((P & 0x4040404040201008) * 0x0020202020408102) >> 56, 3);	// (g8)
+	flipped = FLIPPED_3_V[outflank_d1g4g8] & 0x0040404040201000;
 
-	outflank_d7 = ((O | ~0x0408102000000000ULL) + 0x0000002000000000ULL) & P & 0x0408102000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0408102000000000ULL;
+	outflank_c8g4g1 = OUTFLANK_4[((O & 0x0008102040404000) * 0x0001008040404040) >> 57];
+	outflank_c8g4g1 &= ((P & 0x0408102040404040) * 0x0040200000080808) >> 59;	// 67812
+	flipped |= vertical_mirror(FLIPPED_4_V[outflank_c8g4g1]) & 0x0008102040404000;
 
-	flip_d9 = O & 0x0000000000200000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
+	outflank_h = outflank_right_H(((unsigned int) O >> 25) << 27) & (unsigned int) (P << 2);
+	flipped |= (outflank_h * (unsigned int) -2) >> 2;
 
 	return flipped;
 }
@@ -1072,21 +1003,19 @@ static unsigned long long flip_G4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_H4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57] & (((P & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0080808080808000ULL;
+	unsigned int outflank_h, outflank_e1h4h8, outflank_d8h4h1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= ((-outflank_h) & 0x3f) << 25;
+	outflank_e1h4h8 = OUTFLANK_3[((O & 0x0080808080402000) * 0x0010101010204081) >> 57];
+	outflank_e1h4h8 &= rotl8(((P & 0x8080808080402010) * 0x0010101010204081) >> 56, 3);	// (h8)
+	flipped = FLIPPED_3_V[outflank_e1h4h8] & 0x0080808080402000;
 
-	outflank_d7 = ((O | ~0x0810204000000000ULL) + 0x0000004000000000ULL) & P & 0x0810204000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0810204000000000ULL;
+	outflank_d8h4h1 = OUTFLANK_4[((O & 0x0010204080808000) * 0x0000804020202020) >> 57];
+	outflank_d8h4h1 &= ((P & 0x0810204080808080) * 0x0020100000040404) >> 59;	// 67812
+	flipped |= vertical_mirror(FLIPPED_4_V[outflank_d8h4h1]) & 0x0010204080808000;
 
-	flip_d9 = O & 0x0000000000400000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
+	outflank_h = outflank_right_H(((unsigned int) O >> 25) << 26) & (unsigned int) (P << 1);
+	flipped |= (outflank_h * (unsigned int) -2) >> 1;
 
 	return flipped;
 }
@@ -1100,17 +1029,19 @@ static unsigned long long flip_H4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_a1a5d8, outflank_a8a5e1;
-	unsigned long long flipped, outflank_h;
+	unsigned int outflank_h, outflank_a1a5d8, outflank_a8a5e1;
+	unsigned long long flipped;
 
-	outflank_a1a5d8 = OUTFLANK_4[((O & 0x0004020101010100ULL) * 0x0102040810101010ULL) >> 57] & (((P & 0x0804020101010101ULL) * 0x0102040810101010ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_a1a5d8] & 0x0004020101010100ULL;
+	outflank_a1a5d8 = OUTFLANK_4[((O & 0x0004020101010100) * 0x0102040810101010) >> 57];
+	outflank_a1a5d8 &= ((P & 0x0804020101010101) * 0x2040800000000202) >> 59;	// 32187
+	flipped = FLIPPED_4_V[outflank_a1a5d8] & 0x0004020101010100;
 
-	outflank_a8a5e1 = OUTFLANK_3[((O & 0x0001010102040800ULL) * 0x0808080808040201ULL) >> 57] & (((P & 0x0101010102040810ULL) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_a8a5e1] & 0x0001010102040800ULL;
+	outflank_a8a5e1 = OUTFLANK_3[((O & 0x0001010102040800) * 0x0808080808040201) >> 57];
+	outflank_a8a5e1 &= ((P & 0x0101010102040810) * 0x0202020000008040) >> 59;	// 78123
+	flipped |= vertical_mirror(FLIPPED_3_V[outflank_a8a5e1]) & 0x0001010102040800;
 
-	outflank_h = ((O & 0x0000007e00000000ULL) + 0x0000000200000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000007e00000000ULL;
+	outflank_h = ((unsigned int) (O >> 8) + 0x02000000) & (unsigned int) (P >> 8);
+	flipped |= (((unsigned long long) outflank_h << 8) - outflank_h) & 0x0000007e00000000;
 
 	return flipped;
 }
@@ -1124,17 +1055,19 @@ static unsigned long long flip_A5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_b1b5e8, outflank_b8b5f1;
-	unsigned long long flipped, outflank_h;
+	unsigned int outflank_h, outflank_b1b5e8, outflank_b8b5f1;
+	unsigned long long flipped;
 
-	outflank_b1b5e8 = OUTFLANK_4[((O & 0x0008040202020200ULL) * 0x0081020408080808ULL) >> 57] & (((P & 0x1008040202020202ULL) * 0x0081020408080808ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_b1b5e8] & 0x0008040202020200ULL;
+	outflank_b1b5e8 = OUTFLANK_4[((O & 0x0008040202020200) * 0x0081020408080808) >> 57];
+	outflank_b1b5e8 &= ((P & 0x1008040202020202) * 0x1020400000000101) >> 59;	// 32187
+	flipped = FLIPPED_4_V[outflank_b1b5e8] & 0x0008040202020200;
 
-	outflank_b8b5f1 = OUTFLANK_3[((O & 0x0002020204081000ULL) * 0x0808080808040201ULL) >> 58] & ((((P & 0x0202020204081020ULL) >> 1) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_b8b5f1] & 0x0002020204081000ULL;
+	outflank_b8b5f1 = OUTFLANK_3[((O & 0x0002020204081000) * 0x0808080808040201) >> 58];
+	outflank_b8b5f1 &= ((P & 0x0202020204081020) * 0x0101010000004020) >> 59;	// 78123
+	flipped |= vertical_mirror(FLIPPED_3_V[outflank_b8b5f1]) & 0x0002020204081000;
 
-	outflank_h = ((O & 0x0000007c00000000ULL) + 0x0000000400000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000007c00000000ULL;
+	outflank_h = ((unsigned int) (O >> 8) + 0x04000000) & (unsigned int) (P >> 8);
+	flipped |= (((unsigned long long) outflank_h << 8) - outflank_h) & 0x0000007c00000000;
 
 	return flipped;
 }
@@ -1148,19 +1081,21 @@ static unsigned long long flip_B5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_c1c5f8, outflank_c8c5g1;
-	unsigned long long flipped, outflank_h;
+	unsigned int outflank_h, outflank_c1c5f8, outflank_c8c5g1;
+	unsigned long long flipped;
 
-	outflank_c1c5f8 = OUTFLANK_4[((O & 0x0010080404040400ULL) * 0x0040810204040404ULL) >> 57] & (((P & 0x2010080404040404ULL) * 0x0040810204040404ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_c1c5f8] & 0x0010080404040400ULL;
+	outflank_c1c5f8 = OUTFLANK_4[((O & 0x0010080404040400) * 0x0040810204040404) >> 57];
+	outflank_c1c5f8 &= rotl8(((P & 0x2010080404040404) * 0x0040810204040404) >> 56, 2);	// (f8)
+	flipped = FLIPPED_4_V[outflank_c1c5f8] & 0x0010080404040400;
 
-	outflank_c8c5g1 = OUTFLANK_3[((O & 0x0004040408102000ULL) * 0x0002020202010080ULL) >> 57] & ((((P & 0x0404040408102040ULL) >> 2) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_c8c5g1] & 0x0004040408102000ULL;
+	outflank_c8c5g1 = OUTFLANK_3[((O & 0x0004040408102000) * 0x0002020202010080) >> 57];
+	outflank_c8c5g1 &= ((P & 0x0404040408102040) * 0x0080808000002010) >> 59;	// 78123
+	flipped |= vertical_mirror(FLIPPED_3_V[outflank_c8c5g1]) & 0x0004040408102000;
 
-	outflank_h = OUTFLANK_2[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= ((unsigned long long) FLIPPED_2[outflank_h]) << 33;
+	outflank_h = OUTFLANK_2[(O >> 33) & 0x3f] & rotl8(P >> 32, 4);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_2_H[outflank_h] << 32;
 
-	flipped |= (((P << 9) & 0x0000000002000000ULL) | ((P >> 7) & 0x0000020000000000ULL)) & O;
+	flipped |= (((P << 9) & 0x0000000002000000) | ((P >> 7) & 0x0000020000000000)) & O;
 
 	return flipped;
 }
@@ -1177,17 +1112,20 @@ static unsigned long long flip_D5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_4[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800ULL;
+	outflank_v = OUTFLANK_4[((O & 0x0008080808080800) * 0x0020408102040810) >> 57];
+	outflank_v &= ((P & 0x0808080808080808) * 0x0408100000000102) >> 59;	// 32187
+	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800;
 
-	outflank_h = OUTFLANK_3[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000ULL;
+	outflank_h = OUTFLANK_3[(O >> 33) & 0x3f] & rotl8(P >> 32, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 32;
 
-	outflank_d7 = OUTFLANK_3[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000ULL;
+	outflank_d7 = OUTFLANK_3[(((HIDWORD(O) & 0x00020408) + (LODWORD(O) & 0x10204000)) * 0x01010101) >> 25];
+	outflank_d7 &= ((P & 0x0102040810204080) * 0x0040404000004040) >> 59;	// bahgf
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000;
 
-	outflank_d9 = OUTFLANK_3[((O & 0x0020100804020000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x4020100804020100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000ULL;
+	outflank_d9 = OUTFLANK_3[(((HIDWORD(O) & 0x00201008) + (LODWORD(O) & 0x04020000)) * 0x01010101) >> 25];
+	outflank_d9 &= rotl8((((HIDWORD(P) & 0x40201008) + (LODWORD(P) & 0x04020100)) * 0x01010101) >> 24, 3);	// (g8)
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000;
 
 	return flipped;
 }
@@ -1204,17 +1142,20 @@ static unsigned long long flip_E5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_4[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000ULL;
+	outflank_v = OUTFLANK_4[((O & 0x0010101010101000) * 0x0010204081020408) >> 57];
+	outflank_v &= ((P & 0x1010101010101010) * 0x0204080000000081) >> 59;	// 32187
+	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000;
 
-	outflank_h = OUTFLANK_4[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000ULL;
+	outflank_h = OUTFLANK_4[(O >> 33) & 0x3f] & rotl8(P >> 32, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 32;
 
-	outflank_d7 = OUTFLANK_4[((O & 0x0004081020400000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0204081020408000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000ULL;
+	outflank_d7 = OUTFLANK_4[(((HIDWORD(O) & 0x00040810) + (LODWORD(O) & 0x20400000)) * 0x01010101) >> 25];
+	outflank_d7 &= ((P & 0x0204081020408000) * 0x0000202000002020) >> 59;	// cb0hg
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000;
 
-	outflank_d9 = OUTFLANK_4[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200ULL;
+	outflank_d9 = OUTFLANK_4[(((HIDWORD(O) & 0x00402010) + (LODWORD(O) & 0x08040200)) * 0x01010101) >> 25];
+	outflank_d9 &= rotl8((((HIDWORD(P) & 0x80402010) + (LODWORD(P) & 0x08040201)) * 0x01010101) >> 24, 2);	// (h8)
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1231,16 +1172,18 @@ static unsigned long long flip_F5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_b1f5f8, outflank_c8f5f1;
 	unsigned long long flipped;
 
-	outflank_b1f5f8 = OUTFLANK_4[((O & 0x0020202010080400ULL) * 0x0080808080810204ULL) >> 57] & (((P & 0x2020202010080402ULL) * 0x0080808080810204ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_b1f5f8] & 0x0020202010080400ULL;
+	outflank_b1f5f8 = OUTFLANK_4[((O & 0x0020202010080400) * 0x0080808080810204) >> 57];
+	outflank_b1f5f8 &= rotl8(((P & 0x2020202010080402) * 0x0080808080810204) >> 56, 2);	// (f8)
+	flipped = FLIPPED_4_V[outflank_b1f5f8] & 0x0020202010080400;
 
-	outflank_c8f5f1 = OUTFLANK_3[((O & 0x0008102020202000ULL) * 0x0002010080404040ULL) >> 57] & ((((P & 0x0408102020202020ULL) >> 2) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_c8f5f1] & 0x0008102020202000ULL;
+	outflank_c8f5f1 = OUTFLANK_3[((O & 0x0008102020202000) * 0x0002010080404040) >> 57];
+	outflank_c8f5f1 &= ((P & 0x0408102020202020) * 0x0100804000001010) >> 59;	// 78123
+	flipped |= vertical_mirror(FLIPPED_3_V[outflank_c8f5f1]) & 0x0008102020202000;
 
-	outflank_h = OUTFLANK_5[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= ((unsigned long long) FLIPPED_5[outflank_h]) << 33;
+	outflank_h = OUTFLANK_5[(O >> 33) & 0x3f] & rotl8(P >> 32, 1);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_5_H[outflank_h] << 32;
 
-	flipped |= (((P << 7) & 0x0000000040000000ULL) | ((P >> 9) & 0x0000400000000000ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000040000000) | ((P >> 9) & 0x0000400000000000)) & O;
 
 	return flipped;
 }
@@ -1257,14 +1200,16 @@ static unsigned long long flip_G5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_c1g5g8, outflank_d8g5g1;
 	unsigned long long flipped;
 
-	outflank_c1g5g8 = OUTFLANK_4[((O & 0x0040404020100800ULL) * 0x0040404040408102ULL) >> 57] & (((P & 0x4040404020100804ULL) * 0x0040404040408102ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_c1g5g8] & 0x0040404020100800ULL;
+	outflank_c1g5g8 = OUTFLANK_4[((O & 0x0040404020100800) * 0x0040404040408102) >> 57];
+	outflank_c1g5g8 &= rotl8(((P & 0x4040404020100804) * 0x0040404040408102) >> 56, 2);	// (g8)
+	flipped = FLIPPED_4_V[outflank_c1g5g8] & 0x0040404020100800;
 
-	outflank_d8g5g1 = OUTFLANK_3[((O & 0x0010204040404000ULL) * 0x0001008040202020ULL) >> 57] & ((((P & 0x0810204040404040ULL) >> 3) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_d8g5g1] & 0x0010204040404000ULL;
+	outflank_d8g5g1 = OUTFLANK_3[((O & 0x0010204040404000) * 0x0001008040202020) >> 57];
+	outflank_d8g5g1 &= ((P & 0x0810204040404040) * 0x0080402000000808) >> 59;	// 78123
+	flipped |= vertical_mirror(FLIPPED_3_V[outflank_d8g5g1]) & 0x0010204040404000;
 
-	outflank_h = OUTFLANK_7[(O >> 32) & 0x3e] & (P >> 31);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 32;
+	outflank_h = outflank_right_H((unsigned int) (O >> 33) << 27) & (unsigned int) (P >> 6);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 6;
 
 	return flipped;
 }
@@ -1281,14 +1226,16 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d1h5h8, outflank_e8h5h1;
 	unsigned long long flipped;
 
-	outflank_d1h5h8 = OUTFLANK_4[((O & 0x0080808040201000ULL) * 0x0020202020204081ULL) >> 57] & (((P & 0x8080808040201008ULL) * 0x0020202020204081ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_d1h5h8] & 0x0080808040201000ULL;
+	outflank_d1h5h8 = OUTFLANK_4[((O & 0x0080808040201000) * 0x0020202020204081) >> 57];
+	outflank_d1h5h8 &= rotl8(((P & 0x8080808040201008) * 0x0020202020204081) >> 56, 2);	// (h8)
+	flipped = FLIPPED_4_V[outflank_d1h5h8] & 0x0080808040201000;
 
-	outflank_e8h5h1 = OUTFLANK_3[((O & 0x0020408080808000ULL) * 0x0000804020101010ULL) >> 57] & ((((P & 0x1020408080808080ULL) >> 4) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_e8h5h1] & 0x0020408080808000ULL;
+	outflank_e8h5h1 = OUTFLANK_3[((O & 0x0020408080808000) * 0x0000804020101010) >> 57];
+	outflank_e8h5h1 &= ((P & 0x1020408080808080) * 0x0040201000000404) >> 59;	// 78123
+	flipped |= vertical_mirror(FLIPPED_3_V[outflank_e8h5h1]) & 0x0020408080808000;
 
-	outflank_h = OUTFLANK_7[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 33;
+	outflank_h = outflank_right_H((unsigned int) (O >> 33) << 26) & (unsigned int) (P >> 7);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 7;
 
 	return flipped;
 }
@@ -1302,18 +1249,19 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000101010100ULL) ^ 0x0000000101010101ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000000101010100ULL;
+	unsigned int outflank_h, outflank_a1a6c8, outflank_a8a6f1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00007e0000000000ULL) + 0x0000020000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007e0000000000ULL;
+	outflank_a1a6c8 = OUTFLANK_5[((O & 0x0002010101010100) * 0x0102040810202020) >> 57];
+	outflank_a1a6c8 &= ((P & 0x0402010101010101) * 0x1020408000000002) >> 59;	// 43218
+	flipped = FLIPPED_5_V[outflank_a1a6c8] & 0x0002010101010100;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000204081000ULL) ^ 0x0000000204081020ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000000204081000ULL;
+	outflank_a8a6f1 = OUTFLANK_2[((O & 0x0001010204081000) * 0x0404040404040201) >> 57];
+	outflank_a8a6f1 &= ((P & 0x0101010204081020) * 0x0202020200000080) >> 59;	// 81234
+	flipped |= vertical_mirror(FLIPPED_2_V[outflank_a8a6f1]) & 0x0001010204081000;
 
-	flipped |= (((P >> 8) & 0x0001000000000000ULL) | ((P >> 9) & 0x0002000000000000ULL)) & O;
+	outflank_h = ((unsigned int) (O >> 16) + 0x02000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x00007e0000000000;
 
 	return flipped;
 }
@@ -1327,18 +1275,19 @@ static unsigned long long flip_A6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000202020200ULL) ^ 0x0000000202020202ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000000202020200ULL;
+	unsigned int outflank_h, outflank_b1b6d8, outflank_b8b6g1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00007c0000000000ULL) + 0x0000040000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007c0000000000ULL;
+	outflank_b1b6d8 = OUTFLANK_5[((O & 0x0004020202020200) * 0x0081020408101010) >> 57];
+	outflank_b1b6d8 &= ((P & 0x0804020202020202) * 0x0810204000000001) >> 59;	// 43218
+	flipped = FLIPPED_5_V[outflank_b1b6d8] & 0x0004020202020200;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000408102000ULL) ^ 0x0000000408102040ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000000408102000ULL;
+	outflank_b8b6g1 = OUTFLANK_2[((O & 0x0002020408102000) * 0x0404040404040201) >> 58];
+	outflank_b8b6g1 &= ((P & 0x0202020408102040) * 0x0101010100000040) >> 59;	// 81234
+	flipped |= vertical_mirror(FLIPPED_2_V[outflank_b8b6g1]) & 0x0002020408102000;
 
-	flipped |= (((P >> 8) & 0x0002000000000000ULL) | ((P >> 9) & 0x0004000000000000ULL)) & O;
+	outflank_h = ((unsigned int) (O >> 16) + 0x04000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x00007c0000000000;
 
 	return flipped;
 }
@@ -1352,19 +1301,21 @@ static unsigned long long flip_B6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_v, outflank_d7;
+	unsigned long long flipped;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000404040400ULL) ^ 0x0000000404040404ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000000404040400ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0004040404040400) * 0x0040810204081020) >> 57];
+	outflank_v &= ((P & 0x0404040404040404) * 0x0408102000000002) >> 59;	// 43218
+	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400;
 
-	outflank_h = OUTFLANK_2[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= ((unsigned long long) FLIPPED_2[outflank_h]) << 41;
+	outflank_h = OUTFLANK_2[(O >> 41) & 0x3f] & rotl8(P >> 40, 4);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_2_H[outflank_h] << 40;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000810204000ULL) ^ 0x0000000810204080ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000000810204000ULL;
+	outflank_d7 = OUTFLANK_2[(((HIDWORD(O) & 0x00020408) + (LODWORD(O) & 0x10204000)) * 0x01010101) >> 25];
+	outflank_d7 &= ((P & 0x0102040810204080) * 0x0080808080000080) >> 59;	// ahgfe
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000;
 
-	flipped |= (((P >> 8) & 0x0004000000000000ULL) | ((P >> 7) & 0x0002000000000000ULL) | (((P >> 9) | (P << 9)) & 0x0008000200000000ULL)) & O;
+	flipped |= ((P >> 9) | (P << 9)) & 0x0008000200000000 & O;
 
 	return flipped;
 }
@@ -1378,20 +1329,21 @@ static unsigned long long flip_C6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	unsigned int outflank_h, outflank_v, outflank_d;
+	unsigned long long flipped;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000000808080800ULL) ^ 0x0000000808080808ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000000808080800ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0008080808080800) * 0x0020408102040810) >> 57];
+	outflank_v &= ((P & 0x0808080808080808) * 0x0204081020408001) >> 59;	// 43218
+	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800;
 
-	outflank_h = OUTFLANK_3[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000ULL;
+	outflank_h = OUTFLANK_3[(O >> 41) & 0x3f] & rotl8(P >> 40, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 40;
 
-	outflank_d = OUTFLANK_3[((O & 0x0000001422400000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000001422418000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000001422400000ULL;	// A3D6H2
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 16) & 0x08142240) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000081422418000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000081422400000;	// A3D6H2
 
-	flipped |= (((P >> 8) & 0x0008000000000000ULL) | ((P >> 9) & 0x0010000000000000ULL) | ((P >> 7) & 0x0004000000000000ULL)) & O;
+	flipped |= (((P >> 9) & 0x0010000000000000) | ((P >> 7) & 0x0004000000000000)) & O;
 
 	return flipped;
 }
@@ -1405,20 +1357,21 @@ static unsigned long long flip_D6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	unsigned int outflank_h, outflank_v, outflank_d;
+	unsigned long long flipped;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000001010101000ULL) ^ 0x0000001010101010ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000001010101000ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0010101010101000) * 0x0010204081020408) >> 57];
+	outflank_v &= rotl8(((P & 0x1010101010101010) * 0x0010204081020408) >> 56, 1);	// (e8)
+	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000;
 
-	outflank_h = OUTFLANK_4[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000ULL;
+	outflank_h = OUTFLANK_4[(O >> 41) & 0x3f] & rotl8(P >> 40, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 40;
 
-	outflank_d = OUTFLANK_4[((O & 0x0000002844020000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000002844820100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000002844020000ULL;	// A2E6H3
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 16) & 0x10284402) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000102844820100) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000102844020000;	// A2E6H3
 
-	flipped |= (((P >> 8) & 0x0010000000000000ULL) | ((P >> 9) & 0x0020000000000000ULL) | ((P >> 7) & 0x0008000000000000ULL)) & O;
+	flipped |= (((P >> 9) & 0x0020000000000000) | ((P >> 7) & 0x0008000000000000)) & O;
 
 	return flipped;
 }
@@ -1432,19 +1385,21 @@ static unsigned long long flip_E6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d9;
+	unsigned long long flipped;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000002020202000ULL) ^ 0x0000002020202020ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000002020202000ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0020202020202000) * 0x0008102040810204) >> 57];
+	outflank_v &= rotl8(((P & 0x2020202020202020) * 0x0008102040810204) >> 56, 1);	// (f8)
+	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000;
 
-	outflank_h = OUTFLANK_5[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= ((unsigned long long) FLIPPED_5[outflank_h]) << 41;
+	outflank_h = OUTFLANK_5[(O >> 41) & 0x3f] & rotl8(P >> 40, 1);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_5_H[outflank_h] << 40;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000001008040200ULL) ^ 0x0000001008040201ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000001008040200ULL;
+	flipped |= ((P >> 7) | (P << 7)) & 0x0010004000000000 & O;
 
-	flipped |= (((P >> 8) & 0x0020000000000000ULL) | ((P >> 9) & 0x0040000000000000ULL) | (((P >> 7) | (P << 7)) & 0x0010004000000000ULL)) & O;
+	outflank_d9 = OUTFLANK_5[(((HIDWORD(O) & 0x00402010) + (LODWORD(O) & 0x08040200)) * 0x01010101) >> 25];
+	outflank_d9 &= rotl8((((HIDWORD(P) & 0x80402010) + (LODWORD(P) & 0x08040201)) * 0x01010101) >> 24, 1);	// (h8)
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1458,19 +1413,19 @@ static unsigned long long flip_F6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_G6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000004040404000ULL) ^ 0x0000004040404040ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000004040404000ULL;
+	unsigned int outflank_h, outflank_b1g6g8, outflank_e8g6g1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 40) & 0x3e] & (P >> 39);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 40;
+	outflank_b1g6g8 = OUTFLANK_5[((O & 0x0040402010080400) * 0x0080808080808102) >> 57];
+	outflank_b1g6g8 &= rotl8(((P & 0x4040402010080402) * 0x0080808080808102) >> 56, 1);	// (g8)
+	flipped = FLIPPED_5_V[outflank_b1g6g8] & 0x0040402010080400;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000002010080400ULL) ^ 0x0000002010080402ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000002010080400ULL;
+	outflank_e8g6g1 = OUTFLANK_2[((O & 0x0020404040404000) * 0x0001008040201010) >> 57];
+	outflank_e8g6g1 &= ((P & 0x1020404040404040) * 0x0100804020000008) >> 59;	// 81234
+	flipped |= vertical_mirror(FLIPPED_2_V[outflank_e8g6g1]) & 0x0020404040404000;
 
-	flipped |= (((P >> 8) & 0x0040000000000000ULL) | ((P >> 7) & 0x0020000000000000ULL)) & O;
+	outflank_h = outflank_right_H((unsigned int) (O >> 41) << 27) & (unsigned int) (P >> 14);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 14;
 
 	return flipped;
 }
@@ -1484,19 +1439,19 @@ static unsigned long long flip_G6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_H6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000008080808000ULL) ^ 0x0000008080808080ULL)) & P;
-	flipped = (-outflank_v * 2) & 0x0000008080808000ULL;
+	unsigned int outflank_h, outflank_c1h6h8, outflank_f8h6h1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 41;
+	outflank_c1h6h8 = OUTFLANK_5[((O & 0x0080804020100800) * 0x0040404040404081) >> 57];
+	outflank_c1h6h8 &= rotl8(((P & 0x8080804020100804) * 0x0040404040404081) >> 56, 1);	// (h8)
+	flipped = FLIPPED_5_V[outflank_c1h6h8] & 0x0080804020100800;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000004020100800ULL) ^ 0x0000004020100804ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000004020100800ULL;
+	outflank_f8h6h1 = OUTFLANK_2[((O & 0x0040808080808000) * 0x0000804020100808) >> 57];
+	outflank_f8h6h1 &= ((P & 0x2040808080808080) * 0x0080402010000004) >> 59;	// 81234
+	flipped |= vertical_mirror(FLIPPED_2_V[outflank_f8h6h1]) & 0x0040808080808000;
 
-	flipped |= (((P >> 8) & 0x0080000000000000ULL) | ((P >> 7) & 0x0040000000000000ULL)) & O;
+	outflank_h = outflank_right_H((unsigned int) (O >> 41) << 26) & (unsigned int) (P >> 15);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 15;
 
 	return flipped;
 }
@@ -1510,16 +1465,17 @@ static unsigned long long flip_H6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A7(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000010101010100ULL) ^ 0x0000010101010101ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000010101010100ULL;
+	outflank_v = outflank_right(O, 0x0000010101010101) & P;
+	flipped  = (outflank_v * -2) & 0x0000010101010101;
 
-	outflank_h = ((O & 0x007e000000000000ULL) + 0x0002000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007e000000000000ULL;
+	outflank_d7 = outflank_right(O, 0x0000020408102040) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000020408102040;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000020408102000ULL) ^ 0x0000020408102040ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000020408102000ULL;
+	outflank_h = ((unsigned int) (O >> 24) + 0x02000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x007e000000000000;
 
 	return flipped;
 }
@@ -1533,16 +1489,17 @@ static unsigned long long flip_A7(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B7(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000020202020200ULL) ^ 0x0000020202020202ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000020202020200ULL;
+	outflank_v = outflank_right(O, 0x0000020202020202) & P;
+	flipped  = (outflank_v * -2) & 0x0000020202020202;
 
-	outflank_h = ((O & 0x007c000000000000ULL) + 0x0004000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007c000000000000ULL;
+	outflank_d7 = outflank_right(O, 0x0000040810204080) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000040810204080;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000040810204000ULL) ^ 0x0000040810204080ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000040810204000ULL;
+	outflank_h = ((unsigned int) (O >> 24) + 0x04000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x007c000000000000;
 
 	return flipped;
 }
@@ -1556,19 +1513,18 @@ static unsigned long long flip_B7(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C7(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_d7, outflank_v;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000040404040400ULL) ^ 0x0000040404040404ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000040404040400ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_2[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= ((unsigned long long) FLIPPED_2[outflank_h]) << 49;
+	outflank_v = outflank_right(O, 0x0000040404040404) & P;
+	flipped  = (outflank_v * -2) & 0x0000040404040404;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000081020400000ULL) ^ 0x0000081020408000ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000081020400000ULL;
+	outflank_d = OUTFLANK_2[(((HIDWORD(O) & 0x00040a10) + (LODWORD(O) & 0x20400000)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x00040a1120408000) * 0x0101010101010101) >> 52;	// hgfedcb[ahgfe]...
+	flipped |= FLIPPED_2_H[outflank_d] & 0x00040a1020400000;	// A5C7H2
 
-	flipped |= (P << 9) & 0x0000020000000000ULL & O;
+	outflank_h = OUTFLANK_2[(O >> 49) & 0x3f] & rotl8(P >> 48, 4);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_2_H[outflank_h] << 48;
 
 	return flipped;
 }
@@ -1585,15 +1541,15 @@ static unsigned long long flip_D7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000080808080800ULL) ^ 0x0000080808080808ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000080808080800ULL;
+	outflank_v = outflank_right(O, 0x0000080808080808) & P;
+	flipped  = (outflank_v * -2) & 0x0000080808080808;
 
-	outflank_h = OUTFLANK_3[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000ULL;
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 24) & 0x08142240) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0008142241800000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0008142240000000;	// A4D7H3
 
-	outflank_d = OUTFLANK_3[((O & 0x0000142240000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000142241800000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000142240000000ULL;	// A4D7H3
+	outflank_h = OUTFLANK_3[(O >> 49) & 0x3f] & rotl8(P >> 48, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 48;
 
 	return flipped;
 }
@@ -1610,15 +1566,15 @@ static unsigned long long flip_E7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000101010101000ULL) ^ 0x0000101010101010ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000101010101000ULL;
+	outflank_v = outflank_right(O, 0x0000101010101010) & P;
+	flipped  = (outflank_v * -2) & 0x0000101010101010;
 
-	outflank_h = OUTFLANK_4[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000ULL;
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 24) & 0x10284402) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0010284482010000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0010284402000000;	// A3E7H4
 
-	outflank_d = OUTFLANK_4[((O & 0x0000284402000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000284482010000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000284402000000ULL;	// A3E7H4
+	outflank_h = OUTFLANK_4[(O >> 49) & 0x3f] & rotl8(P >> 48, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 48;
 
 	return flipped;
 }
@@ -1632,19 +1588,18 @@ static unsigned long long flip_E7(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F7(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_d9, outflank_v;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000202020202000ULL) ^ 0x0000202020202020ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000202020202000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_5[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= ((unsigned long long) FLIPPED_5[outflank_h]) << 49;
+	outflank_v = outflank_right(O, 0x0000202020202020) & P;
+	flipped  = (outflank_v * -2) & 0x0000202020202020;
 
-	flipped |= (P << 7) & 0x0000400000000000ULL & O;
+	outflank_d = OUTFLANK_5[(((HIDWORD(O) & 0x00205008) + (LODWORD(O) & 0x04020000)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0020508804020100) * 0x0101010101010101) >> 55;	// hgfe[dcbah]...
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0020500804020000;	// A2F7H5
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000100804020000ULL) ^ 0x0000100804020100ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000100804020000ULL;
+	outflank_h = OUTFLANK_5[(O >> 49) & 0x3f] & rotl8(P >> 48, 1);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_5_H[outflank_h] << 48;
 
 	return flipped;
 }
@@ -1661,14 +1616,14 @@ static unsigned long long flip_G7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000404040404000ULL) ^ 0x0000404040404040ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000404040404000ULL;
+	outflank_v = outflank_right(O, 0x0000404040404040) & P;
+	flipped  = (outflank_v * -2) & 0x0000404040404040;
 
-	outflank_h = OUTFLANK_7[(O >> 48) & 0x3e] & (P >> 47);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 48;
+	outflank_d9 = outflank_right(O, 0x0000201008040201) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000201008040201;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000201008040200ULL) ^ 0x0000201008040201ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000201008040200ULL;
+	outflank_h = outflank_right_H((unsigned int) (O >> 49) << 27) & (unsigned int) (P >> 22);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 22;
 
 	return flipped;
 }
@@ -1685,14 +1640,14 @@ static unsigned long long flip_H7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000808080808000ULL) ^ 0x0000808080808080ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0000808080808000ULL;
+	outflank_v = outflank_right(O, 0x0000808080808080) & P;
+	flipped  = (outflank_v * -2) & 0x0000808080808080;
 
-	outflank_h = OUTFLANK_7[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 49;
+	outflank_d9 = outflank_right(O, 0x0000402010080402) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000402010080402;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0000402010080400ULL) ^ 0x0000402010080402ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000402010080400ULL;
+	outflank_h = outflank_right_H((unsigned int) (O >> 49) << 26) & (unsigned int) (P >> 23);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 23;
 
 	return flipped;
 }
@@ -1708,14 +1663,14 @@ static unsigned long long flip_A8(const unsigned long long P, const unsigned lon
 {
 	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0001010101010100ULL) ^ 0x0001010101010101ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0001010101010100ULL;
+	outflank_v = outflank_right(O, 0x0001010101010101) & P;
+	flipped  = (outflank_v * -2) & 0x0001010101010101;
 
-	outflank_h = ((O & 0x7e00000000000000ULL) + 0x0200000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00000000000000ULL;
+	outflank_d7 = outflank_right(O, 0x0002040810204080) & P;
+	flipped |= (outflank_d7 * -2) & 0x0002040810204080;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0002040810204000ULL) ^ 0x0002040810204080ULL)) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0002040810204000ULL;
+	outflank_h = (O + 0x0200000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00000000000000;
 
 	return flipped;
 }
@@ -1731,14 +1686,14 @@ static unsigned long long flip_B8(const unsigned long long P, const unsigned lon
 {
 	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0002020202020200ULL) ^ 0x0002020202020202ULL)) & P;
-	flipped  = (0x8000000000000000ULL - outflank_v * 2) & 0x0002020202020200ULL;
+	outflank_v = outflank_right(O, 0x0002020202020202) & P;
+	flipped  = (outflank_v * -2) & 0x0002020202020202;
 
-	outflank_h = ((O & 0x7c00000000000000ULL) + 0x0400000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00000000000000ULL;
+	outflank_d7 = outflank_right(O, 0x0004081020408000) & P;
+	flipped |= (outflank_d7 * -2) & 0x0004081020408000;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0004081020400000ULL) ^ 0x0004081020408000ULL)) & P;
-	flipped |= (0x8000000000000000ULL - outflank_d7 * 2) & 0x0004081020400000ULL;
+	outflank_h = (O + 0x0400000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00000000000000;
 
 	return flipped;
 }
@@ -1752,19 +1707,18 @@ static unsigned long long flip_B8(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C8(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_d7, outflank_v;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0004040404040400ULL) ^ 0x0004040404040404ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0004040404040400ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_2[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= ((unsigned long long) FLIPPED_2[outflank_h]) << 57;
+	outflank_v = outflank_right(O, 0x0004040404040404) & P;
+	flipped  = (outflank_v * -2) & 0x0004040404040404;
 
-	outflank_d7 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0008102040000000ULL) ^ 0x0008102040800000ULL)) & P;
-	flipped |= (0x8000000000000000ULL - outflank_d7 * 2) & 0x0008102040000000ULL;
+	outflank_d = OUTFLANK_2[(((HIDWORD(O) & 0x040a1020) + (LODWORD(O) & 0x40000000)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x040a112040800000) * 0x0101010101010101) >> 52;	// hgfedcb[ahgfe]d0ba...
+	flipped |= FLIPPED_2_H[outflank_d] & 0x040a102040000000;	// A6C8H3
 
-	flipped |= (P << 9) & 0x0002000000000000ULL & O;
+	outflank_h = OUTFLANK_2[(O >> 57) & 0x3f] & rotl8(P >> 56, 4);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_2_H[outflank_h] << 56;
 
 	return flipped;
 }
@@ -1781,15 +1735,15 @@ static unsigned long long flip_D8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0008080808080800ULL) ^ 0x0008080808080808ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0008080808080800ULL;
+	outflank_v = outflank_right(O, 0x0008080808080808) & P;
+	flipped  = (outflank_v * -2) & 0x0008080808080808;
 
-	outflank_h = OUTFLANK_3[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000ULL;
+	outflank_d = OUTFLANK_3[((HIDWORD(O) & 0x08142240) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0814224180000000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]e0cba...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0814224000000000;	// A5D8H4
 
-	outflank_d = OUTFLANK_3[((O & 0x0014224000000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0014224180000000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0014224000000000ULL;	// A5D8H4
+	outflank_h = OUTFLANK_3[(O >> 57) & 0x3f] & rotl8(P >> 56, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 56;
 
 	return flipped;
 }
@@ -1806,15 +1760,15 @@ static unsigned long long flip_E8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0010101010101000ULL) ^ 0x0010101010101010ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0010101010101000ULL;
+	outflank_v = outflank_right(O, 0x0010101010101010) & P;
+	flipped  = (outflank_v * -2) & 0x0010101010101010;
 
-	outflank_h = OUTFLANK_4[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000ULL;
+	outflank_d = OUTFLANK_4[((HIDWORD(O) & 0x10284402) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x1028448201000000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]f0dcba...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x1028440200000000;	// A4E8H5
 
-	outflank_d = OUTFLANK_4[((O & 0x0028440200000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0028448201000000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0028440200000000ULL;	// A4E8H5
+	outflank_h = OUTFLANK_4[(O >> 57) & 0x3f] & rotl8(P >> 56, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 56;
 
 	return flipped;
 }
@@ -1828,19 +1782,18 @@ static unsigned long long flip_E8(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F8(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_d9, outflank_v;
-
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0020202020202000ULL) ^ 0x0020202020202020ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0020202020202000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_5[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= ((unsigned long long) FLIPPED_5[outflank_h]) << 57;
+	outflank_v = outflank_right(O, 0x0020202020202020) & P;
+	flipped  = (outflank_v * -2) & 0x0020202020202020;
 
-	flipped |= ((P << 7) & 0x0040000000000000ULL & O);
+	outflank_d = OUTFLANK_5[(((HIDWORD(O) & 0x20500804) + (LODWORD(O) & 0x02000000)) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x2050880402010000) * 0x0101010101010101) >> 55;	// hgfe[dcbah]g0edcba...
+	flipped |= FLIPPED_5_H[outflank_d] & 0x2050080402000000;	// A3F8H6
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0010080402000000ULL) ^ 0x0010080402010000ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0010080402000000ULL;
+	outflank_h = OUTFLANK_5[(O >> 57) & 0x3f] & rotl8(P >> 56, 1);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_5_H[outflank_h] << 56;
 
 	return flipped;
 }
@@ -1857,14 +1810,14 @@ static unsigned long long flip_G8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0040404040404000ULL) ^ 0x0040404040404040ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0040404040404000ULL;
+	outflank_v = outflank_right(O, 0x0040404040404040) & P;
+	flipped  = (outflank_v * -2) & 0x0040404040404040;
 
-	outflank_h = OUTFLANK_7[(O >> 56) & 0x3e] & (P >> 55);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 56;
+	outflank_d9 = outflank_right(O, 0x0020100804020100) & P;
+	flipped |= (outflank_d9 * -2) & 0x0020100804020100;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0020100804020000ULL) ^ 0x0020100804020100ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0020100804020000ULL;
+	outflank_h = outflank_right_H((unsigned int) (O >> 57) << 27) & (unsigned int) (P >> 30);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 30;
 
 	return flipped;
 }
@@ -1881,14 +1834,14 @@ static unsigned long long flip_H8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0080808080808000ULL) ^ 0x0080808080808080ULL)) & P;
-	flipped  = (-outflank_v * 2) & 0x0080808080808000ULL;
+	outflank_v = outflank_right(O, 0x0080808080808080) & P;
+	flipped  = (outflank_v * -2) & 0x0080808080808080;
 
-	outflank_h = OUTFLANK_7[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 57;
+	outflank_d9 = outflank_right(O, 0x0040201008040201) & P;
+	flipped |= (outflank_d9 * -2) & 0x0040201008040201;
 
-	outflank_d9 = (0x8000000000000000ULL >> __builtin_clzll((O & 0x0040201008040200ULL) ^ 0x0040201008040201ULL)) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0040201008040200ULL;
+	outflank_h = outflank_right_H((unsigned int) (O >> 57) << 26) & (unsigned int) (P >> 31);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 31;
 
 	return flipped;
 }
@@ -1910,22 +1863,14 @@ static unsigned long long flip_pass(const unsigned long long P, const unsigned l
 
 /** Array of functions to compute flipped discs */
 unsigned long long (*flip[])(const unsigned long long, const unsigned long long) = {
-	flip_A1, flip_B1, flip_C1, flip_D1,
-	flip_E1, flip_F1, flip_G1, flip_H1,
-	flip_A2, flip_B2, flip_C2, flip_D2,
-	flip_E2, flip_F2, flip_G2, flip_H2,
-	flip_A3, flip_B3, flip_C3, flip_D3,
-	flip_E3, flip_F3, flip_G3, flip_H3,
-	flip_A4, flip_B4, flip_C4, flip_D4,
-	flip_E4, flip_F4, flip_G4, flip_H4,
-	flip_A5, flip_B5, flip_C5, flip_D5,
-	flip_E5, flip_F5, flip_G5, flip_H5,
-	flip_A6, flip_B6, flip_C6, flip_D6,
-	flip_E6, flip_F6, flip_G6, flip_H6,
-	flip_A7, flip_B7, flip_C7, flip_D7,
-	flip_E7, flip_F7, flip_G7, flip_H7,
-	flip_A8, flip_B8, flip_C8, flip_D8,
-	flip_E8, flip_F8, flip_G8, flip_H8,
+	flip_A1, flip_B1, flip_C1, flip_D1, flip_E1, flip_F1, flip_G1, flip_H1,
+	flip_A2, flip_B2, flip_C2, flip_D2, flip_E2, flip_F2, flip_G2, flip_H2,
+	flip_A3, flip_B3, flip_C3, flip_D3, flip_E3, flip_F3, flip_G3, flip_H3,
+	flip_A4, flip_B4, flip_C4, flip_D4, flip_E4, flip_F4, flip_G4, flip_H4,
+	flip_A5, flip_B5, flip_C5, flip_D5, flip_E5, flip_F5, flip_G5, flip_H5,
+	flip_A6, flip_B6, flip_C6, flip_D6, flip_E6, flip_F6, flip_G6, flip_H6,
+	flip_A7, flip_B7, flip_C7, flip_D7, flip_E7, flip_F7, flip_G7, flip_H7,
+	flip_A8, flip_B8, flip_C8, flip_D8, flip_E8, flip_F8, flip_G8, flip_H8,
 	flip_pass, flip_pass
 };
 
diff --git a/src/flip_bmi2.c b/src/flip_bmi2.c
new file mode 100644
index 00000000..09b984de
--- /dev/null
+++ b/src/flip_bmi2.c
@@ -0,0 +1,279 @@
+/**
+ * @file flip_bmi2.c
+ *
+ * This module deals with flipping discs.
+ *
+ * A function is provided for each square of the board. These functions are
+ * gathered into an array of functions, so that a fast access to each function
+ * is allowed. The generic form of the function take as input the player and
+ * the opponent bitboards and return the flipped squares into a bitboard.
+ *
+ * Given the following notation:
+ *  - x = square where we play,
+ *  - P = player's disc pattern,
+ *  - O = opponent's disc pattern,
+ * the basic principle is to read into an array the result of a move. Doing
+ * this is easier for a single line ; so we can use arrays of the form:
+ *  - ARRAY[x][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by the 
+ * BMI2 PEXT instruction.
+ * Once we get our 8-bits disc patterns,a first array (OUTFLANK) is used to
+ * get the player's discs that surround the opponent discs:
+ *  - outflank = OUTFLANK[x][O] & P
+ * The result is then used as an index to access a second array giving the
+ * flipped discs according to the surrounding player's discs:
+ *  - flipped = FLIPPED[x][outflank].
+ * Finally, BMI2 PDEP instruction transform the 8-bits disc pattern back into a
+ * 64-bits disc pattern, and the flipped squares for each line are gathered and
+ * returned to generate moves.
+ *
+ * @date 1998 - 2014
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include <x86intrin.h>
+
+/* bit masks for diagonal/vertical/all lines */
+static const unsigned long long mask_x[66][4] = {
+	{ 0x0000000000000001ULL, 0x8040201008040201ULL, 0x0101010101010101ULL, 0x81412111090503ffULL },
+	{ 0x0000000000000102ULL, 0x0080402010080402ULL, 0x0202020202020202ULL, 0x02824222120a07ffULL },
+	{ 0x0000000000010204ULL, 0x0000804020100804ULL, 0x0404040404040404ULL, 0x0404844424150effULL },
+	{ 0x0000000001020408ULL, 0x0000008040201008ULL, 0x0808080808080808ULL, 0x08080888492a1cffULL },
+	{ 0x0000000102040810ULL, 0x0000000080402010ULL, 0x1010101010101010ULL, 0x10101011925438ffULL },
+	{ 0x0000010204081020ULL, 0x0000000000804020ULL, 0x2020202020202020ULL, 0x2020212224a870ffULL },
+	{ 0x0001020408102040ULL, 0x0000000000008040ULL, 0x4040404040404040ULL, 0x404142444850e0ffULL },
+	{ 0x0102040810204080ULL, 0x0000000000000080ULL, 0x8080808080808080ULL, 0x8182848890a0c0ffULL },
+	{ 0x0000000000000102ULL, 0x4020100804020104ULL, 0x0101010101010101ULL, 0x412111090503ff03ULL },
+	{ 0x0000000000010204ULL, 0x8040201008040201ULL, 0x0202020202020202ULL, 0x824222120a07ff07ULL },
+	{ 0x0000000001020408ULL, 0x0080402010080402ULL, 0x0404040404040404ULL, 0x04844424150eff0eULL },
+	{ 0x0000000102040810ULL, 0x0000804020100804ULL, 0x0808080808080808ULL, 0x080888492a1cff1cULL },
+	{ 0x0000010204081020ULL, 0x0000008040201008ULL, 0x1010101010101010ULL, 0x101011925438ff38ULL },
+	{ 0x0001020408102040ULL, 0x0000000080402010ULL, 0x2020202020202020ULL, 0x20212224a870ff70ULL },
+	{ 0x0102040810204080ULL, 0x0000000000804020ULL, 0x4040404040404040ULL, 0x4142444850e0ffe0ULL },
+	{ 0x0204081020408001ULL, 0x0000000000008040ULL, 0x8080808080808080ULL, 0x82848890a0c0ffc0ULL },
+	{ 0x0000000000010204ULL, 0x201008040201000aULL, 0x0101010101010101ULL, 0x2111090503ff0305ULL },
+	{ 0x0000000001020408ULL, 0x4020100804020101ULL, 0x0202020202020202ULL, 0x4222120a07ff070aULL },
+	{ 0x0000000102040810ULL, 0x8040201008040201ULL, 0x0404040404040404ULL, 0x844424150eff0e15ULL },
+	{ 0x0000010204081020ULL, 0x0080402010080402ULL, 0x0808080808080808ULL, 0x0888492a1cff1c2aULL },
+	{ 0x0001020408102040ULL, 0x0000804020100804ULL, 0x1010101010101010ULL, 0x1011925438ff3854ULL },
+	{ 0x0102040810204080ULL, 0x0000008040201008ULL, 0x2020202020202020ULL, 0x212224a870ff70a8ULL },
+	{ 0x0204081020408001ULL, 0x0000000080402010ULL, 0x4040404040404040ULL, 0x42444850e0ffe050ULL },
+	{ 0x0408102040800003ULL, 0x0000000000804020ULL, 0x8080808080808080ULL, 0x848890a0c0ffc0a0ULL },
+	{ 0x0000000001020408ULL, 0x1008040201000016ULL, 0x0101010101010101ULL, 0x11090503ff030509ULL },
+	{ 0x0000000102040810ULL, 0x2010080402010005ULL, 0x0202020202020202ULL, 0x22120a07ff070a12ULL },
+	{ 0x0000010204081020ULL, 0x4020100804020101ULL, 0x0404040404040404ULL, 0x4424150eff0e1524ULL },
+	{ 0x0001020408102040ULL, 0x8040201008040201ULL, 0x0808080808080808ULL, 0x88492a1cff1c2a49ULL },
+	{ 0x0102040810204080ULL, 0x0080402010080402ULL, 0x1010101010101010ULL, 0x11925438ff385492ULL },
+	{ 0x0204081020408001ULL, 0x0000804020100804ULL, 0x2020202020202020ULL, 0x2224a870ff70a824ULL },
+	{ 0x0408102040800003ULL, 0x0000008040201008ULL, 0x4040404040404040ULL, 0x444850e0ffe05048ULL },
+	{ 0x0810204080000007ULL, 0x0000000080402010ULL, 0x8080808080808080ULL, 0x8890a0c0ffc0a090ULL },
+	{ 0x0000000102040810ULL, 0x080402010000002eULL, 0x0101010101010101ULL, 0x090503ff03050911ULL },
+	{ 0x0000010204081020ULL, 0x100804020100000dULL, 0x0202020202020202ULL, 0x120a07ff070a1222ULL },
+	{ 0x0001020408102040ULL, 0x2010080402010003ULL, 0x0404040404040404ULL, 0x24150eff0e152444ULL },
+	{ 0x0102040810204080ULL, 0x4020100804020101ULL, 0x0808080808080808ULL, 0x492a1cff1c2a4988ULL },
+	{ 0x0204081020408002ULL, 0x8040201008040201ULL, 0x1010101010101010ULL, 0x925438ff38549211ULL },
+	{ 0x0408102040800005ULL, 0x0080402010080402ULL, 0x2020202020202020ULL, 0x24a870ff70a82422ULL },
+	{ 0x081020408000000bULL, 0x0000804020100804ULL, 0x4040404040404040ULL, 0x4850e0ffe0504844ULL },
+	{ 0x1020408000000017ULL, 0x0000008040201008ULL, 0x8080808080808080ULL, 0x90a0c0ffc0a09088ULL },
+	{ 0x0000010204081020ULL, 0x040201000000005eULL, 0x0101010101010101ULL, 0x0503ff0305091121ULL },
+	{ 0x0001020408102040ULL, 0x080402010000001dULL, 0x0202020202020202ULL, 0x0a07ff070a122242ULL },
+	{ 0x0102040810204080ULL, 0x100804020100000bULL, 0x0404040404040404ULL, 0x150eff0e15244484ULL },
+	{ 0x0204081020408001ULL, 0x2010080402010003ULL, 0x0808080808080808ULL, 0x2a1cff1c2a498808ULL },
+	{ 0x0408102040800003ULL, 0x4020100804020101ULL, 0x1010101010101010ULL, 0x5438ff3854921110ULL },
+	{ 0x081020408000000eULL, 0x8040201008040201ULL, 0x2020202020202020ULL, 0xa870ff70a8242221ULL },
+	{ 0x102040800000001dULL, 0x0080402010080402ULL, 0x4040404040404040ULL, 0x50e0ffe050484442ULL },
+	{ 0x204080000000003bULL, 0x0000804020100804ULL, 0x8080808080808080ULL, 0xa0c0ffc0a0908884ULL },
+	{ 0x0001020408102040ULL, 0x02010000000000beULL, 0x0101010101010101ULL, 0x03ff030509112141ULL },
+	{ 0x0102040810204080ULL, 0x040201000000003dULL, 0x0202020202020202ULL, 0x07ff070a12224282ULL },
+	{ 0x0204081020408001ULL, 0x080402010000001bULL, 0x0404040404040404ULL, 0x0eff0e1524448404ULL },
+	{ 0x0408102040800003ULL, 0x1008040201000007ULL, 0x0808080808080808ULL, 0x1cff1c2a49880808ULL },
+	{ 0x0810204080000007ULL, 0x2010080402010003ULL, 0x1010101010101010ULL, 0x38ff385492111010ULL },
+	{ 0x102040800000000fULL, 0x4020100804020101ULL, 0x2020202020202020ULL, 0x70ff70a824222120ULL },
+	{ 0x204080000000003eULL, 0x8040201008040201ULL, 0x4040404040404040ULL, 0xe0ffe05048444241ULL },
+	{ 0x408000000000007dULL, 0x0080402010080402ULL, 0x8080808080808080ULL, 0xc0ffc0a090888482ULL },
+	{ 0x0102040810204080ULL, 0x010000000000027eULL, 0x0101010101010101ULL, 0xff03050911214181ULL },
+	{ 0x0204081020408001ULL, 0x020100000000007dULL, 0x0202020202020202ULL, 0xff070a1222428202ULL },
+	{ 0x0408102040800003ULL, 0x040201000000003bULL, 0x0404040404040404ULL, 0xff0e152444840404ULL },
+	{ 0x0810204080000007ULL, 0x0804020100000017ULL, 0x0808080808080808ULL, 0xff1c2a4988080808ULL },
+	{ 0x102040800000000fULL, 0x1008040201000007ULL, 0x1010101010101010ULL, 0xff38549211101010ULL },
+	{ 0x204080000000001fULL, 0x2010080402010003ULL, 0x2020202020202020ULL, 0xff70a82422212020ULL },
+	{ 0x408000000000003fULL, 0x4020100804020101ULL, 0x4040404040404040ULL, 0xffe0504844424140ULL },
+	{ 0x800000000000017eULL, 0x8040201008040201ULL, 0x8080808080808080ULL, 0xffc0a09088848281ULL },
+	{ 0, 0, 0, 0 },	// pass
+	{ 0, 0, 0, 0 }
+};
+
+/** outflank array */
+const unsigned char OUTFLANK[8][64] = {
+	{
+		0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
+		0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x40,
+		0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
+		0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x80,
+	},
+	{
+		0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
+		0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00,
+		0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
+		0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0x00,
+	},
+	{
+		0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
+		0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x41, 0x00, 0x00,
+		0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
+		0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00,
+	},
+	{
+		0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x40, 0x40, 0x40, 0x40, 0x44, 0x44, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x80, 0x80, 0x80, 0x80, 0x84, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x88, 0x88, 0x88, 0x88, 0x84, 0x84, 0x82, 0x81,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+		0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+	},
+};
+
+/** flip array */
+const unsigned char FLIPPED[8][144] = {
+	{
+		0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x08, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x18, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x38, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x78, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x06, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x10, 0x16, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x30, 0x36, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x70, 0x76, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x0e, 0x0c, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x20, 0x2e, 0x2c, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x60, 0x6e, 0x6c, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x1e, 0x1c, 0x00, 0x18, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x40, 0x5e, 0x5c, 0x00, 0x58, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x3e, 0x3c, 0x00, 0x38, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{
+		0x00, 0x7e, 0x7c, 0x00, 0x78, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+};
+
+unsigned long long flip(int pos, unsigned long long P, unsigned long long O)
+{
+	int	index;
+	unsigned long long	flipped, mask;
+	int	x = pos & 7;
+	int	y = pos & 0x38;
+
+	P &= mask_x[pos][3];	// mask out unrelated bits to make dummy 0 bits for outside
+
+	index = OUTFLANK[x][_bextr_u32((O >> y), 1, 6)] & (P >> y);
+	flipped = ((unsigned long long) FLIPPED[x][index]) << y;
+
+	y >>= 3;
+	mask = mask_x[pos][0];
+	index = OUTFLANK[y][_bextr_u32(_pext_u64(O, mask), 1, 6)] & _pext_u64(P, mask);
+	flipped |= _pdep_u64(FLIPPED[y][index], mask);
+
+	mask = mask_x[pos][1];
+	index = OUTFLANK[y][_bextr_u32(_pext_u64(O, mask), 1, 6)] & _pext_u64(P, mask);
+	flipped |= _pdep_u64(FLIPPED[y][index], mask);
+
+	mask = mask_x[pos][2];
+	index = OUTFLANK[y][_bextr_u32(_pext_u64(O, mask), 1, 6)] & _pext_u64(P, mask);
+	flipped |= _pdep_u64(FLIPPED[y][index], mask);
+
+	return flipped;
+}
diff --git a/src/flip_carry_32.c b/src/flip_carry_32.c
index fcbd59ac..badf0398 100644
--- a/src/flip_carry_32.c
+++ b/src/flip_carry_32.c
@@ -35,10 +35,10 @@
  * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
  * can be used to determine contiguous discs.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2018
  * @author Richard Delorme
  * @author Toshihiko Okuhara
- * @version 4.2
+ * @version 4.4
  */
 
 #define LODWORD(l) ((unsigned int)(l))
@@ -103,168 +103,166 @@ static const unsigned char OUTFLANK_7[64] = {
 
 /** flip array (indexed with outflank, returns inner 6 bits) */
 static const unsigned long long FLIPPED_2_H[130] = {
-	0x0000000000000000ULL, 0x0202020202020202ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0808080808080808ULL, 0x0a0a0a0a0a0a0a0aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1818181818181818ULL, 0x1a1a1a1a1a1a1a1aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3838383838383838ULL, 0x3a3a3a3a3a3a3a3aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7878787878787878ULL, 0x7a7a7a7a7a7a7a7aULL
+	0x0000000000000000, 0x0202020202020202, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0808080808080808, 0x0a0a0a0a0a0a0a0a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1818181818181818, 0x1a1a1a1a1a1a1a1a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x3838383838383838, 0x3a3a3a3a3a3a3a3a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7878787878787878, 0x7a7a7a7a7a7a7a7a
 };
 
 static const unsigned long long FLIPPED_3_H[131] = {
-	0x0000000000000000ULL, 0x0606060606060606ULL, 0x0404040404040404ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x1616161616161616ULL, 0x1414141414141414ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3030303030303030ULL, 0x3636363636363636ULL, 0x3434343434343434ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7070707070707070ULL, 0x7676767676767676ULL, 0x7474747474747474ULL
+	0x0000000000000000, 0x0606060606060606, 0x0404040404040404, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x1616161616161616, 0x1414141414141414, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x3030303030303030, 0x3636363636363636, 0x3434343434343434, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7070707070707070, 0x7676767676767676, 0x7474747474747474
 };
 
 static const unsigned long long FLIPPED_4_H[133] = {
-	0x0000000000000000ULL, 0x0e0e0e0e0e0e0e0eULL, 0x0c0c0c0c0c0c0c0cULL, 0x0000000000000000ULL, 0x0808080808080808ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x2020202020202020ULL, 0x2e2e2e2e2e2e2e2eULL, 0x2c2c2c2c2c2c2c2cULL, 0x0000000000000000ULL, 0x2828282828282828ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x6060606060606060ULL, 0x6e6e6e6e6e6e6e6eULL, 0x6c6c6c6c6c6c6c6cULL, 0x0000000000000000ULL, 0x6868686868686868ULL
+	0x0000000000000000, 0x0e0e0e0e0e0e0e0e, 0x0c0c0c0c0c0c0c0c, 0x0000000000000000, 0x0808080808080808, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x2020202020202020, 0x2e2e2e2e2e2e2e2e, 0x2c2c2c2c2c2c2c2c, 0x0000000000000000, 0x2828282828282828, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x6060606060606060, 0x6e6e6e6e6e6e6e6e, 0x6c6c6c6c6c6c6c6c, 0x0000000000000000, 0x6868686868686868
 };
 
 static const unsigned long long FLIPPED_5_H[137] = {
-	0x0000000000000000ULL, 0x1e1e1e1e1e1e1e1eULL, 0x1c1c1c1c1c1c1c1cULL, 0x0000000000000000ULL, 0x1818181818181818ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x4040404040404040ULL, 0x5e5e5e5e5e5e5e5eULL, 0x5c5c5c5c5c5c5c5cULL, 0x0000000000000000ULL, 0x5858585858585858ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x5050505050505050ULL
-};
-
-static const unsigned long long FLIPPED_2_V[130] = {
-	0x0000000000000000ULL, 0x000000000000ff00ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ff000000ULL, 0x00000000ff00ff00ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ffff000000ULL, 0x000000ffff00ff00ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ffffff000000ULL, 0x0000ffffff00ff00ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffffffff000000ULL, 0x00ffffffff00ff00ULL
+	0x0000000000000000, 0x1e1e1e1e1e1e1e1e, 0x1c1c1c1c1c1c1c1c, 0x0000000000000000, 0x1818181818181818, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x4040404040404040, 0x5e5e5e5e5e5e5e5e, 0x5c5c5c5c5c5c5c5c, 0x0000000000000000, 0x5858585858585858, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x5050505050505050
 };
 
 static const unsigned long long FLIPPED_3_V[131] = {
-	0x0000000000000000ULL, 0x0000000000ffff00ULL, 0x0000000000ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x000000ff00ffff00ULL, 0x000000ff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ffff00000000ULL, 0x0000ffff00ffff00ULL, 0x0000ffff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffffff00000000ULL, 0x00ffffff00ffff00ULL, 0x00ffffff00ff0000ULL
+	0x0000000000000000, 0x0000000000ffff00, 0x0000000000ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x000000ff00ffff00, 0x000000ff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ffff00000000, 0x0000ffff00ffff00, 0x0000ffff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffff00000000, 0x00ffffff00ffff00, 0x00ffffff00ff0000
 };
 
 static const unsigned long long FLIPPED_4_V[133] = {
-	0x0000000000000000ULL, 0x00000000ffffff00ULL, 0x00000000ffff0000ULL, 0x0000000000000000ULL, 0x00000000ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ff0000000000ULL, 0x0000ff00ffffff00ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffff0000000000ULL, 0x00ffff00ffffff00ULL, 0x00ffff00ffff0000ULL, 0x0000000000000000ULL, 0x00ffff00ff000000ULL
+	0x0000000000000000, 0x00000000ffffff00, 0x00000000ffff0000, 0x0000000000000000, 0x00000000ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ff0000000000, 0x0000ff00ffffff00, 0x0000ff00ffff0000, 0x0000000000000000, 0x0000ff00ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffff0000000000, 0x00ffff00ffffff00, 0x00ffff00ffff0000, 0x0000000000000000, 0x00ffff00ff000000
 };
 
 static const unsigned long long  FLIPPED_5_V[137] = {
-	0x0000000000000000ULL, 0x000000ffffffff00ULL, 0x000000ffffff0000ULL, 0x0000000000000000ULL, 0x000000ffff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ff000000000000ULL, 0x00ff00ffffffff00ULL, 0x00ff00ffffff0000ULL, 0x0000000000000000ULL, 0x00ff00ffff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ff00ff00000000ULL
+	0x0000000000000000, 0x000000ffffffff00, 0x000000ffffff0000, 0x0000000000000000, 0x000000ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff000000000000, 0x00ff00ffffffff00, 0x00ff00ffffff0000, 0x0000000000000000, 0x00ff00ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff00ff00000000
 };
 
 
+/*
+ * Set all bits below the sole outflank bit if outfrank != 0
+ */
+#if (_MSC_VER >= 1800) && (defined(_M_IX86) || defined (_M_X64))
+#include <intrin.h>
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned int flipmaskL, flipmaskH;
+	unsigned char cy;
+	cy = _subborrow_u32(0, LODWORD(outflank), 1, &flipmaskL);
+	cy = _subborrow_u32(cy, HIDWORD(outflank), 0, &flipmaskH);
+	cy = _addcarry_u32(cy, flipmaskL, 0, &flipmaskL);
+	_addcarry_u32(cy, flipmaskH, 0, &flipmaskH);
+	return ((unsigned long long) flipmaskH << 32) | flipmaskL;
+}
+#else
+	#define OutflankToFlipmask(x)	((x) - (unsigned int) ((x) != 0))
+#endif
+
 /**
  * Compute flipped discs when playing on square A1.
  *
@@ -277,14 +275,14 @@ static unsigned long long flip_A1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101010100ULL) + 0x0000000000000100ULL) & P & 0x0101010101010000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0001010101010100ULL;
+	outflank_v = ((O | ~0x0101010101010100) + 1) & P & 0x0101010101010100;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010100;
 
-	outflank_h = ((O & 0x7e) + 0x02) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x7e;
+	outflank_d9 = ((O | ~0x8040201008040200) + 1) & P & 0x8040201008040200;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040200;
 
-	outflank_d9 = ((O | ~0x8040201008040200ULL) + 0x0000000000000200ULL) & P & 0x8040201008040000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0040201008040200ULL;
+	outflank_h = (unsigned char) (O + 0x02) & P;
+	flipped |= outflank_h - ((unsigned int) (outflank_h != 0) << 1);
 
 	return flipped;
 }
@@ -301,14 +299,14 @@ static unsigned long long flip_B1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202020200ULL) + 0x0000000000000200ULL) & P & 0x0202020202020000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0002020202020200ULL;
+	outflank_v = ((O | ~0x0202020202020200) + 1) & P & 0x0202020202020200;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020200;
 
-	outflank_h = ((O & 0x7c) + 0x04) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x7c;
+	outflank_d9 = ((O | ~0x0080402010080400) + 1) & P & 0x0080402010080400;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0080402010080400;
 
-	outflank_d9 = ((O | ~0x0080402010080400ULL) + 0x0000000000000400ULL) & P & 0x0080402010080000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000402010080400ULL;
+	outflank_h = (unsigned char) (O + 0x04) & P;
+	flipped |= outflank_h - ((unsigned int) (outflank_h != 0) << 2);
 
 	return flipped;
 }
@@ -325,16 +323,16 @@ static unsigned long long flip_C1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0404040404040400ULL) + 0x0000000000000400ULL) & P & 0x0404040404040400ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404040400ULL;
+	outflank_v = ((O | ~0x0404040404040400) + 1) & P & 0x0404040404040400;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_2_H[outflank_h];
 
 	flipped |= (((unsigned int) P >> 7) & 0x00000200u & (unsigned int) O);
 
-	outflank_d9 = ((O | ~0x0000804020100800ULL) + 0x0000000000000800ULL) & P & 0x0000804020100800ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000804020100800ULL;
+	outflank_d9 = ((O | ~0x0000804020100800) + 1) & P & 0x0000804020100800;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0000804020100800;
 
 	return flipped;
 }
@@ -348,20 +346,18 @@ static unsigned long long flip_C1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_d7;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_v = ((O | ~0x0808080808080800ULL) + 0x0000000000000800ULL) & P & 0x0808080808080800ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808080800ULL;
+	outflank_v = ((O | ~0x0808080808080800) + 1) & P & 0x0808080808080800;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
 
-	outflank_d7 = ((O | ~0x01020400u) + 0x00000400u) & P & 0x01020000u;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00020400u;
-
-	outflank_d9 = ((O | ~0x0000008040201000ULL) + 0x0000000000001000ULL) & P & 0x0000008040201000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000008040201000ULL;
+	outflank_d = OUTFLANK_3[((LODWORD(O) & 0x40221400u) * 0x01010101u) >> 25]
+		& ((((HIDWORD(P) & 0x00000080u) + (LODWORD(P) & 0x41221400u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x40221400u;	// A4D1H5
 
 	return flipped;
 }
@@ -375,20 +371,18 @@ static unsigned long long flip_D1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_d9;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_v = ((O | ~0x1010101010101000ULL) + 0x0000000000001000ULL) & P & 0x1010101010101000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010101000ULL;
+	outflank_v = ((O | ~0x1010101010101000) + 1) & P & 0x1010101010101000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
 
-	outflank_d7 = ((O | ~0x0000000102040800ULL) + 0x0000000000000800ULL) & P & 0x0000000102040800ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000102040800ULL;
-
-	outflank_d9 = ((O | ~0x80402000u) + 0x00002000u) & P & 0x80400000u;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00402000u;
+	outflank_d = OUTFLANK_4[((LODWORD(O) & 0x02442800u) * 0x01010101u) >> 25]
+		& ((((HIDWORD(P) & 0x00000001u) + (LODWORD(P) & 0x82442800u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x82442800u;	// A5E1H4
 
 	return flipped;
 }
@@ -405,14 +399,14 @@ static unsigned long long flip_F1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x2020202020202000ULL) + 0x0000000000002000ULL) & P & 0x2020202020202000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020202000ULL;
+	outflank_v = ((O | ~0x2020202020202000) + 1) & P & 0x2020202020202000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_5_H[outflank_h];
 
-	outflank_d7 = ((O | ~0x0000010204081000ULL) + 0x0000000000001000ULL) & P & 0x0000010204080000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000204081000ULL;
+	outflank_d7 = ((O | ~0x0000010204081000) + 1) & P & 0x0000010204080000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0000000204081000;
 
 	flipped |= (((unsigned int) P >> 9) & 0x00004000u & (unsigned int) O);
 
@@ -431,14 +425,14 @@ static unsigned long long flip_G1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040404000ULL) + 0x0000000000004000ULL) & P & 0x4040404040400000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0040404040404000ULL;
+	outflank_v = ((O | ~0x4040404040404000) + 1) & P & 0x4040404040400000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040404000;
 
 	outflank_h = OUTFLANK_7[O & 0x3e] & (P << 1);
 	flipped |= ((-outflank_h) & 0x3e) << 0;
 
-	outflank_d7 = ((O | ~0x0001020408102000ULL) + 0x0000000000002000ULL) & P & 0x0001020408100000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000020408102000ULL;
+	outflank_d7 = ((O | ~0x0001020408102000) + 1) & P & 0x0001020408100000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0001020408102000;
 
 	return flipped;
 }
@@ -455,14 +449,14 @@ static unsigned long long flip_H1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080808000ULL) + 0x0000000000008000ULL) & P & 0x8080808080800000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0080808080808000ULL;
+	outflank_v = ((O | ~0x8080808080808000) + 1) & P & 0x8080808080800000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 1) & 0x3f] & (unsigned int) P;
 	flipped |= ((-outflank_h) & 0x3f) << 1;
 
-	outflank_d7 = ((O | ~0x0102040810204000ULL) + 0x0000000000004000ULL) & P & 0x0102040810200000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0002040810204000ULL;
+	outflank_d7 = ((O | ~0x0102040810204000) + 1) & P & 0x0102040810200000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810204000;
 
 	return flipped;
 }
@@ -479,14 +473,14 @@ static unsigned long long flip_A2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101010000ULL) + 0x0000000000010000ULL) & P & 0x0101010101000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0001010101010000ULL;
+	outflank_v = ((O | ~0x0101010101010000) + 1) & P & 0x0101010101010000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010000;
 
-	outflank_h = ((O & 0x00007e00u) + 0x00000200u) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007e00u;
+	outflank_d9 = ((O | ~0x4020100804020000) + 1) & P & 0x4020100804020000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x4020100804020000;
 
-	outflank_d9 = ((O | ~0x4020100804020000ULL) + 0x0000000000020000ULL) & P & 0x4020100804000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0020100804020000ULL;
+	outflank_h = (unsigned short) (O + 0x0200) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00;
 
 	return flipped;
 }
@@ -503,14 +497,14 @@ static unsigned long long flip_B2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202020000ULL) + 0x0000000000020000ULL) & P & 0x0202020202000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0002020202020000ULL;
+	outflank_v = ((O | ~0x0202020202020000) + 1) & P & 0x0202020202020000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020000;
 
-	outflank_h = ((O & 0x00007c00u) + 0x00000400u) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007c00u;
+	outflank_d9 = ((O | ~0x8040201008040000) + 1) & P & 0x8040201008040000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040000;
 
-	outflank_d9 = ((O | ~0x8040201008040000ULL) + 0x0000000000040000ULL) & P & 0x8040201008000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0040201008040000ULL;
+	outflank_h = (unsigned short) (O + 0x0400) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00;
 
 	return flipped;
 }
@@ -527,16 +521,16 @@ static unsigned long long flip_C2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0404040404040000ULL) + 0x0000000000040000ULL) & P & 0x0404040404000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0004040404040000ULL;
+	outflank_v = ((O | ~0x0404040404040000) + 1) & P & 0x0404040404000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040000;
 
 	outflank_h = OUTFLANK_2[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x000000000000ff00ULL;
+	flipped |= (unsigned int) FLIPPED_2_H[outflank_h] & 0x0000ff00u;
 
 	flipped |= (((unsigned int) P >> 7) & 0x00020000u & (unsigned int) O);
 
-	outflank_d9 = ((O | ~0x0080402010080000ULL) + 0x0000000000080000ULL) & P & 0x0080402010080000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000402010080000ULL;
+	outflank_d9 = ((O | ~0x0080402010080000) + 1) & P & 0x0080402010080000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0000402010080000;
 
 	return flipped;
 }
@@ -553,17 +547,17 @@ static unsigned long long flip_D2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
 
-	outflank_v = ((O | ~0x0808080808080000ULL) + 0x0000000000080000ULL) & P & 0x0808080808000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0008080808080000ULL;
+	outflank_v = ((O | ~0x0808080808080000) + 1) & P & 0x0808080808000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080000;
 
 	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000000000ff00ULL;
+	flipped |= (unsigned int) FLIPPED_3_H[outflank_h] & 0x0000ff00u;
 
-	outflank_d7 = ((O | ~0x0000000102040000ULL) + 0x0000000000040000ULL) & P & 0x0000000102000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000002040000ULL;
+	outflank_d7 = ((O | ~0x0000000102040000) + 1) & P & 0x0000000102000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0000000002040000;
 
-	outflank_d9 = ((O | ~0x0000804020100000ULL) + 0x0000000000100000ULL) & P & 0x0000804020000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000004020100000ULL;
+	outflank_d9 = ((O | ~0x0000804020100000) + 1) & P & 0x0000804020000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0000004020100000;
 
 	return flipped;
 }
@@ -580,17 +574,17 @@ static unsigned long long flip_E2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
 
-	outflank_v = ((O | ~0x1010101010100000ULL) + 0x0000000000100000ULL) & P & 0x1010101010000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0010101010100000ULL;
+	outflank_v = ((O | ~0x1010101010100000) + 1) & P & 0x1010101010000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010100000;
 
 	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000000000ff00ULL;
+	flipped |= (unsigned int) FLIPPED_4_H[outflank_h] & 0x0000ff00u;
 
-	outflank_d7 = ((O | ~0x0000010204080000ULL) + 0x0000000000080000ULL) & P & 0x0000010204000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000204080000ULL;
+	outflank_d7 = ((O | ~0x0000010204080000) + 1) & P & 0x0000010204000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0000000204080000;
 
-	outflank_d9 = ((O | ~0x0000008040200000ULL) + 0x0000000000200000ULL) & P & 0x0000008040000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000000040200000ULL;
+	outflank_d9 = ((O | ~0x0000008040200000) + 1) & P & 0x0000008040000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0000000040200000;
 
 	return flipped;
 }
@@ -607,14 +601,14 @@ static unsigned long long flip_F2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x2020202020200000ULL) + 0x0000000000200000ULL) & P & 0x2020202020000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0020202020200000ULL;
+	outflank_v = ((O | ~0x2020202020200000) + 1) & P & 0x2020202020000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020200000;
 
 	outflank_h = OUTFLANK_5[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
 	flipped |= (unsigned int) FLIPPED_5_H[outflank_h] & 0x0000ff00U;
 
-	outflank_d7 = ((O | ~0x0001020408100000ULL) + 0x0000000000100000ULL) & P & 0x0001020408000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000020408100000ULL;
+	outflank_d7 = ((O | ~0x0001020408100000) + 1) & P & 0x0001020408000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0000020408100000;
 
 	flipped |= (((unsigned int) P >> 9) & 0x00400000u & (unsigned int) O);
 
@@ -633,14 +627,14 @@ static unsigned long long flip_G2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040400000ULL) + 0x0000000000400000ULL) & P & 0x4040404040000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0040404040400000ULL;
+	outflank_v = ((O | ~0x4040404040400000) + 1) & P & 0x4040404040000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040400000;
 
 	outflank_h = OUTFLANK_7[(O >> 8) & 0x3e] & ((unsigned int) P >> 7);
 	flipped |= ((-outflank_h) & 0x3e) << 8;
 
-	outflank_d7 = ((O | ~0x0102040810200000ULL) + 0x0000000000200000ULL) & P & 0x0102040810000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0002040810200000ULL;
+	outflank_d7 = ((O | ~0x0102040810200000) + 1) & P & 0x0102040810000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810200000;
 
 	return flipped;
 }
@@ -657,14 +651,14 @@ static unsigned long long flip_H2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080800000ULL) + 0x0000000000800000ULL) & P & 0x8080808080000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0080808080800000ULL;
+	outflank_v = ((O | ~0x8080808080800000) + 1) & P & 0x8080808080000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080800000;
 
 	outflank_h = OUTFLANK_7[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
 	flipped |= ((-outflank_h) & 0x3f) << 9;
 
-	outflank_d7 = ((O | ~0x0204081020400000ULL) + 0x0000000000400000ULL) & P & 0x0204081020000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0004081020400000ULL;
+	outflank_d7 = ((O | ~0x0204081020400000) + 1) & P & 0x0204081020000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0204081020400000;
 
 	return flipped;
 }
@@ -681,18 +675,16 @@ static unsigned long long flip_A3(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101000000ULL) + 0x0000000001000000ULL) & P & 0x0101010101000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00000100u & (unsigned int) O);
+	outflank_v = ((O | ~0x0101010101000000) + 1) & P & 0x0101010101000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101000000;
 
 	outflank_h = ((O & 0x007e0000u) + 0x00020000u) & P;
 	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007e0000u;
 
-	flipped |= (((unsigned int) P << 7) & 0x00000200u & (unsigned int) O);
+	outflank_d9 = ((O | ~0x2010080402000000) + 1) & P & 0x2010080400000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0010080402000000;
 
-	outflank_d9 = ((O | ~0x2010080402000000ULL) + 0x0000000002000000ULL) & P & 0x2010080400000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0010080402000000ULL;
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00000100u) | ((LODWORD(P) << 7) & 0x00000200u));
 
 	return flipped;
 }
@@ -709,19 +701,16 @@ static unsigned long long flip_B3(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202000000ULL) + 0x0000000002000000ULL) & P & 0x0202020202000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00000200u & (unsigned int) O);
+	outflank_v = ((O | ~0x0202020202000000) + 1) & P & 0x0202020202000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202000000;
 
 	outflank_h = ((O & 0x007c0000u) + 0x00040000u) & P;
 	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007c0000u;
 
-	flipped |= (((unsigned int) P << 7) & 0x00000400u & (unsigned int) O);
-
-	outflank_d9 = ((O | ~0x4020100804000000ULL) + 0x0000000004000000ULL) & P & 0x4020100800000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0020100804000000ULL;
+	outflank_d9 = ((O | ~0x4020100804000000) + 1) & P & 0x4020100800000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0020100804000000;
 
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00000200u) | ((LODWORD(P) << 7) & 0x00000400u));
 	return flipped;
 }
 
@@ -737,20 +726,19 @@ static unsigned long long flip_C3(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0404040404000000ULL) + 0x0000000004000000ULL) & P & 0x0404040404000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00000400u & (unsigned int) O);
+	outflank_v = ((O | ~0x0404040404000000) + 1) & P & 0x0404040404000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404000000;
 
 	outflank_h = OUTFLANK_2[(O >> 17) & 0x3f] & ((unsigned int) P >> 16);
 	flipped |= (unsigned int) FLIPPED_2_H[outflank_h] & 0x00ff0000u;
 
-	flipped |= ((HIDWORD(P) << 25) | ((unsigned int) P << 7)) & 0x02000800u & (unsigned int) O;
 
-	outflank_d9 = ((O | ~0x8040201008000000ULL) + 0x0000000008000000ULL) & P & 0x8040201008000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008000000ULL;
+	outflank_d9 = ((O | ~0x8040201008000000) + 1) & P & 0x8040201008000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008000000;
 
-	flipped |= (((unsigned int) P << 9) & 0x00000200u & (unsigned int) O);
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00000400u)
+			| ((LODWORD(P) << 9) & 0x00000200u)
+			| (((HIDWORD(P) << 25) | (LODWORD(P) << 7)) & 0x02000800u));
 
 	return flipped;
 }
@@ -764,26 +752,22 @@ static unsigned long long flip_C3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_v = ((O | ~0x0808080808000000ULL) + 0x0000000008000000ULL) & P & 0x0808080808000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00000800u & (unsigned int) O);
+	outflank_v = ((O | ~0x0808080808000000) + 1) & P & 0x0808080808000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808000000;
 
 	outflank_h = OUTFLANK_3[(O >> 17) & 0x3f] & ((unsigned int) P >> 16);
 	flipped |= (unsigned int) FLIPPED_3_H[outflank_h] & 0x00ff0000u;
 
-	outflank_d7 = ((O | ~0x0000010204000000ULL) + 0x0000000004000000ULL) & P & 0x0000010204000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 24)) & 0x0000010204000000ULL;
-
-	flipped |= (((unsigned int) P << 7) & 0x00001000u & (unsigned int) O);
+	outflank_d = OUTFLANK_3[(((HIDWORD(O) & 0x00004022u) + (LODWORD(O) & 0x14080000u)) * 0x01010101u) >> 25]
+		& ((((HIDWORD(P) & 0x00804122u) + (LODWORD(P) & 0x14080000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000402214080000;	// A6D3H7
 
-	outflank_d9 = ((O | ~0x0080402010000000ULL) + 0x0000000010000000ULL) & P & 0x0080402010000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010000000ULL;
-
-	flipped |= (((unsigned int) P << 9) & 0x00000400u & (unsigned int) O);
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00000800u)
+			| ((LODWORD(P) << 7) & 0x00001000u)
+			| ((LODWORD(P) << 9) & 0x00000400u));
 
 	return flipped;
 }
@@ -797,26 +781,22 @@ static unsigned long long flip_D3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x1010101010000000ULL) + 0x0000000010000000ULL) & P & 0x1010101010000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010000000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	flipped |= (((unsigned int) P << 8) & 0x00001000u & (unsigned int) O);
+	outflank_v = ((O | ~0x1010101010000000) + 1) & P & 0x1010101010000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010000000;
 
 	outflank_h = OUTFLANK_4[(O >> 17) & 0x3f] & ((unsigned int) P >> 16);
 	flipped |= (unsigned int) FLIPPED_4_H[outflank_h] & 0x00ff0000u;
 
-	outflank_d7 = ((O | ~0x0001020408000000ULL) + 0x0000000008000000ULL) & P & 0x0001020408000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408000000ULL;
-
-	flipped |= (((unsigned int) P << 7) & 0x00002000u & (unsigned int) O);
+	outflank_d = OUTFLANK_4[(((HIDWORD(O) & 0x00000244u) + (LODWORD(O) & 0x28100000u)) * 0x01010101u) >> 25]
+		& ((((HIDWORD(P) & 0x00018244u) + (LODWORD(P) & 0x28100000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000024428100000;	// A7E7H6
 
-	outflank_d9 = ((O | ~0x0000804020000000ULL) + 0x0000000020000000ULL) & P & 0x0000804020000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 24)) & 0x0000804020000000ULL;
-
-	flipped |= (((unsigned int) P << 9) & 0x00000800u & (unsigned int) O);
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00001000u)
+			| ((LODWORD(P) << 7) & 0x00002000u)
+			| ((LODWORD(P) << 9) & 0x00000800u));
 
 	return flipped;
 }
@@ -833,20 +813,18 @@ static unsigned long long flip_F3(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x2020202020000000ULL) + 0x0000000020000000ULL) & P & 0x2020202020000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00002000u & (unsigned int) O);
+	outflank_v = ((O | ~0x2020202020000000) + 1) & P & 0x2020202020000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020000000;
 
 	outflank_h = OUTFLANK_5[(O >> 17) & 0x3f] & ((unsigned int) P >> 16);
 	flipped |= (unsigned int) FLIPPED_5_H[outflank_h] & 0x00ff0000u;
 
-	outflank_d7 = ((O | ~0x0102040810000000ULL) + 0x0000000010000000ULL) & P & 0x0102040810000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810000000ULL;
+	outflank_d7 = ((O | ~0x0102040810000000) + 1) & P & 0x0102040810000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810000000;
 
-	flipped |= (((unsigned int) P << 7) & 0x00004000u & (unsigned int) O);
-
-	flipped |= ((HIDWORD(P) << 23) | ((unsigned int) P << 9)) & 0x40001000u & (unsigned int) O;
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00002000u)
+			| ((LODWORD(P) << 7) & 0x00004000u)
+			| (((HIDWORD(P) << 23) | (LODWORD(P) << 9)) & 0x40001000u));
 
 	return flipped;
 }
@@ -863,18 +841,17 @@ static unsigned long long flip_G3(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040000000ULL) + 0x0000000040000000ULL) & P & 0x4040404040000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00004000u & (unsigned int) O);
+	outflank_v = ((O | ~0x4040404040000000) + 1) & P & 0x4040404040000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040000000;
 
 	outflank_h = OUTFLANK_7[(O >> 16) & 0x3e] & ((unsigned int) P >> 15);
 	flipped |= ((-outflank_h) & 0x3e) << 16;
 
-	outflank_d7 = ((O | ~0x0204081020000000ULL) + 0x0000000020000000ULL) & P & 0x0204081000000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0004081020000000ULL;
+	outflank_d7 = ((O | ~0x0204081020000000) + 1) & P & 0x0204081000000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0004081020000000;
+
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00004000u) | ((LODWORD(P) << 9) & 0x00002000u));
 
-	flipped |= (((unsigned int) P << 9) & 0x00002000u & (unsigned int) O);
 
 	return flipped;
 }
@@ -891,18 +868,16 @@ static unsigned long long flip_H3(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080000000ULL) + 0x0000000080000000ULL) & P & 0x8080808080000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080000000ULL;
-
-	flipped |= (((unsigned int) P << 8) & 0x00008000u & (unsigned int) O);
+	outflank_v = ((O | ~0x8080808080000000) + 1) & P & 0x8080808080000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080000000;
 
 	outflank_h = OUTFLANK_7[(O >> 17) & 0x3f] & ((unsigned int) P >> 16);
 	flipped |= ((-outflank_h) & 0x3f) << 17;
 
-	outflank_d7 = ((O | ~0x0408102040000000ULL) + 0x0000000040000000ULL) & P & 0x0408102000000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0008102040000000ULL;
+	outflank_d7 = ((O | ~0x0408102040000000) + 1) & P & 0x0408102000000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0008102040000000;
 
-	flipped |= (((unsigned int) P << 9) & 0x00004000u & (unsigned int) O);
+	flipped |= LODWORD(O) & (((LODWORD(P) << 8) & 0x00008000u) | ((LODWORD(P) << 9) & 0x00004000u));
 
 	return flipped;
 }
@@ -921,16 +896,16 @@ static unsigned long long flip_A4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[(((LODWORD(O) & 0x01010100u) + ((HIDWORD(O) & 0x00010101u) << 4)) * 0x01020408u) >> 25]
 		& ((((LODWORD(P) & 0x01010101u) + ((HIDWORD(P) & 0x01010101u) << 4)) * 0x01020408u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0001010101010100ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0001010101010100;
 
-	outflank_h = ((O & 0x7e000000u) + 0x02000000u) & P;
+	outflank_h = (LODWORD(O) + 0x02000000u) & P;
 	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e000000u;
 
 	flip_d7 = LODWORD(O) & 0x00020000u;
 	flip_d7 |= (flip_d7 >> 7) & LODWORD(O);
 	flipped |= flip_d7 & -(flip_d7 & (LODWORD(P) << 7));
 
-	outflank_d9 = ((HIDWORD(O) | ~0x10080402u) + 0x00000002u) & HIDWORD(P) & 0x10080400u;
+	outflank_d9 = ((HIDWORD(O) | ~0x10080402u) + 1) & HIDWORD(P) & 0x10080400u;
 	flipped |= (unsigned long long) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00080402u) << 32;
 
 	return flipped;
@@ -950,16 +925,16 @@ static unsigned long long flip_B4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[(((LODWORD(O) & 0x02020200u) + ((HIDWORD(O) & 0x00020202u) << 4)) * 0x00810204u) >> 25]
 		& ((((LODWORD(P) & 0x02020202u) + ((HIDWORD(P) & 0x02020202u) << 4)) * 0x00810204u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0002020202020200ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0002020202020200;
 
-	outflank_h = ((O & 0x7c000000u) + 0x04000000u) & P;
+	outflank_h = (LODWORD(O) + 0x04000000u) & P;
 	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c000000u;
 
 	flip_d7 = LODWORD(O) & 0x00040000u;
 	flip_d7 |= (flip_d7 >> 7) & LODWORD(O);
 	flipped |= flip_d7 & -(flip_d7 & (LODWORD(P) << 7));
 
-	outflank_d9 = ((HIDWORD(O) | ~0x20100804u) + 0x00000004u) & HIDWORD(P) & 0x20100800u;
+	outflank_d9 = ((HIDWORD(O) | ~0x20100804u) + 1) & HIDWORD(P) & 0x20100800u;
 	flipped |= (unsigned long long) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00100804u) << 32;
 
 	return flipped;
@@ -979,18 +954,18 @@ static unsigned long long flip_C4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[(((LODWORD(O) & 0x04040400u) + ((HIDWORD(O) & 0x00040404u) << 4)) * 0x00408102u) >> 25]
 		& ((((LODWORD(P) & 0x04040404u) + ((HIDWORD(P) & 0x04040404u) << 4)) * 0x00408102u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0004040404040400ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 25) & 0x3f] & ((unsigned int) P >> 24);
 	flipped |= (unsigned int) FLIPPED_2_H[outflank_h] & 0xff000000u;
 
 	outflank_d7 = OUTFLANK_2[(((LODWORD(O) & 0x04081000u) + (HIDWORD(O) & 0x00000002u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x04081020u) + (HIDWORD(P) & 0x00000102u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d7] & 0x0000000204081000ULL;
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0000000204081000;
 
 	outflank_d9 = OUTFLANK_2[(((LODWORD(O) & 0x04020000u) + (HIDWORD(O) & 0x00201008u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x04020100u) + (HIDWORD(P) & 0x40201008u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d9] & 0x0020100804020000ULL;
+	flipped |= FLIPPED_2_H[outflank_d9] & 0x0020100804020000;
 
 	return flipped;
 }
@@ -1009,18 +984,18 @@ static unsigned long long flip_D4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[(((LODWORD(O) & 0x08080800u) + ((HIDWORD(O) & 0x00080808u) << 4)) * 0x00204081u) >> 25]
 		& ((((LODWORD(P) & 0x08080808u) + ((HIDWORD(P) & 0x08080808u) << 4)) * 0x00204081u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 25) & 0x3f] & ((unsigned int) P >> 24);
 	flipped |= (unsigned int) FLIPPED_3_H[outflank_h] & 0xff000000u;
 
 	outflank_d7 = OUTFLANK_3[(((LODWORD(O) & 0x08102000u) + (HIDWORD(O) & 0x00000204u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x08102040u) + (HIDWORD(P) & 0x00010204u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000ULL;
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000;
 
 	outflank_d9 = OUTFLANK_3[(((LODWORD(O) & 0x08040200u) + (HIDWORD(O) & 0x00402010u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x08040201u) + (HIDWORD(P) & 0x80402010u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200ULL;
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1039,18 +1014,18 @@ static unsigned long long flip_E4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[((((LODWORD(O) & 0x10101000u) >> 4) + (HIDWORD(O) & 0x00101010u)) * 0x01020408u) >> 25]
 		& (((((LODWORD(P) & 0x10101010u) >> 4) + (HIDWORD(P) & 0x10101010u)) * 0x01020408u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 25) & 0x3f] & ((unsigned int) P >> 24);
 	flipped |= (unsigned int) FLIPPED_4_H[outflank_h] & 0xff000000u;
 
 	outflank_d7 = OUTFLANK_4[(((LODWORD(O) & 0x10204000u) + (HIDWORD(O) & 0x00020408u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x10204080u) + (HIDWORD(P) & 0x01020408u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000ULL;
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000;
 
 	outflank_d9 = OUTFLANK_4[(((LODWORD(O) & 0x10080400u) + (HIDWORD(O) & 0x00004020u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x10080402u) + (HIDWORD(P) & 0x00804020u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400ULL;
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400;
 
 	return flipped;
 }
@@ -1069,18 +1044,18 @@ static unsigned long long flip_F4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[((((LODWORD(O) & 0x20202000u) >> 4) + (HIDWORD(O) & 0x00202020u)) * 0x00810204u) >> 25]
 		& (((((LODWORD(P) & 0x20202020u) >> 4) + (HIDWORD(P) & 0x20202020u)) * 0x00810204u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0020202020202000ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 25) & 0x3f] & ((unsigned int) P >> 24);
 	flipped |= (unsigned int) FLIPPED_5_H[outflank_h] & 0xff000000u;
 
 	outflank_d7 = OUTFLANK_5[(((LODWORD(O) & 0x20400000u) + (HIDWORD(O) & 0x00040810u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x20408000u) + (HIDWORD(P) & 0x02040810u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d7] & 0x0004081020400000ULL;
+	flipped |= FLIPPED_5_H[outflank_d7] & 0x0004081020400000;
 
 	outflank_d9 = OUTFLANK_5[(((LODWORD(O) & 0x20100800u) + (HIDWORD(O) & 0x00000040u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x20100804u) + (HIDWORD(P) & 0x00008040u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d9] & 0x0000004020100800ULL;
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0000004020100800;
 
 	return flipped;
 }
@@ -1099,12 +1074,12 @@ static unsigned long long flip_G4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[((((LODWORD(O) & 0x40404000u) >> 4) + (HIDWORD(O) & 0x00404040u)) * 0x00408102u) >> 25]
 		& (((((LODWORD(P) & 0x40404040u) >> 4) + (HIDWORD(P) & 0x40404040u)) * 0x00408102u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0040404040404000ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0040404040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 24) & 0x3e] & ((unsigned int) P >> 23);
 	flipped |= ((-outflank_h) & 0x3e) << 24;
 
-	outflank_d7 = ((HIDWORD(O) | ~0x04081020u) + 0x00000020u) & HIDWORD(P) & 0x04081000u;
+	outflank_d7 = ((HIDWORD(O) | ~0x04081020u) + 1) & HIDWORD(P) & 0x04081000u;
 	flipped |= (unsigned long long) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00081020u) << 32;
 
 	flip_d9 = LODWORD(O) & 0x00200000u;
@@ -1128,12 +1103,12 @@ static unsigned long long flip_H4(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_3[((((LODWORD(O) & 0x80808000u) >> 4) + (HIDWORD(O) & 0x00808080u)) * 0x00204081u) >> 25]
 		& (((((LODWORD(P) & 0x80808080u) >> 4) + (HIDWORD(P) & 0x80808080u)) * 0x00204081u) >> 24);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0080808080808000ULL;
+	flipped = FLIPPED_3_V[outflank_v] & 0x0080808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 25) & 0x3f] & ((unsigned int) P >> 24);
 	flipped |= ((-outflank_h) & 0x3f) << 25;
 
-	outflank_d7 = ((HIDWORD(O) | ~0x08102040u) + 0x00000040u) & HIDWORD(P) & 0x08102000u;
+	outflank_d7 = ((HIDWORD(O) | ~0x08102040u) + 1) & HIDWORD(P) & 0x08102000u;
 	flipped |= (unsigned long long) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00102040u) << 32;
 
 	flip_d9 = LODWORD(O) & 0x00400000u;
@@ -1152,21 +1127,22 @@ static unsigned long long flip_H4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v, flip_d7, outflank_d9;
+	unsigned int outflank_v, flip_d7, outflank_d9;
+	unsigned char outflank_h;
 	unsigned long long flipped;
 
 	outflank_v = OUTFLANK_4[(((LODWORD(O) & 0x01010100u) + ((HIDWORD(O) & 0x00010101u) << 4)) * 0x01020408u) >> 25]
 		& ((((LODWORD(P) & 0x01010101u) + ((HIDWORD(P) & 0x01010101u) << 4)) * 0x01020408u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0001010101010100ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0001010101010100;
 
-	outflank_h = ((HIDWORD(O) & 0x0000007eu) + 0x00000002u) & HIDWORD(P);
-	flipped |= (unsigned long long) ((((outflank_h << 8) - outflank_h) >> 8) & 0x0000007eu) << 32;
+	outflank_h = (HIDWORD(O) + 0x02) & HIDWORD(P);
+	flipped |= (unsigned long long) (((outflank_h * 0xff) >> 8) & 0x0000007eu) << 32;
 
 	flip_d7 = LODWORD(O) & ((LODWORD(O) >> 7) | 0x02000000u);
 	flip_d7 &= ((flip_d7 & 0x02040000u) >> 14) | 0x02040000u;
 	flipped |= flip_d7 & -(flip_d7 & (LODWORD(P) << 7));
 
-	outflank_d9 = ((HIDWORD(O) | ~0x08040200u) + 0x00000200u) & HIDWORD(P) & 0x08040000u;
+	outflank_d9 = ((HIDWORD(O) | ~0x08040200u) + 1) & HIDWORD(P) & 0x08040000u;
 	flipped |= (unsigned long long) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00040200u) << 32;
 
 	return flipped;
@@ -1181,21 +1157,22 @@ static unsigned long long flip_A5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v, flip_d7, outflank_d9;
+	unsigned int outflank_v, flip_d7, outflank_d9;
+	unsigned char outflank_h;
 	unsigned long long flipped;
 
 	outflank_v = OUTFLANK_4[(((LODWORD(O) & 0x02020200u) + ((HIDWORD(O) & 0x00020202u) << 4)) * 0x00810204u) >> 25]
 		& ((((LODWORD(P) & 0x02020202u) + ((HIDWORD(P) & 0x02020202u) << 4)) * 0x00810204u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0002020202020200ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0002020202020200;
 
-	outflank_h = ((HIDWORD(O) & 0x0000007cu) + 0x00000004u) & (P >> 32);
-	flipped |= (unsigned long long) ((((outflank_h << 8) - outflank_h) >> 8) & 0x0000007cu) << 32;
+	outflank_h = (HIDWORD(O) + 0x04) & HIDWORD(P);
+	flipped |= (unsigned long long) (((outflank_h * 0xff) >> 8) & 0x0000007cu) << 32;
 
 	flip_d7 = LODWORD(O) & ((LODWORD(O) >> 7) | 0x04000000u);
 	flip_d7 &= ((flip_d7 & 0x04080000u) >> 14) | 0x04080000u;
 	flipped |= flip_d7 & -(flip_d7 & (LODWORD(P) << 7));
 
-	outflank_d9 = ((HIDWORD(O) | ~0x10080400u) + 0x00000400u) & HIDWORD(P) & 0x10080000u;
+	outflank_d9 = ((HIDWORD(O) | ~0x10080400u) + 1) & HIDWORD(P) & 0x10080000u;
 	flipped |= (unsigned long long) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00080400u) << 32;
 
 	return flipped;
@@ -1215,18 +1192,18 @@ static unsigned long long flip_C5(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_4[(((LODWORD(O) & 0x04040400u) + ((HIDWORD(O) & 0x00040404u) << 4)) * 0x00408102u) >> 25]
 		& ((((LODWORD(P) & 0x04040404u) + ((HIDWORD(P) & 0x04040404u) << 4)) * 0x00408102u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0004040404040400ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x000000ff00000000;
 
 	outflank_d7 = OUTFLANK_2[(((LODWORD(O) & 0x08102000u) + (HIDWORD(O) & 0x00000204u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x08102040u) + (HIDWORD(P) & 0x00010204u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d7] & 0x0000020408102000ULL;
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0000020408102000;
 
 	outflank_d9 = OUTFLANK_2[(((LODWORD(O) & 0x02000000u) + (HIDWORD(O) & 0x00100804u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x02010000u) + (HIDWORD(P) & 0x20100804u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d9] & 0x0010080402000000ULL;
+	flipped |= FLIPPED_2_H[outflank_d9] & 0x0010080402000000;
 
 	return flipped;
 }
@@ -1245,18 +1222,18 @@ static unsigned long long flip_D5(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_4[(((LODWORD(O) & 0x08080800u) + ((HIDWORD(O) & 0x00080808u) << 4)) * 0x00204081u) >> 25]
 		& ((((LODWORD(P) & 0x08080808u) + ((HIDWORD(P) & 0x08080808u) << 4)) * 0x00204081u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000;
 
 	outflank_d7 = OUTFLANK_3[(((LODWORD(O) & 0x10204000u) + (HIDWORD(O) & 0x00020408u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x10204080u) + (HIDWORD(P) & 0x01020408u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000ULL;
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000;
 
 	outflank_d9 = OUTFLANK_3[(((LODWORD(O) & 0x04020000u) + (HIDWORD(O) & 0x00201008u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x04020100u) + (HIDWORD(P) & 0x40201008u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000ULL;
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000;
 
 	return flipped;
 }
@@ -1275,18 +1252,18 @@ static unsigned long long flip_E5(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_4[((((LODWORD(O) & 0x10101000u) >> 4) + (HIDWORD(O) & 0x00101010u)) * 0x01020408u) >> 25]
 		& (((((LODWORD(P) & 0x10101010u) >> 4) + (HIDWORD(P) & 0x10101010u)) * 0x01020408u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000;
 
 	outflank_d7 = OUTFLANK_4[(((LODWORD(O) & 0x20400000u) + (HIDWORD(O) & 0x00040810u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x20408000u) + (HIDWORD(P) & 0x02040810u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000ULL;
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000;
 
 	outflank_d9 = OUTFLANK_4[(((LODWORD(O) & 0x08040200u) + (HIDWORD(O) & 0x00402010u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x08040201u) + (HIDWORD(P) & 0x80402010u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200ULL;
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1305,18 +1282,18 @@ static unsigned long long flip_F5(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_4[((((LODWORD(O) & 0x20202000u) >> 4) + (HIDWORD(O) & 0x00202020u)) * 0x00810204u) >> 25]
 		& (((((LODWORD(P) & 0x20202020u) >> 4) + (HIDWORD(P) & 0x20202020u)) * 0x00810204u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0020202020202000ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0x000000ff00000000;
 
 	outflank_d7 = OUTFLANK_5[(((LODWORD(O) & 0x40000000u) + (HIDWORD(O) & 0x00081020u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x40800000u) + (HIDWORD(P) & 0x04081020u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d7] & 0x0008102040000000ULL;
+	flipped |= FLIPPED_5_H[outflank_d7] & 0x0008102040000000;
 
 	outflank_d9 = OUTFLANK_5[(((LODWORD(O) & 0x10080400u) + (HIDWORD(O) & 0x00004020u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x10080402u) + (HIDWORD(P) & 0x00804020u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d9] & 0x0000402010080400ULL;
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0000402010080400;
 
 	return flipped;
 }
@@ -1335,12 +1312,12 @@ static unsigned long long flip_G5(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_4[((((LODWORD(O) & 0x40404000u) >> 4) + (HIDWORD(O) & 0x00404040u)) * 0x00408102u) >> 25]
 		& (((((LODWORD(P) & 0x40404040u) >> 4) + (HIDWORD(P) & 0x40404040u)) * 0x00408102u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0040404040404000ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0040404040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 32) & 0x3e] & (P >> 31);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 32;
 
-	outflank_d7 = ((HIDWORD(O) | ~0x08102000u) + 0x00002000u) & HIDWORD(P) & 0x08100000u;
+	outflank_d7 = ((HIDWORD(O) | ~0x08102000u) + 1) & HIDWORD(P) & 0x08100000u;
 	flipped |= (unsigned long long) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00102000u) << 32;
 
 	flip_d9 = LODWORD(O) & ((LODWORD(O) >> 9) | 0x20000000u);
@@ -1364,12 +1341,12 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_4[((((LODWORD(O) & 0x80808000u) >> 4) + (HIDWORD(O) & 0x00808080u)) * 0x00204081u) >> 25]
 		& (((((LODWORD(P) & 0x80808080u) >> 4) + (HIDWORD(P) & 0x80808080u)) * 0x00204081u) >> 24);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0080808080808000ULL;
+	flipped = FLIPPED_4_V[outflank_v] & 0x0080808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 33) & 0x3f] & (P >> 32);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 33;
 
-	outflank_d7 = ((HIDWORD(O) | ~0x10204000u) + 0x00004000u) & HIDWORD(P) & 0x10200000u;
+	outflank_d7 = ((HIDWORD(O) | ~0x10204000u) + 1) & HIDWORD(P) & 0x10200000u;
 	flipped |= (unsigned long long) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00204000u) << 32;
 
 	flip_d9 = LODWORD(O) & ((LODWORD(O) >> 9) | 0x40000000u);
@@ -1388,14 +1365,15 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v, flip_d7;
+	unsigned int outflank_v, flip_d7;
+	unsigned short outflank_h;
 	unsigned long long flipped;
 
 	outflank_v = OUTFLANK_5[(((LODWORD(O) & 0x01010100u) + ((HIDWORD(O) & 0x00010101u) << 4)) * 0x01020408u) >> 25]
 		& ((((LODWORD(P) & 0x01010101u) + ((HIDWORD(P) & 0x01010101u) << 4)) * 0x01020408u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0001010101010100ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0001010101010100;
 
-	outflank_h = ((HIDWORD(O) & 0x00007e00u) + 0x00000200u) & HIDWORD(P);
+	outflank_h = (HIDWORD(O) + 0x0200) & HIDWORD(P);
 	flipped |= (unsigned long long) ((outflank_h - (outflank_h >> 8)) & 0x00007e00u) << 32;
 
 	flip_d7 = (unsigned int) (O >> 8);
@@ -1417,14 +1395,15 @@ static unsigned long long flip_A6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v, flip_d7;
+	unsigned int outflank_v, flip_d7;
+	unsigned short outflank_h;
 	unsigned long long flipped;
 
 	outflank_v = OUTFLANK_5[(((LODWORD(O) & 0x02020200u) + ((HIDWORD(O) & 0x00020202u) << 4)) * 0x00810204u) >> 25]
 		& ((((LODWORD(P) & 0x02020202u) + ((HIDWORD(P) & 0x02020202u) << 4)) * 0x00810204u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0002020202020200ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0002020202020200;
 
-	outflank_h = ((HIDWORD(O) & 0x00007c00u) + 0x00000400u) & HIDWORD(P);
+	outflank_h = (HIDWORD(O) + 0x0400) & HIDWORD(P);
 	flipped |= (unsigned long long) ((outflank_h - (outflank_h >> 8)) & 0x00007c00u) << 32;
 
 	flip_d7 = (unsigned int) (O >> 8);
@@ -1451,14 +1430,14 @@ static unsigned long long flip_C6(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_5[(((LODWORD(O) & 0x04040400u) + ((HIDWORD(O) & 0x00040404u) << 4)) * 0x00408102u) >> 25]
 		& ((((LODWORD(P) & 0x04040404u) + ((HIDWORD(P) & 0x04040404u) << 4)) * 0x00408102u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x0000ff0000000000;
 
 	outflank_d7 = OUTFLANK_2[(((LODWORD(O) & 0x10204000u) + (HIDWORD(O) & 0x00020408u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x10204080u) + (HIDWORD(P) & 0x01020408u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000ULL;
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000;
 
 	flipped |= (unsigned long long) (((HIDWORD(P) >> 9) | (LODWORD(P) >> 23)) & 0x00080002u & HIDWORD(O)) << 32;
 
@@ -1474,23 +1453,22 @@ static unsigned long long flip_C6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d;
 	unsigned long long flipped;
 
 	outflank_v = OUTFLANK_5[(((LODWORD(O) & 0x08080800u) + ((HIDWORD(O) & 0x00080808u) << 4)) * 0x00204081u) >> 25]
 		& ((((LODWORD(P) & 0x08080808u) + ((HIDWORD(P) & 0x08080808u) << 4)) * 0x00204081u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000;
 
-	outflank_d7 = OUTFLANK_3[(((LODWORD(O) & 0x20400000u) + (HIDWORD(O) & 0x00040810u)) * 0x01010101u) >> 25]
-		& ((((LODWORD(P) & 0x20408000u) + (HIDWORD(P) & 0x02040810u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0004081020400000ULL;
+	outflank_d = OUTFLANK_3[(((LODWORD(O) & 0x22400000u) + (HIDWORD(O) & 0x00000814u)) * 0x01010101u) >> 25]
+		& ((((LODWORD(P) & 0x22418000u) + (HIDWORD(P) & 0x00000814u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000081422400000;	// A3D6H2
 
-	outflank_d9 = OUTFLANK_3[(((LODWORD(O) & 0x02000000u) + (HIDWORD(O) & 0x00100804u)) * 0x01010101u) >> 25]
-		& ((((LODWORD(P) & 0x02010000u) + (HIDWORD(P) & 0x20100804u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0010080402000000ULL;
+	flipped |= (unsigned long long) (HIDWORD(O) &
+		(((HIDWORD(P) >> 9) & 0x00100000u) | ((HIDWORD(P) >> 7) & 0x00040000u))) << 32;
 
 	return flipped;
 }
@@ -1504,23 +1482,22 @@ static unsigned long long flip_D6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d;
 	unsigned long long flipped;
 
 	outflank_v = OUTFLANK_5[((((LODWORD(O) & 0x10101000u) >> 4) + (HIDWORD(O) & 0x00101010u)) * 0x01020408u) >> 25]
 		& (((((LODWORD(P) & 0x10101010u) >> 4) + (HIDWORD(P) & 0x10101010u)) * 0x01020408u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000;
 
-	outflank_d7 = OUTFLANK_4[(((LODWORD(O) & 0x40000000u) + (HIDWORD(O) & 0x00081020u)) * 0x01010101u) >> 25]
-		& ((((LODWORD(P) & 0x40800000u) + (HIDWORD(P) & 0x04081020u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0008102040000000ULL;
+	outflank_d = OUTFLANK_4[(((LODWORD(O) & 0x44020000u) + (HIDWORD(O) & 0x00001028u)) * 0x01010101u) >> 25]
+		& ((((LODWORD(P) & 0x44820100u) + (HIDWORD(P) & 0x00001028u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000102844020000;	// A2E6H3
 
-	outflank_d9 = OUTFLANK_4[(((LODWORD(O) & 0x04020100u) + (HIDWORD(O) & 0x00201008u)) * 0x01010101u) >> 25]
-		& ((((LODWORD(P) & 0x04020100u) + (HIDWORD(P) & 0x40201008u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0020100804020100ULL;
+	flipped |= (unsigned long long) (HIDWORD(O) &
+		(((HIDWORD(P) >> 9) & 0x00200000u) | ((HIDWORD(P) >> 7) & 0x00080000u))) << 32;
 
 	return flipped;
 }
@@ -1539,16 +1516,16 @@ static unsigned long long flip_F6(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_5[((((LODWORD(O) & 0x20202000u) >> 4) + (HIDWORD(O) & 0x00202020u)) * 0x00810204u) >> 25]
 		& (((((LODWORD(P) & 0x20202020u) >> 4) + (HIDWORD(P) & 0x20202020u)) * 0x00810204u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0x0000ff0000000000;
 
 	flipped |= (unsigned long long) (((HIDWORD(P) >> 7) | (LODWORD(P) >> 25)) & 0x00100040u & HIDWORD(O)) << 32;
 
 	outflank_d9 = OUTFLANK_5[(((LODWORD(O) & 0x08040200u) + (HIDWORD(O) & 0x00402010u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x08040201u) + (HIDWORD(P) & 0x80402010u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200ULL;
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1567,7 +1544,7 @@ static unsigned long long flip_G6(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_5[((((LODWORD(O) & 0x40404000u) >> 4) + (HIDWORD(O) & 0x00404040u)) * 0x00408102u) >> 25]
 		& (((((LODWORD(P) & 0x40404040u) >> 4) + (HIDWORD(P) & 0x40404040u)) * 0x00408102u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0040404040404000ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0040404040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 40) & 0x3e] & (P >> 39);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 40;
@@ -1596,7 +1573,7 @@ static unsigned long long flip_H6(const unsigned long long P, const unsigned lon
 
 	outflank_v = OUTFLANK_5[((((LODWORD(O) & 0x80808000u) >> 4) + (HIDWORD(O) & 0x00808080u)) * 0x00204081u) >> 25]
 		& (((((LODWORD(P) & 0x80808080u) >> 4) + (HIDWORD(P) & 0x80808080u)) * 0x00204081u) >> 24);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0080808080808000ULL;
+	flipped = FLIPPED_5_V[outflank_v] & 0x0080808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 41) & 0x3f] & (P >> 40);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 41;
@@ -1625,14 +1602,14 @@ static unsigned long long flip_A7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x01010100u) << 4) + (HIDWORD(O) & 0x00000101u)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x01010101u) << 4) + (HIDWORD(P) & 0x00000001u)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x0000003e1e0e0602ULL) & 0x0000010101010100ULL;
+	flipped = (outflank_v * 0x0000003e1e0e0602) & 0x0000010101010100;
 
 	outflank_h = ((HIDWORD(O) & 0x007e0000u) + 0x00020000u) & HIDWORD(P);
 	flipped |= (unsigned long long) ((outflank_h - (outflank_h >> 8)) & 0x007e0000u) << 32;
 
 	outflank_d7 = (((((LODWORD(O) & 0x08102000u) + (HIDWORD(O) & 0x00000204u)) * 0x01010101u) >> 24) + 2)
 		& ((((LODWORD(P) & 0x08102040u) + (HIDWORD(P) & 0x00000004u)) * 0x01010101u) >> 24);
-	flipped |= (outflank_d7 * 0x000000f8f0e0c080ULL) & 0x0000020408102000ULL;
+	flipped |= (outflank_d7 * 0x000000f8f0e0c080) & 0x0000020408102000;
 
 	return flipped;
 }
@@ -1651,14 +1628,14 @@ static unsigned long long flip_B7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x02020200u) << 3) + ((HIDWORD(O) & 0x00000202u) >> 1)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x02020202u) << 3) + ((HIDWORD(P) & 0x00000002u) >> 1)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x0000007c3c1c0c04ULL) & 0x0000020202020200ULL;
+	flipped = (outflank_v * 0x0000007c3c1c0c04) & 0x0000020202020200;
 
 	outflank_h = ((HIDWORD(O) & 0x007c0000u) + 0x00040000u) & HIDWORD(P);
 	flipped |= (unsigned long long) ((outflank_h - (outflank_h >> 8)) & 0x007c0000u) << 32;
 
 	outflank_d7 = (((((LODWORD(O) & 0x10204000u) + (HIDWORD(O) & 0x00000408u)) * 0x01010101u) >> 25) + 2)
 		& ((((LODWORD(P) & 0x10204080u) + (HIDWORD(P) & 0x00000008u)) * 0x01010101u) >> 25);
-	flipped |= (outflank_d7 * 0x000001f1e1c18100ULL) & 0x0000040810204000ULL;
+	flipped |= (outflank_d7 * 0x000001f1e1c18100) & 0x0000040810204000;
 
 	return flipped;
 }
@@ -1677,14 +1654,14 @@ static unsigned long long flip_C7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x04040400u) << 2) + ((HIDWORD(O) & 0x00000404u) >> 2)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x04040404u) << 2) + ((HIDWORD(P) & 0x00000004u) >> 2)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x000000f878381808ULL) & 0x0000040404040400ULL;
+	flipped = (outflank_v * 0x000000f878381808) & 0x0000040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x00ff000000000000;
 
 	outflank_d = OUTFLANK_2[(((HIDWORD(O) & 0x00000a10u) + (LODWORD(O) & 0x20400000u)) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00000a11u) + (LODWORD(P) & 0x20408000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d] & 0x00000a1020400000ULL;	// A5-C7-H2
+	flipped |= FLIPPED_2_H[outflank_d] & 0x00040a1020400000;	// A5C7H2
 
 	return flipped;
 }
@@ -1703,14 +1680,14 @@ static unsigned long long flip_D7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x08080800u) << 1) + ((HIDWORD(O) & 0x00000808u) >> 3)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x08080808u) << 1) + ((HIDWORD(P) & 0x00000008u) >> 3)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x000001f0f0703010ULL) & 0x0000080808080800ULL;
+	flipped = (outflank_v * 0x000001f0f0703010) & 0x0000080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000;
 
 	outflank_d = OUTFLANK_3[(((HIDWORD(O) & 0x00001422u) + (LODWORD(O) & 0x40000000u)) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00001422u) + (LODWORD(P) & 0x41800000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000142240000000ULL;	// A4-D7-H3
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0008142240000000;	// A4D7H3
 
 	return flipped;
 }
@@ -1729,14 +1706,14 @@ static unsigned long long flip_E7(const unsigned long long P, const unsigned lon
 
 	outflank_v = (((((LODWORD(O) & 0x10101000u) + ((HIDWORD(O) & 0x00001010u) >> 4)) * 0x08040201u) >> 24) + 4)
 		& ((((LODWORD(P) & 0x10101010u) + ((HIDWORD(P) & 0x00000010u) >> 4)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x000003e1e0e06020ULL) & 0x0000101010101000ULL;
+	flipped = (outflank_v * 0x000003e1e0e06020) & 0x0000101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000;
 
 	outflank_d = OUTFLANK_4[(((HIDWORD(O) & 0x00002844u) + (LODWORD(O) & 0x02000000u)) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00002844u) + (LODWORD(P) & 0x82010000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000284402000000ULL;	// A3-E7-H4
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0010284402000000;	// A3E7H4
 
 	return flipped;
 }
@@ -1755,14 +1732,14 @@ static unsigned long long flip_F7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x20202000u) >> 1) + ((HIDWORD(O) & 0x00002020u) >> 5)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x20202020u) >> 1) + ((HIDWORD(P) & 0x00000020u) >> 5)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x000007c3c1c0c040ULL) & 0x0000202020202000ULL;
+	flipped = (outflank_v * 0x000007c3c1c0c040) & 0x0000202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0x00ff000000000000;
 
 	outflank_d = OUTFLANK_5[(((HIDWORD(O) & 0x00005008u) + (LODWORD(O) & 0x04020000u)) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00005088u) + (LODWORD(P) & 0x04020100u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d] & 0x0000500804020000ULL;	// A2-F7-H5
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0020500804020000;	// A2F7H5
 
 	return flipped;
 }
@@ -1781,14 +1758,14 @@ static unsigned long long flip_G7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x40404000u) >> 2) + ((HIDWORD(O) & 0x00004040u) >> 6)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x40404040u) >> 2) + ((HIDWORD(P) & 0x00000040u) >> 6)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x00000f8783818080ULL) & 0x0000404040404000ULL;
+	flipped = (outflank_v * 0x00000f8783818080) & 0x0000404040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 48) & 0x3e] & (P >> 47);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 48;
 
 	outflank_d9 = OUTFLANK_7[(((LODWORD(O) & 0x08040200u) + (HIDWORD(O) & 0x00002010u)) * 0x01010101u) >> 24]
 		& ((((LODWORD(P) & 0x08040201u) + (HIDWORD(P) & 0x00000010u)) * 0x01010101u) >> 23);
-	flipped |= (outflank_d9 * 0x00001f0f07030100ULL) & 0x0000201008040200ULL;
+	flipped |= (outflank_d9 * 0x00001f0f07030100) & 0x0000201008040200;
 
 	return flipped;
 }
@@ -1807,14 +1784,14 @@ static unsigned long long flip_H7(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x80808000u) >> 3) + ((HIDWORD(O) & 0x00008080u) >> 7)) * 0x08040201u) >> 24) + 4)
 		& (((((LODWORD(P) & 0x80808080u) >> 3) + ((HIDWORD(P) & 0x00000080u) >> 7)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x00001f0f07030100ULL) & 0x0000808080808000ULL;
+	flipped = (outflank_v * 0x00001f0f07030100) & 0x0000808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 49) & 0x3f] & (P >> 48);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 49;
 
 	outflank_d9 = OUTFLANK_7[(((LODWORD(O) & 0x10080400u) + (HIDWORD(O) & 0x00004020u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x10080402u) + (HIDWORD(P) & 0x00000020u)) * 0x01010101u) >> 24);
-	flipped |= (outflank_d9 * 0x00003e1e0e060200ULL) & 0x0000402010080400ULL;
+	flipped |= (outflank_d9 * 0x00003e1e0e060200) & 0x0000402010080400;
 
 	return flipped;
 }
@@ -1833,14 +1810,14 @@ static unsigned long long flip_A8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x01010100u) << 4) + (HIDWORD(O) & 0x00010101u)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x01010101u) << 4) + (HIDWORD(P) & 0x00000101u)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x00007e3e1e0e0602ULL) & 0x0001010101010100ULL;
+	flipped = (outflank_v * 0x00007e3e1e0e0602) & 0x0001010101010100;
 
-	outflank_h = ((HIDWORD(O) & 0x7e000000u) + 0x02000000u) & HIDWORD(P);
+	outflank_h = (HIDWORD(O) + 0x02000000u) & HIDWORD(P);
 	flipped |= (unsigned long long) ((outflank_h - (outflank_h >> 8)) & 0x7e000000u) << 32;
 
 	outflank_d7 = (((((LODWORD(O) & 0x10204000u) + (HIDWORD(O) & 0x00020408u)) * 0x01010101u) >> 24) + 2)
 		& ((((LODWORD(P) & 0x10204080u) + (HIDWORD(P) & 0x00000408u)) * 0x01010101u) >> 24);
-	flipped |= (outflank_d7 * 0x0000fcf8f0e0c080ULL) & 0x0002040810204000ULL;
+	flipped |= (outflank_d7 * 0x0000fcf8f0e0c080) & 0x0002040810204000;
 
 	return flipped;
 }
@@ -1859,14 +1836,14 @@ static unsigned long long flip_B8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x02020200u) << 3) + ((HIDWORD(O) & 0x00020202u) >> 1)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x02020202u) << 3) + ((HIDWORD(P) & 0x00000202u) >> 1)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x0000fc7c3c1c0c04ULL) & 0x0002020202020200ULL;
+	flipped = (outflank_v * 0x0000fc7c3c1c0c04) & 0x0002020202020200;
 
-	outflank_h = ((HIDWORD(O) & 0x7c000000u) + 0x04000000u) & HIDWORD(P);
+	outflank_h = (HIDWORD(O) + 0x04000000u) & HIDWORD(P);
 	flipped |= (unsigned long long) ((outflank_h - (outflank_h >> 8)) & 0x7c000000u) << 32;
 
 	outflank_d7 = (((((LODWORD(O) & 0x20400000u) + (HIDWORD(O) & 0x00040810u)) * 0x01010101u) >> 25) + 2)
 		& ((((LODWORD(P) & 0x20408000u) + (HIDWORD(P) & 0x00000810u)) * 0x01010101u) >> 25);
-	flipped |= (outflank_d7 * 0x0001f9f1e1c18000ULL) & 0x0004081020400000ULL;
+	flipped |= (outflank_d7 * 0x0001f9f1e1c18000) & 0x0004081020400000;
 
 	return flipped;
 }
@@ -1885,14 +1862,14 @@ static unsigned long long flip_C8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x04040400u) << 2) + ((HIDWORD(O) & 0x00040404u) >> 2)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x04040404u) << 2) + ((HIDWORD(P) & 0x00000404u) >> 2)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x0001f8f878381808ULL) & 0x0004040404040400ULL;
+	flipped = (outflank_v * 0x0001f8f878381808) & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_2_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0xff00000000000000;
 
 	outflank_d = OUTFLANK_2[(((HIDWORD(O) & 0x000a1020u) + (LODWORD(O) & 0x40000000u)) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x000a1120u) + (LODWORD(P) & 0x40800000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_2_H[outflank_d] & 0x000a102040000000ULL;	// A6-C8-H3
+	flipped |= FLIPPED_2_H[outflank_d] & 0x040a102040000000;	// A6C8H3
 
 	return flipped;
 }
@@ -1911,14 +1888,14 @@ static unsigned long long flip_D8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x08080800u) << 1) + ((HIDWORD(O) & 0x00080808u) >> 3)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x08080808u) << 1) + ((HIDWORD(P) & 0x00000808u) >> 3)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x0003f1f0f0703010ULL) & 0x0008080808080800ULL;
+	flipped = (outflank_v * 0x0003f1f0f0703010) & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000;
 
 	outflank_d = OUTFLANK_3[((HIDWORD(O) & 0x00142240u) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00142241u) + (LODWORD(P) & 0x80000000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0014224000000000ULL;	// A5-D8-H4
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0814224000000000;	// A5D8H4
 
 	return flipped;
 }
@@ -1937,14 +1914,14 @@ static unsigned long long flip_E8(const unsigned long long P, const unsigned lon
 
 	outflank_v = (((((LODWORD(O) & 0x10101000u) + ((HIDWORD(O) & 0x00101010u) >> 4)) * 0x08040201u) >> 24) + 2)
 		& ((((LODWORD(P) & 0x10101010u) + ((HIDWORD(P) & 0x00001010u) >> 4)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x0007e3e1e0e06020ULL) & 0x0010101010101000ULL;
+	flipped = (outflank_v * 0x0007e3e1e0e06020) & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000;
 
 	outflank_d = OUTFLANK_4[((HIDWORD(O) & 0x00284402u) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00284482u) + (LODWORD(P) & 0x01000000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0028440200000000ULL;	// A4-E8-H5
+	flipped |= FLIPPED_4_H[outflank_d] & 0x1028440200000000;	// A4E8H5
 
 	return flipped;
 }
@@ -1963,14 +1940,14 @@ static unsigned long long flip_F8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x20202000u) >> 1) + ((HIDWORD(O) & 0x00202020u) >> 5)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x20202020u) >> 1) + ((HIDWORD(P) & 0x00002020u) >> 5)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x000fc7c3c1c0c040ULL) & 0x0020202020202000ULL;
+	flipped = (outflank_v * 0x000fc7c3c1c0c040) & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_5_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0xff00000000000000;
 
 	outflank_d = OUTFLANK_5[(((HIDWORD(O) & 0x00500804u) + (LODWORD(O) & 0x02000000u)) * 0x01010101u) >> 25]
 		& ((((HIDWORD(P) & 0x00508804u) + (LODWORD(P) & 0x02010000u)) * 0x01010101u) >> 24);
-	flipped |= FLIPPED_5_H[outflank_d] & 0x0050080402000000ULL;	// A3-F8-H6
+	flipped |= FLIPPED_5_H[outflank_d] & 0x2050080402000000;	// A3F8H6
 
 	return flipped;
 }
@@ -1989,14 +1966,14 @@ static unsigned long long flip_G8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x40404000u) >> 2) + ((HIDWORD(O) & 0x00404040u) >> 6)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x40404040u) >> 2) + ((HIDWORD(P) & 0x00004040u) >> 6)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x001f8f8783818080ULL) & 0x0040404040404000ULL;
+	flipped = (outflank_v * 0x001f8f8783818080) & 0x0040404040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 56) & 0x3e] & (P >> 55);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 56;
 
 	outflank_d9 = OUTFLANK_7[(((LODWORD(O) & 0x04020000u) + (HIDWORD(O) & 0x00201008u)) * 0x01010101u) >> 24]
 		& ((((LODWORD(P) & 0x04020100u) + (HIDWORD(P) & 0x00001008u)) * 0x01010101u) >> 23);
-	flipped |= (outflank_d9 * 0x001f0f0703010000ULL) & 0x0020100804020000ULL;
+	flipped |= (outflank_d9 * 0x001f0f0703010000) & 0x0020100804020000;
 
 	return flipped;
 }
@@ -2015,14 +1992,14 @@ static unsigned long long flip_H8(const unsigned long long P, const unsigned lon
 
 	outflank_v = ((((((LODWORD(O) & 0x80808000u) >> 3) + ((HIDWORD(O) & 0x00808080u) >> 7)) * 0x08040201u) >> 24) + 2)
 		& (((((LODWORD(P) & 0x80808080u) >> 3) + ((HIDWORD(P) & 0x00008080u) >> 7)) * 0x08040201u) >> 24);
-	flipped = (outflank_v * 0x003f1f0f07030100ULL) & 0x0080808080808000ULL;
+	flipped = (outflank_v * 0x003f1f0f07030100) & 0x0080808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 57) & 0x3f] & (P >> 56);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 57;
 
 	outflank_d9 = OUTFLANK_7[(((LODWORD(O) & 0x08040200u) + (HIDWORD(O) & 0x00402010u)) * 0x01010101u) >> 25]
 		& ((((LODWORD(P) & 0x08040201u) + (HIDWORD(P) & 0x00002010u)) * 0x01010101u) >> 24);
-	flipped |= (outflank_d9 * 0x007e3e1e0e060200ULL) & 0x0040201008040200ULL;
+	flipped |= (outflank_d9 * 0x007e3e1e0e060200) & 0x0040201008040200;
 
 	return flipped;
 }
@@ -2044,22 +2021,14 @@ static unsigned long long flip_pass(const unsigned long long P, const unsigned l
 
 /** Array of functions to compute flipped discs */
 unsigned long long (*flip[])(const unsigned long long, const unsigned long long) = {
-	flip_A1, flip_B1, flip_C1, flip_D1,
-	flip_E1, flip_F1, flip_G1, flip_H1,
-	flip_A2, flip_B2, flip_C2, flip_D2,
-	flip_E2, flip_F2, flip_G2, flip_H2,
-	flip_A3, flip_B3, flip_C3, flip_D3,
-	flip_E3, flip_F3, flip_G3, flip_H3,
-	flip_A4, flip_B4, flip_C4, flip_D4,
-	flip_E4, flip_F4, flip_G4, flip_H4,
-	flip_A5, flip_B5, flip_C5, flip_D5,
-	flip_E5, flip_F5, flip_G5, flip_H5,
-	flip_A6, flip_B6, flip_C6, flip_D6,
-	flip_E6, flip_F6, flip_G6, flip_H6,
-	flip_A7, flip_B7, flip_C7, flip_D7,
-	flip_E7, flip_F7, flip_G7, flip_H7,
-	flip_A8, flip_B8, flip_C8, flip_D8,
-	flip_E8, flip_F8, flip_G8, flip_H8,
+	flip_A1, flip_B1, flip_C1, flip_D1, flip_E1, flip_F1, flip_G1, flip_H1,
+	flip_A2, flip_B2, flip_C2, flip_D2, flip_E2, flip_F2, flip_G2, flip_H2,
+	flip_A3, flip_B3, flip_C3, flip_D3, flip_E3, flip_F3, flip_G3, flip_H3,
+	flip_A4, flip_B4, flip_C4, flip_D4, flip_E4, flip_F4, flip_G4, flip_H4,
+	flip_A5, flip_B5, flip_C5, flip_D5, flip_E5, flip_F5, flip_G5, flip_H5,
+	flip_A6, flip_B6, flip_C6, flip_D6, flip_E6, flip_F6, flip_G6, flip_H6,
+	flip_A7, flip_B7, flip_C7, flip_D7, flip_E7, flip_F7, flip_G7, flip_H7,
+	flip_A8, flip_B8, flip_C8, flip_D8, flip_E8, flip_F8, flip_G8, flip_H8,
 	flip_pass, flip_pass
 };
 
diff --git a/src/flip_carry_64.c b/src/flip_carry_64.c
index cb91c89e..5cbf39f0 100644
--- a/src/flip_carry_64.c
+++ b/src/flip_carry_64.c
@@ -37,12 +37,14 @@
  * If the OUTFLANK search is in MSB to LSB direction, CONTIG_X tables
  * are used to determine coutiguous opponent discs.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @author Toshihiko Okuhara
  * @version 4.4
  */
 
+#include "bit.h"
+
 /** outflank array (indexed with inner 6 bits) */
 /* static const unsigned char OUTFLANK_0[64] = {
 	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
@@ -126,167 +128,287 @@ static const unsigned char CONTIG_UPRIGHT[64] = {
 
 /** flip array (indexed with outflank, returns inner 6 bits) */
 static const unsigned long long FLIPPED_2_H[130] = {
-	0x0000000000000000ULL, 0x0202020202020202ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0808080808080808ULL, 0x0a0a0a0a0a0a0a0aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1818181818181818ULL, 0x1a1a1a1a1a1a1a1aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3838383838383838ULL, 0x3a3a3a3a3a3a3a3aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7878787878787878ULL, 0x7a7a7a7a7a7a7a7aULL
+	0x0000000000000000, 0x0202020202020202, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0808080808080808, 0x0a0a0a0a0a0a0a0a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1818181818181818, 0x1a1a1a1a1a1a1a1a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x3838383838383838, 0x3a3a3a3a3a3a3a3a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7878787878787878, 0x7a7a7a7a7a7a7a7a
 };
 
 static const unsigned long long FLIPPED_3_H[131] = {
-	0x0000000000000000ULL, 0x0606060606060606ULL, 0x0404040404040404ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x1616161616161616ULL, 0x1414141414141414ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3030303030303030ULL, 0x3636363636363636ULL, 0x3434343434343434ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7070707070707070ULL, 0x7676767676767676ULL, 0x7474747474747474ULL
+	0x0000000000000000, 0x0606060606060606, 0x0404040404040404, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x1616161616161616, 0x1414141414141414, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x3030303030303030, 0x3636363636363636, 0x3434343434343434, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7070707070707070, 0x7676767676767676, 0x7474747474747474
 };
 
 static const unsigned long long FLIPPED_4_H[133] = {
-	0x0000000000000000ULL, 0x0e0e0e0e0e0e0e0eULL, 0x0c0c0c0c0c0c0c0cULL, 0x0000000000000000ULL, 0x0808080808080808ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x2020202020202020ULL, 0x2e2e2e2e2e2e2e2eULL, 0x2c2c2c2c2c2c2c2cULL, 0x0000000000000000ULL, 0x2828282828282828ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x6060606060606060ULL, 0x6e6e6e6e6e6e6e6eULL, 0x6c6c6c6c6c6c6c6cULL, 0x0000000000000000ULL, 0x6868686868686868ULL
+	0x0000000000000000, 0x0e0e0e0e0e0e0e0e, 0x0c0c0c0c0c0c0c0c, 0x0000000000000000, 0x0808080808080808, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x2020202020202020, 0x2e2e2e2e2e2e2e2e, 0x2c2c2c2c2c2c2c2c, 0x0000000000000000, 0x2828282828282828, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x6060606060606060, 0x6e6e6e6e6e6e6e6e, 0x6c6c6c6c6c6c6c6c, 0x0000000000000000, 0x6868686868686868
 };
 
 static const unsigned long long FLIPPED_5_H[137] = {
-	0x0000000000000000ULL, 0x1e1e1e1e1e1e1e1eULL, 0x1c1c1c1c1c1c1c1cULL, 0x0000000000000000ULL, 0x1818181818181818ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x4040404040404040ULL, 0x5e5e5e5e5e5e5e5eULL, 0x5c5c5c5c5c5c5c5cULL, 0x0000000000000000ULL, 0x5858585858585858ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x5050505050505050ULL
+	0x0000000000000000, 0x1e1e1e1e1e1e1e1e, 0x1c1c1c1c1c1c1c1c, 0x0000000000000000, 0x1818181818181818, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x4040404040404040, 0x5e5e5e5e5e5e5e5e, 0x5c5c5c5c5c5c5c5c, 0x0000000000000000, 0x5858585858585858, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x5050505050505050
+};
+
+static const unsigned long long FLIPPED_2_V[130] = {
+	0x0000000000000000, 0x000000000000ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ff000000, 0x00000000ff00ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ffff000000, 0x000000ffff00ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ffffff000000, 0x0000ffffff00ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffffff000000, 0x00ffffffff00ff00
 };
 
 static const unsigned long long FLIPPED_3_V[131] = {
-	0x0000000000000000ULL, 0x0000000000ffff00ULL, 0x0000000000ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x000000ff00ffff00ULL, 0x000000ff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ffff00000000ULL, 0x0000ffff00ffff00ULL, 0x0000ffff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffffff00000000ULL, 0x00ffffff00ffff00ULL, 0x00ffffff00ff0000ULL
+	0x0000000000000000, 0x0000000000ffff00, 0x0000000000ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x000000ff00ffff00, 0x000000ff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ffff00000000, 0x0000ffff00ffff00, 0x0000ffff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffff00000000, 0x00ffffff00ffff00, 0x00ffffff00ff0000
 };
 
 static const unsigned long long FLIPPED_4_V[133] = {
-	0x0000000000000000ULL, 0x00000000ffffff00ULL, 0x00000000ffff0000ULL, 0x0000000000000000ULL, 0x00000000ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ff0000000000ULL, 0x0000ff00ffffff00ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffff0000000000ULL, 0x00ffff00ffffff00ULL, 0x00ffff00ffff0000ULL, 0x0000000000000000ULL, 0x00ffff00ff000000ULL
+	0x0000000000000000, 0x00000000ffffff00, 0x00000000ffff0000, 0x0000000000000000, 0x00000000ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ff0000000000, 0x0000ff00ffffff00, 0x0000ff00ffff0000, 0x0000000000000000, 0x0000ff00ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffff0000000000, 0x00ffff00ffffff00, 0x00ffff00ffff0000, 0x0000000000000000, 0x00ffff00ff000000
 };
 
-static const unsigned long long  FLIPPED_5_V[137] = {
-	0x0000000000000000ULL, 0x000000ffffffff00ULL, 0x000000ffffff0000ULL, 0x0000000000000000ULL, 0x000000ffff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ff000000000000ULL, 0x00ff00ffffffff00ULL, 0x00ff00ffffff0000ULL, 0x0000000000000000ULL, 0x00ff00ffff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ff00ff00000000ULL
+static const unsigned long long FLIPPED_5_V[137] = {
+	0x0000000000000000, 0x000000ffffffff00, 0x000000ffffff0000, 0x0000000000000000, 0x000000ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff000000000000, 0x00ff00ffffffff00, 0x00ff00ffffff0000, 0x0000000000000000, 0x00ff00ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff00ff00000000
+};
+
+static const unsigned long long FLIPPED_2_U[130] = {
+	0x0000000000000000, 0x00ff000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x00ff00ff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ffff000000, 0x00ff00ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ffffff0000, 0x00ff00ffffff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ffffffff00, 0x00ff00ffffffff00
 };
 
 static const unsigned long long FLIPPED_3_U[131] = {
-	0x0000000000000000ULL, 0x00ffff0000000000ULL, 0x0000ff0000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ff000000ULL, 0x00ffff00ff000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ffff0000ULL, 0x00ffff00ffff0000ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ffffff00ULL, 0x00ffff00ffffff00ULL, 0x0000ff00ffffff00ULL
+	0x0000000000000000, 0x00ffff0000000000, 0x0000ff0000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ff000000, 0x00ffff00ff000000, 0x0000ff00ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ffff0000, 0x00ffff00ffff0000, 0x0000ff00ffff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ffffff00, 0x00ffff00ffffff00, 0x0000ff00ffffff00
 };
 
+static const unsigned long long FLIPPED_4_U[133] = {
+	0x0000000000000000, 0x00ffffff00000000, 0x0000ffff00000000, 0x0000000000000000, 0x000000ff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000ff0000, 0x00ffffff00ff0000, 0x0000ffff00ff0000, 0x0000000000000000, 0x000000ff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000ffff00, 0x00ffffff00ffff00, 0x0000ffff00ffff00, 0x0000000000000000, 0x000000ff00ffff00
+};
+
+static const unsigned long long  FLIPPED_5_U[137] = {
+	0x0000000000000000, 0x00ffffffff000000, 0x0000ffffff000000, 0x0000000000000000, 0x000000ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000ff00, 0x00ffffffff00ff00, 0x0000ffffff00ff00, 0x0000000000000000, 0x000000ffff00ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ff00ff00
+};
+
+
+/*
+ * Set all bits below the sole outflank bit if outfrank != 0
+ */
+#if __has_builtin(__builtin_subcll)
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned long long flipmask, cy;
+	flipmask = __builtin_subcll(outflank, 1, 0, &cy);
+	return __builtin_addcll(flipmask, 0, cy, &cy);
+}
+#elif (defined(_M_X64) && (_MSC_VER >= 1800)) || (defined(__x86_64__) && defined(__GNUC__) && (__GNUC__ > 7 || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2)))
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned long long flipmask;
+	unsigned char cy = _subborrow_u64(0, outflank, 1, &flipmask);
+	_addcarry_u64(cy, flipmask, 0, &flipmask);
+	return flipmask;
+}
+#else
+	#define OutflankToFlipmask(outflank)	((outflank) - (unsigned int) ((outflank) != 0))
+#endif
+
+/*
+ * Scan non-opponent bit (player or empty) from LSB
+ */
+#if 0 // LS1B
+static unsigned long long OUTFLANK_LEFT(unsigned long long O, unsigned long long M) {
+	unsigned long long b = ~O & M;
+	return b & -b;
+}
+#else // carry propagation - less register pressure
+/*
+ *	((~O & M) & -(~O & M)) & P		// LS1B
+ *	((~O & M) & (~(~O & M) + 1)) & P	// -x = (~x + 1)
+ *	(~O & M & ((O | ~M) + 1)) & P		// De Morgan
+ *	(((O | ~M) + 1) & M) & (P & ~O)		// P & O = 0, so P & ~O = P
+ *	(((O | ~M) + 1) & M) & P		// carry propagation
+ */
+#define OUTFLANK_LEFT(O,M)	((((O) | ~(M)) + 1) & (M))
+#endif
 
 /**
  * Compute flipped discs when playing on square A1.
@@ -297,16 +419,17 @@ static const unsigned long long FLIPPED_3_U[131] = {
  */
 static unsigned long long flip_A1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
+	unsigned char outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101010100ULL) + 0x0000000000000100ULL) & P & 0x0101010101010100ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101010100ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0101010101010100) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010100;
 
-	outflank_h = ((O & 0x000000000000007eULL) + 0x0000000000000002ULL) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x000000000000007eULL;
+	outflank_d9 = OUTFLANK_LEFT(O, 0x8040201008040200) & P;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040200;
 
-	outflank_d9 = ((O | ~0x8040201008040200ULL) + 0x0000000000000200ULL) & P & 0x8040201008040200ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008040200ULL;
+	outflank_h = (O + 0x02) & P;
+	flipped += ((outflank_h * 0x7f) >> 8) << 1;
 
 	return flipped;
 }
@@ -320,16 +443,17 @@ static unsigned long long flip_A1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
+	unsigned char outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202020200ULL) + 0x0000000000000200ULL) & P & 0x0202020202020200ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202020200ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0202020202020200) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020200;
 
-	outflank_h = ((O & 0x000000000000007cULL) + 0x0000000000000004ULL) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x000000000000007cULL;
+	outflank_d9 = OUTFLANK_LEFT(O, 0x0080402010080400) & P;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0080402010080400;
 
-	outflank_d9 = ((O | ~0x0080402010080400ULL) + 0x0000000000000400ULL) & P & 0x0080402010080400ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010080400ULL;
+	outflank_h = (O + 0x04) & P;
+	flipped += ((outflank_h * 0x3f) >> 8) << 2;
 
 	return flipped;
 }
@@ -343,20 +467,19 @@ static unsigned long long flip_B1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = OUTFLANK_LEFT(O, 0x0404040404040400) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040400;
 
-	outflank_v = ((O | ~0x0404040404040400ULL) + 0x0000000000000400ULL) & P & 0x0404040404040400ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404040400ULL;
+	outflank_d = OUTFLANK_2[((O & 0x0000004020100a04) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000804020110a04) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_2_H[outflank_d] & 0x0000004020100a04;	// A3C1H6
 
 	outflank_h = OUTFLANK_2[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_2_H[outflank_h];
 
-	flipped |= ((P >> 7) & 0x0000000000000200ULL & O);
-
-	outflank_d9 = ((O | ~0x0000804020100800ULL) + 0x0000000000000800ULL) & P & 0x0000804020100800ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000804020100800ULL;
-
 	return flipped;
 }
 
@@ -369,21 +492,19 @@ static unsigned long long flip_C1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_v = ((O | ~0x0808080808080800ULL) + 0x0000000000000800ULL) & P & 0x0808080808080800ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808080800ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0808080808080800) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080800;
+
+	outflank_d = OUTFLANK_3[((O & 0x0000000040221408) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000008041221408) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000000040221408;	// A4D1H5
 
 	outflank_h = OUTFLANK_3[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
 
-	outflank_d7 = ((O | ~0x0000000001020400ULL) + 0x0000000000000400ULL) & P & 0x0000000001020400ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000001020400ULL;
-
-	outflank_d9 = ((O | ~0x0000008040201000ULL) + 0x0000000000001000ULL) & P & 0x0000008040201000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000008040201000ULL;
-
 	return flipped;
 }
 
@@ -396,21 +517,19 @@ static unsigned long long flip_D1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = OUTFLANK_LEFT(O, 0x1010101010101000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010101000;
 
-	outflank_v = ((O | ~0x1010101010101000ULL) + 0x0000000000001000ULL) & P & 0x1010101010101000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010101000ULL;
+	outflank_d = OUTFLANK_4[((O & 0x0000000002442810) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000000182442810) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000002442810;	// A5E1H4
 
 	outflank_h = OUTFLANK_4[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
 
-	outflank_d7 = ((O | ~0x0000000102040800ULL) + 0x0000000000000800ULL) & P & 0x0000000102040800ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000102040800ULL;
-
-	outflank_d9 = ((O | ~0x0000000080402000ULL) + 0x0000000000002000ULL) & P & 0x0000000080402000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000000080402000ULL;
-
 	return flipped;
 }
 
@@ -423,20 +542,19 @@ static unsigned long long flip_E1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F1(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = OUTFLANK_LEFT(O, 0x2020202020202000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020202000;
 
-	outflank_v = ((O | ~0x2020202020202000ULL) + 0x0000000000002000ULL) & P & 0x2020202020202000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020202000ULL;
+	outflank_d = OUTFLANK_5[((O & 0x0000000204085020) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000010204885020) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0000000204085020;	// A6F1H3
 
 	outflank_h = OUTFLANK_5[(O >> 1) & 0x3f] & P;
 	flipped |= (unsigned char) FLIPPED_5_H[outflank_h];
 
-	outflank_d7 = ((O | ~0x0000010204081000ULL) + 0x0000000000001000ULL) & P & 0x0000010204081000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000010204081000ULL;
-
-	flipped |= ((P >> 9) & 0x0000000000004000ULL & O);
-
 	return flipped;
 }
 
@@ -452,15 +570,15 @@ static unsigned long long flip_G1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040404000ULL) + 0x0000000000004000ULL) & P & 0x4040404040404000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040404000ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x4040404040404000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040404000;
+
+	outflank_d7 = OUTFLANK_LEFT(O, 0x0001020408102000) & P;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0001020408102000;
 
 	outflank_h = OUTFLANK_7[O & 0x3e] & (P << 1);
 	flipped |= ((-outflank_h) & 0x3e) << 0;
 
-	outflank_d7 = ((O | ~0x0001020408102000ULL) + 0x0000000000002000ULL) & P & 0x0001020408102000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408102000ULL;
-
 	return flipped;
 }
 
@@ -476,15 +594,15 @@ static unsigned long long flip_H1(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080808000ULL) + 0x0000000000008000ULL) & P & 0x8080808080808000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080808000ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x8080808080808000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080808000;
+
+	outflank_d7 = OUTFLANK_LEFT(O, 0x0102040810204000) & P;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810204000;
 
 	outflank_h = OUTFLANK_7[(O >> 1) & 0x3f] & P;
 	flipped |= ((-outflank_h) & 0x3f) << 1;
 
-	outflank_d7 = ((O | ~0x0102040810204000ULL) + 0x0000000000004000ULL) & P & 0x0102040810204000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810204000ULL;
-
 	return flipped;
 }
 
@@ -497,17 +615,17 @@ static unsigned long long flip_H1(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
+	unsigned short outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0101010101010000ULL) + 0x0000000000010000ULL) & P & 0x0101010101010000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101010000ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0101010101010000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010000;
 
-	outflank_h = ((O & 0x0000000000007e00ULL) + 0x0000000000000200ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000000000007e00ULL;
+	outflank_d9 = OUTFLANK_LEFT(O, 0x4020100804020000) & P;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x4020100804020000;
 
-	outflank_d9 = ((O | ~0x4020100804020000ULL) + 0x0000000000020000ULL) & P & 0x4020100804020000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x4020100804020000ULL;
+	outflank_h = (O + 0x0200) & P;
+	flipped |= ((outflank_h * 0x7f) >> 16) << 9;
 
 	return flipped;
 }
@@ -521,17 +639,17 @@ static unsigned long long flip_A2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
+	unsigned short outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = ((O | ~0x0202020202020000ULL) + 0x0000000000020000ULL) & P & 0x0202020202020000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202020000ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0202020202020000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020000;
 
-	outflank_h = ((O & 0x0000000000007c00ULL) + 0x0000000000000400ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000000000007c00ULL;
+	outflank_d9 = OUTFLANK_LEFT(O, 0x8040201008040000) & P;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040000;
 
-	outflank_d9 = ((O | ~0x8040201008040000ULL) + 0x0000000000040000ULL) & P & 0x8040201008040000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008040000ULL;
+	outflank_h = (O + 0x0400) & P;
+	flipped |= ((outflank_h * 0x3f) >> 16) << 10;
 
 	return flipped;
 }
@@ -545,19 +663,18 @@ static unsigned long long flip_B2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = ((O | ~0x0404040404040000ULL) + 0x0000000000040000ULL) & P & 0x0404040404040000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404040000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_2[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x000000000000ff00ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0404040404040000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040000;
 
-	flipped |= ((P >> 7) & 0x0000000000020000ULL & O);
+	outflank_d = OUTFLANK_2[((O & 0x00004020100a0400) * 0x0101010101010101) >> 57]
+		& (((P & 0x00804020110a0400) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_2_H[outflank_d] & 0x00004020100a0400;	// A4C2H7
 
-	outflank_d9 = ((O | ~0x0080402010080000ULL) + 0x0000000000080000ULL) & P & 0x0080402010080400ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010080000ULL;
+	outflank_h = OUTFLANK_2[(O >> 9) & 0x3f] & (P >> 8);
+	flipped |= FLIPPED_2_H[outflank_h] & 0x000000000000ff00;
 
 	return flipped;
 }
@@ -571,20 +688,18 @@ static unsigned long long flip_C2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x0808080808080000ULL) + 0x0000000000080000ULL) & P & 0x0808080808080000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808080000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000000000ff00ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x0808080808080000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080000;
 
-	outflank_d7 = ((O | ~0x0000000102040000ULL) + 0x0000000000040000ULL) & P & 0x0000000102040000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000102040000ULL;
+	outflank_d = OUTFLANK_3[((O & 0x0000004022140800) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000804122140800) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000004022140800;	// A5D2H6
 
-	outflank_d9 = ((O | ~0x0000804020100000ULL) + 0x0000000000100000ULL) & P & 0x0000804020100000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000804020100000ULL;
+	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & (P >> 8);
+	flipped |= FLIPPED_3_H[outflank_h] & 0x000000000000ff00;
 
 	return flipped;
 }
@@ -598,20 +713,18 @@ static unsigned long long flip_D2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
-
-	outflank_v = ((O | ~0x1010101010100000ULL) + 0x0000000000100000ULL) & P & 0x1010101010100000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010100000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000000000ff00ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x1010101010100000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010100000;
 
-	outflank_d7 = ((O | ~0x0000010204080000ULL) + 0x0000000000080000ULL) & P & 0x0000010204080000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000010204080000ULL;
+	outflank_d = OUTFLANK_4[((O & 0x0000000244281000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000018244281000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000244281000;	// A6E2H5
 
-	outflank_d9 = ((O | ~0x0000008040200000ULL) + 0x0000000000200000ULL) & P & 0x0000008040200000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000008040200000ULL;
+	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & (P >> 8);
+	flipped |= FLIPPED_4_H[outflank_h] & 0x000000000000ff00;
 
 	return flipped;
 }
@@ -625,19 +738,18 @@ static unsigned long long flip_E2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F2(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x2020202020200000ULL) + 0x0000000000200000ULL) & P & 0x2020202020200000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020200000ULL;
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
 
-	outflank_h = OUTFLANK_5[(O >> 9) & 0x3f] & (P >> 8);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x000000000000ff00ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x2020202020200000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020200000;
 
-	outflank_d7 = ((O | ~0x0001020408100000ULL) + 0x0000000000100000ULL) & P & 0x0001020408100000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408100000ULL;
+	outflank_d = OUTFLANK_5[((O & 0x0000020408502000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0001020488502000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0000020408502000;	// A7F2H4
 
-	flipped |= ((P >> 9) & 0x0000000000400000ULL & O);
+	outflank_h = OUTFLANK_5[(O >> 9) & 0x3f] & (P >> 8);
+	flipped |= FLIPPED_5_H[outflank_h] & 0x000000000000ff00;
 
 	return flipped;
 }
@@ -654,15 +766,15 @@ static unsigned long long flip_G2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x4040404040400000ULL) + 0x0000000000400000ULL) & P & 0x4040404040400000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040400000ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x4040404040400000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040400000;
+
+	outflank_d7 = OUTFLANK_LEFT(O, 0x0102040810200000) & P;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810200000;
 
 	outflank_h = OUTFLANK_7[(O >> 8) & 0x3e] & (P >> 7);
 	flipped |= ((-outflank_h) & 0x3e) << 8;
 
-	outflank_d7 = ((O | ~0x0102040810200000ULL) + 0x0000000000200000ULL) & P & 0x0102040810200000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810200000ULL;
-
 	return flipped;
 }
 
@@ -678,15 +790,15 @@ static unsigned long long flip_H2(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d7;
 
-	outflank_v = ((O | ~0x8080808080800000ULL) + 0x0000000000800000ULL) & P & 0x8080808080800000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080800000ULL;
+	outflank_v = OUTFLANK_LEFT(O, 0x8080808080800000) & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080800000;
+
+	outflank_d7 = OUTFLANK_LEFT(O, 0x0204081020400000) & P;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0204081020400000;
 
 	outflank_h = OUTFLANK_7[(O >> 9) & 0x3f] & (P >> 8);
 	flipped |= ((-outflank_h) & 0x3f) << 9;
 
-	outflank_d7 = ((O | ~0x0204081020400000ULL) + 0x0000000000400000ULL) & P & 0x0204081020400000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0204081020400000ULL;
-
 	return flipped;
 }
 
@@ -699,18 +811,19 @@ static unsigned long long flip_H2(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
-
-	outflank_v = ((O | ~0x0101010101000000ULL) + 0x0000000001000000ULL) & P & 0x0101010101000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101000000ULL;
+	unsigned int outflank_h, outflank_a1a3f8, outflank_a8a3c1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00000000007e0000ULL) + 0x0000000000020000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00000000007e0000ULL;
+	outflank_a1a3f8 = OUTFLANK_2[((O & 0x0010080402010100) * 0x0102040404040404) >> 57]
+		& (((P & 0x2010080402010101) * 0x0102040404040404) >> 56);
+	flipped = FLIPPED_2_V[outflank_a1a3f8] & 0x0010080402010100;
 
-	outflank_d9 = ((O | ~0x2010080402000000ULL) + 0x0000000002000000ULL) & P & 0x2010080402000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x2010080402000000ULL;
+	outflank_a8a3c1 = OUTFLANK_5[((O & 0x0001010101010200) * 0x2020201008040201) >> 57]
+		& (((P & 0x0101010101010204) * 0x2020201008040201) >> 56);
+	flipped |= FLIPPED_5_U[outflank_a8a3c1] & 0x0001010101010200;
 
-	flipped |= (((P << 8) & 0x0000000000000100ULL) | ((P << 7) & 0x0000000000000200ULL)) & O;
+	outflank_h = ((O & 0x007e0000u) + 0x00020000u) & P;
+	flipped |= ((outflank_h * 0x7f) >> 24) << 17;
 
 	return flipped;
 }
@@ -724,18 +837,19 @@ static unsigned long long flip_A3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
-
-	outflank_v = ((O | ~0x0202020202000000ULL) + 0x0000000002000000ULL) & P & 0x0202020202000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202000000ULL;
+	unsigned int outflank_h, outflank_b1b3g8, outflank_b8b3d1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00000000007c0000ULL) + 0x0000000000040000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00000000007c0000ULL;
+	outflank_b1b3g8 = OUTFLANK_2[((O & 0x0020100804020200) * 0x0081020202020202) >> 57]
+		& (((P & 0x4020100804020202) * 0x0081020202020202) >> 56);
+	flipped = FLIPPED_2_V[outflank_b1b3g8] & 0x0020100804020200;
 
-	outflank_d9 = ((O | ~0x4020100804000000ULL) + 0x0000000004000000ULL) & P & 0x4020100804000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x4020100804000000ULL;
+	outflank_b8b3d1 = OUTFLANK_5[((O & 0x0002020202020400) * 0x0010100804020100) >> 57]
+		& ((((P & 0x0202020202020408) >> 1) * 0x2020201008040201) >> 56);
+	flipped |= FLIPPED_5_U[outflank_b8b3d1] & 0x0002020202020400;
 
-	flipped |= (((P << 8) & 0x0000000000000200ULL) | ((P << 7) & 0x0000000000000400ULL)) & O;
+	outflank_h = ((O & 0x007c0000u) + 0x00040000u) & P;
+	flipped |= ((outflank_h * 0x3f) >> 24) << 18;
 
 	return flipped;
 }
@@ -749,19 +863,21 @@ static unsigned long long flip_B3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d9;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x0404040404000000ULL) + 0x0000000004000000ULL) & P & 0x0404040404000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404000000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0004040404040400) * 0x0040810204081020) >> 57]
+		& (((P & 0x0404040404040404) * 0x0040810204081020) >> 56);
+	flipped = FLIPPED_2_V[outflank_v] & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x0000000000ff0000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x0000000000ff0000;
 
-	outflank_d9 = ((O | ~0x8040201008000000ULL) + 0x0000000008000000ULL) & P & 0x8040201008000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008000000ULL;
+	flipped |= (((P >> 7) | (P << 7)) & 0x000000002000800) & O;
 
-	flipped |= (((P << 8) & 0x0000000000000400ULL) | ((P << 9) & 0x0000000000000200ULL) | (((P >> 7) | (P << 7)) & 0x000000002000800ULL)) & O;
+	outflank_d9 = OUTFLANK_2[((O & 0x0040201008040200) * 0x0101010101010101) >> 57]
+		& (((P & 0x8040201008040201) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_2_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -775,22 +891,21 @@ static unsigned long long flip_C3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_D3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x0808080808000000ULL) + 0x0000000008000000ULL) & P & 0x0808080808000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808000000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0008080808080800) * 0x0020408102040810) >> 57]
+		& (((P & 0x0808080808080808) * 0x0020408102040810) >> 56);
+	flipped = FLIPPED_2_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000000000ff0000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x0000000000ff0000;
 
-	outflank_d7 = ((O | ~0x0000010204000000ULL) + 0x0000000004000000ULL) & P & 0x0000010204000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 24)) & 0x0000010204000000ULL;
+	outflank_d = OUTFLANK_3[((O & 0x0000402214080000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0080412214080000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000402214080000;	// A6D3H7
 
-	outflank_d9 = ((O | ~0x0080402010000000ULL) + 0x0000000010000000ULL) & P & 0x0080402010000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010000000ULL;
-
-	flipped |= (((P << 8) & 0x0000000000000800ULL) | ((P << 7) & 0x0000000000001000ULL) | ((P << 9) & 0x000000000000400ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000000001000) | ((P << 9) & 0x000000000000400)) & O;
 
 	return flipped;
 }
@@ -804,22 +919,21 @@ static unsigned long long flip_D3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_E3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	unsigned int outflank_h, outflank_v, outflank_d;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x1010101010000000ULL) + 0x0000000010000000ULL) & P & 0x1010101010000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010000000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0010101010101000) * 0x0010204081020408) >> 57]
+		& (((P & 0x1010101010101010) * 0x0010204081020408) >> 56);
+	flipped = FLIPPED_2_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000000000ff0000ULL;
-
-	outflank_d7 = ((O | ~0x0001020408000000ULL) + 0x0000000008000000ULL) & P & 0x0001020408000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x0000000000ff0000;
 
-	outflank_d9 = ((O | ~0x0000804020000000ULL) + 0x0000000020000000ULL) & P & 0x0000804020000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 24)) & 0x0000804020000000ULL;
+	outflank_d = OUTFLANK_4[((O & 0x0000024428100000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0001824428100000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000024428100000;	// A7E3H6
 
-	flipped |= (((P << 8) & 0x0000000000001000ULL) | ((P << 7) & 0x0000000000002000ULL) | ((P << 9) & 0x000000000000800ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000000002000) | ((P << 9) & 0x000000000000800)) & O;
 
 	return flipped;
 }
@@ -833,19 +947,21 @@ static unsigned long long flip_E3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_v, outflank_d7;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x2020202020000000ULL) + 0x0000000020000000ULL) & P & 0x2020202020000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020000000ULL;
+	outflank_v = OUTFLANK_2[((O & 0x0020202020202000) * 0x0008102040810204) >> 57]
+		& (((P & 0x2020202020202020) * 0x0008102040810204) >> 56);
+	flipped = FLIPPED_2_V[outflank_v] & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x0000000000ff0000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0x0000000000ff0000;
 
-	outflank_d7 = ((O | ~0x0102040810000000ULL) + 0x0000000010000000ULL) & P & 0x0102040810000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810000000ULL;
+	outflank_d7 = OUTFLANK_5[((O & 0x0002040810204000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0102040810204080) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_5_H[outflank_d7] & 0x0002040810204000;
 
-	flipped |= (((P << 8) & 0x0000000000002000ULL) | ((P << 7) & 0x0000000000004000ULL) | (((P >> 9) | (P << 9)) & 0x0000000040001000ULL)) & O;
+	flipped |= (((P >> 9) | (P << 9)) & 0x0000000040001000) & O;
 
 	return flipped;
 }
@@ -859,20 +975,20 @@ static unsigned long long flip_F3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_G3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_e1g3g8, outflank_b8g3g1;
+	unsigned long long flipped;
+
+	outflank_e1g3g8 = OUTFLANK_2[((O & 0x0040404040402000) * 0x0010101020408102) >> 57]
+		& (((P & 0x4040404040402010) * 0x0010101020408102) >> 56);
+	flipped = FLIPPED_2_V[outflank_e1g3g8] & 0x0040404040402000;
 
-	outflank_v = ((O | ~0x4040404040000000ULL) + 0x0000000040000000ULL) & P & 0x4040404040000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040000000ULL;
+	outflank_b8g3g1 = OUTFLANK_5[((O & 0x0004081020404000) * 0x0402010101010101) >> 58]
+		& ((((P & 0x0204081020404040) >> 1) * 0x0402010101010101) >> 56);
+	flipped |= FLIPPED_5_U[outflank_b8g3g1] & 0x0004081020404000;
 
 	outflank_h = OUTFLANK_7[(O >> 16) & 0x3e] & (P >> 15);
 	flipped |= ((-outflank_h) & 0x3e) << 16;
 
-	outflank_d7 = ((O | ~0x0204081020000000ULL) + 0x0000000020000000ULL) & P & 0x0204081020000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0204081020000000ULL;
-
-	flipped |= (((P << 8) & 0x0000000000004000ULL) | ((P << 9) & 0x0000000000002000ULL)) & O;
-
 	return flipped;
 }
 
@@ -885,20 +1001,20 @@ static unsigned long long flip_G3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_H3(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h, outflank_f1h3h8, outflank_c8h3h1;
+	unsigned long long flipped;
 
-	outflank_v = ((O | ~0x8080808080000000ULL) + 0x0000000080000000ULL) & P & 0x8080808080000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080000000ULL;
+	outflank_f1h3h8 = OUTFLANK_2[((O & 0x0080808080804000) * 0x0008080810204081) >> 57]
+		& (((P & 0x8080808080804020) * 0x0008080810204081) >> 56);
+	flipped = FLIPPED_2_V[outflank_f1h3h8] & 0x0080808080804000;
+
+	outflank_c8h3h1 = OUTFLANK_5[((O & 0x0008102040808000) * 0x0000804040404040) >> 57]
+		& ((((P & 0x0408102040808080) >> 2) * 0x0402010101010101) >> 56);
+	flipped |= FLIPPED_5_U[outflank_c8h3h1] & 0x0008102040808000;
 
 	outflank_h = OUTFLANK_7[(O >> 17) & 0x3f] & (P >> 16);
 	flipped |= ((-outflank_h) & 0x3f) << 17;
 
-	outflank_d7 = ((O | ~0x0408102040000000ULL) + 0x0000000040000000ULL) & P & 0x0408102040000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0408102040000000ULL;
-
-	flipped |= (((P << 8) & 0x0000000000008000ULL) | ((P << 9) & 0x0000000000004000ULL)) & O;
-
 	return flipped;
 }
 
@@ -911,21 +1027,19 @@ static unsigned long long flip_H3(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57] & (((P & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0001010101010100ULL;
+	unsigned int outflank_h, outflank_a1a4e8, outflank_a8a4d1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x000000007e000000ULL) + 0x0000000002000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x000000007e000000ULL;
+	outflank_a1a4e8 = OUTFLANK_3[((O & 0x0008040201010100) * 0x0102040808080808) >> 57]
+		& (((P & 0x1008040201010101) * 0x0102040808080808) >> 56);
+	flipped = FLIPPED_3_V[outflank_a1a4e8] & 0x0008040201010100;
 
-	flip_d7 = O & 0x0000000000020000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_a8a4d1 = OUTFLANK_4[((O & 0x0001010101020400) * 0x1010101008040201) >> 57]
+		& (((P & 0x0101010101020408) * 0x1010101008040201) >> 56);
+	flipped |= FLIPPED_4_U[outflank_a8a4d1] & 0x0001010101020400;
 
-	outflank_d9 = ((O | ~0x1008040200000000ULL) + 0x0000000200000000ULL) & P & 0x1008040200000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x1008040200000000ULL;
+	outflank_h = ((unsigned int) O + 0x02000000u) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e000000u;
 
 	return flipped;
 }
@@ -939,21 +1053,19 @@ static unsigned long long flip_A4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57] & (((P & 0x0202020202020202ULL) * 0x0081020408102040ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0002020202020200ULL;
+	unsigned int outflank_h, outflank_b1b4f8, outflank_b8b4e1;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x000000007c000000ULL) + 0x0000000004000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x000000007c000000ULL;
+	outflank_b1b4f8 = OUTFLANK_3[((O & 0x0010080402020200) * 0x0081020404040404) >> 57]
+		& (((P & 0x2010080402020202) * 0x0081020404040404) >> 56);
+	flipped = FLIPPED_3_V[outflank_b1b4f8] & 0x0010080402020200;
 
-	flip_d7 = O & 0x0000000000040000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_b8b4e1 = OUTFLANK_4[((O & 0x0002020202040800) * 0x1010101008040201) >> 58]
+		& ((((P & 0x0202020202040810) >> 1) * 0x1010101008040201) >> 56);
+	flipped |= FLIPPED_4_U[outflank_b8b4e1] & 0x0002020202040800;
 
-	outflank_d9 = ((O | ~0x2010080400000000ULL) + 0x0000000400000000ULL) & P & 0x2010080400000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x2010080400000000ULL;
+	outflank_h = ((unsigned int) O + 0x04000000u) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c000000u;
 
 	return flipped;
 }
@@ -967,23 +1079,21 @@ static unsigned long long flip_B4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57] & (((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0004040404040400ULL;
+	unsigned int outflank_h, outflank_c1c4g8, outflank_c8c4f1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_2[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x00000000ff000000ULL;
+	outflank_c1c4g8 = OUTFLANK_3[((O & 0x0020100804040400) * 0x0040810202020202) >> 57]
+		& (((P & 0x4020100804040404) * 0x0040810202020202) >> 56);
+	flipped = FLIPPED_3_V[outflank_c1c4g8] & 0x0020100804040400;
 
-	flip_d7 = O & 0x0000000000080000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_c8c4f1 = OUTFLANK_4[((O & 0x0004040404081000) * 0x0404040402010080) >> 57]
+		& ((((P & 0x0404040404081020) >> 2) * 0x1010101008040201) >> 56);
+	flipped |= FLIPPED_4_U[outflank_c8c4f1] & 0x0004040404081000;
 
-	outflank_d9 = ((O | ~0x4020100800000000ULL) + 0x0000000800000000ULL) & P & 0x4020100800000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x4020100800000000ULL;
+	outflank_h = OUTFLANK_2[(O >> 25) & 0x3f] & (P >> 24);
+	flipped |= FLIPPED_2_H[outflank_h] & 0x00000000ff000000;
 
-	flipped |= (((P << 9) & 0x00000000000020000ULL) | ((P >> 7) & 0x00000000200000000ULL)) & O;
+	flipped |= (((P << 9) & 0x00000000000020000) | ((P >> 7) & 0x00000000200000000)) & O;
 
 	return flipped;
 }
@@ -1000,17 +1110,20 @@ static unsigned long long flip_D4(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_3[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800ULL;
+	outflank_v = OUTFLANK_3[((O & 0x0008080808080800) * 0x0020408102040810) >> 57]
+		& (((P & 0x0808080808080808) * 0x0020408102040810) >> 56);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00000000ff000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x00000000ff000000;
 
-	outflank_d7 = OUTFLANK_3[((O & 0x0000020408102000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0001020408102040ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000ULL;
+	outflank_d7 = OUTFLANK_3[((O & 0x0000020408102000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0001020408102040) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000;
 
-	outflank_d9 = OUTFLANK_3[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200ULL;
+	outflank_d9 = OUTFLANK_3[((O & 0x0040201008040200) * 0x0101010101010101) >> 57]
+		& (((P & 0x8040201008040201) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1027,17 +1140,20 @@ static unsigned long long flip_E4(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_3[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000ULL;
+	outflank_v = OUTFLANK_3[((O & 0x0010101010101000) * 0x0010204081020408) >> 57]
+		& (((P & 0x1010101010101010) * 0x0010204081020408) >> 56);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00000000ff000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x00000000ff000000;
 
-	outflank_d7 = OUTFLANK_4[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000ULL;
+	outflank_d7 = OUTFLANK_4[((O & 0x0002040810204000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0102040810204080) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000;
 
-	outflank_d9 = OUTFLANK_4[((O & 0x0000402010080400ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0080402010080402ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400ULL;
+	outflank_d9 = OUTFLANK_4[((O & 0x0000402010080400) * 0x0101010101010101) >> 57]
+		& (((P & 0x0080402010080402) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400;
 
 	return flipped;
 }
@@ -1051,23 +1167,21 @@ static unsigned long long flip_E4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_F4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57] & (((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0020202020202000ULL;
+	unsigned int outflank_h, outflank_c1f4f8, outflank_b8f4f1;
+	unsigned long long flipped;
 
-	outflank_h = OUTFLANK_5[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x00000000ff000000ULL;
+	outflank_c1f4f8 = OUTFLANK_3[((O & 0x0020202020100800) * 0x0040404040810204) >> 57]
+		& (((P & 0x2020202020100804) * 0x0040404040810204) >> 56);
+	flipped = FLIPPED_3_V[outflank_c1f4f8] & 0x0020202020100800;
 
-	outflank_d7 = ((O | ~0x0204081000000000ULL) + 0x0000001000000000ULL) & P & 0x0204081000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0204081000000000ULL;
+	outflank_b8f4f1 = OUTFLANK_4[((O & 0x0004081020202000) * 0x0804020101010101) >> 58]
+		& ((((P & 0x0204081020202020) >> 1) * 0x0804020101010101) >> 56);
+	flipped |= FLIPPED_4_U[outflank_b8f4f1] & 0x0004081020202000;
 
-	flip_d9 = O & 0x0000000000100000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
+	outflank_h = OUTFLANK_5[(O >> 25) & 0x3f] & (P >> 24);
+	flipped |= FLIPPED_5_H[outflank_h] & 0x00000000ff000000;
 
-	flipped |= (((P << 7) & 0x0000000000400000ULL) | ((P >> 9) & 0x0000004000000000ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000000400000) | ((P >> 9) & 0x0000004000000000)) & O;
 
 	return flipped;
 }
@@ -1081,22 +1195,20 @@ static unsigned long long flip_F4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_G4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
+	unsigned int outflank_h, outflank_d1g4g8, outflank_c8g4g1;
+	unsigned long long flipped;
+
+	outflank_d1g4g8 = OUTFLANK_3[((O & 0x0040404040201000) * 0x0020202020408102) >> 57]
+		& (((P & 0x4040404040201008) * 0x0020202020408102) >> 56);
+	flipped = FLIPPED_3_V[outflank_d1g4g8] & 0x0040404040201000;
 
-	outflank_v = OUTFLANK_3[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57] & (((P & 0x4040404040404040ULL) * 0x0004081020408102ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0040404040404000ULL;
+	outflank_c8g4g1 = OUTFLANK_4[((O & 0x0008102040404000) * 0x0001008040404040) >> 57]
+		& ((((P & 0x0408102040404040) >> 2) * 0x0804020101010101) >> 56);
+	flipped |= FLIPPED_4_U[outflank_c8g4g1] & 0x0008102040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 24) & 0x3e] & (P >> 23);
 	flipped |= ((-outflank_h) & 0x3e) << 24;
 
-	outflank_d7 = ((O | ~0x0408102000000000ULL) + 0x0000002000000000ULL) & P & 0x0408102000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0408102000000000ULL;
-
-	flip_d9 = O & 0x0000000000200000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
 	return flipped;
 }
 
@@ -1109,22 +1221,20 @@ static unsigned long long flip_G4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_H4(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
+	unsigned int outflank_h, outflank_e1h4h8, outflank_d8h4h1;
+	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_3[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57] & (((P & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0080808080808000ULL;
+	outflank_e1h4h8 = OUTFLANK_3[((O & 0x0080808080402000) * 0x0010101010204081) >> 57]
+		& (((P & 0x8080808080402010) * 0x0010101010204081) >> 56);
+	flipped = FLIPPED_3_V[outflank_e1h4h8] & 0x0080808080402000;
+
+	outflank_d8h4h1 = OUTFLANK_4[((O & 0x0010204080808000) * 0x0000804020202020) >> 57]
+		& ((((P & 0x0810204080808080) >> 3) * 0x0804020101010101) >> 56);
+	flipped |= FLIPPED_4_U[outflank_d8h4h1] & 0x0010204080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 25) & 0x3f] & (P >> 24);
 	flipped |= ((-outflank_h) & 0x3f) << 25;
 
-	outflank_d7 = ((O | ~0x0810204000000000ULL) + 0x0000004000000000ULL) & P & 0x0810204000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0810204000000000ULL;
-
-	flip_d9 = O & 0x0000000000400000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
 	return flipped;
 }
 
@@ -1137,17 +1247,19 @@ static unsigned long long flip_H4(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_a1a5d8, outflank_a8a5e1;
-	unsigned long long flipped, outflank_h;
+	unsigned int outflank_a1a5d8, outflank_a8a5e1, outflank_h;
+	unsigned long long flipped;
 
-	outflank_a1a5d8 = OUTFLANK_4[((O & 0x0004020101010100ULL) * 0x0102040810101010ULL) >> 57] & (((P & 0x0804020101010101ULL) * 0x0102040810101010ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_a1a5d8] & 0x0004020101010100ULL;
+	outflank_a1a5d8 = OUTFLANK_4[((O & 0x0004020101010100) * 0x0102040810101010) >> 57]
+		& (((P & 0x0804020101010101) * 0x0102040810101010) >> 56);
+	flipped = FLIPPED_4_V[outflank_a1a5d8] & 0x0004020101010100;
 
-	outflank_a8a5e1 = OUTFLANK_3[((O & 0x0001010102040800ULL) * 0x0808080808040201ULL) >> 57] & (((P & 0x0101010102040810ULL) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_a8a5e1] & 0x0001010102040800ULL;
+	outflank_a8a5e1 = OUTFLANK_3[((O & 0x0001010102040800) * 0x0808080808040201) >> 57]
+		& (((P & 0x0101010102040810) * 0x0808080808040201) >> 56);
+	flipped |= FLIPPED_3_U[outflank_a8a5e1] & 0x0001010102040800;
 
-	outflank_h = ((O & 0x0000007e00000000ULL) + 0x0000000200000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000007e00000000ULL;
+	outflank_h = ((unsigned int) (O >> 8) + 0x02000000) & (unsigned int) (P >> 8);
+	flipped |= (((unsigned long long) outflank_h << 8) - outflank_h) & 0x0000007e00000000;
 
 	return flipped;
 }
@@ -1161,17 +1273,19 @@ static unsigned long long flip_A5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_b1b5e8, outflank_b8b5f1;
-	unsigned long long flipped, outflank_h;
+	unsigned int outflank_b1b5e8, outflank_b8b5f1, outflank_h;
+	unsigned long long flipped;
 
-	outflank_b1b5e8 = OUTFLANK_4[((O & 0x0008040202020200ULL) * 0x0081020408080808ULL) >> 57] & (((P & 0x1008040202020202ULL) * 0x0081020408080808ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_b1b5e8] & 0x0008040202020200ULL;
+	outflank_b1b5e8 = OUTFLANK_4[((O & 0x0008040202020200) * 0x0081020408080808) >> 57]
+		& (((P & 0x1008040202020202) * 0x0081020408080808) >> 56);
+	flipped = FLIPPED_4_V[outflank_b1b5e8] & 0x0008040202020200;
 
-	outflank_b8b5f1 = OUTFLANK_3[((O & 0x0002020204081000ULL) * 0x0808080808040201ULL) >> 58] & ((((P & 0x0202020204081020ULL) >> 1) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_b8b5f1] & 0x0002020204081000ULL;
+	outflank_b8b5f1 = OUTFLANK_3[((O & 0x0002020204081000) * 0x0808080808040201) >> 58]
+		& ((((P & 0x0202020204081020) >> 1) * 0x0808080808040201) >> 56);
+	flipped |= FLIPPED_3_U[outflank_b8b5f1] & 0x0002020204081000;
 
-	outflank_h = ((O & 0x0000007c00000000ULL) + 0x0000000400000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000007c00000000ULL;
+	outflank_h = ((unsigned int) (O >> 8) + 0x04000000) & (unsigned int) (P >> 8);
+	flipped |= (((unsigned long long) outflank_h << 8) - outflank_h) & 0x0000007c00000000;
 
 	return flipped;
 }
@@ -1185,19 +1299,21 @@ static unsigned long long flip_B5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_C5(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_c1c5f8, outflank_c8c5g1;
-	unsigned long long flipped, outflank_h;
+	unsigned int outflank_h, outflank_c1c5f8, outflank_c8c5g1;
+	unsigned long long flipped;
 
-	outflank_c1c5f8 = OUTFLANK_4[((O & 0x0010080404040400ULL) * 0x0040810204040404ULL) >> 57] & (((P & 0x2010080404040404ULL) * 0x0040810204040404ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_c1c5f8] & 0x0010080404040400ULL;
+	outflank_c1c5f8 = OUTFLANK_4[((O & 0x0010080404040400) * 0x0040810204040404) >> 57]
+		& (((P & 0x2010080404040404) * 0x0040810204040404) >> 56);
+	flipped = FLIPPED_4_V[outflank_c1c5f8] & 0x0010080404040400;
 
-	outflank_c8c5g1 = OUTFLANK_3[((O & 0x0004040408102000ULL) * 0x0002020202010080ULL) >> 57] & ((((P & 0x0404040408102040ULL) >> 2) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_c8c5g1] & 0x0004040408102000ULL;
+	outflank_c8c5g1 = OUTFLANK_3[((O & 0x0004040408102000) * 0x0002020202010080) >> 57]
+		& ((((P & 0x0404040408102040) >> 2) * 0x0808080808040201) >> 56);
+	flipped |= FLIPPED_3_U[outflank_c8c5g1] & 0x0004040408102000;
 
 	outflank_h = OUTFLANK_2[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x000000ff00000000;
 
-	flipped |= (((P << 9) & 0x0000000002000000ULL) | ((P >> 7) & 0x0000020000000000ULL)) & O;
+	flipped |= (((P << 9) & 0x0000000002000000) | ((P >> 7) & 0x0000020000000000)) & O;
 
 	return flipped;
 }
@@ -1214,17 +1330,20 @@ static unsigned long long flip_D5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_4[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800ULL;
+	outflank_v = OUTFLANK_4[((O & 0x0008080808080800) * 0x0020408102040810) >> 57]
+		& (((P & 0x0808080808080808) * 0x0020408102040810) >> 56);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000;
 
-	outflank_d7 = OUTFLANK_3[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000ULL;
+	outflank_d7 = OUTFLANK_3[((O & 0x0002040810204000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0102040810204080) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000;
 
-	outflank_d9 = OUTFLANK_3[((O & 0x0020100804020000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x4020100804020100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000ULL;
+	outflank_d9 = OUTFLANK_3[((O & 0x0020100804020000) * 0x0101010101010101) >> 57]
+		& (((P & 0x4020100804020100) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000;
 
 	return flipped;
 }
@@ -1241,17 +1360,20 @@ static unsigned long long flip_E5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_4[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000ULL;
+	outflank_v = OUTFLANK_4[((O & 0x0010101010101000) * 0x0010204081020408) >> 57]
+		& (((P & 0x1010101010101010) * 0x0010204081020408) >> 56);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000;
 
-	outflank_d7 = OUTFLANK_4[((O & 0x0004081020400000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0204081020408000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000ULL;
+	outflank_d7 = OUTFLANK_4[((O & 0x0004081020400000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0204081020408000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000;
 
-	outflank_d9 = OUTFLANK_4[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200ULL;
+	outflank_d9 = OUTFLANK_4[((O & 0x0040201008040200) * 0x0101010101010101) >> 57]
+		& (((P & 0x8040201008040201) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1268,16 +1390,18 @@ static unsigned long long flip_F5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_b1f5f8, outflank_c8f5f1;
 	unsigned long long flipped;
 
-	outflank_b1f5f8 = OUTFLANK_4[((O & 0x0020202010080400ULL) * 0x0080808080810204ULL) >> 57] & (((P & 0x2020202010080402ULL) * 0x0080808080810204ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_b1f5f8] & 0x0020202010080400ULL;
+	outflank_b1f5f8 = OUTFLANK_4[((O & 0x0020202010080400) * 0x0080808080810204) >> 57]
+		& (((P & 0x2020202010080402) * 0x0080808080810204) >> 56);
+	flipped = FLIPPED_4_V[outflank_b1f5f8] & 0x0020202010080400;
 
-	outflank_c8f5f1 = OUTFLANK_3[((O & 0x0008102020202000ULL) * 0x0002010080404040ULL) >> 57] & ((((P & 0x0408102020202020ULL) >> 2) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_c8f5f1] & 0x0008102020202000ULL;
+	outflank_c8f5f1 = OUTFLANK_3[((O & 0x0008102020202000) * 0x0002010080404040) >> 57]
+		& ((((P & 0x0408102020202020) >> 2) * 0x1008040201010101) >> 56);
+	flipped |= FLIPPED_3_U[outflank_c8f5f1] & 0x0008102020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x000000ff00000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0x000000ff00000000;
 
-	flipped |= (((P << 7) & 0x0000000040000000ULL) | ((P >> 9) & 0x0000400000000000ULL)) & O;
+	flipped |= (((P << 7) & 0x0000000040000000) | ((P >> 9) & 0x0000400000000000)) & O;
 
 	return flipped;
 }
@@ -1294,11 +1418,13 @@ static unsigned long long flip_G5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_c1g5g8, outflank_d8g5g1;
 	unsigned long long flipped;
 
-	outflank_c1g5g8 = OUTFLANK_4[((O & 0x0040404020100800ULL) * 0x0040404040408102ULL) >> 57] & (((P & 0x4040404020100804ULL) * 0x0040404040408102ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_c1g5g8] & 0x0040404020100800ULL;
+	outflank_c1g5g8 = OUTFLANK_4[((O & 0x0040404020100800) * 0x0040404040408102) >> 57]
+		& (((P & 0x4040404020100804) * 0x0040404040408102) >> 56);
+	flipped = FLIPPED_4_V[outflank_c1g5g8] & 0x0040404020100800;
 
-	outflank_d8g5g1 = OUTFLANK_3[((O & 0x0010204040404000ULL) * 0x0001008040202020ULL) >> 57] & ((((P & 0x0810204040404040ULL) >> 3) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_d8g5g1] & 0x0010204040404000ULL;
+	outflank_d8g5g1 = OUTFLANK_3[((O & 0x0010204040404000) * 0x0001008040202020) >> 57]
+		& ((((P & 0x0810204040404040) >> 3) * 0x1008040201010101) >> 56);
+	flipped |= FLIPPED_3_U[outflank_d8g5g1] & 0x0010204040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 32) & 0x3e] & (P >> 31);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 32;
@@ -1318,11 +1444,13 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d1h5h8, outflank_e8h5h1;
 	unsigned long long flipped;
 
-	outflank_d1h5h8 = OUTFLANK_4[((O & 0x0080808040201000ULL) * 0x0020202020204081ULL) >> 57] & (((P & 0x8080808040201008ULL) * 0x0020202020204081ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_d1h5h8] & 0x0080808040201000ULL;
+	outflank_d1h5h8 = OUTFLANK_4[((O & 0x0080808040201000) * 0x0020202020204081) >> 57]
+		& (((P & 0x8080808040201008) * 0x0020202020204081) >> 56);
+	flipped = FLIPPED_4_V[outflank_d1h5h8] & 0x0080808040201000;
 
-	outflank_e8h5h1 = OUTFLANK_3[((O & 0x0020408080808000ULL) * 0x0000804020101010ULL) >> 57] & ((((P & 0x1020408080808080ULL) >> 4) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_e8h5h1] & 0x0020408080808000ULL;
+	outflank_e8h5h1 = OUTFLANK_3[((O & 0x0020408080808000) * 0x0000804020101010) >> 57]
+		& ((((P & 0x1020408080808080) >> 4) * 0x1008040201010101) >> 56);
+	flipped |= FLIPPED_3_U[outflank_e8h5h1] & 0x0020408080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 33) & 0x3f] & (P >> 32);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 33;
@@ -1339,21 +1467,19 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7;
-
-	outflank_v = OUTFLANK_5[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57] & (((P & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0001010101010100ULL;
+	unsigned int outflank_a1a6c8, outflank_a8a6f1, outflank_h;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00007e0000000000ULL) + 0x0000020000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007e0000000000ULL;
+	outflank_a1a6c8 = OUTFLANK_5[((O & 0x0002010101010100) * 0x0102040810202020) >> 57]
+		& (((P & 0x0402010101010101) * 0x0102040810202020) >> 56);
+	flipped = FLIPPED_5_V[outflank_a1a6c8] & 0x0002010101010100;
 
-	flip_d7 = O | 0x0040810000000000ULL;
-	flip_d7 &= flip_d7 >> 7;
-	flip_d7 &= (flip_d7 >> 14) & 0x0000000204081000ULL;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_a8a6f1 = OUTFLANK_2[((O & 0x0001010204081000) * 0x0404040404040201) >> 57]
+		& (((P & 0x0101010204081020) * 0x0404040404040201) >> 56);
+	flipped |= FLIPPED_2_U[outflank_a8a6f1] & 0x0001010204081000;
 
-	flipped |= (P >> 9) & 0x0002000000000000ULL & O;
+	outflank_h = ((unsigned int) (O >> 16) + 0x02000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x00007e0000000000;
 
 	return flipped;
 }
@@ -1367,21 +1493,19 @@ static unsigned long long flip_A6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7;
-
-	outflank_v = OUTFLANK_5[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57] & (((P & 0x0202020202020202ULL) * 0x0081020408102040ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0002020202020200ULL;
+	unsigned int outflank_a1a6c8, outflank_a8a6f1, outflank_h;
+	unsigned long long flipped;
 
-	outflank_h = ((O & 0x00007c0000000000ULL) + 0x0000040000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007c0000000000ULL;
+	outflank_a1a6c8 = OUTFLANK_5[((O & 0x0004020202020200) * 0x0081020408101010) >> 57]
+		& (((P & 0x0804020202020202) * 0x0081020408101010) >> 56);
+	flipped = FLIPPED_5_V[outflank_a1a6c8] & 0x0004020202020200;
 
-	flip_d7 = O | 0x0081020000000000ULL;
-	flip_d7 &= flip_d7 >> 7;
-	flip_d7 &= (flip_d7 >> 14) & 0x0000000408102000ULL;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_a8a6f1 = OUTFLANK_2[((O & 0x0002020408102000) * 0x0404040404040201) >> 58]
+		& ((((P & 0x0202020408102040) >> 1) * 0x0404040404040201) >> 56);
+	flipped |= FLIPPED_2_U[outflank_a8a6f1] & 0x0002020408102000;
 
-	flipped |= (P >> 9) & 0x0004000000000000ULL & O;
+	outflank_h = ((unsigned int) (O >> 16) + 0x04000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x00007c0000000000;
 
 	return flipped;
 }
@@ -1398,16 +1522,18 @@ static unsigned long long flip_C6(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d7;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_5[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57] & (((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0004040404040400) * 0x0040810204081020) >> 57]
+		& (((P & 0x0404040404040404) * 0x0040810204081020) >> 56);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x0000ff0000000000;
 
-	outflank_d7 = OUTFLANK_2[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000ULL;
+	outflank_d7 = OUTFLANK_2[((O & 0x0002040810204000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0102040810204080) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000;
 
-	flipped |= ((P >> 9) | (P << 9)) & 0x0008000200000000ULL & O;
+	flipped |= ((P >> 9) | (P << 9)) & 0x0008000200000000 & O;
 
 	return flipped;
 }
@@ -1424,17 +1550,18 @@ static unsigned long long flip_D6(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_5[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0008080808080800) * 0x0020408102040810) >> 57]
+		& (((P & 0x0808080808080808) * 0x0020408102040810) >> 56);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000;
 
-	outflank_d = OUTFLANK_3[((O & 0x0000001422400000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000001422418000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000001422400000ULL;	// A3D6H2
+	outflank_d = OUTFLANK_3[((O & 0x0000081422400000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000081422418000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000081422400000;	// A3D6H2
 
-	flipped |= (((P >> 9) & 0x0010000000000000ULL) | ((P >> 7) & 0x0004000000000000ULL)) & O;
+	flipped |= (((P >> 9) & 0x0010000000000000) | ((P >> 7) & 0x0004000000000000)) & O;
 
 	return flipped;
 }
@@ -1451,17 +1578,18 @@ static unsigned long long flip_E6(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_5[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0010101010101000) * 0x0010204081020408) >> 57]
+		& (((P & 0x1010101010101010) * 0x0010204081020408) >> 56);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000;
 
-	outflank_d = OUTFLANK_4[((O & 0x0000002844020000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000002844820100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000002844020000ULL;	// A2E6H3
+	outflank_d = OUTFLANK_4[((O & 0x0000102844020000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0000102844820100) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000102844020000;	// A2E6H3
 
-	flipped |= (((P >> 9) & 0x0020000000000000ULL) | ((P >> 7) & 0x0008000000000000ULL)) & O;
+	flipped |= (((P >> 9) & 0x0020000000000000) | ((P >> 7) & 0x0008000000000000)) & O;
 
 	return flipped;
 }
@@ -1478,16 +1606,18 @@ static unsigned long long flip_F6(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_v, outflank_d9;
 	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_5[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57] & (((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000ULL;
+	outflank_v = OUTFLANK_5[((O & 0x0020202020202000) * 0x0008102040810204) >> 57]
+		& (((P & 0x2020202020202020) * 0x0008102040810204) >> 56);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= (FLIPPED_5_H[outflank_h] & 0x0000ff0000000000ULL);
+	flipped |= FLIPPED_5_H[outflank_h] & 0x0000ff0000000000;
 
-	flipped |= ((P >> 7) | (P << 7)) & 0x0010004000000000ULL & O;
+	flipped |= ((P >> 7) | (P << 7)) & 0x0010004000000000 & O;
 
-	outflank_d9 = OUTFLANK_5[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200ULL;
+	outflank_d9 = OUTFLANK_5[((O & 0x0040201008040200) * 0x0101010101010101) >> 57]
+		& (((P & 0x8040201008040201) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200;
 
 	return flipped;
 }
@@ -1501,21 +1631,20 @@ static unsigned long long flip_F6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_G6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d9;
+	unsigned int outflank_h, outflank_b1g6g8, outflank_e8g6g1;
+	unsigned long long flipped;
+
+	outflank_b1g6g8 = OUTFLANK_5[((O & 0x0040402010080400) * 0x0080808080808102) >> 57]
+		& (((P & 0x4040402010080402) * 0x0080808080808102) >> 56);
+	flipped = FLIPPED_5_V[outflank_b1g6g8] & 0x0040402010080400;
 
-	outflank_v = OUTFLANK_5[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57] & (((P & 0x4040404040404040ULL) * 0x0004081020408102ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0040404040404000ULL;
+	outflank_e8g6g1 = OUTFLANK_2[((O & 0x0020404040404000) * 0x0001008040201010) >> 57]
+		& ((((P & 0x1020404040404040) >> 4) * 0x2010080402010101) >> 56);
+	flipped |= FLIPPED_2_U[outflank_e8g6g1] & 0x0020404040404000;
 
 	outflank_h = OUTFLANK_7[(O >> 40) & 0x3e] & (P >> 39);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 40;
 
-	flipped |= (P >> 7) & 0x0020000000000000ULL & O;
-
-	flip_d9 = O & ((O >> 9) | 0x0000002000000000ULL);
-	flip_d9 &= (((flip_d9 & 0x0000002010000000ULL) >> 18) | 0x0000002010000000ULL);
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
 	return flipped;
 }
 
@@ -1528,21 +1657,20 @@ static unsigned long long flip_G6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_H6(const unsigned long long P, const unsigned long long O)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d9;
+	unsigned int outflank_h, outflank_c1h6h8, outflank_f8h6h1;
+	unsigned long long flipped;
 
-	outflank_v = OUTFLANK_5[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57] & (((P & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0080808080808000ULL;
+	outflank_c1h6h8 = OUTFLANK_5[((O & 0x0080804020100800) * 0x0040404040404081) >> 57]
+		& (((P & 0x8080804020100804) * 0x0040404040404081) >> 56);
+	flipped = FLIPPED_5_V[outflank_c1h6h8] & 0x0080804020100800;
+
+	outflank_f8h6h1 = OUTFLANK_2[((O & 0x0040808080808000) * 0x0000804020100808) >> 57]
+		& ((((P & 0x2040808080808080) >> 5) * 0x2010080402010101) >> 56);
+	flipped |= FLIPPED_2_U[outflank_f8h6h1] & 0x0040808080808000;
 
 	outflank_h = OUTFLANK_7[(O >> 41) & 0x3f] & (P >> 40);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 41;
 
-	flipped |= (P >> 7) & 0x0040000000000000ULL & O;
-
-	flip_d9 = O & ((O >> 9) | 0x0000004000000000ULL);
-	flip_d9 &= (((flip_d9 & 0x0000004020000000ULL) >> 18) | 0x0000004020000000ULL);
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
 	return flipped;
 }
 
@@ -1555,16 +1683,17 @@ static unsigned long long flip_H6(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_A7(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h;
 
-	outflank_v = (0x0000010000000000ULL >> CONTIG_UP[((O & 0x0000010101010100ULL) * 0x0102040810204080ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000010101010100ULL;
+	outflank_v = (0x0000010000000000 >> CONTIG_UP[((O & 0x0000010101010100) * 0x0102040810204080) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000010101010100;
 
-	outflank_h = ((O & 0x007e000000000000ULL) + 0x0002000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007e000000000000ULL;
+	outflank_d7 = (0x0000020000000000 >> CONTIG_UPRIGHT[((O & 0x0000020408102000) * 0x0101010101010101) >> 57]) & P;
+	flipped |= (-outflank_d7 * 2) & 0x0000020408102000;
 
-	outflank_d7 = (0x0000020000000000ULL >> CONTIG_UPRIGHT[((O & 0x0000020408102000ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000020408102000ULL;
+	outflank_h = ((unsigned int) (O >> 24) + 0x02000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x007e000000000000;
 
 	return flipped;
 }
@@ -1578,16 +1707,17 @@ static unsigned long long flip_A7(const unsigned long long P, const unsigned lon
  */
 static unsigned long long flip_B7(const unsigned long long P, const unsigned long long O)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h;
 
-	outflank_v = (0x0000020000000000ULL >> CONTIG_UP[((O & 0x0000020202020200ULL) * 0x0081020408102040ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000020202020200ULL;
+	outflank_v = (0x0000020000000000 >> CONTIG_UP[((O & 0x0000020202020200) * 0x0081020408102040) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000020202020200;
 
-	outflank_h = ((O & 0x007c000000000000ULL) + 0x0004000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007c000000000000ULL;
+	outflank_d7 = (0x0000040000000000 >> CONTIG_UPRIGHT[((O & 0x0000040810204000) * 0x0101010101010101) >> 58]) & P;
+	flipped |= (-outflank_d7 * 2) & 0x0000040810204000;
 
-	outflank_d7 = (0x0000040000000000ULL >> CONTIG_UPRIGHT[((O & 0x0000040810204000ULL) * 0x0101010101010101ULL) >> 58]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000040810204000ULL;
+	outflank_h = ((unsigned int) (O >> 24) + 0x04000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x007c000000000000;
 
 	return flipped;
 }
@@ -1604,15 +1734,15 @@ static unsigned long long flip_C7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0000040000000000ULL >> CONTIG_UP[((O & 0x0000040404040400ULL) * 0x0040810204081020ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000040404040400ULL;
+	outflank_v = (0x0000040000000000 >> CONTIG_UP[((O & 0x0000040404040400) * 0x0040810204081020) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0x00ff000000000000;
 
-	outflank_d = OUTFLANK_2[((O & 0x00000a1020400000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x00000a1120408000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_2_H[outflank_d] & 0x00000a1020400000ULL;	// A5C7H2
+	outflank_d = OUTFLANK_2[((O & 0x00040a1020400000) * 0x0101010101010101) >> 57]
+		& (((P & 0x00040a1120408000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_2_H[outflank_d] & 0x00040a1020400000;	// A5C7H2
 
 	return flipped;
 }
@@ -1629,15 +1759,15 @@ static unsigned long long flip_D7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0000080000000000ULL >> CONTIG_UP[((O & 0x0000080808080800ULL) * 0x0020408102040810ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000080808080800ULL;
+	outflank_v = (0x0000080000000000 >> CONTIG_UP[((O & 0x0000080808080800) * 0x0020408102040810) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000;
 
-	outflank_d = OUTFLANK_3[((O & 0x0000142240000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000142241800000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000142240000000ULL;	// A4D7H3
+	outflank_d = OUTFLANK_3[((O & 0x0008142240000000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0008142241800000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0008142240000000;	// A4D7H3
 
 	return flipped;
 }
@@ -1654,15 +1784,15 @@ static unsigned long long flip_E7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0000100000000000ULL >> CONTIG_UP[((O & 0x0000101010101000ULL) * 0x0010204081020408ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000101010101000ULL;
+	outflank_v = (0x0000100000000000 >> CONTIG_UP[((O & 0x0000101010101000) * 0x0010204081020408) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000;
 
-	outflank_d = OUTFLANK_4[((O & 0x0000284402000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000284482010000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000284402000000ULL;	// A3E7H4
+	outflank_d = OUTFLANK_4[((O & 0x0010284402000000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0010284482010000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0010284402000000;	// A3E7H4
 
 	return flipped;
 }
@@ -1679,15 +1809,15 @@ static unsigned long long flip_F7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0000200000000000ULL >> CONTIG_UP[((O & 0x0000202020202000ULL) * 0x0008102040810204ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000202020202000ULL;
+	outflank_v = (0x0000200000000000 >> CONTIG_UP[((O & 0x0000202020202000) * 0x0008102040810204) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0x00ff000000000000;
 
-	outflank_d = OUTFLANK_5[((O & 0x0000500804020000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000508804020100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_5_H[outflank_d] & 0x0000500804020000ULL;	// A2F7H5
+	outflank_d = OUTFLANK_5[((O & 0x0020500804020000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0020508804020100) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0020500804020000;	// A2F7H5
 
 	return flipped;
 }
@@ -1704,15 +1834,15 @@ static unsigned long long flip_G7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x0000400000000000ULL >> CONTIG_UP[((O & 0x0000404040404000ULL) * 0x0004081020408102ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000404040404000ULL;
+	outflank_v = (0x0000400000000000 >> CONTIG_UP[((O & 0x0000404040404000) * 0x0004081020408102) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000404040404000;
+
+	outflank_d9 = (0x0000200000000000 >> CONTIG_UPLEFT[((O & 0x0000201008040200) * 0x0101010101010101) >> 56]) & P;
+	flipped |= (-outflank_d9 * 2) & 0x0000201008040200;
 
 	outflank_h = OUTFLANK_7[(O >> 48) & 0x3e] & (P >> 47);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 48;
 
-	outflank_d9 = (0x0000200000000000ULL >> CONTIG_UPLEFT[((O & 0x0000201008040200ULL) * 0x0101010101010101ULL) >> 56]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000201008040200ULL;
-
 	return flipped;
 }
 
@@ -1728,15 +1858,15 @@ static unsigned long long flip_H7(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x0000800000000000ULL >> CONTIG_UP[((O & 0x0000808080808000ULL) * 0x0002040810204081ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000808080808000ULL;
+	outflank_v = (0x0000800000000000 >> CONTIG_UP[((O & 0x0000808080808000) * 0x0002040810204081) >> 56]) & P;
+	flipped  = (-outflank_v * 2) & 0x0000808080808000;
+
+	outflank_d9 = (0x0000400000000000 >> CONTIG_UPLEFT[((O & 0x0000402010080400) * 0x0101010101010101) >> 57]) & P;
+	flipped |= (-outflank_d9 * 2) & 0x0000402010080400;
 
 	outflank_h = OUTFLANK_7[(O >> 49) & 0x3f] & (P >> 48);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 49;
 
-	outflank_d9 = (0x0000400000000000ULL >> CONTIG_UPLEFT[((O & 0x0000402010080400ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000402010080400ULL;
-
 	return flipped;
 }
 
@@ -1751,14 +1881,14 @@ static unsigned long long flip_A8(const unsigned long long P, const unsigned lon
 {
 	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
 
-	outflank_v = (0x0001000000000000ULL >> CONTIG_UP[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0001010101010100ULL;
+	outflank_v = (0x0001000000000000 >> CONTIG_UP[((O & 0x0001010101010100) * 0x0102040810204080) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0001010101010100;
 
-	outflank_h = ((O & 0x7e00000000000000ULL) + 0x0200000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00000000000000ULL;
+	outflank_d7 = (0x0002000000000000 >> CONTIG_UPRIGHT[((O & 0x0002040810204000) * 0x0101010101010101) >> 57]) & P;
+	flipped |= (-outflank_d7 * 2) & 0x0002040810204000;
 
-	outflank_d7 = (0x0002000000000000ULL >> CONTIG_UPRIGHT[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0002040810204000ULL;
+	outflank_h = (O + 0x0200000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00000000000000;
 
 	return flipped;
 }
@@ -1774,14 +1904,14 @@ static unsigned long long flip_B8(const unsigned long long P, const unsigned lon
 {
 	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
 
-	outflank_v = (0x0002000000000000ULL >> CONTIG_UP[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0002020202020200ULL;
+	outflank_v = (0x0002000000000000 >> CONTIG_UP[((O & 0x0002020202020200) * 0x0081020408102040) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0002020202020200;
 
-	outflank_h = ((O & 0x7c00000000000000ULL) + 0x0400000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00000000000000ULL;
+	outflank_d7 = (0x0004000000000000 >> CONTIG_UPRIGHT[((O & 0x0004081020400000) * 0x0101010101010101) >> 58]) & P;
+	flipped |= (-outflank_d7 * 2) & 0x0004081020400000;
 
-	outflank_d7 = (0x0004000000000000ULL >> CONTIG_UPRIGHT[((O & 0x0004081020400000ULL) * 0x0101010101010101ULL) >> 58]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0004081020400000ULL;
+	outflank_h = (O + 0x0400000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00000000000000;
 
 	return flipped;
 }
@@ -1798,15 +1928,15 @@ static unsigned long long flip_C8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0004000000000000ULL >> CONTIG_UP[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0004040404040400ULL;
+	outflank_v = (0x0004000000000000 >> CONTIG_UP[((O & 0x0004040404040400) * 0x0040810204081020) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0004040404040400;
 
 	outflank_h = OUTFLANK_2[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_2_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_2_H[outflank_h] & 0xff00000000000000;
 
-	outflank_d = OUTFLANK_2[((O & 0x000a102040000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x000a112040800000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_2_H[outflank_d] & 0x000a102040000000ULL;	// A6C8H3
+	outflank_d = OUTFLANK_2[((O & 0x040a102040000000) * 0x0101010101010101) >> 57]
+		& (((P & 0x040a112040800000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_2_H[outflank_d] & 0x040a102040000000;	// A6C8H3
 
 	return flipped;
 }
@@ -1823,15 +1953,15 @@ static unsigned long long flip_D8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0008000000000000ULL >> CONTIG_UP[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0008080808080800ULL;
+	outflank_v = (0x0008000000000000 >> CONTIG_UP[((O & 0x0008080808080800) * 0x0020408102040810) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0008080808080800;
 
 	outflank_h = OUTFLANK_3[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000;
 
-	outflank_d = OUTFLANK_3[((O & 0x0014224000000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0014224180000000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0014224000000000ULL;	// A5D8H4
+	outflank_d = OUTFLANK_3[((O & 0x0814224000000000) * 0x0101010101010101) >> 57]
+		& (((P & 0x0814224180000000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0814224000000000;	// A5D8H4
 
 	return flipped;
 }
@@ -1848,15 +1978,15 @@ static unsigned long long flip_E8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0010000000000000ULL >> CONTIG_UP[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0010101010101000ULL;
+	outflank_v = (0x0010000000000000 >> CONTIG_UP[((O & 0x0010101010101000) * 0x0010204081020408) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0010101010101000;
 
 	outflank_h = OUTFLANK_4[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000;
 
-	outflank_d = OUTFLANK_4[((O & 0x0028440200000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0028448201000000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0028440200000000ULL;	// A4E8H5
+	outflank_d = OUTFLANK_4[((O & 0x1028440200000000) * 0x0101010101010101) >> 57]
+		& (((P & 0x1028448201000000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x1028440200000000;	// A4E8H5
 
 	return flipped;
 }
@@ -1873,15 +2003,15 @@ static unsigned long long flip_F8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h, outflank_d;
 	unsigned long long flipped, outflank_v;
 
-	outflank_v = (0x0020000000000000ULL >> CONTIG_UP[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0020202020202000ULL;
+	outflank_v = (0x0020000000000000 >> CONTIG_UP[((O & 0x0020202020202000) * 0x0008102040810204) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0020202020202000;
 
 	outflank_h = OUTFLANK_5[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_5_H[outflank_h] & 0xff00000000000000ULL;
+	flipped |= FLIPPED_5_H[outflank_h] & 0xff00000000000000;
 
-	outflank_d = OUTFLANK_5[((O & 0x0050080402000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0050880402010000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_5_H[outflank_d] & 0x0050080402000000ULL;	// A3F8H6
+	outflank_d = OUTFLANK_5[((O & 0x2050080402000000) * 0x0101010101010101) >> 57]
+		& (((P & 0x2050880402010000) * 0x0101010101010101) >> 56);
+	flipped |= FLIPPED_5_H[outflank_d] & 0x2050080402000000;	// A3F8H6
 
 	return flipped;
 }
@@ -1898,15 +2028,15 @@ static unsigned long long flip_G8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x0040000000000000ULL >> CONTIG_UP[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0040404040404000ULL;
+	outflank_v = (0x0040000000000000 >> CONTIG_UP[((O & 0x0040404040404000) * 0x0004081020408102) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0040404040404000;
+
+	outflank_d9 = (0x0020000000000000 >> CONTIG_UPLEFT[((O & 0x0020100804020000) * 0x0101010101010101) >> 56]) & P;
+	flipped |= (-outflank_d9 * 2) & 0x0020100804020000;
 
 	outflank_h = OUTFLANK_7[(O >> 56) & 0x3e] & (P >> 55);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 56;
 
-	outflank_d9 = (0x0020000000000000ULL >> CONTIG_UPLEFT[((O & 0x0020100804020000ULL) * 0x0101010101010101ULL) >> 56]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0020100804020000ULL;
-
 	return flipped;
 }
 
@@ -1922,15 +2052,15 @@ static unsigned long long flip_H8(const unsigned long long P, const unsigned lon
 	unsigned int outflank_h;
 	unsigned long long flipped, outflank_v, outflank_d9;
 
-	outflank_v = (0x0080000000000000ULL >> CONTIG_UP[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0080808080808000ULL;
+	outflank_v = (0x0080000000000000 >> CONTIG_UP[((O & 0x0080808080808000) * 0x0002040810204081) >> 57]) & P;
+	flipped  = (-outflank_v * 2) & 0x0080808080808000;
+
+	outflank_d9 = (0x0040000000000000 >> CONTIG_UPLEFT[((O & 0x0040201008040200) * 0x0101010101010101) >> 57]) & P;
+	flipped |= (-outflank_d9 * 2) & 0x0040201008040200;
 
 	outflank_h = OUTFLANK_7[(O >> 57) & 0x3f] & (P >> 56);
 	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 57;
 
-	outflank_d9 = (0x0040000000000000ULL >> CONTIG_UPLEFT[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0040201008040200ULL;
-
 	return flipped;
 }
 
@@ -1951,22 +2081,14 @@ static unsigned long long flip_pass(const unsigned long long P, const unsigned l
 
 /** Array of functions to compute flipped discs */
 unsigned long long (*flip[])(const unsigned long long, const unsigned long long) = {
-	flip_A1, flip_B1, flip_C1, flip_D1,
-	flip_E1, flip_F1, flip_G1, flip_H1,
-	flip_A2, flip_B2, flip_C2, flip_D2,
-	flip_E2, flip_F2, flip_G2, flip_H2,
-	flip_A3, flip_B3, flip_C3, flip_D3,
-	flip_E3, flip_F3, flip_G3, flip_H3,
-	flip_A4, flip_B4, flip_C4, flip_D4,
-	flip_E4, flip_F4, flip_G4, flip_H4,
-	flip_A5, flip_B5, flip_C5, flip_D5,
-	flip_E5, flip_F5, flip_G5, flip_H5,
-	flip_A6, flip_B6, flip_C6, flip_D6,
-	flip_E6, flip_F6, flip_G6, flip_H6,
-	flip_A7, flip_B7, flip_C7, flip_D7,
-	flip_E7, flip_F7, flip_G7, flip_H7,
-	flip_A8, flip_B8, flip_C8, flip_D8,
-	flip_E8, flip_F8, flip_G8, flip_H8,
+	flip_A1, flip_B1, flip_C1, flip_D1, flip_E1, flip_F1, flip_G1, flip_H1,
+	flip_A2, flip_B2, flip_C2, flip_D2, flip_E2, flip_F2, flip_G2, flip_H2,
+	flip_A3, flip_B3, flip_C3, flip_D3, flip_E3, flip_F3, flip_G3, flip_H3,
+	flip_A4, flip_B4, flip_C4, flip_D4, flip_E4, flip_F4, flip_G4, flip_H4,
+	flip_A5, flip_B5, flip_C5, flip_D5, flip_E5, flip_F5, flip_G5, flip_H5,
+	flip_A6, flip_B6, flip_C6, flip_D6, flip_E6, flip_F6, flip_G6, flip_H6,
+	flip_A7, flip_B7, flip_C7, flip_D7, flip_E7, flip_F7, flip_G7, flip_H7,
+	flip_A8, flip_B8, flip_C8, flip_D8, flip_E8, flip_F8, flip_G8, flip_H8,
 	flip_pass, flip_pass
 };
 
diff --git a/src/flip_carry_sse_32.c b/src/flip_carry_sse_32.c
new file mode 100644
index 00000000..ff0e0af3
--- /dev/null
+++ b/src/flip_carry_sse_32.c
@@ -0,0 +1,4654 @@
+/**
+ * @file flip_carry_sse_32.c
+ *
+ * This module deals with flipping discs.
+ *
+ * A function is provided for each square of the board. These functions are
+ * gathered into an array of functions, so that a fast access to each function
+ * is allowed. The generic form of the function take as input the player and
+ * the opponent bitboards and return the flipped squares into a bitboard.
+ *
+ * Given the following notation:
+ *  - x = square where we play,
+ *  - P = player's disc pattern,
+ *  - O = opponent's disc pattern,
+ * the basic principle is to read into an array the result of a move. Doing
+ * this is easier for a single line ; so we can use arrays of the form:
+ *  - ARRAY[x][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by a simple
+ * multiplication and to right-shift the result to scale it into a number
+ * between 0 and 255.
+ * Once we get our 8-bits disc patterns,a first array (OUTFLANK) is used to
+ * get the player's discs that surround the opponent discs:
+ *  - outflank = OUTFLANK[x][O] & P
+ * (Only inner 6-bits of the P are in interest here.)
+ * The result is then used as an index to access a second array giving the
+ * flipped discs according to the surrounding player's discs:
+ *  - flipped = FLIPPED[x][outflank].
+ * (Flipped discs fall into inner 6-bits.)
+ * Finally, a precomputed array transform the inner 6-bits disc pattern back into a
+ * 64-bits disc pattern, and the flipped squares for each line are gathered and
+ * returned to generate moves.
+ *
+ * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
+ * can be used to determine contiguous discs.
+ *
+ * @date 1998 - 2018
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#if defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+#include <string.h>	// memcpy
+#endif
+
+#ifdef __TURBOC__
+// bcc32 -c -pr -O1 flip_carry_sse_32.c
+#pragma warn -ngu
+#define	UINT64	unsigned __int64
+#else
+#include "bit.h"
+#define	UINT64	unsigned long long
+#endif
+
+#ifdef USE_GAS_MMX
+#define	STATIC	__attribute__((used))
+#ifdef __unix__
+#define	_
+#else
+#define	_	"_"
+#endif
+#else
+#define	STATIC	static
+#endif
+
+#define	ULL(H,L)	(((UINT64) (H) << 32) | (L))
+
+/** outflank array (indexed with inner 6 bits) */
+/* static const unsigned char OUTFLANK_0[64] = {
+	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
+	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x40,
+	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
+	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x80
+}; */
+
+/* static const unsigned char OUTFLANK_1[64] = {
+	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
+	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00,
+	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
+	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0x00
+}; */
+
+STATIC const unsigned char OUTFLANK_2[64] = {
+	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
+	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x41, 0x00, 0x00,
+	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
+	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00
+};
+
+STATIC const unsigned char OUTFLANK_3[64] = {
+	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00
+};
+
+STATIC const unsigned char OUTFLANK_4[64] = {
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x40, 0x40, 0x40, 0x40, 0x44, 0x44, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x80, 0x80, 0x80, 0x80, 0x84, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+STATIC const unsigned char OUTFLANK_5[64] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x88, 0x88, 0x88, 0x88, 0x84, 0x84, 0x82, 0x81,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* static const unsigned char OUTFLANK_6[64] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+}; */
+
+STATIC const unsigned char OUTFLANK_7[64] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01
+};
+
+
+/** flip array (indexed with outflank, returns inner 6 bits) */
+STATIC const UINT64 FLIPPED_2_H[130] = {
+	0x0000000000000000, 0x0202020202020202, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0808080808080808, 0x0a0a0a0a0a0a0a0a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1818181818181818, 0x1a1a1a1a1a1a1a1a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x3838383838383838, 0x3a3a3a3a3a3a3a3a, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7878787878787878, 0x7a7a7a7a7a7a7a7a
+};
+
+STATIC const UINT64 FLIPPED_3_H[131] = {
+	0x0000000000000000, 0x0606060606060606, 0x0404040404040404, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x1616161616161616, 0x1414141414141414, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x3030303030303030, 0x3636363636363636, 0x3434343434343434, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x7070707070707070, 0x7676767676767676, 0x7474747474747474
+};
+
+STATIC const UINT64 FLIPPED_4_H[133] = {
+	0x0000000000000000, 0x0e0e0e0e0e0e0e0e, 0x0c0c0c0c0c0c0c0c, 0x0000000000000000, 0x0808080808080808, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x2020202020202020, 0x2e2e2e2e2e2e2e2e, 0x2c2c2c2c2c2c2c2c, 0x0000000000000000, 0x2828282828282828, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x6060606060606060, 0x6e6e6e6e6e6e6e6e, 0x6c6c6c6c6c6c6c6c, 0x0000000000000000, 0x6868686868686868
+};
+
+STATIC const UINT64 FLIPPED_5_H[137] = {
+	0x0000000000000000, 0x1e1e1e1e1e1e1e1e, 0x1c1c1c1c1c1c1c1c, 0x0000000000000000, 0x1818181818181818, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x1010101010101010, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x4040404040404040, 0x5e5e5e5e5e5e5e5e, 0x5c5c5c5c5c5c5c5c, 0x0000000000000000, 0x5858585858585858, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x5050505050505050
+};
+
+STATIC const UINT64 FLIPPED_3_V[131] = {
+	0x0000000000000000, 0x0000000000ffff00, 0x0000000000ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x000000ff00ffff00, 0x000000ff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ffff00000000, 0x0000ffff00ffff00, 0x0000ffff00ff0000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffff00000000, 0x00ffffff00ffff00, 0x00ffffff00ff0000
+};
+
+STATIC const UINT64 FLIPPED_4_V[133] = {
+	0x0000000000000000, 0x00000000ffffff00, 0x00000000ffff0000, 0x0000000000000000, 0x00000000ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ff0000000000, 0x0000ff00ffffff00, 0x0000ff00ffff0000, 0x0000000000000000, 0x0000ff00ff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffff0000000000, 0x00ffff00ffffff00, 0x00ffff00ffff0000, 0x0000000000000000, 0x00ffff00ff000000
+};
+
+STATIC const UINT64 FLIPPED_5_V[137] = {
+	0x0000000000000000, 0x000000ffffffff00, 0x000000ffffff0000, 0x0000000000000000, 0x000000ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000ff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff000000000000, 0x00ff00ffffffff00, 0x00ff00ffffff0000, 0x0000000000000000, 0x00ff00ffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff00ff00000000
+};
+
+
+/*
+ * Set all bits below the sole outflank bit if outfrank != 0
+ */
+#if (_MSC_VER >= 1800) && (defined(_M_IX86) || defined (_M_X64))
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned int flipmaskL, flipmaskH, outflankH = outflank >> 32;
+	unsigned char cy;
+	cy = _subborrow_u32(0, outflank, 1, &flipmaskL);
+	cy = _subborrow_u32(cy, outflankH, 0, &flipmaskH);
+	cy = _addcarry_u32(cy, flipmaskL, 0, &flipmaskL);
+	_addcarry_u32(cy, flipmaskH, 0, &flipmaskH);
+	return ULL(flipmaskH, flipmaskL);
+}
+#else
+	#define OutflankToFlipmask(x)	((x) - (unsigned int) ((x) != 0))
+#endif
+
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+
+#define minusone	_mm_set1_epi32(-1)
+static const V2DI	k1e52 = {{ (1023ULL + 52) << 52, (1023ULL + 52) << 52 }};
+static const V2DI	expmask = {{ 0xfff0000000000000, 0xfff0000000000000 }};
+static const V2DI	minustwo   = {{ 0xfffefffefffefffe, 0xfffefffefffefffe }};
+static const V2DI	minusfour  = {{ 0xfffcfffcfffcfffc, 0xfffcfffcfffcfffc }};
+static const V2DI	minuseight = {{ 0xfff8fff8fff8fff8, 0xfff8fff8fff8fff8 }};
+static const V2DI	minus0400  = {{ 0xfc00fc00fc00fc00, 0xfc00fc00fc00fc00 }};
+static const V2DI	minus0800  = {{ 0xf800f800f800f800, 0xf800f800f800f800 }};
+static const V2DI	k02000100  = {{ 0x0100000000000100, 0x0200000000000200 }};
+
+
+STATIC const UINT64 OUTFLANK_7_V[64] = {
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000,
+	0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000, 0x0000ff0000000000,
+	0x000000ff00000000, 0x000000ff00000000, 0x000000ff00000000, 0x000000ff00000000, 0x000000ff00000000, 0x000000ff00000000, 0x000000ff00000000, 0x000000ff00000000,
+	0x00000000ff000000, 0x00000000ff000000, 0x00000000ff000000, 0x00000000ff000000, 0x0000000000ff0000, 0x0000000000ff0000, 0x000000000000ff00, 0x00000000000000ff
+};
+
+
+STATIC const UINT64 FLIPPED_7_V[33] = {
+	0x0000000000000000, 0x00ffffffffffff00, 0x00ffffffffff0000, 0x0000000000000000, 0x00ffffffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffff0000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff000000000000
+};
+
+#if defined(hasSSE2) || defined(USE_MSVC_X86)
+
+#define	SWAP64	0x4e	// for _mm_shuffle_epi32
+#define	SWAP32	0xb1
+#define	DUPLO	0x44
+#define	DUPHI	0xee
+
+
+/*
+ * Extract most significant bit set from 2 x i32
+ */
+static inline __m128i MS1B_epi32(__m128i x) {
+	return _mm_cvtpd_epi32(_mm_and_pd(_mm_cvtepi32_pd(x), expmask.d2));	// clear mantissa = non msb bits
+}
+
+/*
+ * Extract most significant bit set
+ * valid only for x < 0x000fffffffffffffULL
+ *
+ * https://software.intel.com/en-us/forums/intel-isa-extensions/topic/301988
+ */
+static inline __m128i MS1B_epi52(__m128i x) {
+	__m128d f;
+	f = _mm_or_pd(_mm_castsi128_pd(x), k1e52.d2);	// construct double x + 2^52
+	f = _mm_sub_pd(f, k1e52.d2);	// extract 2^52 from double -- mantissa will be automatically normalized
+	f = _mm_and_pd(f, expmask.d2);	// clear mantissa = non msb bits
+	f = _mm_add_pd(f, k1e52.d2);	// add 2^52 to push back the msb
+	// f = _mm_xor_pd(f, k1e52.d2);	// remove exponent	// cleared in caller
+	return _mm_castpd_si128(f);
+}
+/**
+ * Make inverted flip mask if opponent's disc are surrounded by player's.
+ *
+ * 0xffffffffffffffff (-1) if outflank is 0
+ * 0x0000000000000000 ( 0) if a 1 is in 64 bit
+ */
+static inline __m128i flipmask (__m128i outflank) {
+	return _mm_cmpeq_epi32(_mm_shuffle_epi32(outflank, SWAP32), outflank);
+}
+
+/**
+ * Load 2 unsigned long longs into xmm.
+ */
+static inline __m128i load64x2 (const UINT64 *x0, const UINT64 *x1) {
+	return _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(_mm_loadl_epi64((__m128i *) x0)), (__m64 *) x1));
+}
+
+/**
+ * _mm_set1_epi64x equivalent to utilize store to load forwarding
+ *
+ * AMD 47414 pp.96
+ */
+static inline __m128i set1_by_movd (unsigned int L, unsigned int H) {
+	__m128i	Y;
+	Y = _mm_unpacklo_epi32(_mm_cvtsi32_si128(L), _mm_cvtsi32_si128(H));
+	return _mm_unpacklo_epi64(Y, Y);
+}
+
+#define FLIP_CARRY_2_VEC(flip_l)	__m128i	outflank_vd;\
+	outflank_vd = _mm_andnot_si128(set1_by_movd(OL, OH), mask.v2);\
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), set1_by_movd(PL, PH));\
+	outflank_vd = _mm_and_si128(mask.v2, _mm_sub_epi64(outflank_vd, _mm_sub_epi64(flipmask(outflank_vd), minusone)));\
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(outflank_vd, _mm_shuffle_epi32(outflank_vd, SWAP64))) | (flip_l)
+
+#define FLIP_CARRY_AB12(next)	__m128i outflank_vd, outflank_h, flipped_v2, PP, OO;\
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[next]);\
+	OO = set1_by_movd(OL, OH);\
+	PP = set1_by_movd(PL, PH);\
+	outflank_vd = _mm_andnot_si128(OO, mask.v2);\
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);\
+	flipped_v2 = _mm_and_si128(mask.v2, _mm_sub_epi64(outflank_vd, _mm_sub_epi64(flipmask(outflank_vd), minusone)));\
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);\
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_subs_epu8(outflank_h, next_h));\
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)))
+
+#define	FLIP_CARRY_3_VEC(flip_l)	__m128i	outflank_vd, outflank_d_, PP, OO, mask2_;\
+	OO = set1_by_movd(OL, OH);\
+	PP = set1_by_movd(PL, PH);\
+	mask2_ = _mm_loadl_epi64((__m128i *) &mask2);\
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(mask01.v2, _mm_sub_epi64(_mm_or_si128(OO, mask01.v2), minusone)), PP);\
+	outflank_d_ = _mm_and_si128(_mm_andnot_si128(mask2_, _mm_sub_epi64(_mm_or_si128(OO, mask2_), minusone)), PP);\
+	outflank_vd = _mm_andnot_si128(mask01.v2, _mm_sub_epi64(outflank_vd, _mm_sub_epi64(flipmask(outflank_vd), minusone)));\
+	outflank_d_ = _mm_andnot_si128(mask2_, _mm_sub_epi64(outflank_d_, _mm_sub_epi64(flipmask(outflank_d_), minusone)));\
+	outflank_vd = _mm_or_si128(outflank_vd, _mm_or_si128(_mm_shuffle_epi32(outflank_vd, SWAP64), outflank_d_));\
+	flipped = _mm_cvtsi128_si64(outflank_vd) | (flip_l)
+
+#define FLIP_CARRY_GH12	__m128i outflank_vd, outflank_h, flipped_v2, PP, OO;\
+	OO = set1_by_movd(OL, OH);\
+	PP = set1_by_movd(PL, PH);\
+	outflank_vd = _mm_andnot_si128(OO, mask1.v2);\
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);\
+	flipped_v2 = _mm_and_si128(mask1.v2, _mm_sub_epi64(outflank_vd, _mm_sub_epi64(flipmask(outflank_vd), minusone)));\
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask2.v2)), PP);\
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(_mm_mullo_epi16(outflank_h, minustwo.v2), mask2.v2));\
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)))
+
+#define FLIP_MS1B_2_VEC	__m128i PP = set1_by_movd(PL, PH);\
+	__m128i OO = set1_by_movd(OL, OH);\
+	__m128i outflank_vd = _mm_and_si128(MS1B_epi52(_mm_andnot_si128(OO, mask1.v2)), PP);\
+	__m128i flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);\
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)))
+
+#define FLIP_MS1B_AB78(next)	__m128i PP = set1_by_movd(PL, PH);\
+	__m128i OO = set1_by_movd(OL, OH);\
+	__m128i outflank_vd = _mm_and_si128(MS1B_epi52(_mm_andnot_si128(OO, mask1.v2)), PP);\
+	__m128i flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);\
+	__m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[next]);\
+	__m128i outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);\
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_subs_epu8(outflank_h, next_h));\
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)))
+
+#else
+
+#define FLIP_CARRY_2_VEC(flip_l)	__asm__ (\
+		"movd	%1, %%xmm0\n\t"		"movd	%3, %%xmm1\n\t"\
+		"movd	%2, %%xmm2\n\t"		"movd	%4, %%xmm3\n\t"\
+		"punpckldq %%xmm2, %%xmm0\n\t"	"punpckldq %%xmm3, %%xmm1\n\t"\
+		"movdqa	%5, %%xmm2\n\t"		"pxor	%%xmm3, %%xmm3\n\t"\
+		"punpcklqdq %%xmm0, %%xmm0\n\t"	"punpcklqdq %%xmm1, %%xmm1\n\t"\
+		"pandn	%%xmm2, %%xmm1\n\t"\
+		"psubq	%%xmm1, %%xmm3\n\t"\
+		"pand	%%xmm0, %%xmm1\n\t"\
+		"pand	%%xmm1, %%xmm3\n\t"	"pcmpeqd %%xmm0, %%xmm0\n\t"\
+		"pshufd	$177, %%xmm3, %%xmm1\n\t"\
+		"pcmpeqd %%xmm3, %%xmm1\n\t"\
+		"psubq	%%xmm0, %%xmm1\n\t"\
+		"psubq	%%xmm1, %%xmm3\n\t"\
+		"pand	%%xmm2, %%xmm3\n\t"\
+		"pshufd	$78, %%xmm3, %%xmm1\n\t"\
+		"por	%%xmm1, %%xmm3\n\t"\
+		"movd	%%xmm3, %%edx\n\t"	"psrlq	$32, %%xmm3\n\t"\
+		"orl	%%edx, %%eax\n\t"	"movd	%%xmm3, %%edx"\
+	: "=A" (flipped)\
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask), "a" (flip_l))
+
+#define FLIP_CARRY_AB12(next)	__asm__(\
+		"movd	%1, %%xmm0\n\t"		"movd	%3, %%xmm1\n\t"\
+		"movd	%2, %%xmm2\n\t"		"movd	%4, %%xmm3\n\t"\
+		"punpckldq %%xmm2, %%xmm0\n\t"	"punpckldq %%xmm3, %%xmm1\n\t"\
+		"movdqa	%5, %%xmm2\n\t"		"pxor	%%xmm3, %%xmm3\n\t"\
+		"punpcklqdq %%xmm0, %%xmm0\n\t"	"punpcklqdq %%xmm1, %%xmm1\n\t"\
+						"movdqa	%%xmm1, %%xmm5\n\t"\
+		"pandn	%%xmm2, %%xmm1\n\t"	"movq	%6, %%xmm4\n\t"\
+		"psubq	%%xmm1, %%xmm3\n\t"	"paddb	%%xmm4, %%xmm5\n\t"\
+		"pand	%%xmm0, %%xmm1\n\t"	"pand	%%xmm0, %%xmm5\n\t"\
+		"pand	%%xmm1, %%xmm3\n\t"	"psubusb %%xmm4, %%xmm5\n\t"\
+		"pshufd	$177, %%xmm3, %%xmm1\n\t"\
+		"pcmpeqd %%xmm3, %%xmm1\n\t"	"pcmpeqd %%xmm0, %%xmm0\n\t"\
+		"psubq	%%xmm0, %%xmm1\n\t"\
+		"psubq	%%xmm1, %%xmm3\n\t"\
+		"pand	%%xmm2, %%xmm3\n\t"	"por	%%xmm5, %%xmm3\n\t"\
+		"pshufd	$78, %%xmm3, %%xmm1\n\t"\
+		"por	%%xmm1, %%xmm3\n\t"\
+		"movd	%%xmm3, %%eax\n\t"	"psrlq	$32, %%xmm3\n\t"\
+						"movd	%%xmm3, %%edx"\
+	: "=A" (flipped)\
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask), "m" (X_TO_BIT[next]))
+
+#define	FLIP_CARRY_3_VEC(flip_l)	__asm__ (\
+		"movd	%1, %%xmm0\n\t"		"movd	%3, %%xmm1\n\t"		"pcmpeqd %%xmm6, %%xmm6\n\t"\
+		"movd	%2, %%xmm2\n\t"		"movd	%4, %%xmm3\n\t"\
+		"punpckldq %%xmm2, %%xmm0\n\t"	"punpckldq %%xmm3, %%xmm1\n\t"\
+		"movdqa	%5, %%xmm2\n\t"		"movq	%6, %%xmm5\n\t"\
+		"punpcklqdq %%xmm0, %%xmm0\n\t"	"punpcklqdq %%xmm1, %%xmm1\n\t"\
+		"movdqa	%%xmm0, %%xmm3\n\t"	"movdqa	%%xmm1, %%xmm4\n\t"\
+		"por	%%xmm2, %%xmm1\n\t"	"por	%%xmm5, %%xmm4\n\t"\
+		"psubq	%%xmm6, %%xmm1\n\t"	"psubq	%%xmm6, %%xmm4\n\t"\
+		"pand	%%xmm1, %%xmm0\n\t"	"pand	%%xmm4, %%xmm3\n\t"\
+		"movdqa	%%xmm2, %%xmm1\n\t"	"movdqa	%%xmm5, %%xmm4\n\t"\
+		"pandn	%%xmm0, %%xmm1\n\t"	"pandn	%%xmm3, %%xmm4\n\t"\
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"	"pshuflw $78, %%xmm4, %%xmm3\n\t"\
+		"pcmpeqd %%xmm1, %%xmm0\n\t"	"pcmpeqd %%xmm4, %%xmm3\n\t"\
+		"paddq	%%xmm6, %%xmm1\n\t"	"paddq	%%xmm6, %%xmm4\n\t"\
+		"psubq	%%xmm0, %%xmm1\n\t"	"psubq	%%xmm3, %%xmm4\n\t"\
+		"pandn	%%xmm1, %%xmm2\n\t"	"pandn	%%xmm4, %%xmm5\n\t"\
+		"pshufd	$78, %%xmm2, %%xmm0\n\t"\
+		"por	%%xmm2, %%xmm0\n\t"	"por	%%xmm5, %%xmm0\n\t"\
+		"movd	%%xmm0, %%edx\n\t"	"psrlq	$32, %%xmm0\n\t"\
+		"orl	%%edx, %%eax\n\t"	"movd	%%xmm0, %%edx"\
+	: "=A" (flipped)\
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask01), "m" (mask2), "a" (flip_l))
+
+#define FLIP_CARRY_GH12	__asm__(\
+		"movd	%4, %%xmm3\n\t"		"movd	%2, %%xmm2\n\t"\
+		"movd	%3, %%xmm1\n\t"		"movd	%1, %%xmm0\n\t"		"pcmpeqd %%xmm4, %%xmm4\n\t"\
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm2, %%xmm0\n\t"\
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm0, %%xmm0\n\t"\
+		"movdqa	%%xmm1, %%xmm3\n\t"	"pandn	%5, %%xmm3\n\t"		"pxor	%%xmm2, %%xmm2\n\t"\
+		"pandn	%6, %%xmm1\n\t"		"psubq	%%xmm3, %%xmm2\n\t"\
+		"cvtdq2pd %%xmm1, %%xmm1\n\t"	"pand	%%xmm0, %%xmm3\n\t"\
+		"andpd	%7, %%xmm1\n\t"		"pand	%%xmm3, %%xmm2\n\t"\
+		"cvtpd2dq %%xmm1, %%xmm1\n\t"	"pshufd	$177, %%xmm2, %%xmm3\n\t"\
+		"pand	%%xmm1, %%xmm0\n\t"	"pcmpeqd %%xmm2, %%xmm3\n\t"\
+						"psubq	%%xmm4, %%xmm3\n\t"\
+		"pmullw	%8, %%xmm0\n\t"		"psubq	%%xmm3, %%xmm2\n\t"\
+		"pand	%6, %%xmm0\n\t"		"pand	%5, %%xmm2\n\t"\
+		"por	%%xmm2, %%xmm0\n\t"\
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"\
+		"por	%%xmm1, %%xmm0\n\t"\
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"\
+		"movd	%%xmm0, %%eax\n\t"\
+		"movd	%%xmm1, %%edx"\
+	: "=A" (flipped)\
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minustwo))
+
+#define FLIP_MS1B_2_VEC	__asm__(\
+		"movd	%2, %%xmm3\n\t"		"movd	%4, %%xmm2\n\t"\
+		"movd	%1, %%xmm1\n\t"		"movd	%3, %%xmm0\n\t"\
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm2, %%xmm0\n\t"\
+		"movapd	%6, %%xmm2\n\t"\
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm0, %%xmm0\n\t"\
+		"pandn	%5, %%xmm0\n\t"\
+		"orpd	%%xmm2, %%xmm0\n\t"\
+		"subpd	%%xmm2, %%xmm0\n\t"\
+		"andpd	%7, %%xmm0\n\t"\
+		"addpd	%%xmm2, %%xmm0\n\t"\
+		"pand	%%xmm0, %%xmm1\n\t"\
+		"pxor	%%xmm0, %%xmm0\n\t"\
+		"paddq	%%xmm1, %%xmm1\n\t"\
+		"psubq	%%xmm1, %%xmm0\n\t"\
+		"pand	%5, %%xmm0\n\t"\
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"\
+		"por	%%xmm1, %%xmm0\n\t"\
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"\
+		"movd	%%xmm0, %%eax\n\t"\
+		"movd	%%xmm1, %%edx\n\t"\
+	: "=A" (flipped)\
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (k1e52), "m" (expmask))
+
+#define FLIP_MS1B_AB78(next)	__asm__(\
+		"movd	%2, %%xmm3\n\t"		"movd	%4, %%xmm2\n\t"\
+		"movd	%1, %%xmm1\n\t"		"movd	%3, %%xmm0\n\t"\
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm2, %%xmm0\n\t"\
+		"movapd	%6, %%xmm2\n\t"\
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm0, %%xmm0\n\t"\
+						"movdqa	%%xmm0, %%xmm3\n\t"\
+		"pandn	%5, %%xmm0\n\t"		"movq	%8, %%xmm4\n\t"\
+		"orpd	%%xmm2, %%xmm0\n\t"	"paddb	%%xmm4, %%xmm3\n\t"\
+		"subpd	%%xmm2, %%xmm0\n\t"	"pand	%%xmm1, %%xmm3\n\t"\
+		"andpd	%7, %%xmm0\n\t"		"psubusb %%xmm4, %%xmm3\n\t"\
+		"addpd	%%xmm2, %%xmm0\n\t"\
+		"pand	%%xmm0, %%xmm1\n\t"\
+		"pxor	%%xmm0, %%xmm0\n\t"\
+		"paddq	%%xmm1, %%xmm1\n\t"\
+		"psubq	%%xmm1, %%xmm0\n\t"\
+		"pand	%5, %%xmm0\n\t"		"por	%%xmm3, %%xmm0\n\t"\
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"\
+		"por	%%xmm1, %%xmm0\n\t"\
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"\
+		"movd	%%xmm0, %%eax\n\t"\
+		"movd	%%xmm1, %%edx\n\t"\
+	: "=A" (flipped)\
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (k1e52), "m" (expmask), "m" (X_TO_BIT[next]))
+
+#endif // hasSSE2
+
+#endif // has| USE_GAS_MMX | _P_IX86
+
+/**
+ * Compute flipped discs when playing on square A1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned char outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0101010101010100) + 1) & ULL(PH, PL) & 0x0101010101010000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010100;
+
+	outflank_h = (OL + 0x02) & PL;
+	flipped |= ((outflank_h * 0xff) >> 8) & 0x7e;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x8040201008040200) + 1) & ULL(PH, PL) & 0x8040201008040000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040200;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0101010101010100, 0x8040201008040200 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_AB12(1);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned char outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0202020202020200) + 1) & ULL(PH, PL) & 0x0202020202020000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020200;
+
+	outflank_h = (OL + 0x04) & PL;
+	flipped |= ((outflank_h * 0xff) >> 8) & 0x7c;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x0080402010080400) + 1) & ULL(PH, PL) & 0x0080402010080000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0080402010080400;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0202020202020200, 0x0080402010080400 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_AB12(2);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0404040404040400) + 1) & ULL(PH, PL) & 0x0404040404040400;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040400;
+
+	outflank_h = OUTFLANK_2[(OL >> 1) & 0x3f] & PL;
+	flipped |= (unsigned char) FLIPPED_2_H[outflank_h];
+
+	flipped |= ((PL >> 7) & 0x00000200u & OL);
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x0000804020100800) + 1) & ULL(PH, PL) & 0x0000804020100800;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0000804020100800;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0404040404040400, 0x0000804020100800 }};
+	unsigned int outflank_h = OUTFLANK_2[(OL >> 1) & 0x3f] & PL;
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC((unsigned char) FLIPPED_2_H[outflank_h] | ((PL >> 7) & 0x00000200u & OL));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_d;
+	UINT64 flipped, outflank_v;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0808080808080800) + 1) & ULL(PH, PL) & 0x0808080808080800;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080800;
+
+	outflank_h = OUTFLANK_3[(OL >> 1) & 0x3f] & PL;
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
+
+	outflank_d = OUTFLANK_3[((OL & 0x40221400u) * 0x01010101u) >> 25]
+		& ((((PH & 0x00000080u) + (PL & 0x41221400u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x40221400u;	// A4D1H5
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0808080808080800, 0x0000008040201000 }};
+	unsigned int outflank_h = OUTFLANK_3[(OL >> 1) & 0x3f] & PL;
+	unsigned int outflank_d7 = ((OL | ~0x01020400u) + 1) & PL & 0x01020400u;
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC((unsigned char) FLIPPED_3_H[outflank_h]
+		| ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x01020400u));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_d;
+	UINT64 flipped, outflank_v;
+
+	outflank_v = ((ULL(OH, OL) | ~0x1010101010101000) + 1) & ULL(PH, PL) & 0x1010101010101000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010101000;
+
+	outflank_h = OUTFLANK_4[(OL >> 1) & 0x3f] & PL;
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
+
+	outflank_d = OUTFLANK_4[((OL & 0x02442800u) * 0x01010101u) >> 25]
+		& ((((PH & 0x00000001u) + (PL & 0x82442800u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x82442800u;	// A5E1H4
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x1010101010101000, 0x0000000102040800 }};
+	unsigned int outflank_h = OUTFLANK_4[(OL >> 1) & 0x3f] & PL;
+	unsigned int outflank_d9 = ((OL | ~0x80402000u) + 1) & PL & 0x80402000u;
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC((unsigned char) FLIPPED_4_H[outflank_h]
+		| ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x80402000u));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x2020202020202000) + 1) & ULL(PH, PL) & 0x2020202020202000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020202000;
+
+	outflank_h = OUTFLANK_5[(OL >> 1) & 0x3f] & PL;
+	flipped |= (unsigned char) FLIPPED_5_H[outflank_h];
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0000010204081000) + 1) & ULL(PH, PL) & 0x0000010204080000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0000000204081000;
+
+	flipped |= ((PL >> 9) & 0x00004000u & OL);
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x2020202020202000, 0x0000010204081000 }};
+	unsigned int outflank_h = OUTFLANK_5[(OL >> 1) & 0x3f] & PL;
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC((unsigned char) FLIPPED_5_H[outflank_h] | ((PL >> 9) & 0x00004000u & OL));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x4040404040404000) + 1) & ULL(PH, PL) & 0x4040404040400000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040404000;
+
+	outflank_h = OUTFLANK_7[OL & 0x3e] & (PL << 1);
+	flipped |= ((-outflank_h) & 0x3e) << 0;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0001020408102000) + 1) & ULL(PH, PL) & 0x0001020408100000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0001020408102000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x4040404040404000, 0x0001020408102000 }};
+	static const V2DI mask2 = {{ 0x000000000000003f, 0 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_GH12;
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x8080808080808000) + 1) & ULL(PH, PL) & 0x8080808080800000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080808000;
+
+	outflank_h = OUTFLANK_7[(OL >> 1) & 0x3f] & PL;
+	flipped |= ((-outflank_h) & 0x3f) << 1;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0102040810204000) + 1) & ULL(PH, PL) & 0x0102040810200000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810204000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H1(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x8080808080808000, 0x0102040810204000 }};
+	static const V2DI mask2 = {{ 0x000000000000007f, 0 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_GH12;
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned short outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0101010101010000) + 1) & ULL(PH, PL) & 0x0101010101000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101010000;
+
+	outflank_h = (OL + 0x0200) & PL;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007e00;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x4020100804020000) + 1) & ULL(PH, PL) & 0x4020100804000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x4020100804020000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0101010101010000, 0x4020100804020000 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_AB12(9);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned short outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0202020202020000) + 1) & ULL(PH, PL) & 0x0202020202000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202020000;
+
+	outflank_h = (OL + 0x0400) & PL;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007c00;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x8040201008040000) + 1) & ULL(PH, PL) & 0x8040201008000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008040000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0202020202020000, 0x8040201008040000 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_AB12(10);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0404040404040000) + 1) & ULL(PH, PL) & 0x0404040404000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404040000;
+
+	outflank_h = OUTFLANK_2[(OL >> 9) & 0x3f] & (PL >> 8);
+	flipped |= (unsigned int) FLIPPED_2_H[outflank_h] & 0x0000ff00u;
+
+	flipped |= ((PL >> 7) & 0x00020000u & OL);
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x0080402010080000) + 1) & ULL(PH, PL) & 0x0080402010080000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0000402010080000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0404040404040000, 0x0080402010080000 }};
+	unsigned int outflank_h = OUTFLANK_2[(OL >> 9) & 0x3f] & (PL >> 8);
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC(((unsigned char) FLIPPED_2_H[outflank_h] << 8) | ((PL >> 7) & 0x00020000u & OL));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_d;
+	UINT64 flipped, outflank_v;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0808080808080000) + 1) & ULL(PH, PL) & 0x0808080808000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080000;
+
+	outflank_h = OUTFLANK_3[(OL >> 9) & 0x3f] & (PL >> 8);
+	flipped |= (unsigned int) FLIPPED_3_H[outflank_h] & 0x0000ff00u;
+
+	outflank_d = OUTFLANK_3[(((OH & 0x00000040u) + (OL & 0x22140000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00008041u) + (PL & 0x22140000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000004022140000;	// A5D2H6
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask01 = {{ ~0x0808080808080000, ~0x0000804020100000 }};
+	static const UINT64 mask2 = ~0x0000000102040000;
+	unsigned int outflank_h = OUTFLANK_3[(OL >> 9) & 0x3f] & (PL >> 8);
+	UINT64 flipped;
+
+	FLIP_CARRY_3_VEC((unsigned char) FLIPPED_3_H[outflank_h] << 8);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_d;
+	UINT64 flipped, outflank_v;
+
+	outflank_v = ((ULL(OH, OL) | ~0x1010101010100000) + 1) & ULL(PH, PL) & 0x1010101010000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010100000;
+
+	outflank_h = OUTFLANK_4[(OL >> 9) & 0x3f] & (PL >> 8);
+	flipped |= (unsigned int) FLIPPED_4_H[outflank_h] & 0x0000ff00u;
+
+	outflank_d = OUTFLANK_4[(((OH & 0x00000002u) + (OL & 0x44280000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00000182u) + (PL & 0x44280000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000244280000;	// A6E2H5
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask01 = {{ ~0x1010101010100000, ~0x0000010204080000 }};
+	static const UINT64 mask2 = ~0x0000008040200000;
+	unsigned int outflank_h = OUTFLANK_4[(OL >> 9) & 0x3f] & (PL >> 8);
+	UINT64 flipped;
+
+	FLIP_CARRY_3_VEC((unsigned char) FLIPPED_4_H[outflank_h] << 8);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x2020202020200000) + 1) & ULL(PH, PL) & 0x2020202020000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020200000;
+
+	outflank_h = OUTFLANK_5[(OL >> 9) & 0x3f] & (PL >> 8);
+	flipped |= (unsigned int) FLIPPED_5_H[outflank_h] & 0x0000ff00u;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0001020408100000) + 1) & ULL(PH, PL) & 0x0001020408000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0000020408100000;
+
+	flipped |= ((PL >> 9) & 0x00400000u & OL);
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x2020202020200000, 0x0001020408100000 }};
+	unsigned int outflank_h = OUTFLANK_5[(OL >> 9) & 0x3f] & (PL >> 8);
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC(((unsigned char) FLIPPED_5_H[outflank_h] << 8) | ((PL >> 9) & 0x00400000u & OL));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x4040404040400000) + 1) & ULL(PH, PL) & 0x4040404040000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040400000;
+
+	outflank_h = OUTFLANK_7[(OL >> 8) & 0x3e] & (PL >> 7);
+	flipped |= ((-outflank_h) & 0x3e) << 8;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0102040810200000) + 1) & ULL(PH, PL) & 0x0102040810000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810200000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x4040404040400000, 0x0102040810200000 }};
+	static const V2DI mask2 = {{ 0x0000000000003f00, 0 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_GH12;
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x8080808080800000) + 1) & ULL(PH, PL) & 0x8080808080000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080800000;
+
+	outflank_h = OUTFLANK_7[(OL >> 9) & 0x3f] & (PL >> 8);
+	flipped |= ((-outflank_h) & 0x3f) << 9;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0204081020400000) + 1) & ULL(PH, PL) & 0x0204081020000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0204081020400000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H2(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x8080808080800000, 0x0204081020400000 }};
+	static const V2DI mask2 = {{ 0x0000000000007f00, 0 }};
+	UINT64 flipped;
+
+	FLIP_CARRY_GH12;
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0101010101000000) + 1) & ULL(PH, PL) & 0x0101010101000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0101010101000000;
+
+	outflank_h = ((OL & 0x007e0000u) + 0x00020000u) & PL;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007e0000u;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x2010080402000000) + 1) & ULL(PH, PL) & 0x2010080400000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0010080402000000;
+
+	flipped |= OL & (((PL << 8) & 0x00000100u) | ((PL << 7) & 0x00000200u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0101010101000000, 0x2010080402000000 }};
+	unsigned int outflank_h = ((OL & 0x007e0000u) + 0x00020000u) & PL;
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC(((outflank_h - (outflank_h >> 8)) & 0x007e0000u)
+		| (OL & (((PL << 8) & 0x00000100u) | ((PL << 7) & 0x00000200u))));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0202020202000000) + 1) & ULL(PH, PL) & 0x0202020202000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0202020202000000;
+
+	outflank_h = ((OL & 0x007c0000u) + 0x00040000u) & PL;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007c0000u;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x4020100804000000) + 1) & ULL(PH, PL) & 0x4020100800000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x0020100804000000;
+
+	flipped |= OL & (((PL << 8) & 0x00000200u) | ((PL << 7) & 0x00000400u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0202020202000000, 0x4020100804000000 }};
+	unsigned int outflank_h = ((OL & 0x007c0000u) + 0x00040000u) & PL;
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC(((outflank_h - (outflank_h >> 8)) & 0x007c0000u)
+		| (OL & (((PL << 8) & 0x00000200u) | ((PL << 7) & 0x00000400u))));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d9;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0404040404000000) + 1) & ULL(PH, PL) & 0x0404040404000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0404040404000000;
+
+	outflank_h = OUTFLANK_2[(OL >> 17) & 0x3f] & (PL >> 16);
+	flipped |= (unsigned int) FLIPPED_2_H[outflank_h] & 0x00ff0000u;
+
+	outflank_d9 = ((ULL(OH, OL) | ~0x8040201008000000) + 1) & ULL(PH, PL) & 0x8040201008000000;
+	flipped |= OutflankToFlipmask(outflank_d9) & 0x8040201008000000;
+
+	flipped |= OL & (((PL << 8) & 0x00000400u)
+			| ((PL << 9) & 0x00000200u)
+			| (((PH << 25) | (PL << 7)) & 0x02000800u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x0404040404000000, 0x8040201008000000 }};
+	unsigned int outflank_h = OUTFLANK_2[(OL >> 17) & 0x3f] & (PL >> 16);
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC(((unsigned char) FLIPPED_2_H[outflank_h] << 16)
+		| (OL & (((PL << 8) & 0x00000400u)
+			| ((PL << 9) & 0x00000200u)
+			| (((PH << 25) | (PL << 7)) & 0x02000800u))));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_d;
+	UINT64 flipped, outflank_v;
+
+	outflank_v = ((ULL(OH, OL) | ~0x0808080808000000) + 1) & ULL(PH, PL) & 0x0808080808000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808000000;
+
+	outflank_h = OUTFLANK_3[(OL >> 17) & 0x3f] & (PL >> 16);
+	flipped |= (unsigned int) FLIPPED_3_H[outflank_h] & 0x00ff0000u;
+
+	outflank_d = OUTFLANK_3[(((OH & 0x00004022u) + (OL & 0x14080000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00804122u) + (PL & 0x14080000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000402214080000;	// A6D3H7
+
+	flipped |= OL & (((PL << 8) & 0x00000800u)
+			| ((PL << 7) & 0x00001000u)
+			| ((PL << 9) & 0x00000400u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask01 = {{ ~0x0808080808000000, ~0x0080402010000000 }};
+	static const UINT64 mask2 = ~0x0000010204000000;
+	unsigned int outflank_h = OUTFLANK_3[(OL >> 17) & 0x3f] & (PL >> 16);
+	UINT64 flipped;
+
+	FLIP_CARRY_3_VEC(((unsigned char) FLIPPED_3_H[outflank_h] << 16)
+		| (OL & (((PL << 8) & 0x00000800u)
+			| ((PL << 7) & 0x00001000u)
+			| ((PL << 9) & 0x00000400u))));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_d;
+	UINT64 flipped, outflank_v;
+
+	outflank_v = ((ULL(OH, OL) | ~0x1010101010000000) + 1) & ULL(PH, PL) & 0x1010101010000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010000000;
+
+	outflank_h = OUTFLANK_4[(OL >> 17) & 0x3f] & (PL >> 16);
+	flipped |= (unsigned int) FLIPPED_4_H[outflank_h] & 0x00ff0000u;
+
+	outflank_d = OUTFLANK_4[(((OH & 0x00000244u) + (OL & 0x28100000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00018244u) + (PL & 0x28100000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000024428100000;	// A7E7H6
+
+	flipped |= OL & (((PL << 8) & 0x00001000u)
+			| ((PL << 7) & 0x00002000u)
+			| ((PL << 9) & 0x00000800u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask01 = {{ ~0x1010101010000000, ~0x0001020408000000 }};
+	static const UINT64 mask2 = ~0x0000804020000000;
+	unsigned int outflank_h = OUTFLANK_4[(OL >> 17) & 0x3f] & (PL >> 16);
+	UINT64 flipped;
+
+	FLIP_CARRY_3_VEC(((unsigned char) FLIPPED_4_H[outflank_h] << 16)
+		| (OL & (((PL << 8) & 0x00001000u)
+			| ((PL << 7) & 0x00002000u)
+			| ((PL << 9) & 0x00000800u))));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x2020202020000000) + 1) & ULL(PH, PL) & 0x2020202020000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x2020202020000000;
+
+	outflank_h = OUTFLANK_5[(OL >> 17) & 0x3f] & (PL >> 16);
+	flipped |= (unsigned int) FLIPPED_5_H[outflank_h] & 0x00ff0000u;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0102040810000000) + 1) & ULL(PH, PL) & 0x0102040810000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0102040810000000;
+
+	flipped |= OL & (((PL << 8) & 0x00002000u)
+			| ((PL << 7) & 0x00004000u)
+			| (((PH << 23) | (PL << 9)) & 0x40001000u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask = {{ 0x2020202020000000, 0x0102040810000000 }};
+	unsigned int outflank_h = OUTFLANK_5[(OL >> 17) & 0x3f] & (PL >> 16);
+	UINT64 flipped;
+
+	FLIP_CARRY_2_VEC(((unsigned char) FLIPPED_5_H[outflank_h] << 16)
+		| (OL & (((PL << 8) & 0x00002000u)
+			| ((PL << 7) & 0x00004000u)
+			| (((PH << 23) | (PL << 9)) & 0x40001000u))));
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x4040404040000000) + 1) & ULL(PH, PL) & 0x4040404040000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x4040404040000000;
+
+	outflank_h = OUTFLANK_7[(OL >> 16) & 0x3e] & (PL >> 15);
+	flipped |= ((-outflank_h) & 0x3e) << 16;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0204081020000000) + 1) & ULL(PH, PL) & 0x0204081000000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0004081020000000;
+
+	flipped |= OL & (((PL << 8) & 0x00004000u) | ((PL << 9) & 0x00002000u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x4040404040000000, 0x0204081020000000 }};
+	static const V2DI mask2 = {{ 0x0000000000000040, 0x0000000000000010 }};
+	static const V2DI mask3 = {{ 0x00000000003f0000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined(USE_MSVC_X86)
+	__m128i OO = set1_by_movd(OL, OH);
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i	outflank_vd, outflank_h, flipped_v2, flipped_h2g2;
+
+	outflank_vd = _mm_andnot_si128(OO, mask1.v2);
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);
+	flipped_v2 = _mm_and_si128(mask1.v2, _mm_sub_epi64(outflank_vd, _mm_sub_epi64(flipmask(outflank_vd), minusone)));
+
+	flipped_h2g2 = _mm_mullo_epi16(_mm_and_si128(PP, mask2.v2), k02000100.v2);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_h2g2, OO));
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask3.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minus0800.v2), 10));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+#else
+	__asm__(\
+		"movd	%4, %%xmm4\n\t"		"movd	%1, %%xmm1\n\t"
+		"movd	%3, %%xmm5\n\t"		"movd	%2, %%xmm0\n\t"
+		"punpckldq %%xmm4, %%xmm5\n\t"	"punpckldq %%xmm0, %%xmm1\n\t"
+		"punpcklqdq %%xmm5, %%xmm5\n\t"	"punpcklqdq %%xmm1, %%xmm1\n\t"
+						"pxor	%%xmm3, %%xmm3\n\t"
+						"movdqa	%%xmm5, %%xmm4\n\t"
+						"pandn	%5, %%xmm4\n\t"
+		"movdqa	%%xmm5, %%xmm2\n\t"	"movdqa	%%xmm1, %%xmm0\n\t"
+		"pandn	%7, %%xmm2\n\t"		"psubq	%%xmm4, %%xmm3\n\t"
+		"cvtdq2pd %%xmm2, %%xmm2\n\t"	"pand	%%xmm4, %%xmm0\n\t"
+		"andpd	%8, %%xmm2\n\t"		"pand	%%xmm0, %%xmm3\n\t"	"movdqa	%6, %%xmm0\n\t"
+		"cvtpd2dq %%xmm2, %%xmm2\n\t"	"pshufd	$177, %%xmm3, %%xmm4\n\t"
+						"pcmpeqd %%xmm3, %%xmm4\n\t"	"pand	%%xmm1, %%xmm0\n\t"
+		"pand	%%xmm2, %%xmm1\n\t"	"pcmpeqd %%xmm2, %%xmm2\n\t"	"pmullw	%10, %%xmm0\n\t"
+		"pmullw	%9, %%xmm1\n\t"		"psubq	%%xmm2, %%xmm4\n\t"	"pand	%%xmm5, %%xmm0\n\t"
+		"psrlw	$10, %%xmm1\n\t"	"psubq	%%xmm4, %%xmm3\n\t"
+		"por	%%xmm1, %%xmm0\n\t"	"pand	%5, %%xmm3\n\t"
+		"por	%%xmm3, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm3\n\t"
+		"por	%%xmm3, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (mask3), "m" (expmask), "m" (minus0800), "m" (k02000100));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h;
+	UINT64 flipped, outflank_v, outflank_d7;
+
+	outflank_v = ((ULL(OH, OL) | ~0x8080808080000000) + 1) & ULL(PH, PL) & 0x8080808080000000;
+	flipped = OutflankToFlipmask(outflank_v) & 0x8080808080000000;
+
+	outflank_h = OUTFLANK_7[(OL >> 17) & 0x3f] & (PL >> 16);
+	flipped |= ((-outflank_h) & 0x3f) << 17;
+
+	outflank_d7 = ((ULL(OH, OL) | ~0x0408102040000000) + 1) & ULL(PH, PL) & 0x0408102000000000;
+	flipped |= OutflankToFlipmask(outflank_d7) & 0x0008102040000000;
+
+	flipped |= OL & (((PL << 8) & 0x00008000u) | ((PL << 9) & 0x00004000u));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H3(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x8080808080000000, 0x0408102040000000 }};
+	static const V2DI mask2 = {{ 0x0000000000000080, 0x0000000000000020 }};
+	static const V2DI mask3 = {{ 0x00000000007f0000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined(USE_MSVC_X86)
+	__m128i OO = set1_by_movd(OL, OH);
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i	outflank_vd, outflank_h, flipped_v2, flipped_h2g2;
+
+	outflank_vd = _mm_andnot_si128(OO, mask1.v2);
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);
+	flipped_v2 = _mm_and_si128(mask1.v2, _mm_sub_epi64(outflank_vd, _mm_sub_epi64(flipmask(outflank_vd), minusone)));
+
+	flipped_h2g2 = _mm_mullo_epi16(_mm_and_si128(PP, mask2.v2), k02000100.v2);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_h2g2, OO));
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask3.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minus0400.v2), 9));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+#else
+	__asm__(\
+		"movd	%4, %%xmm4\n\t"		"movd	%1, %%xmm1\n\t"
+		"movd	%3, %%xmm5\n\t"		"movd	%2, %%xmm0\n\t"
+		"punpckldq %%xmm4, %%xmm5\n\t"	"punpckldq %%xmm0, %%xmm1\n\t"
+		"punpcklqdq %%xmm5, %%xmm5\n\t"	"punpcklqdq %%xmm1, %%xmm1\n\t"
+						"pxor	%%xmm3, %%xmm3\n\t"
+						"movdqa	%%xmm5, %%xmm4\n\t"
+						"pandn	%5, %%xmm4\n\t"
+		"movdqa	%%xmm5, %%xmm2\n\t"	"movdqa	%%xmm1, %%xmm0\n\t"
+		"pandn	%7, %%xmm2\n\t"		"psubq	%%xmm4, %%xmm3\n\t"
+		"cvtdq2pd %%xmm2, %%xmm2\n\t"	"pand	%%xmm4, %%xmm0\n\t"
+		"andpd	%8, %%xmm2\n\t"		"pand	%%xmm0, %%xmm3\n\t"	"movdqa	%6, %%xmm0\n\t"
+		"cvtpd2dq %%xmm2, %%xmm2\n\t"	"pshufd	$177, %%xmm3, %%xmm4\n\t"
+						"pcmpeqd %%xmm3, %%xmm4\n\t"	"pand	%%xmm1, %%xmm0\n\t"
+		"pand	%%xmm2, %%xmm1\n\t"	"pcmpeqd %%xmm2, %%xmm2\n\t"	"pmullw	%10, %%xmm0\n\t"
+		"pmullw	%9, %%xmm1\n\t"		"psubq	%%xmm2, %%xmm4\n\t"	"pand	%%xmm5, %%xmm0\n\t"
+		"psrlw	$9, %%xmm1\n\t"		"psubq	%%xmm4, %%xmm3\n\t"
+		"por	%%xmm1, %%xmm0\n\t"	"pand	%5, %%xmm3\n\t"
+		"por	%%xmm3, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm3\n\t"
+		"por	%%xmm3, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (mask3), "m" (expmask), "m" (minus0400), "m" (k02000100));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, flip_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[(((OL & 0x01010100u) + ((OH & 0x00010101u) << 4)) * 0x01020408u) >> 25]
+		& ((((PL & 0x01010101u) + ((PH & 0x01010101u) << 4)) * 0x01020408u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0001010101010100;
+
+	outflank_h = (OL + 0x02000000u) & PL;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e000000u;
+
+	flip_d7 = OL & 0x00020000u;
+	flip_d7 |= (flip_d7 >> 7) & OL;
+	flipped |= flip_d7 & -(flip_d7 & (PL << 7));
+
+	outflank_d9 = ((OH | ~0x10080402u) + 1) & PH & 0x10080400u;
+	flipped |= (UINT64) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00080402u) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0101010101010101, 0x1008040201020408 }};
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 7));
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_3[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_V[outflank_v], &FLIPPED_3_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$7, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_3_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = (OL + 0x02000000u) & PL;
+	return flipped | ((outflank_h - (outflank_h >> 8)) & 0x7e000000u);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, flip_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[(((OL & 0x02020200u) + ((OH & 0x00020202u) << 4)) * 0x00810204u) >> 25]
+		& ((((PL & 0x02020202u) + ((PH & 0x02020202u) << 4)) * 0x00810204u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0002020202020200;
+
+	outflank_h = (OL + 0x04000000u) & PL;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c000000u;
+
+	flip_d7 = OL & 0x00040000u;
+	flip_d7 |= (flip_d7 >> 7) & OL;
+	flipped |= flip_d7 & -(flip_d7 & (PL << 7));
+
+	outflank_d9 = ((OH | ~0x20100804u) + 1) & PH & 0x20100800u;
+	flipped |= (UINT64) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00100804u) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0202020202020202, 0x2010080402040810 }};
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 6));
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_3[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_V[outflank_v], &FLIPPED_3_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$6, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_3_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = (OL + 0x04000000u) & PL;
+	return flipped | ((outflank_h - (outflank_h >> 8)) & 0x7c000000u);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[(((OL & 0x04040400u) + ((OH & 0x00040404u) << 4)) * 0x00408102u) >> 25]
+		& ((((PL & 0x04040404u) + ((PH & 0x04040404u) << 4)) * 0x00408102u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0004040404040400;
+
+	outflank_h = OUTFLANK_2[(OL >> 25) & 0x3f] & (PL >> 24);
+	flipped |= (unsigned int) FLIPPED_2_H[outflank_h] & 0xff000000u;
+
+	outflank_d7 = OUTFLANK_2[(((OL & 0x04081000u) + (OH & 0x00000002u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x04081020u) + (PH & 0x00000102u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0000000204081000;
+
+	outflank_d9 = OUTFLANK_2[(((OL & 0x04020000u) + (OH & 0x00201008u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x04020100u) + (PH & 0x40201008u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d9] & 0x0020100804020000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0404040404040404, 0x4020100804081020 }};
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 5));
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_3[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_V[outflank_v], &FLIPPED_3_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$5, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_3_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_2[(OL >> 25) & 0x3f] & (PL >> 24);
+	return flipped | ((UINT64) (OH & (PH >> 7) & 0x00000002u) << 32)
+		| ((OL & (PL << 9) & 0x00020000u)
+		| ((unsigned char) FLIPPED_2_H[outflank_h] << 24));
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[(((OL & 0x08080800u) + ((OH & 0x00080808u) << 4)) * 0x00204081u) >> 25]
+		& ((((PL & 0x08080808u) + ((PH & 0x08080808u) << 4)) * 0x00204081u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800;
+
+	outflank_h = OUTFLANK_3[(OL >> 25) & 0x3f] & (PL >> 24);
+	flipped |= (unsigned int) FLIPPED_3_H[outflank_h] & 0xff000000u;
+
+	outflank_d7 = OUTFLANK_3[(((OL & 0x08102000u) + (OH & 0x00000204u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x08102040u) + (PH & 0x00010204u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000;
+
+	outflank_d9 = OUTFLANK_3[(((OL & 0x08040200u) + (OH & 0x00402010u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x08040201u) + (PH & 0x80402010u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x00000000ff000000, 0x0808080808080808 }};
+	static const V2DI mask2 = {{ 0x0001020408102040, 0x8040201008040201 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i flipped_v2, flipped_d, mask_d7, mask_d9;
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9, index_v, index_d7, index_d9;
+	__m128i	Z2 = _mm_setzero_si128();
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_h = OUTFLANK_3[(OL >> 25) & 0x3f] & (PL >> 24);
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_H[outflank_h], &FLIPPED_3_V[outflank_v]), mask1.v2);
+
+	mask_d7 = _mm_shuffle_epi32(mask2.v2, DUPLO);
+	index_d7 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d7), mask_d7));
+	outflank_d7 = OUTFLANK_3[(index_d7 >> 9) & 0x1f] & index_d7;
+
+	mask_d9 = _mm_shuffle_epi32(mask2.v2, DUPHI);
+	index_d9 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d9), mask_d9));
+	outflank_d9 = OUTFLANK_3[(index_d9 >> 9) & 0x3f] & index_d9;
+
+	flipped_d = load64x2(&FLIPPED_3_V[outflank_d7], &FLIPPED_3_V[outflank_d9]);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_d, mask2.v2));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm6\n\t"				"movd	%4, %%xmm5\n\t"
+		"punpckldq %%xmm6, %%xmm1\n\t"			"punpckldq %%xmm5, %%xmm0\n\t"
+		"movl	%3, %%eax\n\t"				"punpcklqdq %%xmm0, %%xmm1\n\t"
+		"shrl	$25, %%eax\n\t"				"movdqa	%%xmm1, %%xmm0\n\t"
+		"movdqa	%6, %%xmm4\n\t"				"psllq	$4, %%xmm0\n\t"
+		"andl	$63, %%eax\n\t"				"pmovmskb %%xmm0, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%eax), %%ecx\n\t"	"movl	%%edx, %%ebx\n\t"
+		"movl	%1, %%eax\n\t"				"shrl	$9, %%ebx\n\t"
+		"shrl	$24, %%eax\n\t"				"andl	$63, %%ebx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+								"andl	%%ebx, %%edx\n\t"
+		"movq	"_"FLIPPED_3_H(,%%eax,8), %%xmm3\n\t"	"movhps	"_"FLIPPED_3_V(,%%edx,8), %%xmm3\n\t"
+		"movdqa	%%xmm1, %%xmm2\n\t"			"movdqa	%%xmm1, %%xmm6\n\t"
+		"pshufd	$68, %%xmm4, %%xmm0\n\t"		"pshufd	$238, %%xmm4, %%xmm5\n\t"
+		"pand	%%xmm0, %%xmm2\n\t"			"pand	%%xmm5, %%xmm6\n\t"
+		"pcmpeqb %%xmm2, %%xmm0\n\t"			"pcmpeqb %%xmm5, %%xmm6\n\t"
+		"pmovmskb %%xmm0, %%eax\n\t"			"pmovmskb %%xmm6, %%ebx\n\t"
+		"movl	%%eax, %%ecx\n\t"			"movl	%%ebx, %%edx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%edx\n\t"
+		"andl	$31, %%ecx\n\t"				"andl	$63, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%edx), %%edx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"andl	%%edx, %%ebx\n\t"
+		"movq	"_"FLIPPED_3_V(,%%eax,8), %%xmm2\n\t"	"movhps	"_"FLIPPED_3_V(,%%ebx,8), %%xmm2\n\t"
+		"movdqa	%5, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm1\n\t"			"pand	%%xmm2, %%xmm4\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$78, %%xmm4, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$177, %%xmm4, %%xmm1\n\t"
+		"movd	%%xmm4, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[((((OL & 0x10101000u) >> 4) + (OH & 0x00101010u)) * 0x01020408u) >> 25]
+		& (((((PL & 0x10101010u) >> 4) + (PH & 0x10101010u)) * 0x01020408u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000;
+
+	outflank_h = OUTFLANK_4[(OL >> 25) & 0x3f] & (PL >> 24);
+	flipped |= (unsigned int) FLIPPED_4_H[outflank_h] & 0xff000000u;
+
+	outflank_d7 = OUTFLANK_4[(((OL & 0x10204000u) + (OH & 0x00020408u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x10204080u) + (PH & 0x01020408u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000;
+
+	outflank_d9 = OUTFLANK_4[(((OL & 0x10080400u) + (OH & 0x00004020u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x10080402u) + (PH & 0x00804020u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x00000000ff000000, 0x1010101010101010 }};
+	static const V2DI mask2 = {{ 0x0102040810204080, 0x0080402010080402 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i flipped_v2, flipped_d, mask_d7, mask_d9;
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9, index_v, index_d7, index_d9;
+	__m128i	Z2 = _mm_setzero_si128();
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_h = OUTFLANK_4[(OL >> 25) & 0x3f] & (PL >> 24);
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_H[outflank_h], &FLIPPED_3_V[outflank_v]), mask1.v2);
+
+	mask_d7 = _mm_shuffle_epi32(mask2.v2, DUPLO);
+	index_d7 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d7), mask_d7));
+	outflank_d7 = OUTFLANK_3[(index_d7 >> 9) & 0x3f] & index_d7;
+
+	mask_d9 = _mm_shuffle_epi32(mask2.v2, DUPHI);
+	index_d9 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d9), mask_d9));
+	outflank_d9 = OUTFLANK_3[(index_d9 >> 9) & 0x1f] & index_d9;
+
+	flipped_d = load64x2(&FLIPPED_3_V[outflank_d7], &FLIPPED_3_V[outflank_d9]);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_d, mask2.v2));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm6\n\t"				"movd	%4, %%xmm5\n\t"
+		"punpckldq %%xmm6, %%xmm1\n\t"			"punpckldq %%xmm5, %%xmm0\n\t"
+		"movl	%3, %%eax\n\t"				"punpcklqdq %%xmm0, %%xmm1\n\t"
+		"shrl	$25, %%eax\n\t"				"movdqa	%%xmm1, %%xmm0\n\t"
+		"movdqa	%6, %%xmm4\n\t"				"psllq	$3, %%xmm0\n\t"
+		"andl	$63, %%eax\n\t"				"pmovmskb %%xmm0, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%eax), %%ecx\n\t"	"movl	%%edx, %%ebx\n\t"
+		"movl	%1, %%eax\n\t"				"shrl	$9, %%ebx\n\t"
+		"shrl	$24, %%eax\n\t"				"andl	$63, %%ebx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+								"andl	%%ebx, %%edx\n\t"
+		"movq	"_"FLIPPED_4_H(,%%eax,8), %%xmm3\n\t"	"movhps	"_"FLIPPED_3_V(,%%edx,8), %%xmm3\n\t"
+		"movdqa	%%xmm1, %%xmm2\n\t"			"movdqa	%%xmm1, %%xmm6\n\t"
+		"pshufd	$68, %%xmm4, %%xmm0\n\t"		"pshufd	$238, %%xmm4, %%xmm5\n\t"
+		"pand	%%xmm0, %%xmm2\n\t"			"pand	%%xmm5, %%xmm6\n\t"
+		"pcmpeqb %%xmm2, %%xmm0\n\t"			"pcmpeqb %%xmm5, %%xmm6\n\t"
+		"pmovmskb %%xmm0, %%eax\n\t"			"pmovmskb %%xmm6, %%ebx\n\t"
+		"movl	%%eax, %%ecx\n\t"			"movl	%%ebx, %%edx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%edx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$31, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%edx), %%edx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"andl	%%edx, %%ebx\n\t"
+		"movq	"_"FLIPPED_3_V(,%%eax,8), %%xmm2\n\t"	"movhps	"_"FLIPPED_3_V(,%%ebx,8), %%xmm2\n\t"
+		"movdqa	%5, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm1\n\t"			"pand	%%xmm2, %%xmm4\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$78, %%xmm4, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$177, %%xmm4, %%xmm1\n\t"
+		"movd	%%xmm4, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[((((OL & 0x20202000u) >> 4) + (OH & 0x00202020u)) * 0x00810204u) >> 25]
+		& (((((PL & 0x20202020u) >> 4) + (PH & 0x20202020u)) * 0x00810204u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0020202020202000;
+
+	outflank_h = OUTFLANK_5[(OL >> 25) & 0x3f] & (PL >> 24);
+	flipped |= (unsigned int) FLIPPED_5_H[outflank_h] & 0xff000000u;
+
+	outflank_d7 = OUTFLANK_5[(((OL & 0x20400000u) + (OH & 0x00040810u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x20408000u) + (PH & 0x02040810u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d7] & 0x0004081020400000;
+
+	outflank_d9 = OUTFLANK_5[(((OL & 0x20100800u) + (OH & 0x00000040u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x20100804u) + (PH & 0x00008040u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0000004020100800;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x2020202020202020, 0x0204081020100804 }};
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 2));
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_3[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_V[outflank_v], &FLIPPED_3_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$2, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_3_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_5[(OL >> 25) & 0x3f] & (PL >> 24);
+	return flipped | ((UINT64) (OH & (PH >> 9) & 0x00000040u) << 32)
+		| ((OL & (PL << 7) & 0x00400000u)
+		| ((unsigned char) FLIPPED_5_H[outflank_h] << 24));
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, flip_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[((((OL & 0x40404000u) >> 4) + (OH & 0x00404040u)) * 0x00408102u) >> 25]
+		& (((((PL & 0x40404040u) >> 4) + (PH & 0x40404040u)) * 0x00408102u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0040404040404000;
+
+	outflank_h = OUTFLANK_7[(OL >> 24) & 0x3e] & (PL >> 23);
+	flipped |= ((-outflank_h) & 0x3e) << 24;
+
+	outflank_d7 = ((OH | ~0x04081020u) + 1) & PH & 0x04081000u;
+	flipped |= (UINT64) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00081020u) << 32;
+
+	flip_d9 = OL & 0x00200000u;
+	flip_d9 |= (flip_d9 >> 9) & OL;
+	flipped |= flip_d9 & -(flip_d9 & (PL << 9));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x4040404040404040, 0x0408102040201008 }};
+	static const V2DI mask2 = {{ 0x000000003f000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	outflank_h, flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 1));
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_3[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_V[outflank_v], &FLIPPED_3_V[outflank_d]), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask2.v2)), OP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minuseight.v2), 2));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%3, %%xmm1\n\t"		"movd	%1, %%xmm0\n\t"
+		"movd	%4, %%xmm3\n\t"		"movd	%2, %%xmm4\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm4, %%xmm0\n\t"
+		"punpcklqdq %%xmm1, %%xmm0\n\t"	"pshufd	$238, %5, %%xmm1\n\t"
+		"movdqa	%%xmm0, %%xmm3\n\t"	"movdqa	%%xmm0, %%xmm2\n\t"	"pshufd	$238, %%xmm0, %%xmm4\n\t"
+		"psllq	$1, %%xmm3\n\t"		"pand	%%xmm1, %%xmm2\n\t"	"pandn	%6, %%xmm4\n\t"
+						"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm3, %%edx\n\t"	"pmovmskb %%xmm1, %%eax\n\t"	"cvtdq2pd %%xmm4, %%xmm4\n\t"
+		"movl	%%edx, %%ecx\n\t"	"movl	%%eax, %%ebx\n\t"	"andpd	%7, %%xmm4\n\t"
+		"shrl	$9, %%ecx\n\t"		"shrl	$9, %%ebx\n\t"		"cvtpd2dq %%xmm4, %%xmm4\n\t"
+		"andl	$63, %%ecx\n\t"		"andl	$63, %%ebx\n\t"		"pand	%%xmm4, %%xmm0\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"
+						"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"andl	%%edx, %%ecx\n\t"	"andl	%%ebx, %%eax\n\t"	"pmullw	%8, %%xmm0\n\t"
+		"movq	"_"FLIPPED_3_V(,%%ecx,8), %%xmm2\n\t"
+						"movhps	"_"FLIPPED_3_V(,%%eax,8), %%xmm2\n\t"
+		"pand	%5, %%xmm2\n\t"						"psrlw	$2, %%xmm0\n\t"
+		"por	%%xmm2, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minuseight)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, flip_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_3[((((OL & 0x80808000u) >> 4) + (OH & 0x00808080u)) * 0x00204081u) >> 25]
+		& (((((PL & 0x80808080u) >> 4) + (PH & 0x80808080u)) * 0x00204081u) >> 24);
+	flipped = FLIPPED_3_V[outflank_v] & 0x0080808080808000;
+
+	outflank_h = OUTFLANK_7[(OL >> 25) & 0x3f] & (PL >> 24);
+	flipped |= ((-outflank_h) & 0x3f) << 25;
+
+	outflank_d7 = ((OH | ~0x08102040u) + 1) & PH & 0x08102000u;
+	flipped |= (UINT64) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00102040u) << 32;
+
+	flip_d9 = OL & 0x00400000u;
+	flip_d9 |= (flip_d9 >> 9) & OL;
+	flipped |= flip_d9 & -(flip_d9 & (PL << 9));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H4(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x8080808080808080, 0x0810204080402010 }};
+	static const V2DI mask2 = {{ 0x000000007f000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	outflank_h, flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(OP);
+	outflank_v = OUTFLANK_3[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_3[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_V[outflank_v], &FLIPPED_3_V[outflank_d]), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask2.v2)), OP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minusfour.v2), 1));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%3, %%xmm1\n\t"		"movd	%1, %%xmm0\n\t"
+		"movd	%4, %%xmm3\n\t"		"movd	%2, %%xmm4\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm4, %%xmm0\n\t"
+		"punpcklqdq %%xmm1, %%xmm0\n\t"	"pshufd	$238, %5, %%xmm1\n\t"
+		"movdqa	%%xmm0, %%xmm3\n\t"	"movdqa	%%xmm0, %%xmm2\n\t"	"pshufd	$238, %%xmm0, %%xmm4\n\t"
+						"pand	%%xmm1, %%xmm2\n\t"	"pandn	%6, %%xmm4\n\t"
+						"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm3, %%edx\n\t"	"pmovmskb %%xmm1, %%eax\n\t"	"cvtdq2pd %%xmm4, %%xmm4\n\t"
+		"movl	%%edx, %%ecx\n\t"	"movl	%%eax, %%ebx\n\t"	"andpd	%7, %%xmm4\n\t"
+		"shrl	$9, %%ecx\n\t"		"shrl	$9, %%ebx\n\t"		"cvtpd2dq %%xmm4, %%xmm4\n\t"
+		"andl	$63, %%ecx\n\t"		"andl	$63, %%ebx\n\t"		"pand	%%xmm4, %%xmm0\n\t"
+		"movzbl	"_"OUTFLANK_3(%%ecx), %%ecx\n\t"
+						"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"andl	%%edx, %%ecx\n\t"	"andl	%%ebx, %%eax\n\t"	"pmullw	%8, %%xmm0\n\t"
+		"movq	"_"FLIPPED_3_V(,%%ecx,8), %%xmm2\n\t"
+						"movhps	"_"FLIPPED_3_V(,%%eax,8), %%xmm2\n\t"
+		"pand	%5, %%xmm2\n\t"						"psrlw	$1, %%xmm0\n\t"
+		"por	%%xmm2, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minusfour)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, flip_d7, outflank_d9;
+	unsigned char outflank_h;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[(((OL & 0x01010100u) + ((OH & 0x00010101u) << 4)) * 0x01020408u) >> 25]
+		& ((((PL & 0x01010101u) + ((PH & 0x01010101u) << 4)) * 0x01020408u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0001010101010100;
+
+	outflank_h = (OH + 0x02) & PH;
+	flipped |= (UINT64) (((outflank_h * 0xff) >> 8) & 0x0000007eu) << 32;
+
+	flip_d7 = OL & ((OL >> 7) | 0x02000000u);
+	flip_d7 &= ((flip_d7 & 0x02040000u) >> 14) | 0x02040000u;
+	flipped |= flip_d7 & -(flip_d7 & (PL << 7));
+
+	outflank_d9 = ((OH | ~0x08040200u) + 1) & PH & 0x08040000u;
+	flipped |= (UINT64) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00040200u) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0101010101010101, 0x0804020102040810 }};
+	UINT64 flipped;
+	unsigned char outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 7));
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_4[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_V[outflank_v], &FLIPPED_4_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$7, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_4_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = (OH + 0x02) & PH;
+	return  flipped | ((UINT64) (((outflank_h * 0xff) >> 8) & 0x0000007eu) << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, flip_d7, outflank_d9;
+	unsigned char outflank_h;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[(((OL & 0x02020200u) + ((OH & 0x00020202u) << 4)) * 0x00810204u) >> 25]
+		& ((((PL & 0x02020202u) + ((PH & 0x02020202u) << 4)) * 0x00810204u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0002020202020200;
+
+	outflank_h = (OH + 0x04) & PH;
+	flipped |= (UINT64) (((outflank_h * 0xff) >> 8) & 0x0000007cu) << 32;
+
+	flip_d7 = OL & ((OL >> 7) | 0x04000000u);
+	flip_d7 &= ((flip_d7 & 0x04080000u) >> 14) | 0x04080000u;
+	flipped |= flip_d7 & -(flip_d7 & (PL << 7));
+
+	outflank_d9 = ((OH | ~0x10080400u) + 1) & PH & 0x10080000u;
+	flipped |= (UINT64) ((outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00080400u) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0202020202020202, 0x1008040204081020 }};
+	UINT64 flipped;
+	unsigned char outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 6));
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_4[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_V[outflank_v], &FLIPPED_4_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$6, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_4_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = (OH + 0x04) & PH;
+	return  flipped | ((UINT64) (((outflank_h * 0xff) >> 8) & 0x0000007cu) << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[(((OL & 0x04040400u) + ((OH & 0x00040404u) << 4)) * 0x00408102u) >> 25]
+		& ((((PL & 0x04040404u) + ((PH & 0x04040404u) << 4)) * 0x00408102u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0004040404040400;
+
+	outflank_h = OUTFLANK_2[(OH >> 1) & 0x3f] & (PH >> 0);
+	flipped |= FLIPPED_2_H[outflank_h] & 0x000000ff00000000;
+
+	outflank_d7 = OUTFLANK_2[(((OL & 0x08102000u) + (OH & 0x00000204u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x08102040u) + (PH & 0x00010204u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0000020408102000;
+
+	outflank_d9 = OUTFLANK_2[(((OL & 0x02000000u) + (OH & 0x00100804u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x02010000u) + (PH & 0x20100804u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d9] & 0x0010080402000000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0404040404040404, 0x2010080408102040 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 5));
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_4[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_V[outflank_v], &FLIPPED_4_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$5, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_4_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_2[(OH >> 1) & 0x3f] & (PH >> 0);
+	FH = (unsigned char) FLIPPED_2_H[outflank_h] | (OH & (PH >> 7) & 0x00000200u);
+	return flipped | ((UINT64) FH << 32) | (OL & (PL << 9) & 0x02000000u);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[(((OL & 0x08080800u) + ((OH & 0x00080808u) << 4)) * 0x00204081u) >> 25]
+		& ((((PL & 0x08080808u) + ((PH & 0x08080808u) << 4)) * 0x00204081u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800;
+
+	outflank_h = OUTFLANK_3[(OH >> 1) & 0x3f] & (PH >> 0);
+	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000;
+
+	outflank_d7 = OUTFLANK_3[(((OL & 0x10204000u) + (OH & 0x00020408u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x10204080u) + (PH & 0x01020408u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000;
+
+	outflank_d9 = OUTFLANK_3[(((OL & 0x04020000u) + (OH & 0x00201008u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x04020100u) + (PH & 0x40201008u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x000000ff00000000, 0x0808080808080808 }};
+	static const V2DI mask2 = {{ 0x4020100804020100, 0x0102040810204080 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i flipped_v2, flipped_d, mask_d7, mask_d9;
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9, index_v, index_d7, index_d9;
+	__m128i	Z2 = _mm_setzero_si128();
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_h = OUTFLANK_3[(OH >> 1) & 0x3f] & PH;
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_3_H[outflank_h], &FLIPPED_4_V[outflank_v]), mask1.v2);
+
+	mask_d7 = _mm_shuffle_epi32(mask2.v2, DUPLO);
+	index_d7 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d7), mask_d7));
+	outflank_d7 = OUTFLANK_4[(index_d7 >> 9) & 0x3e] & index_d7;
+
+	mask_d9 = _mm_shuffle_epi32(mask2.v2, DUPHI);
+	index_d9 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d9), mask_d9));
+	outflank_d9 = OUTFLANK_4[(index_d9 >> 9) & 0x3f] & index_d9;
+
+	flipped_d = load64x2(&FLIPPED_4_V[outflank_d7], &FLIPPED_4_V[outflank_d9]);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_d, mask2.v2));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm6\n\t"				"movd	%4, %%xmm5\n\t"
+		"punpckldq %%xmm6, %%xmm1\n\t"			"punpckldq %%xmm5, %%xmm0\n\t"
+		"movl	%4, %%eax\n\t"				"punpcklqdq %%xmm0, %%xmm1\n\t"
+		"shrl	$1, %%eax\n\t"				"movdqa	%%xmm1, %%xmm0\n\t"
+		"movdqa	%6, %%xmm4\n\t"				"psllq	$4, %%xmm0\n\t"
+		"andl	$63, %%eax\n\t"				"pmovmskb %%xmm0, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_3(%%eax), %%ecx\n\t"	"movl	%%edx, %%ebx\n\t"
+		"movl	%2, %%eax\n\t"				"shrl	$9, %%ebx\n\t"
+								"andl	$63, %%ebx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+								"andl	%%ebx, %%edx\n\t"
+		"movq	"_"FLIPPED_3_H(,%%eax,8), %%xmm3\n\t"	"movhps	"_"FLIPPED_4_V(,%%edx,8), %%xmm3\n\t"
+		"movdqa	%%xmm1, %%xmm2\n\t"			"movdqa	%%xmm1, %%xmm6\n\t"
+		"pshufd	$68, %%xmm4, %%xmm0\n\t"		"pshufd	$238, %%xmm4, %%xmm5\n\t"
+		"pand	%%xmm0, %%xmm2\n\t"			"pand	%%xmm5, %%xmm6\n\t"
+		"pcmpeqb %%xmm2, %%xmm0\n\t"			"pcmpeqb %%xmm5, %%xmm6\n\t"
+		"pmovmskb %%xmm0, %%eax\n\t"			"pmovmskb %%xmm6, %%ebx\n\t"
+		"movl	%%eax, %%ecx\n\t"			"movl	%%ebx, %%edx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%edx\n\t"
+		"andl	$62, %%ecx\n\t"				"andl	$63, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%edx), %%edx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"andl	%%edx, %%ebx\n\t"
+		"movq	"_"FLIPPED_4_V(,%%eax,8), %%xmm2\n\t"	"movhps	"_"FLIPPED_4_V(,%%ebx,8), %%xmm2\n\t"
+		"movdqa	%5, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm1\n\t"			"pand	%%xmm2, %%xmm4\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$78, %%xmm4, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$177, %%xmm4, %%xmm1\n\t"
+		"movd	%%xmm4, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[((((OL & 0x10101000u) >> 4) + (OH & 0x00101010u)) * 0x01020408u) >> 25]
+		& (((((PL & 0x10101010u) >> 4) + (PH & 0x10101010u)) * 0x01020408u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000;
+
+	outflank_h = OUTFLANK_4[(OH >> 1) & 0x3f] & (PH >> 0);
+	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000;
+
+	outflank_d7 = OUTFLANK_4[(((OL & 0x20400000u) + (OH & 0x00040810u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x20408000u) + (PH & 0x02040810u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000;
+
+	outflank_d9 = OUTFLANK_4[(((OL & 0x08040200u) + (OH & 0x00402010u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x08040201u) + (PH & 0x80402010u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x000000ff00000000, 0x1010101010101010 }};
+	static const V2DI mask2 = {{ 0x8040201008040201, 0x0204081020408000 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i flipped_v2, flipped_d, mask_d7, mask_d9;
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9, index_v, index_d7, index_d9;
+	__m128i	Z2 = _mm_setzero_si128();
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_h = OUTFLANK_4[(OH >> 1) & 0x3f] & PH;
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_H[outflank_h], &FLIPPED_4_V[outflank_v]), mask1.v2);
+
+	mask_d7 = _mm_shuffle_epi32(mask2.v2, DUPLO);
+	index_d7 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d7), mask_d7));
+	outflank_d7 = OUTFLANK_4[(index_d7 >> 9) & 0x3f] & index_d7;
+
+	mask_d9 = _mm_shuffle_epi32(mask2.v2, DUPHI);
+	index_d9 = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d9), mask_d9));
+	outflank_d9 = OUTFLANK_4[(index_d9 >> 9) & 0x3e] & index_d9;
+
+	flipped_d = load64x2(&FLIPPED_4_V[outflank_d7], &FLIPPED_4_V[outflank_d9]);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_d, mask2.v2));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm6\n\t"				"movd	%4, %%xmm5\n\t"
+		"punpckldq %%xmm6, %%xmm1\n\t"			"punpckldq %%xmm5, %%xmm0\n\t"
+		"movl	%4, %%eax\n\t"				"punpcklqdq %%xmm0, %%xmm1\n\t"
+		"shrl	$1, %%eax\n\t"				"movdqa	%%xmm1, %%xmm0\n\t"
+		"movdqa	%6, %%xmm4\n\t"				"psllq	$3, %%xmm0\n\t"
+		"andl	$63, %%eax\n\t"				"pmovmskb %%xmm0, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%eax), %%ecx\n\t"	"movl	%%edx, %%ebx\n\t"
+		"movl	%2, %%eax\n\t"				"shrl	$9, %%ebx\n\t"
+								"andl	$63, %%ebx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+								"andl	%%ebx, %%edx\n\t"
+		"movq	"_"FLIPPED_4_H(,%%eax,8), %%xmm3\n\t"	"movhps	"_"FLIPPED_4_V(,%%edx,8), %%xmm3\n\t"
+		"movdqa	%%xmm1, %%xmm2\n\t"			"movdqa	%%xmm1, %%xmm6\n\t"
+		"pshufd	$68, %%xmm4, %%xmm0\n\t"		"pshufd	$238, %%xmm4, %%xmm5\n\t"
+		"pand	%%xmm0, %%xmm2\n\t"			"pand	%%xmm5, %%xmm6\n\t"
+		"pcmpeqb %%xmm2, %%xmm0\n\t"			"pcmpeqb %%xmm5, %%xmm6\n\t"
+		"pmovmskb %%xmm0, %%eax\n\t"			"pmovmskb %%xmm6, %%ebx\n\t"
+		"movl	%%eax, %%ecx\n\t"			"movl	%%ebx, %%edx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%edx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$62, %%edx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%edx), %%edx\n\t"
+		"andl	%%ecx, %%eax\n\t"			"andl	%%edx, %%ebx\n\t"
+		"movq	"_"FLIPPED_4_V(,%%eax,8), %%xmm2\n\t"	"movhps	"_"FLIPPED_4_V(,%%ebx,8), %%xmm2\n\t"
+		"movdqa	%5, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm1\n\t"			"pand	%%xmm2, %%xmm4\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$78, %%xmm4, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm4\n\t"
+		"pshufd	$177, %%xmm4, %%xmm1\n\t"
+		"movd	%%xmm4, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[((((OL & 0x20202000u) >> 4) + (OH & 0x00202020u)) * 0x00810204u) >> 25]
+		& (((((PL & 0x20202020u) >> 4) + (PH & 0x20202020u)) * 0x00810204u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0020202020202000;
+
+	outflank_h = OUTFLANK_5[(OH >> 1) & 0x3f] & (PH >> 0);
+	flipped |= FLIPPED_5_H[outflank_h] & 0x000000ff00000000;
+
+	outflank_d7 = OUTFLANK_5[(((OL & 0x40000000u) + (OH & 0x00081020u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x40800000u) + (PH & 0x04081020u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d7] & 0x0008102040000000;
+
+	outflank_d9 = OUTFLANK_5[(((OL & 0x10080400u) + (OH & 0x00004020u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x10080402u) + (PH & 0x00804020u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0000402010080400;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x2020202020202020, 0x0408102010080402 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 2));
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_4[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_V[outflank_v], &FLIPPED_4_V[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$2, %%xmm0\n\t"				"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"pmovmskb %%xmm1, %%eax\n\t"
+		"movl	%%edx, %%ecx\n\t"			"movl	%%eax, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$9, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_4_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_V(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_5[(OH >> 1) & 0x3f] & (PH >> 0);
+	FH = (unsigned char) FLIPPED_5_H[outflank_h] | (OH & (PH >> 9) & 0x00004000u);
+	return flipped | ((UINT64) FH << 32) | (OL & (PL << 7) & 0x40000000u);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, flip_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[((((OL & 0x40404000u) >> 4) + (OH & 0x00404040u)) * 0x00408102u) >> 25]
+		& (((((PL & 0x40404040u) >> 4) + (PH & 0x40404040u)) * 0x00408102u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0040404040404000;
+
+	outflank_h = OUTFLANK_7[(OH >> 0) & 0x3e] & (PH << 1);
+	flipped |= (UINT64) ((-outflank_h) & 0x3e) << 32;
+
+	outflank_d7 = ((OH | ~0x08102000u) + 1) & PH & 0x08100000u;
+	flipped |= (UINT64) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00102000u) << 32;
+
+	flip_d9 = OL & ((OL >> 9) | 0x20000000u);
+	flip_d9 &= ((flip_d9 & 0x20100000u) >> 18) | 0x20100000u;
+	flipped |= flip_d9 & -(flip_d9 & (PL << 9));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x4040404040404040, 0x0810204020100804 }};
+	static const V2DI mask2 = {{ 0x0000003f00000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	outflank_h, flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 1));
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_4[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_V[outflank_v], &FLIPPED_4_V[outflank_d]), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask2.v2)), OP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minus0800.v2), 10));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%3, %%xmm1\n\t"		"movd	%1, %%xmm0\n\t"
+		"movd	%4, %%xmm3\n\t"		"movd	%2, %%xmm4\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm4, %%xmm0\n\t"
+		"punpcklqdq %%xmm1, %%xmm0\n\t"	"pshufd	$238, %5, %%xmm1\n\t"
+		"movdqa	%%xmm0, %%xmm3\n\t"	"movdqa	%%xmm0, %%xmm2\n\t"	"pshufd	$238, %%xmm0, %%xmm4\n\t"
+		"psllq	$1, %%xmm3\n\t"		"pand	%%xmm1, %%xmm2\n\t"	"pandn	%6, %%xmm4\n\t"
+						"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm3, %%edx\n\t"	"pmovmskb %%xmm1, %%eax\n\t"	"cvtdq2pd %%xmm4, %%xmm4\n\t"
+		"movl	%%edx, %%ecx\n\t"	"movl	%%eax, %%ebx\n\t"	"andpd	%7, %%xmm4\n\t"
+		"shrl	$9, %%ecx\n\t"		"shrl	$9, %%ebx\n\t"		"cvtpd2dq %%xmm4, %%xmm4\n\t"
+		"andl	$63, %%ecx\n\t"		"andl	$63, %%ebx\n\t"		"pand	%%xmm4, %%xmm0\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"
+						"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"andl	%%edx, %%ecx\n\t"	"andl	%%ebx, %%eax\n\t"	"pmullw	%8, %%xmm0\n\t"
+		"movq	"_"FLIPPED_4_V(,%%ecx,8), %%xmm2\n\t"
+						"movhps	"_"FLIPPED_4_V(,%%eax,8), %%xmm2\n\t"
+		"pand	%5, %%xmm2\n\t"						"psrlw	$10, %%xmm0\n\t"
+		"por	%%xmm2, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minus0800)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7, flip_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_4[((((OL & 0x80808000u) >> 4) + (OH & 0x00808080u)) * 0x00204081u) >> 25]
+		& (((((PL & 0x80808080u) >> 4) + (PH & 0x80808080u)) * 0x00204081u) >> 24);
+	flipped = FLIPPED_4_V[outflank_v] & 0x0080808080808000;
+
+	outflank_h = OUTFLANK_7[(OH >> 1) & 0x3f] & (PH >> 0);
+	flipped |= (UINT64) (((-outflank_h) & 0x3f) << 1) << 32;
+
+	outflank_d7 = ((OH | ~0x10204000u) + 1) & PH & 0x10200000u;
+	flipped |= (UINT64) ((outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00204000u) << 32;
+
+	flip_d9 = OL & ((OL >> 9) | 0x40000000u);
+	flip_d9 &= ((flip_d9 & 0x40200000u) >> 18) | 0x40200000u;
+	flipped |= flip_d9 & -(flip_d9 & (PL << 9));
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H5(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x8080808080808080, 0x1020408040201008 }};
+	static const V2DI mask2 = {{ 0x0000007f00000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	outflank_h, flipped_v2, mask_d;
+	unsigned int outflank_v, outflank_d, index_v, index_d;
+
+	index_v = _mm_movemask_epi8(OP);
+	outflank_v = OUTFLANK_4[(index_v >> 9) & 0x3f] & index_v;
+
+	mask_d = _mm_shuffle_epi32(mask1.v2, DUPHI);
+	index_d = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(OP, mask_d), mask_d));
+	outflank_d = OUTFLANK_4[(index_d >> 9) & 0x3f] & index_d;
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_4_V[outflank_v], &FLIPPED_4_V[outflank_d]), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask2.v2)), OP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minus0400.v2), 9));
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%3, %%xmm1\n\t"		"movd	%1, %%xmm0\n\t"
+		"movd	%4, %%xmm3\n\t"		"movd	%2, %%xmm4\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"	"punpckldq %%xmm4, %%xmm0\n\t"
+		"punpcklqdq %%xmm1, %%xmm0\n\t"	"pshufd	$238, %5, %%xmm1\n\t"
+		"movdqa	%%xmm0, %%xmm3\n\t"	"movdqa	%%xmm0, %%xmm2\n\t"	"pshufd	$238, %%xmm0, %%xmm4\n\t"
+						"pand	%%xmm1, %%xmm2\n\t"	"pandn	%6, %%xmm4\n\t"
+						"pcmpeqb %%xmm2, %%xmm1\n\t"
+		"pmovmskb %%xmm3, %%edx\n\t"	"pmovmskb %%xmm1, %%eax\n\t"	"cvtdq2pd %%xmm4, %%xmm4\n\t"
+		"movl	%%edx, %%ecx\n\t"	"movl	%%eax, %%ebx\n\t"	"andpd	%7, %%xmm4\n\t"
+		"shrl	$9, %%ecx\n\t"		"shrl	$9, %%ebx\n\t"		"cvtpd2dq %%xmm4, %%xmm4\n\t"
+		"andl	$63, %%ecx\n\t"		"andl	$63, %%ebx\n\t"		"pand	%%xmm4, %%xmm0\n\t"
+		"movzbl	"_"OUTFLANK_4(%%ecx), %%ecx\n\t"
+						"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"andl	%%edx, %%ecx\n\t"	"andl	%%ebx, %%eax\n\t"	"pmullw	%8, %%xmm0\n\t"
+		"movq	"_"FLIPPED_4_V(,%%ecx,8), %%xmm2\n\t"
+						"movhps	"_"FLIPPED_4_V(,%%eax,8), %%xmm2\n\t"
+		"pand	%5, %%xmm2\n\t"						"psrlw	$9, %%xmm0\n\t"
+		"por	%%xmm2, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minus0400)
+	: "ebx", "ecx");
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, flip_d7;
+	unsigned short outflank_h;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[(((OL & 0x01010100u) + ((OH & 0x00010101u) << 4)) * 0x01020408u) >> 25]
+		& ((((PL & 0x01010101u) + ((PH & 0x01010101u) << 4)) * 0x01020408u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0001010101010100;
+
+	outflank_h = (OH + 0x0200) & PH;
+	flipped |= (UINT64) ((outflank_h - (outflank_h >> 8)) & 0x00007e00u) << 32;
+
+	flip_d7 = (OL >> 8) | (OH << 24);
+	flip_d7 &= (flip_d7 >> 7) | 0x02000000u;
+	flip_d7 &= ((flip_d7 & 0x02040000u) >> 14) | 0x02040000u;
+	flipped |= (UINT64) (flip_d7 & -(flip_d7 & (PL >> 1))) << 8;
+
+	flipped |= (UINT64) ((PH >> 9) & 0x00020000u & OH) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000000101010101, 0x0000000204081020 }};
+	UINT64 flipped;
+	unsigned int FH;
+	unsigned short outflank_h;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = (OH + 0x0200) & PH;
+	FH = ((outflank_h - (outflank_h >> 8)) & 0x00007e00u)
+		| (OH & (((PH >> 8) & 0x00010000u) | ((PH >> 9) & 0x00020000u)));
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, flip_d7;
+	unsigned short outflank_h;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[(((OL & 0x02020200u) + ((OH & 0x00020202u) << 4)) * 0x00810204u) >> 25]
+		& ((((PL & 0x02020202u) + ((PH & 0x02020202u) << 4)) * 0x00810204u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0002020202020200;
+
+	outflank_h = (OH + 0x0400) & PH;
+	flipped |= (UINT64) ((outflank_h - (outflank_h >> 8)) & 0x00007c00u) << 32;
+
+	flip_d7 = (OL >> 8) | (OH << 24);
+	flip_d7 &= (flip_d7 >> 7) | 0x04000000u;
+	flip_d7 &= ((flip_d7 & 0x04080000u) >> 14) | 0x04080000u;
+	flipped |= (UINT64) (flip_d7 & -(flip_d7 & (PL >> 1))) << 8;
+
+	flipped |= (UINT64) ((PH >> 9) & 0x00040000u & OH) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000000202020202, 0x0000000408102040 }};
+	UINT64 flipped;
+	unsigned int FH;
+	unsigned short outflank_h;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = (OH + 0x0400) & PH;
+	FH = ((outflank_h - (outflank_h >> 8)) & 0x00007c00u)
+		| (OH & (((PH >> 8) & 0x00020000u) | ((PH >> 9) & 0x00040000u)));
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d7;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[(((OL & 0x04040400u) + ((OH & 0x00040404u) << 4)) * 0x00408102u) >> 25]
+		& ((((PL & 0x04040404u) + ((PH & 0x04040404u) << 4)) * 0x00408102u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400;
+
+	outflank_h = OUTFLANK_2[(OH >> 9) & 0x3f] & (PH >> 8);
+	flipped |= FLIPPED_2_H[outflank_h] & 0x0000ff0000000000;
+
+	outflank_d7 = OUTFLANK_2[(((OL & 0x10204000u) + (OH & 0x00020408u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x10204080u) + (PH & 0x01020408u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000;
+
+	flipped |= (UINT64) (((PH >> 9) | (PL >> 23)) & 0x00080002u & OH) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000000404040404, 0x0000000810204080 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = OUTFLANK_2[(OH >> 9) & 0x3f] & (PH >> 8);
+	FH = ((unsigned char) FLIPPED_2_H[outflank_h] << 8)
+		| (OH & (((PH >> 8) & 0x00040000u)
+			| ((PH >> 7) & 0x00020000u)
+			| (((PH >> 9) | (PL >> 23)) & 0x00080002u)));
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[(((OL & 0x08080800u) + ((OH & 0x00080808u) << 4)) * 0x00204081u) >> 25]
+		& ((((PL & 0x08080808u) + ((PH & 0x08080808u) << 4)) * 0x00204081u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800;
+
+	outflank_h = OUTFLANK_3[(OH >> 9) & 0x3f] & (PH >> 8);
+	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000;
+
+	outflank_d = OUTFLANK_3[(((OL & 0x22400000u) + (OH & 0x00000814u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x22418000u) + (PH & 0x00000814u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000081422400000;	// A3D6H2
+
+	flipped |= (UINT64) (OH & (((PH >> 9) & 0x00100000u) | ((PH >> 7) & 0x00040000u))) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0808080808080808, 0x0000081422418000 }};	// A3D6H2
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, index_d;
+	unsigned int outflank_v, outflank_d, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = OUTFLANK_5[(index_v >> 9) & 0x3f] & index_v;
+
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask1.v2, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & _mm_cvtsi128_si32(index_d);
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_5_V[outflank_v], &FLIPPED_3_H[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$4, %%xmm0\n\t"				"pxor	%%xmm2, %%xmm2\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"psadbw %%xmm2, %%xmm1\n\t"
+		"movl	%%edx, %%ecx\n\t"			"pextrw	$4, %%xmm1, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$1, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_5(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+								"movd	%%xmm1, %%eax\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_5_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_H(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+
+	outflank_h = OUTFLANK_3[(OH >> 9) & 0x3f] & (PH >> 8);
+	FH = ((unsigned char) FLIPPED_3_H[outflank_h] << 8)
+		| (OH & (((PH >> 9) & 0x00100000u) | ((PH >> 7) & 0x00040000u)));
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[((((OL & 0x10101000u) >> 4) + (OH & 0x00101010u)) * 0x01020408u) >> 25]
+		& (((((PL & 0x10101010u) >> 4) + (PH & 0x10101010u)) * 0x01020408u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000;
+
+	outflank_h = OUTFLANK_4[(OH >> 9) & 0x3f] & (PH >> 8);
+	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000;
+
+	outflank_d = OUTFLANK_4[(((OL & 0x44020000u) + (OH & 0x00001028u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x44820100u) + (PH & 0x00001028u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000102844020000;	// A2E6H3
+
+	flipped |= (UINT64) (OH & (((PH >> 9) & 0x00200000u) | ((PH >> 7) & 0x00080000u))) << 32;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x1010101010101010, 0x0000102844820100 }};	// A2E6H3
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, index_d;
+	unsigned int outflank_v, outflank_d, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = OUTFLANK_5[(index_v >> 9) & 0x3f] & index_v;
+
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask1.v2, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & _mm_cvtsi128_si32(index_d);
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_5_V[outflank_v], &FLIPPED_4_H[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$3, %%xmm0\n\t"				"pxor	%%xmm2, %%xmm2\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"psadbw %%xmm2, %%xmm1\n\t"
+		"movl	%%edx, %%ecx\n\t"			"pextrw	$4, %%xmm1, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$1, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_5(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+								"movd	%%xmm1, %%eax\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_5_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_H(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_4[(OH >> 9) & 0x3f] & (PH >> 8);
+	FH = ((unsigned char) FLIPPED_4_H[outflank_h] << 8)
+		| (OH & (((PH >> 9) & 0x00200000u) | ((PH >> 7) & 0x00080000u)));
+
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[((((OL & 0x20202000u) >> 4) + (OH & 0x00202020u)) * 0x00810204u) >> 25]
+		& (((((PL & 0x20202020u) >> 4) + (PH & 0x20202020u)) * 0x00810204u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000;
+
+	outflank_h = OUTFLANK_5[(OH >> 9) & 0x3f] & (PH >> 8);
+	flipped |= FLIPPED_5_H[outflank_h] & 0x0000ff0000000000;
+
+	flipped |= (UINT64) (((PH >> 7) | (PL >> 25)) & 0x00100040u & OH) << 32;
+
+	outflank_d9 = OUTFLANK_5[(((OL & 0x08040200u) + (OH & 0x00402010u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x08040201u) + (PH & 0x80402010u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000002020202020, 0x0000001008040201 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = OUTFLANK_5[(OH >> 9) & 0x3f] & (PH >> 8);
+	FH = ((unsigned char) FLIPPED_5_H[outflank_h] << 8)
+		| (OH & (((PH >> 8) & 0x00200000u)
+			| ((PH >> 9) & 0x00400000u)
+			| (((PH >> 7) | (PL >> 25)) & 0x00100040u)));
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, flip_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[((((OL & 0x40404000u) >> 4) + (OH & 0x00404040u)) * 0x00408102u) >> 25]
+		& (((((PL & 0x40404040u) >> 4) + (PH & 0x40404040u)) * 0x00408102u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0040404040404000;
+
+	outflank_h = OUTFLANK_7[(OH >> 8) & 0x3e] & (PH >> 7);
+	flipped |= (UINT64) ((((-outflank_h) & 0x3e) << 8) | ((PH >> 7) & 0x00200000u & OH)) << 32;
+
+	flip_d9 = (OL >> 8) | (OH << 24);
+	flip_d9 &= (flip_d9 >> 9) | 0x20000000u;
+	flip_d9 &= ((flip_d9 & 0x20100000u) >> 18) | 0x20100000u;
+	flipped |= (UINT64) (flip_d9 & -(flip_d9 & (PL << 1))) << 8;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000004040404040, 0x0000002010080402 }};
+	static const V2DI mask2 = {{ 0x0040000000000000, 0x0020000000000000 }};
+	static const V2DI mask3 = {{ 0x00003f0000000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i outflank_vd, outflank_h, flipped_v2, flipped_g7f7;
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+
+	outflank_vd = _mm_and_si128(MS1B_epi52(_mm_andnot_si128(OO, mask1.v2)), PP);
+	flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+
+	flipped_g7f7 = _mm_and_si128(_mm_mulhi_epu16(PP, k02000100.v2), mask2.v2);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_g7f7, OO));
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask3.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minuseight.v2), 2));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%2, %%xmm4\n\t"		"movd	%3, %%xmm2\n\t"
+		"movd	%1, %%xmm3\n\t"		"movd	%4, %%xmm0\n\t"
+		"movapd	%10, %%xmm1\n\t"
+		"punpckldq %%xmm4, %%xmm3\n\t"	"punpckldq %%xmm0, %%xmm2\n\t"
+		"punpcklqdq %%xmm3, %%xmm3\n\t"	"punpcklqdq %%xmm2, %%xmm2\n\t"
+		"movdqa	%%xmm2, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"					"movdqa	%11, %%xmm4\n\t"
+		"orpd	%%xmm1, %%xmm0\n\t"				"pmulhuw %%xmm3, %%xmm4\n\t"
+		"subpd	%%xmm1, %%xmm0\n\t"				"pand	%6, %%xmm4\n\t"
+		"andpd	%8, %%xmm0\n\t"
+		"addpd	%%xmm1, %%xmm0\n\t"	"movdqa	%%xmm2, %%xmm1\n\t"
+						"pandn	%7, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"	"cvtdq2pd %%xmm1, %%xmm1\n\t"
+						"andpd	%8, %%xmm1\n\t"
+		"paddq	%%xmm0, %%xmm0\n\t"	"cvtpd2dq %%xmm1, %%xmm1\n\t"
+						"pand	%%xmm3, %%xmm1\n\t"
+		"pxor	%%xmm3, %%xmm3\n\t"	"pmullw	%9, %%xmm1\n\t"
+		"psubq	%%xmm0, %%xmm3\n\t"	"psrlq	$2, %%xmm1\n\t"
+		"movdqa	%5, %%xmm0\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"				"pand	%%xmm2, %%xmm4\n\t"
+		"por	%%xmm0, %%xmm1\n\t"				"por	%%xmm4, %%xmm1\n\t"
+		"pshufd	$78, %%xmm1, %%xmm4\n\t"
+		"por	%%xmm4, %%xmm1\n\t"
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"
+		"movd	%%xmm1, %%eax\n\t"
+		"movd	%%xmm0, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (mask3), "m" (expmask), "m" (minuseight), "m" (k1e52), "m" (k02000100));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, flip_d9;
+	UINT64 flipped;
+
+	outflank_v = OUTFLANK_5[((((OL & 0x80808000u) >> 4) + (OH & 0x00808080u)) * 0x00204081u) >> 25]
+		& (((((PL & 0x80808080u) >> 4) + (PH & 0x80808080u)) * 0x00204081u) >> 24);
+	flipped = FLIPPED_5_V[outflank_v] & 0x0080808080808000;
+
+	outflank_h = OUTFLANK_7[(OH >> 9) & 0x3f] & (PH >> 8);
+	flipped |= (UINT64) ((((-outflank_h) & 0x3f) << 9) | ((PH >> 7) & 0x00400000u & OH)) << 32;
+
+	flip_d9 = (OL >> 8) | (OH << 24);
+	flip_d9 &= (flip_d9 >> 9) | 0x40000000u;
+	flip_d9 &= ((flip_d9 & 0x40200000u) >> 18) | 0x40200000u;
+	flipped |= (UINT64) (flip_d9 & -(flip_d9 & (PL << 1))) << 8;
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H6(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000008080808080, 0x0000004020100804 }};
+	static const V2DI mask2 = {{ 0x0080000000000000, 0x0040000000000000 }};
+	static const V2DI mask3 = {{ 0x00007f0000000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i outflank_vd, outflank_h, flipped_v2, flipped_h7g7;
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+
+	outflank_vd = _mm_and_si128(MS1B_epi52(_mm_andnot_si128(OO, mask1.v2)), PP);
+	flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+
+	flipped_h7g7 = _mm_and_si128(_mm_mulhi_epu16(PP, k02000100.v2), mask2.v2);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_and_si128(flipped_h7g7, OO));
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask3.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minusfour.v2), 1));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%2, %%xmm4\n\t"		"movd	%3, %%xmm2\n\t"
+		"movd	%1, %%xmm3\n\t"		"movd	%4, %%xmm0\n\t"
+		"movapd	%10, %%xmm1\n\t"
+		"punpckldq %%xmm4, %%xmm3\n\t"	"punpckldq %%xmm0, %%xmm2\n\t"
+		"punpcklqdq %%xmm3, %%xmm3\n\t"	"punpcklqdq %%xmm2, %%xmm2\n\t"
+		"movdqa	%%xmm2, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"					"movdqa	%11, %%xmm4\n\t"
+		"orpd	%%xmm1, %%xmm0\n\t"				"pmulhuw %%xmm3, %%xmm4\n\t"
+		"subpd	%%xmm1, %%xmm0\n\t"				"pand	%6, %%xmm4\n\t"
+		"andpd	%8, %%xmm0\n\t"
+		"addpd	%%xmm1, %%xmm0\n\t"	"movdqa	%%xmm2, %%xmm1\n\t"
+						"pandn	%7, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"	"cvtdq2pd %%xmm1, %%xmm1\n\t"
+						"andpd	%8, %%xmm1\n\t"
+		"paddq	%%xmm0, %%xmm0\n\t"	"cvtpd2dq %%xmm1, %%xmm1\n\t"
+						"pand	%%xmm3, %%xmm1\n\t"
+		"pxor	%%xmm3, %%xmm3\n\t"	"pmullw	%9, %%xmm1\n\t"
+		"psubq	%%xmm0, %%xmm3\n\t"	"psrlq	$1, %%xmm1\n\t"
+		"movdqa	%5, %%xmm0\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"				"pand	%%xmm2, %%xmm4\n\t"
+		"por	%%xmm0, %%xmm1\n\t"				"por	%%xmm4, %%xmm1\n\t"
+		"pshufd	$78, %%xmm1, %%xmm4\n\t"
+		"por	%%xmm4, %%xmm1\n\t"
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"
+		"movd	%%xmm1, %%eax\n\t"
+		"movd	%%xmm0, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (mask3), "m" (expmask), "m" (minusfour), "m" (k1e52), "m" (k02000100));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, outflank_h, outflank_d7, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x01010100u) << 4) + (OH & 0x00000101u)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x01010101u) << 4) + (PH & 0x00000001u)) * 0x08040201u) >> 24;
+	flippedH = ((outflank_v * 0x00001f0fu) >> 7) & 0x00000101u;
+	flippedL = (outflank_v * 0x000e0602u) & 0x01010100u;
+
+	outflank_h = ((OH & 0x007e0000u) + 0x00020000u) & PH;
+	flippedH |= (outflank_h - (outflank_h >> 8)) & 0x007e0000u;
+
+	outflank_d7 = (((((OL & 0x08102000u) + (OH & 0x00000204u)) * 0x01010101u) >> 24) + 2)
+		& ((((PL & 0x08102040u) + (PH & 0x00000004u)) * 0x01010101u) >> 24);
+	flippedH |= ((outflank_d7 * 0x0000f8f0u) >> 8) & 0x00000204u;
+	flippedL |= (outflank_d7 * 0x00e0c080u) & 0x08102000u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000010101010101, 0x0000020408102040 }};
+	UINT64 flipped;
+
+	FLIP_MS1B_AB78(49);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, outflank_h, outflank_d7, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x02020200u) << 3) + ((OH & 0x00000202u) >> 1)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x02020202u) << 3) + ((PH & 0x00000002u) >> 1)) * 0x08040201u) >> 24;
+	flippedH = ((outflank_v * 0x00001f0fu) >> 6) & 0x00000202u;
+	flippedL = (outflank_v * 0x001c0c04u) & 0x02020200u;
+
+	outflank_h = ((OH & 0x007c0000u) + 0x00040000u) & PH;
+	flippedH |= (outflank_h - (outflank_h >> 8)) & 0x007c0000u;
+
+	outflank_d7 = ((((OL & 0x10204000u) + (OH & 0x00000408u)) * 0x01010101u + 0x04000000u)
+		& ((PL & 0x10204080u) + (PH & 0x00000008u)) * 0x01010101u) >> 25;
+	flippedH |= ((outflank_d7 * 0x0000f8f0u) >> 7) & 0x00000408u;
+	flippedL |= (outflank_d7 * 0x01c18100u) & 0x10204000u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000020202020202, 0x0000040810204080 }};
+	UINT64 flipped;
+
+	FLIP_MS1B_AB78(50);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = (((((OL & 0x04040400u) << 2) + ((OH & 0x00000404u) >> 2)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x04040404u) << 2) + ((PH & 0x00000004u) >> 2)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x00001f0fu) >> 5) & 0x00000404u, (outflank_v * 0x00381808u) & 0x04040400u);
+
+	outflank_h = OUTFLANK_2[(OH >> 17) & 0x3f] & (PH >> 16);
+	flipped |= FLIPPED_2_H[outflank_h] & 0x00ff000000000000;
+
+	outflank_d = OUTFLANK_2[(((OH & 0x00040a10u) + (OL & 0x20400000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00040a11u) + (PL & 0x20408000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d] & 0x00040a1020400000;	// A5C7H2
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000040404040404, 0x0000081020408000 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = OUTFLANK_2[(OH >> 17) & 0x3f] & (PH >> 16);
+	FH = ((unsigned char) FLIPPED_2_H[outflank_h] << 16)
+		| (OH & (PH << 9) & 0x00000200u);
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = (((((OL & 0x08080800u) << 1) + ((OH & 0x00000808u) >> 3)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x08080808u) << 1) + ((PH & 0x00000008u) >> 3)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x00001f0fu) >> 4) & 0x00000808u, (outflank_v * 0x00703010u) & 0x08080800u);
+
+	outflank_h = OUTFLANK_3[(OH >> 17) & 0x3f] & (PH >> 16);
+	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000;
+
+	outflank_d = OUTFLANK_3[(((OH & 0x00081422u) + (OL & 0x40000000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00081422u) + (PL & 0x41800000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0008142240000000;	// A4D7H3
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000080808080808, 0x0008142241800000 }};	// A4D7H3
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, index_d;
+	unsigned int outflank_v, outflank_d, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = (OUTFLANK_7[(index_v >> 8) & 0x3e] >> 1) & index_v;
+
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask1.v2, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & _mm_cvtsi128_si32(index_d);
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_7_V[outflank_v], &FLIPPED_3_H[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$4, %%xmm0\n\t"				"pxor	%%xmm2, %%xmm2\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"psadbw %%xmm2, %%xmm1\n\t"
+								"pextrw	$4, %%xmm1, %%ebx\n\t"
+		"movzx	%%dh, %%ecx\n\t"			"shrl	$1, %%ebx\n\t"
+		"andl	$62, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_7(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+		"shrl	$1, %%ecx\n\t"				"movd	%%xmm1, %%eax\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_7_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_H(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_3[(OH >> 17) & 0x3f] & (PH >> 16);
+	return flipped | (FLIPPED_3_H[outflank_h] & 0x00ff000000000000);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = ((((OL & 0x10101000u) + ((OH & 0x00001010u) >> 4)) * 0x08040201u + 0x04000000u)
+		& ((PL & 0x10101010u) + ((PH & 0x00000010u) >> 4)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x00001f0fu) >> 3) & 0x00001010u, (outflank_v * 0x00e06020u) & 0x10101000u);
+
+	outflank_h = OUTFLANK_4[(OH >> 17) & 0x3f] & (PH >> 16);
+	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000;
+
+	outflank_d = OUTFLANK_4[(((OH & 0x00102844u) + (OL & 0x02000000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00102844u) + (PL & 0x82010000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0010284402000000;	// A3E7H4
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000101010101010, 0x0010284482010000 }};	// A3E7H4
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, index_d;
+	unsigned int outflank_v, outflank_d, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = (OUTFLANK_7[(index_v >> 8) & 0x3e] >> 1) & index_v;
+
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask1.v2, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & _mm_cvtsi128_si32(index_d);
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_7_V[outflank_v], &FLIPPED_4_H[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$3, %%xmm0\n\t"				"pxor	%%xmm2, %%xmm2\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"psadbw %%xmm2, %%xmm1\n\t"
+								"pextrw	$4, %%xmm1, %%ebx\n\t"
+		"movzx	%%dh, %%ecx\n\t"			"shrl	$1, %%ebx\n\t"
+		"andl	$62, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_7(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+		"shrl	$1, %%ecx\n\t"				"movd	%%xmm1, %%eax\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_7_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_H(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_4[(OH >> 17) & 0x3f] & (PH >> 16);
+	return flipped | (FLIPPED_4_H[outflank_h] & 0x00ff000000000000);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = (((((OL & 0x20202000u) >> 1) + ((OH & 0x00002020u) >> 5)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x20202020u) >> 1) + ((PH & 0x00000020u) >> 5)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x00001f0fu) >> 2) & 0x00002020u, (outflank_v * 0x01c0c040u) & 0x20202000u);
+
+	outflank_h = OUTFLANK_5[(OH >> 17) & 0x3f] & (PH >> 16);
+	flipped |= FLIPPED_5_H[outflank_h] & 0x00ff000000000000;
+
+	outflank_d = OUTFLANK_5[(((OH & 0x00205008u) + (OL & 0x04020000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x00205088u) + (PL & 0x04020100u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d] & 0x0020500804020000;	// A2F7H5
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000202020202020, 0x0000100804020100 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = OUTFLANK_5[(OH >> 17) & 0x3f] & (PH >> 16);
+	FH = ((unsigned char) FLIPPED_5_H[outflank_h] << 16)
+		| (OH & (PH << 7) & 0x00004000u);
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d9, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x40404000u) >> 2) + ((OH & 0x00004040u) >> 6)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x40404040u) >> 2) + ((PH & 0x00000040u) >> 6)) * 0x08040201u) >> 24;
+	flippedH = ((outflank_v * 0x00001f0fu) >> 1) & 0x00004040u;
+	flippedL = (outflank_v * 0x03818080u) & 0x40404000u;
+
+	outflank_h = OUTFLANK_7[(OH >> 16) & 0x3e] & (PH >> 15);
+	flippedH |= ((-outflank_h) & 0x3e) << 16;
+
+	outflank_d9 = OUTFLANK_7[(((OL & 0x08040200u) + (OH & 0x00002010u)) * 0x01010101u) >> 24]
+		& ((((PL & 0x08040201u) + (PH & 0x00000010u)) * 0x01010101u) >> 23);
+	flippedH |= (outflank_d9 * 0x00001f0fu) & 0x00002010u;
+	flippedL |= (outflank_d9 * 0x07030100u) & 0x08040200u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000404040404040, 0x0000201008040201 }};
+	static const V2DI mask2 = {{ 0x003f000000000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i outflank_vd, outflank_h, flipped_v2;
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+
+	outflank_vd = _mm_and_si128(MS1B_epi52(_mm_andnot_si128(OO, mask1.v2)), PP);
+	flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask2.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minus0800.v2), 10));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%2, %%xmm0\n\t"		"movd	%3, %%xmm2\n\t"
+		"movd	%1, %%xmm1\n\t"		"movd	%4, %%xmm3\n\t"
+		"punpckldq %%xmm0, %%xmm1\n\t"	"punpckldq %%xmm3, %%xmm2\n\t"
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm2, %%xmm2\n\t"
+		"movapd	%9, %%xmm3\n\t"		"movdqa	%%xmm2, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"		"pandn	%6, %%xmm2\n\t"
+		"orpd	%%xmm3, %%xmm0\n\t"
+		"subpd	%%xmm3, %%xmm0\n\t"	"cvtdq2pd %%xmm2, %%xmm2\n\t"
+		"andpd	%7, %%xmm0\n\t"		"andpd	%7, %%xmm2\n\t"
+		"addpd	%%xmm3, %%xmm0\n\t"	"cvtpd2dq %%xmm2, %%xmm2\n\t"
+		"pand	%%xmm1, %%xmm0\n\t"
+		"pxor	%%xmm3, %%xmm3\n\t"
+		"paddq	%%xmm0, %%xmm0\n\t"
+		"psubq	%%xmm0, %%xmm3\n\t"	"pand	%%xmm2, %%xmm1\n\t"
+		"movdqa	%5, %%xmm0\n\t"		"pmullw	%8, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"	"psrlw	$10, %%xmm1\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$78, %%xmm1, %%xmm0\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"
+		"movd	%%xmm1, %%eax\n\t"
+		"movd	%%xmm0, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minus0800), "m" (k1e52));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d9, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x80808000u) >> 3) + ((OH & 0x00008080u) >> 7)) * 0x08040201u + 0x04000000u)
+		& (((PL & 0x80808080u) >> 3) + ((PH & 0x00000080u) >> 7)) * 0x08040201u) >> 24;
+	flippedH = (outflank_v * 0x00001f0fu) & 0x00008080u;
+	flippedL = (outflank_v * 0x07030100u) & 0x80808000u;
+
+	outflank_h = OUTFLANK_7[(OH >> 17) & 0x3f] & (PH >> 16);
+	flippedH |= ((-outflank_h) & 0x3f) << 17;
+
+	outflank_d9 = OUTFLANK_7[(((OL & 0x10080400u) + (OH & 0x00004020u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x10080402u) + (PH & 0x00000020u)) * 0x01010101u) >> 24);
+	flippedH |= (outflank_d9 * 0x00003e1eu) & 0x00004020u;
+	flippedL |= (outflank_d9 * 0x0e060200u) & 0x10080400u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H7(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0000808080808080, 0x0000402010080402 }};
+	static const V2DI mask2 = {{ 0x007f000000000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i outflank_vd, outflank_h, flipped_v2;
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+
+	outflank_vd = _mm_and_si128(MS1B_epi52(_mm_andnot_si128(OO, mask1.v2)), PP);
+	flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask2.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minus0400.v2), 9));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%2, %%xmm0\n\t"		"movd	%3, %%xmm2\n\t"
+		"movd	%1, %%xmm1\n\t"		"movd	%4, %%xmm3\n\t"
+		"punpckldq %%xmm0, %%xmm1\n\t"	"punpckldq %%xmm3, %%xmm2\n\t"
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm2, %%xmm2\n\t"
+		"movapd	%9, %%xmm3\n\t"		"movdqa	%%xmm2, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"		"pandn	%6, %%xmm2\n\t"
+		"orpd	%%xmm3, %%xmm0\n\t"
+		"subpd	%%xmm3, %%xmm0\n\t"	"cvtdq2pd %%xmm2, %%xmm2\n\t"
+		"andpd	%7, %%xmm0\n\t"		"andpd	%7, %%xmm2\n\t"
+		"addpd	%%xmm3, %%xmm0\n\t"	"cvtpd2dq %%xmm2, %%xmm2\n\t"
+		"pand	%%xmm1, %%xmm0\n\t"
+		"pxor	%%xmm3, %%xmm3\n\t"
+		"paddq	%%xmm0, %%xmm0\n\t"
+		"psubq	%%xmm0, %%xmm3\n\t"	"pand	%%xmm2, %%xmm1\n\t"
+		"movdqa	%5, %%xmm0\n\t"		"pmullw	%8, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"	"psrlw	$9, %%xmm1\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$78, %%xmm1, %%xmm0\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"
+		"movd	%%xmm1, %%eax\n\t"
+		"movd	%%xmm0, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minus0400), "m" (k1e52));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square A8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_A8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, outflank_h, outflank_d7, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x01010100u) << 4) + (OH & 0x00010101u)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x01010101u) << 4) + (PH & 0x00000101u)) * 0x08040201u) >> 24;
+	flippedH = ((outflank_v * 0x003f1f0fu) >> 7) & 0x00010101u;
+	flippedL = (outflank_v * 0x000e0602u) & 0x01010100u;
+
+	outflank_h = (OH + 0x02000000u) & PH;
+	flippedH |= (outflank_h - (outflank_h >> 8)) & 0x7e000000u;
+
+	outflank_d7 = ((((OL & 0x10204000u) + (OH & 0x00020408u)) * 0x01010101u + 0x02000000u)
+		& ((PL & 0x10204080u) + (PH & 0x00000408u)) * 0x01010101u) >> 24;
+	flippedH |= ((outflank_d7 * 0x00fcf8f0u) >> 8) & 0x00020408u;
+	flippedL |= (outflank_d7 * 0x00e0c080u) & 0x10204000u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_A8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0001010101010101, 0x0002040810204080 }};
+	UINT64 flipped;
+
+	FLIP_MS1B_AB78(57);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square B8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_B8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_v, outflank_h, outflank_d7, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x02020200u) << 3) + ((OH & 0x00020202u) >> 1)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x02020202u) << 3) + ((PH & 0x00000202u) >> 1)) * 0x08040201u) >> 24;
+	flippedH = ((outflank_v * 0x003f1f0fu) >> 6) & 0x00020202u;
+	flippedL = (outflank_v * 0x001c0c04u) & 0x02020200u;
+
+	outflank_h = (OH + 0x04000000u) & PH;
+	flippedH |= (outflank_h - (outflank_h >> 8)) & 0x7c000000u;
+
+	outflank_d7 = ((((OL & 0x20400000u) + (OH & 0x00040810u)) * 0x01010101u + 0x04000000u)
+		& ((PL & 0x20408000u) + (PH & 0x00000810u)) * 0x01010101u) >> 25;
+	flippedH |= ((outflank_d7 * 0x00fcf8f0u) >> 7) & 0x00040810u;
+	flippedL |= (outflank_d7 * 0x01c18000u) & 0x20400000u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_B8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0002020202020202, 0x0004081020408000 }};
+	UINT64 flipped;
+
+	FLIP_MS1B_AB78(58);
+
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square C8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_C8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = (((((OL & 0x04040400u) << 2) + ((OH & 0x00040404u) >> 2)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x04040404u) << 2) + ((PH & 0x00000404u) >> 2)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x003f1f0fu) >> 5) & 0x00040404u, (outflank_v * 0x00381808u) & 0x04040400u);
+
+	outflank_h = OUTFLANK_2[(OH >> 25) & 0x3f] & (PH >> 24);
+	flipped |= FLIPPED_2_H[outflank_h] & 0xff00000000000000;
+
+	outflank_d = OUTFLANK_2[(((OH & 0x040a1020u) + (OL & 0x40000000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x040a1120u) + (PL & 0x40800000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_2_H[outflank_d] & 0x040a102040000000;	// A6C8H3
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_C8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0004040404040404, 0x0008102040800000 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+
+	FLIP_MS1B_2_VEC;
+
+	outflank_h = OUTFLANK_2[(OH >> 25) & 0x3f] & (PH >> 24);
+	FH = ((unsigned char) FLIPPED_2_H[outflank_h] << 24)
+		| (OH & (PH << 9) & 0x00020000u);
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square D8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_D8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = (((((OL & 0x08080800u) << 1) + ((OH & 0x00080808u) >> 3)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x08080808u) << 1) + ((PH & 0x00000808u) >> 3)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x003f1f0fu) >> 4) & 0x00080808u, (outflank_v * 0x00703010u) & 0x08080800u);
+
+	outflank_h = OUTFLANK_3[(OH >> 25) & 0x3f] & (PH >> 24);
+	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000;
+
+	outflank_d = OUTFLANK_3[((OH & 0x08142240u) * 0x01010101u) >> 25]
+		& ((((PH & 0x08142241u) + (PL & 0x80000000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0814224000000000;	// A5D8H4
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_D8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0008080808080808, 0x0814224180000000 }};	// A5D8H4
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, index_d;
+	unsigned int outflank_v, outflank_d, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = OUTFLANK_7[(index_v >> 9) & 0x3f] & index_v;
+
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask1.v2, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & _mm_cvtsi128_si32(index_d);
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_7_V[outflank_v], &FLIPPED_3_H[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$4, %%xmm0\n\t"				"pxor	%%xmm2, %%xmm2\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"psadbw %%xmm2, %%xmm1\n\t"
+		"movl	%%edx, %%ecx\n\t"			"pextrw	$4, %%xmm1, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$1, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_7(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_3(%%ebx), %%ebx\n\t"
+								"movd	%%xmm1, %%eax\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_7_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_3_H(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_3[(OH >> 25) & 0x3f] & (PH >> 24);
+	return flipped | (FLIPPED_3_H[outflank_h] & 0xff00000000000000);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square E8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_E8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = ((((OL & 0x10101000u) + ((OH & 0x00101010u) >> 4)) * 0x08040201u + 0x02000000u)
+		& ((PL & 0x10101010u) + ((PH & 0x00001010u) >> 4)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x003f1f0fu) >> 3) & 0x00101010u, (outflank_v * 0x00e06020u) & 0x10101000u);
+
+	outflank_h = OUTFLANK_4[(OH >> 25) & 0x3f] & (PH >> 24);
+	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000;
+
+	outflank_d = OUTFLANK_4[((OH & 0x10284402u) * 0x01010101u) >> 25]
+		& ((((PH & 0x10284482u) + (PL & 0x01000000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_4_H[outflank_d] & 0x1028440200000000;	// A4E8H5
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_E8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0010101010101010, 0x1028448201000000 }};	// A4E8H5
+	UINT64 flipped;
+	unsigned int outflank_h;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i OP = _mm_set_epi32(OH, OL, PH, PL);
+	__m128i	flipped_v2, index_d;
+	unsigned int outflank_v, outflank_d, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = OUTFLANK_7[(index_v >> 9) & 0x3f] & index_v;
+
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask1.v2, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & _mm_cvtsi128_si32(index_d);
+
+	flipped_v2 = _mm_and_si128(load64x2(&FLIPPED_7_V[outflank_v], &FLIPPED_4_H[outflank_d]), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"punpcklqdq %%xmm0, %%xmm1\n\t"			"pshufd	$238, %5, %%xmm2\n\t"
+		"movdqa	%%xmm1, %%xmm0\n\t"			"pand	%%xmm2, %%xmm1\n\t"
+		"psllq	$3, %%xmm0\n\t"				"pxor	%%xmm2, %%xmm2\n\t"
+		"pmovmskb %%xmm0, %%edx\n\t"			"psadbw %%xmm2, %%xmm1\n\t"
+		"movl	%%edx, %%ecx\n\t"			"pextrw	$4, %%xmm1, %%ebx\n\t"
+		"shrl	$9, %%ecx\n\t"				"shrl	$1, %%ebx\n\t"
+		"andl	$63, %%ecx\n\t"				"andl	$63, %%ebx\n\t"
+		"movzbl	"_"OUTFLANK_7(%%ecx), %%ecx\n\t"	"movzbl	"_"OUTFLANK_4(%%ebx), %%ebx\n\t"
+								"movd	%%xmm1, %%eax\n\t"
+		"andl	%%ecx, %%edx\n\t"			"andl	%%ebx, %%eax\n\t"
+		"movq	"_"FLIPPED_7_V(,%%edx,8), %%xmm0\n\t"	"movhps	"_"FLIPPED_4_H(,%%eax,8), %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1)
+	: "ebx", "ecx");
+#endif
+
+	outflank_h = OUTFLANK_4[(OH >> 25) & 0x3f] & (PH >> 24);
+	return flipped | (FLIPPED_4_H[outflank_h] & 0xff00000000000000);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square F8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_F8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d;
+	UINT64 flipped;
+
+	outflank_v = (((((OL & 0x20202000u) >> 1) + ((OH & 0x00202020u) >> 5)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x20202020u) >> 1) + ((PH & 0x00002020u) >> 5)) * 0x08040201u) >> 24;
+	flipped = ULL(((outflank_v * 0x003f1f0fu) >> 2) & 0x00202020u, (outflank_v * 0x01c0c040u) & 0x20202000u);
+
+	outflank_h = OUTFLANK_5[(OH >> 25) & 0x3f] & (PH >> 24);
+	flipped |= FLIPPED_5_H[outflank_h] & 0xff00000000000000;
+
+	outflank_d = OUTFLANK_5[(((OH & 0x20500804u) + (OL & 0x02000000u)) * 0x01010101u) >> 25]
+		& ((((PH & 0x20508804u) + (PL & 0x02010000u)) * 0x01010101u) >> 24);
+	flipped |= FLIPPED_5_H[outflank_d] & 0x2050080402000000;	// A3F8H6
+
+	return flipped;
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_F8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0020202020202020, 0x0010080402010000 }};
+	UINT64 flipped;
+	unsigned int outflank_h, FH;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+	__m128i	outflank_vd, flipped_vd;
+
+	outflank_vd = _mm_and_si128(_mm_slli_epi64(MS1B_epi52(_mm_srli_epi64(_mm_andnot_si128(OO, mask1.v2), 4)), 4), PP);
+	flipped_vd = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_vd, _mm_shuffle_epi32(flipped_vd, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%2, %%xmm3\n\t"				"movd	%4, %%xmm2\n\t"
+		"movd	%1, %%xmm1\n\t"				"movd	%3, %%xmm0\n\t"
+		"punpckldq %%xmm3, %%xmm1\n\t"			"punpckldq %%xmm2, %%xmm0\n\t"
+		"movapd	%6, %%xmm2\n\t"
+		"punpcklqdq %%xmm1, %%xmm1\n\t"			"punpcklqdq %%xmm0, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"
+		"psrlq	$4, %%xmm0\n\t"
+		"orpd	%%xmm2, %%xmm0\n\t"
+		"subpd	%%xmm2, %%xmm0\n\t"
+		"andpd	%7, %%xmm0\n\t"
+		"addpd	%%xmm2, %%xmm0\n\t"
+		"psllq	$4, %%xmm0\n\t"
+		"pand	%%xmm0, %%xmm1\n\t"
+		"pxor	%%xmm0, %%xmm0\n\t"
+		"paddq	%%xmm1, %%xmm1\n\t"
+		"psubq	%%xmm1, %%xmm0\n\t"
+		"pand	%5, %%xmm0\n\t"
+		"pshufd	$78, %%xmm0, %%xmm1\n\t"
+		"por	%%xmm1, %%xmm0\n\t"
+		"pshufd	$177, %%xmm0, %%xmm1\n\t"
+		"movd	%%xmm0, %%eax\n\t"
+		"movd	%%xmm1, %%edx\n\t"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (k1e52), "m" (expmask));
+#endif
+
+	outflank_h = OUTFLANK_5[(OH >> 25) & 0x3f] & (PH >> 24);
+	FH = ((unsigned char) FLIPPED_5_H[outflank_h] << 24)
+		| (OH & (PH << 7) & 0x00400000u);
+	return flipped | ((UINT64) FH << 32);
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square G8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_G8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d9, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x40404000u) >> 2) + ((OH & 0x00404040u) >> 6)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x40404040u) >> 2) + ((PH & 0x00004040u) >> 6)) * 0x08040201u) >> 24;
+	flippedH = ((outflank_v * 0x003f1f0fu) >> 1) & 0x00404040u;
+	flippedL = (outflank_v * 0x03818080u) & 0x40404000u;
+
+	outflank_h = OUTFLANK_7[(OH >> 24) & 0x3e] & (PH >> 23);
+	flippedH |= ((-outflank_h) & 0x3e) << 24;
+
+	outflank_d9 = OUTFLANK_7[(((OL & 0x04020000u) + (OH & 0x00201008u)) * 0x01010101u) >> 24]
+		& ((((PL & 0x04020100u) + (PH & 0x00001008u)) * 0x01010101u) >> 23);
+	flippedH |= (outflank_d9 * 0x001f0f07u) & 0x00201008u;
+	flippedL |= (outflank_d9 * 0x03010000u) & 0x04020000u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_G8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0040404040404040, 0x0020100804020100 }};
+	static const V2DI mask2 = {{ 0x3f00000000000000, 0 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i outflank_vd, outflank_h, flipped_v2;
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+
+	outflank_vd = _mm_and_si128(_mm_slli_epi64(MS1B_epi52(_mm_srli_epi64(_mm_andnot_si128(OO, mask1.v2), 4)), 4), PP);
+	flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask2.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minuseight.v2), 2));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+#else
+	__asm__(
+		"movd	%2, %%xmm0\n\t"		"movd	%3, %%xmm2\n\t"
+		"movd	%1, %%xmm1\n\t"		"movd	%4, %%xmm3\n\t"
+		"punpckldq %%xmm0, %%xmm1\n\t"	"punpckldq %%xmm3, %%xmm2\n\t"
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm2, %%xmm2\n\t"
+		"movapd	%9, %%xmm3\n\t"		"movdqa	%%xmm2, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"		"pandn	%6, %%xmm2\n\t"
+		"psrlq	$4, %%xmm0\n\t"
+		"orpd	%%xmm3, %%xmm0\n\t"
+		"subpd	%%xmm3, %%xmm0\n\t"	"cvtdq2pd %%xmm2, %%xmm2\n\t"
+		"andpd	%7, %%xmm0\n\t"		"andpd	%7, %%xmm2\n\t"
+		"addpd	%%xmm3, %%xmm0\n\t"	"cvtpd2dq %%xmm2, %%xmm2\n\t"
+		"psllq	$4, %%xmm0\n\t"
+		"pand	%%xmm1, %%xmm0\n\t"
+		"pxor	%%xmm3, %%xmm3\n\t"
+		"paddq	%%xmm0, %%xmm0\n\t"
+		"psubq	%%xmm0, %%xmm3\n\t"	"pand	%%xmm2, %%xmm1\n\t"
+		"movdqa	%5, %%xmm0\n\t"		"pmullw	%8, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"	"psrlw	$2, %%xmm1\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$78, %%xmm1, %%xmm0\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"
+		"movd	%%xmm1, %%eax\n\t"
+		"movd	%%xmm0, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minuseight), "m" (k1e52));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute flipped discs when playing on square H8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+#ifndef hasSSE2
+static UINT64 flip_H8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	unsigned int outflank_h, outflank_v, outflank_d9, flippedH, flippedL;
+
+	outflank_v = (((((OL & 0x80808000u) >> 3) + ((OH & 0x00808080u) >> 7)) * 0x08040201u + 0x02000000u)
+		& (((PL & 0x80808080u) >> 3) + ((PH & 0x00008080u) >> 7)) * 0x08040201u) >> 24;
+	flippedH = (outflank_v * 0x003f1f0fu) & 0x00808080u;
+	flippedL = (outflank_v * 0x07030100u) & 0x80808000u;
+
+	outflank_h = OUTFLANK_7[(OH >> 25) & 0x3f] & (PH >> 24);
+	flippedH |= ((-outflank_h) & 0x3f) << 25;
+
+	outflank_d9 = OUTFLANK_7[(((OL & 0x08040200u) + (OH & 0x00402010u)) * 0x01010101u) >> 25]
+		& ((((PL & 0x08040201u) + (PH & 0x00002010u)) * 0x01010101u) >> 24);
+	flippedH |= (outflank_d9 * 0x007e3e1eu) & 0x00402010u;
+	flippedL |= (outflank_d9 * 0x0e060200u) & 0x08040200u;
+
+	return ULL(flippedH, flippedL);
+}
+#endif
+#if defined(hasSSE2) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86)
+static UINT64 flip_sse_H8(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	static const V2DI mask1 = {{ 0x0080808080808080, 0x0040201008040201 }};
+	static const V2DI mask2 = {{ 0x7f00000000000000, 0 }};
+	static const V2DI mulk1 = {{ 0x0001000100010001, 0x0001000100100010 }};
+	static const V2DI mulk2 = {{ 0x0010001000100010, 0x0010001000010001 }};
+	UINT64 flipped;
+#if defined(hasSSE2) || defined (USE_MSVC_X86)
+	__m128i	outflank_vd, outflank_h, flipped_v2;
+	__m128i PP = set1_by_movd(PL, PH);
+	__m128i OO = set1_by_movd(OL, OH);
+
+	outflank_vd = _mm_srli_epi64(_mm_mullo_epi16(_mm_andnot_si128(OO, mask1.v2), mulk1.v2), 4);
+	outflank_vd = _mm_and_si128(_mm_mullo_epi16(MS1B_epi52(outflank_vd), mulk2.v2), PP);
+	flipped_v2 = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask1.v2);
+
+	outflank_h = _mm_and_si128(MS1B_epi32(_mm_andnot_si128(OO, mask2.v2)), PP);
+	flipped_v2 = _mm_or_si128(flipped_v2, _mm_srli_epi16(_mm_mullo_epi16(outflank_h, minusfour.v2), 1));
+
+	flipped = _mm_cvtsi128_si64(_mm_or_si128(flipped_v2, _mm_shuffle_epi32(flipped_v2, SWAP64)));
+
+#else
+	__asm__(
+		"movd	%2, %%xmm0\n\t"		"movd	%3, %%xmm2\n\t"
+		"movd	%1, %%xmm1\n\t"		"movd	%4, %%xmm3\n\t"
+		"punpckldq %%xmm0, %%xmm1\n\t"	"punpckldq %%xmm3, %%xmm2\n\t"
+		"punpcklqdq %%xmm1, %%xmm1\n\t"	"punpcklqdq %%xmm2, %%xmm2\n\t"
+		"movapd	%9, %%xmm3\n\t"		"movdqa	%%xmm2, %%xmm0\n\t"
+		"pandn	%5, %%xmm0\n\t"		"pandn	%6, %%xmm2\n\t"
+		"pmullw	%10, %%xmm0\n\t"
+		"psrlq	$4, %%xmm0\n\t"
+		"orpd	%%xmm3, %%xmm0\n\t"
+		"subpd	%%xmm3, %%xmm0\n\t"	"cvtdq2pd %%xmm2, %%xmm2\n\t"
+		"andpd	%7, %%xmm0\n\t"		"andpd	%7, %%xmm2\n\t"
+		"addpd	%%xmm3, %%xmm0\n\t"	"cvtpd2dq %%xmm2, %%xmm2\n\t"
+		"pmullw	%11, %%xmm0\n\t"
+		"pand	%%xmm1, %%xmm0\n\t"
+		"pxor	%%xmm3, %%xmm3\n\t"
+		"paddq	%%xmm0, %%xmm0\n\t"
+		"psubq	%%xmm0, %%xmm3\n\t"	"pand	%%xmm2, %%xmm1\n\t"
+		"movdqa	%5, %%xmm0\n\t"		"pmullw	%8, %%xmm1\n\t"
+		"pand	%%xmm3, %%xmm0\n\t"	"psrlw	$1, %%xmm1\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$78, %%xmm1, %%xmm0\n\t"
+		"por	%%xmm0, %%xmm1\n\t"
+		"pshufd	$177, %%xmm1, %%xmm0\n\t"
+		"movd	%%xmm1, %%eax\n\t"
+		"movd	%%xmm0, %%edx"
+	: "=A" (flipped)
+	: "m" (PL), "m" (PH), "m" (OL), "m" (OH), "m" (mask1), "m" (mask2), "m" (expmask), "m" (minusfour), "m" (k1e52), "m" (mulk1), "m" (mulk2));
+#endif
+	return flipped;
+}
+#endif
+
+/**
+ * Compute (zero-) flipped discs when plassing.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static UINT64 flip_pass(unsigned int PL, unsigned int PH, unsigned int OL, unsigned int OH)
+{
+	(void) PL; // useless code to shut-up compiler warning
+	(void) PH;
+	(void) OL;
+	(void) OH;
+	return 0;
+}
+
+
+/** Array of functions to compute flipped discs */
+UINT64 (*flip[])(unsigned int, unsigned int, unsigned int, unsigned int) = {
+#ifdef hasSSE2
+	flip_sse_A1, flip_sse_B1, flip_sse_C1, flip_sse_D1, flip_sse_E1, flip_sse_F1, flip_sse_G1, flip_sse_H1,
+	flip_sse_A2, flip_sse_B2, flip_sse_C2, flip_sse_D2, flip_sse_E2, flip_sse_F2, flip_sse_G2, flip_sse_H2,
+	flip_sse_A3, flip_sse_B3, flip_sse_C3, flip_sse_D3, flip_sse_E3, flip_sse_F3, flip_sse_G3, flip_sse_H3,
+	flip_sse_A4, flip_sse_B4, flip_sse_C4, flip_sse_D4, flip_sse_E4, flip_sse_F4, flip_sse_G4, flip_sse_H4,
+	flip_sse_A5, flip_sse_B5, flip_sse_C5, flip_sse_D5, flip_sse_E5, flip_sse_F5, flip_sse_G5, flip_sse_H5,
+	flip_sse_A6, flip_sse_B6, flip_sse_C6, flip_sse_D6, flip_sse_E6, flip_sse_F6, flip_sse_G6, flip_sse_H6,
+	flip_sse_A7, flip_sse_B7, flip_sse_C7, flip_sse_D7, flip_sse_E7, flip_sse_F7, flip_sse_G7, flip_sse_H7,
+	flip_sse_A8, flip_sse_B8, flip_sse_C8, flip_sse_D8, flip_sse_E8, flip_sse_F8, flip_sse_G8, flip_sse_H8,
+#else
+	flip_A1, flip_B1, flip_C1, flip_D1, flip_E1, flip_F1, flip_G1, flip_H1,
+	flip_A2, flip_B2, flip_C2, flip_D2, flip_E2, flip_F2, flip_G2, flip_H2,
+	flip_A3, flip_B3, flip_C3, flip_D3, flip_E3, flip_F3, flip_G3, flip_H3,
+	flip_A4, flip_B4, flip_C4, flip_D4, flip_E4, flip_F4, flip_G4, flip_H4,
+	flip_A5, flip_B5, flip_C5, flip_D5, flip_E5, flip_F5, flip_G5, flip_H5,
+	flip_A6, flip_B6, flip_C6, flip_D6, flip_E6, flip_F6, flip_G6, flip_H6,
+	flip_A7, flip_B7, flip_C7, flip_D7, flip_E7, flip_F7, flip_G7, flip_H7,
+	flip_A8, flip_B8, flip_C8, flip_D8, flip_E8, flip_F8, flip_G8, flip_H8,
+#endif
+	flip_pass, flip_pass
+};
+
+#ifdef __TURBOC__	// entry from Delphi code
+UINT64 flip32(unsigned int pos, unsigned int bb[]) {
+	return (*flip[pos])(bb[0], bb[1], bb[2], bb[3]);
+}
+#endif
+
+#if !defined(hasSSE2) && (defined(USE_GAS_MMX) || defined(USE_MSVC_X86))
+
+static UINT64 (*flip_sse[])(unsigned int, unsigned int, unsigned int, unsigned int) = {
+	flip_sse_A1, flip_sse_B1, flip_sse_C1, flip_sse_D1, flip_sse_E1, flip_sse_F1, flip_sse_G1, flip_sse_H1,
+	flip_sse_A2, flip_sse_B2, flip_sse_C2, flip_sse_D2, flip_sse_E2, flip_sse_F2, flip_sse_G2, flip_sse_H2,
+	flip_sse_A3, flip_sse_B3, flip_sse_C3, flip_sse_D3, flip_sse_E3, flip_sse_F3, flip_sse_G3, flip_sse_H3,
+	flip_sse_A4, flip_sse_B4, flip_sse_C4, flip_sse_D4, flip_sse_E4, flip_sse_F4, flip_sse_G4, flip_sse_H4,
+	flip_sse_A5, flip_sse_B5, flip_sse_C5, flip_sse_D5, flip_sse_E5, flip_sse_F5, flip_sse_G5, flip_sse_H5,
+	flip_sse_A6, flip_sse_B6, flip_sse_C6, flip_sse_D6, flip_sse_E6, flip_sse_F6, flip_sse_G6, flip_sse_H6,
+	flip_sse_A7, flip_sse_B7, flip_sse_C7, flip_sse_D7, flip_sse_E7, flip_sse_F7, flip_sse_G7, flip_sse_H7,
+	flip_sse_A8, flip_sse_B8, flip_sse_C8, flip_sse_D8, flip_sse_E8, flip_sse_F8, flip_sse_G8, flip_sse_H8
+};
+
+void init_flip_sse(void) {
+	memcpy(&flip[0], flip_sse, sizeof(flip_sse));
+}
+#endif
+
+#ifdef USE_GAS_MMX
+#undef	_
+#endif
diff --git a/src/flip_neon_bitscan.c b/src/flip_neon_bitscan.c
new file mode 100644
index 00000000..7e2f0190
--- /dev/null
+++ b/src/flip_neon_bitscan.c
@@ -0,0 +1,1932 @@
+/**
+ * @file flip_neon_bitscan.c
+ *
+ * This module deals with flipping discs.
+ *
+ * A function is provided for each square of the board. These functions are
+ * gathered into an array of functions, so that a fast access to each function
+ * is allowed. The generic form of the function take as input the player and
+ * the opponent bitboards and return the flipped squares into a bitboard.
+ *
+ * Given the following notation:
+ *  - x = square where we play,
+ *  - P = player's disc pattern,
+ *  - O = opponent's disc pattern,
+ * the basic principle is to read into an array the result of a move. Doing
+ * this is easier for a single line ; so we can use arrays of the form:
+ *  - ARRAY[x][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by a simple
+ * multiplication and to right-shift the result to scale it into a number
+ * between 0 and 255.
+ * Once we get our 8-bits disc patterns, a first array (OUTFLANK) is used to
+ * get the player's discs that surround the opponent discs:
+ *  - outflank = OUTFLANK[x][O] & P
+ * Because neighbor-of-x bits in the P are not in interest here, outflank
+ * is stored in bitwise rotated form to reduce the table size.
+ * The result is then used as an index to access a second array giving the
+ * flipped discs according to the surrounding player's discs:
+ *  - flipped = FLIPPED[x][outflank].
+ * (Flipped discs fall into inner 6-bits.)
+ * Finally, a precomputed array transform the inner 6-bits disc pattern back into a
+ * 64-bits disc pattern, and the flipped squares for each line are gathered and
+ * returned to generate moves.
+ *
+ * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
+ * (with Neon if appropriate) can be used to determine contiguous opponent discs.
+ * If the OUTFLANK search is in MSB to LSB direction, lzcnt64 is used.
+ *
+ * @date 1998 - 2022
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "bit_intrinsics.h"
+
+// included from board.c or linked in Android Arm32 dispatch build
+#if defined(flip_neon) || defined(DISPATCH_NEON)
+
+/** rotated outflank array (indexed with inner 6 bits) */
+static const unsigned char OUTFLANK_3[64] = {	// ...bahgf
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x12, 0x0a, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x14, 0x0c, 0x00, 0x00, 0x00, 0x00
+};
+
+static const unsigned char OUTFLANK_4[64] = {	// ...cbahg
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x01, 0x01, 0x01, 0x11, 0x11, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x02, 0x02, 0x02, 0x02, 0x12, 0x12, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/** flip array (indexed with rotated outflank) */
+static const unsigned long long FLIPPED_3_H[21] = {	// ...bahgf
+	0x0000000000000000, 0x1010101010101010, 0x3030303030303030, 0x0000000000000000,
+	0x7070707070707070, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0606060606060606, 0x1616161616161616, 0x3636363636363636, 0x0000000000000000,
+	0x7676767676767676, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0404040404040404, 0x1414141414141414, 0x3434343434343434, 0x0000000000000000,
+	0x7474747474747474
+};
+
+static const unsigned long long FLIPPED_4_H[19] = {	// ...cbahg
+	0x0000000000000000, 0x2020202020202020, 0x6060606060606060, 0x0000000000000000,
+	0x0e0e0e0e0e0e0e0e, 0x2e2e2e2e2e2e2e2e, 0x6e6e6e6e6e6e6e6e, 0x0000000000000000,
+	0x0c0c0c0c0c0c0c0c, 0x2c2c2c2c2c2c2c2c, 0x6c6c6c6c6c6c6c6c, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0808080808080808, 0x2828282828282828, 0x6868686868686868
+};
+
+
+/*
+ * Set all bits below the sole outflank bit if outfrank != 0
+ */
+#if __has_builtin(__builtin_subcll)
+static inline unsigned long long OutflankToFlipmask(unsigned long long outflank) {
+	unsigned long long flipmask, cy;
+	flipmask = __builtin_subcll(outflank, 1, 0, &cy);
+	return __builtin_addcll(flipmask, 0, cy, &cy);
+}
+#else
+	#define OutflankToFlipmask(outflank)	((outflank) - (unsigned int) ((outflank) != 0))
+#endif
+
+// Strictly, (long long) >> 64 is undefined in C, but either 0 bit (no change)
+// or 64 bit (zero out) shift will lead valid result (i.e. flipped == 0).
+#define	outflank_right(O,maskr)	(0x8000000000000000ULL >> lzcnt_u64(~(O) & (maskr)))
+
+// in case continuous from MSB
+#define	outflank_right_H(O)	(0x80000000u >> lzcnt_u32(~(O)))
+
+
+#ifdef __clang__	// poor optimization for vbicq(const,x) (ndk-r15)
+#define not_O_in_mask(mask,O)	vandq_u64((mask), vdupq_n_u64(~(O)))
+#else
+#define not_O_in_mask(mask,O)	vbicq_u64((mask), vdupq_n_u64(O))
+#endif
+
+/**
+ * Compute flipped discs when playing on square A1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A1(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0101010101010100, 0x8040201008040200 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = (unsigned char) (O + 0x02) & P;
+	flipped_h = outflank_h - ((unsigned int) (outflank_h != 0) << 1);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square B1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B1(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0202020202020200, 0x0080402010080400 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = (unsigned char) (O + 0x04) & P;
+	flipped_h = outflank_h - ((unsigned int) (outflank_h != 0) << 2);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square C1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C1(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0404040404040400, 0x0000804020100800 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = (unsigned char) (O + 0x08) & P;
+	flipped_h = outflank_h - ((unsigned int) (outflank_h != 0) << 3);
+
+	flipped_h |= ((((unsigned int) P << 1) & 0x00000002) | (((unsigned int) P >> 7) & 0x00000200)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square D1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D1(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = ~O & 0x0808080808080800;
+	outflank_v = (outflank_v & -outflank_v) & 0x0808080808080800 & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080800;
+
+	outflank_d = OUTFLANK_3[(((unsigned int) O & 0x40221408) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000008041221408) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000000040221408;	// A4D1H5
+
+	outflank_h = OUTFLANK_3[(O >> 1) & 0x3f] & rotl8(P, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square E1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E1(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = ~O & 0x1010101010101000;
+	outflank_v = (outflank_v & -outflank_v) & 0x1010101010101000 & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010101000;
+
+	outflank_d = OUTFLANK_4[(((unsigned int) O & 0x02442810) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000000182442810) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000002442810;	// A5E1H4
+
+	outflank_h = OUTFLANK_4[(O >> 1) & 0x3f] & rotl8(P, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square F1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F1(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x2020202020202000, 0x0000010204081000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped = vandq_u64(vqsubq_u64(outflank_vd, one), mask);
+
+	outflank_h = outflank_right_H((unsigned int) O << 27) & ((unsigned int) P << 27);
+	flipped_h = (outflank_h * (unsigned int) -2) >> 27;
+
+	flipped_h |= ((((unsigned int) P >> 1) & 0x00000040) | (((unsigned int) P >> 9) & 0x00004000)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square G1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G1(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x4040404040404000, 0x0001020408102000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped = vandq_u64(vqsubq_u64(outflank_vd, one), mask);
+
+	outflank_h = outflank_right_H((unsigned int) O << 26) & ((unsigned int) P << 26);
+	flipped_h = (outflank_h * (unsigned int) -2) >> 26;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square H1.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H1(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x8080808080808000, 0x0102040810204000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped = vandq_u64(vqsubq_u64(outflank_vd, one), mask);
+
+	outflank_h = outflank_right_H((unsigned int) O << 25) & ((unsigned int) P << 25);
+	flipped_h = (outflank_h * (unsigned int) -2) >> 25;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square A2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A2(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0101010101010000, 0x4020100804020000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = (unsigned short) (O + 0x0200) & P;
+	flipped_h = (outflank_h - (outflank_h >> 8)) & 0x7e00;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square B2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B2(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0202020202020000, 0x8040201008040000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = (unsigned short) (O + 0x0400) & P;
+	flipped_h = (outflank_h - (outflank_h >> 8)) & 0x7c00;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square C2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C2(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0404040404040000, 0x0080402010080000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = (unsigned short) (O + 0x0800) & P;
+	flipped_h = (outflank_h - (outflank_h >> 8)) & 0x7800;
+
+	flipped_h |= ((((unsigned int) P << 1) & 0x00000200) | (((unsigned int) P >> 7) & 0x00020000)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square D2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D2(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = ~O & 0x0808080808080000;
+	outflank_v = (outflank_v & -outflank_v) & 0x0808080808080000 & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808080000;
+
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 8) & 0x40221408) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000804122140800) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000004022140800;	// A5D2H6
+
+	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & rotl8(P >> 8, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h] << 8;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square E2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E2(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = ~O & 0x1010101010100000;
+	outflank_v = (outflank_v & -outflank_v) & 0x1010101010100000 & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010100000;
+
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 8) & 0x02442810) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000018244281000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000000244281000;	// A6E2H5
+
+	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & rotl8(P >> 8, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h] << 8;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square F2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F2(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x2020202020200000, 0x0001020408100000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped = vandq_u64(vqsubq_u64(outflank_vd, one), mask);
+
+	outflank_h = outflank_right_H(((unsigned int) O >> 9) << 28) & ((unsigned int) P << 19);
+	flipped_h = (outflank_h * (unsigned int) -2) >> 19;
+
+	flipped_h |= ((((unsigned int) P >> 1) & 0x00004000) | (((unsigned int) P >> 9) & 0x00400000)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square G2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G2(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x4040404040400000, 0x0102040810200000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped = vandq_u64(vqsubq_u64(outflank_vd, one), mask);
+
+	outflank_h = outflank_right_H(((unsigned int) O >> 9) << 27) & ((unsigned int) P << 18);
+	flipped_h = (outflank_h * (unsigned int) -2) >> 18;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square H2.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H2(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x8080808080800000, 0x0204081020400000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped = vandq_u64(vqsubq_u64(outflank_vd, one), mask);
+
+	outflank_h = outflank_right_H(((unsigned int) O >> 9) << 26) & ((unsigned int) P << 17);
+	flipped_h = (outflank_h * (unsigned int) -2) >> 17;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square A3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A3(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0101010101000000, 0x2010080402000000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = ((O & 0x007e0000) + 0x00020000) & P;
+	flipped_h = (outflank_h - (outflank_h >> 8)) & 0x007e0000;
+
+	flipped_h |= ((((unsigned int) P << 8) & 0x00000100) | (((unsigned int) P << 7) & 0x00000200)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square B3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B3(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t outflank_vd, flipped_vd;
+	const uint64x2_t mask = { 0x0202020202000000, 0x4020100804000000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+
+	outflank_vd = not_O_in_mask(mask, O);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), vdupq_n_u64(P));
+	flipped_vd = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = ((O & 0x007c0000) + 0x00040000) & P;
+	flipped_h = (outflank_h - (outflank_h >> 8)) & 0x007c0000;
+
+	flipped_h |= ((((unsigned int) P << 8) & 0x00000200) | (((unsigned int) P << 7) & 0x00000400)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped_vd), vget_high_u64(flipped_vd)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square C3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C3(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint64x2_t OO = vdupq_n_u64(O);
+	uint64x2_t outflank_vd, flipped;
+	const uint64x2_t mask = { 0x0404040404000000, 0x8040201008000000 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned int outflank_h, flipped_h;
+	// uint32x4_t PL = vtrnq_u32(vreinterpretq_u32_u64(PP), vreinterpretq_u32_u64(PP)).val[0];
+	// const int32x4_t shiftL = { 1, 7, 8, 9 };
+	// const uint32x4_t maskL = { 0x00020000, 0x00000800, 0x00000400, 0x00000200 };
+
+	outflank_vd = vbicq_u64(mask, OO);
+	outflank_vd = vandq_u64(vbicq_u64(outflank_vd, vsubq_u64(outflank_vd, one)), PP);
+	flipped = vandq_u64(mask, vqsubq_u64(outflank_vd, one));
+
+	outflank_h = ((O & 0x00780000) + 0x00080000) & P;
+	flipped_h = (outflank_h - (outflank_h >> 8)) & 0x00780000;
+#if 1
+	flipped_h |= (((P << 9) & 0x00000200) | ((P << 8) & 0x00000400) | ((P << 1) & 0x00020000)
+		| (((P >> 7) | (P << 7)) & 0x02000800)) & O;
+#else
+	flipped = vbslq_u64(vpaddlq_u32(vandq_u32(vshlq_u32(PL, shiftL), maskL)), OO, flipped);
+	flipped_h |= (P >> 7) & 0x02000000 & O;
+#endif
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_h;
+}
+
+/**
+ * Compute flipped discs when playing on square D3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D3(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = ~O & 0x0808080808000000;
+	outflank_v = (outflank_v & -outflank_v) & 0x0808080808000000 & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x0808080808000000;
+
+	outflank_h = OUTFLANK_3[(O >> 17) & 0x3f] & rotl8(P >> 16, 3);
+	flipped |= (unsigned char) FLIPPED_3_H[outflank_h] << 16;
+
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 16) & 0x40221408) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0080412214080000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000402214080000;	// A6D3H7
+
+	flipped |= (((P << 7) & 0x0000000000001000) | ((P << 8) & 0x000000000000800) | ((P << 9) & 0x000000000000400)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square E3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E3(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = ~O & 0x1010101010000000;
+	outflank_v = (outflank_v & -outflank_v) & 0x1010101010000000 & P;
+	flipped = OutflankToFlipmask(outflank_v) & 0x1010101010000000;
+
+	outflank_h = OUTFLANK_4[(O >> 17) & 0x3f] & rotl8(P >> 16, 2);
+	flipped |= (unsigned char) FLIPPED_4_H[outflank_h] << 16;
+
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 16) & 0x02442810) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0001824428100000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000024428100000;	// A7E3H6
+
+	flipped |= (((P << 7) & 0x0000000000002000) | ((P << 8) & 0x000000000001000) | ((P << 9) & 0x000000000000800)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square F3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F3(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint64x2_t OO = vdupq_n_u64(O);
+	uint32x4_t PL = vtrnq_u32(vreinterpretq_u32_u64(PP), vreinterpretq_u32_u64(PP)).val[0];
+	uint32x4_t OL = vtrnq_u32(vreinterpretq_u32_u64(OO), vreinterpretq_u32_u64(OO)).val[0];
+	uint32x4_t outflankL;
+	uint64x2_t outflankH, flipped;
+	const uint64x2_t maskL = { 0x001f000000002020, 0x0000408000001008 };
+	const uint64x2_t maskH = { 0x2020202020000000, 0x0102040810000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+	unsigned long long flipped_g3g4;
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flipped = vpaddlq_u32(vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL))))));
+
+	outflankH = vbicq_u64(maskH, OO);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	flipped_g3g4 = (((P >> 9) & 0x0000000040000000) | ((P >> 1) & 0x000000000400000)) & O;
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0) | flipped_g3g4;
+}
+
+/**
+ * Compute flipped discs when playing on square G3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G3(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint64x2_t OO = vdupq_n_u64(O);
+	uint32x4_t PL = vtrnq_u32(vreinterpretq_u32_u64(PP), vreinterpretq_u32_u64(PP)).val[0];
+	uint32x4_t OL = vtrnq_u32(vreinterpretq_u32_u64(OO), vreinterpretq_u32_u64(OO)).val[0];
+	uint32x4_t outflankL;
+	uint64x2_t outflankH, flipped;
+	const uint64x2_t maskL = { 0x003f000000004040, 0x0000000000002010 };
+	const uint64x2_t maskH = { 0x4040404040000000, 0x0204081020000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flipped = vpaddlq_u32(vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL))))));
+
+	outflankH = vbicq_u64(maskH, OO);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square H3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H3(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint64x2_t OO = vdupq_n_u64(O);
+	uint32x4_t PL = vtrnq_u32(vreinterpretq_u32_u64(PP), vreinterpretq_u32_u64(PP)).val[0];
+	uint32x4_t OL = vtrnq_u32(vreinterpretq_u32_u64(OO), vreinterpretq_u32_u64(OO)).val[0];
+	uint32x4_t outflankL;
+	uint64x2_t outflankH, flipped;
+	const uint64x2_t maskL = { 0x007f000000008080, 0x0000000000004020 };
+	const uint64x2_t maskH = { 0x8080808080000000, 0x0408102040000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flipped = vpaddlq_u32(vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL))))));
+
+	outflankH = vbicq_u64(maskH, OO);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square A4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A4(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint64x2_t flipped;
+	uint32x4_t outflankL, outflankH;
+	const uint64x2_t maskL = { 0x0000000000010101, 0x0000000000020408 };
+	const uint64x2_t maskH = { 0x01010101fe000000, 0x1008040200000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OO)))));
+	outflankL = vandq_u32(outflankL, PP);
+	flipped = vandq_u64(maskL, vreinterpretq_u64_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OO);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vreinterpretq_u64_u32(vqsubq_u32(outflankH, one)), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square B4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B4(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint64x2_t flipped;
+	uint32x4_t outflankL, outflankH;
+	const uint64x2_t maskL = { 0x0000000000020202, 0x0000000000040810 };
+	const uint64x2_t maskH = { 0x02020202fc000000, 0x2010080400000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OO)))));
+	outflankL = vandq_u32(outflankL, PP);
+	flipped = vandq_u64(maskL, vreinterpretq_u64_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OO);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vreinterpretq_u64_u32(vqsubq_u32(outflankH, one)), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square C4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C4(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PH = vsetq_lane_u32(vgetq_lane_u32(PP, 1), PP, 2);	// HHHL
+	uint32x4_t OH = vsetq_lane_u32(vgetq_lane_u32(OO, 1), OO, 2);
+	uint32x4_t outflankL, outflankH, flippedL4, flippedH;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x0004040403000000, 0x0008102000020100 };
+	const uint64x2_t maskH = { 0x04040404f8000000, 0x0000010240201008 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), vtrnq_u32(OO, OO).val[0])))));
+	outflankL = vandq_u32(outflankL, vtrnq_u32(PP, PP).val[0]);
+	flippedL4 = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OH);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PH);
+	flippedH = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vorr_u32(vget_low_u32(flippedL4), vget_high_u32(flippedL4)), vget_high_u32(flippedH));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedH)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square D4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D4(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PH = vsetq_lane_u32(vgetq_lane_u32(PP, 1), PP, 2);	// HHHL
+	uint32x4_t OH = vsetq_lane_u32(vgetq_lane_u32(OO, 1), OO, 2);
+	uint32x4_t outflankL, outflankH, flippedL4, flippedH;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x0008080807000000, 0x0010204000040201 };
+	const uint64x2_t maskH = { 0x08080808f0000000, 0x0001020480402010 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), vtrnq_u32(OO, OO).val[0])))));
+	outflankL = vandq_u32(outflankL, vtrnq_u32(PP, PP).val[0]);
+	flippedL4 = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OH);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PH);
+	flippedH = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vorr_u32(vget_low_u32(flippedL4), vget_high_u32(flippedL4)), vget_high_u32(flippedH));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedH)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square E3.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E4(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PH = vsetq_lane_u32(vgetq_lane_u32(PP, 1), PP, 2);	// HHHL
+	uint32x4_t OH = vsetq_lane_u32(vgetq_lane_u32(OO, 1), OO, 2);
+	uint32x4_t outflankL, outflankH, flippedL4, flippedH;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x001010100f000000, 0x0020408000080402 };
+	const uint64x2_t maskH = { 0x10101010e0000000, 0x0102040800804020 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), vtrnq_u32(OO, OO).val[0])))));
+	outflankL = vandq_u32(outflankL, vtrnq_u32(PP, PP).val[0]);
+	flippedL4 = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OH);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PH);
+	flippedH = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vorr_u32(vget_low_u32(flippedL4), vget_high_u32(flippedL4)), vget_high_u32(flippedH));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedH)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square F4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F4(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PH = vsetq_lane_u32(vgetq_lane_u32(PP, 1), PP, 2);	// HHHL
+	uint32x4_t OH = vsetq_lane_u32(vgetq_lane_u32(OO, 1), OO, 2);
+	uint32x4_t outflankL, outflankH, flippedL4, flippedH;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x002020201f000000, 0x0040800000100804 };
+	const uint64x2_t maskH = { 0x20202020c0000000, 0x0204081000008040 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), vtrnq_u32(OO, OO).val[0])))));
+	outflankL = vandq_u32(outflankL, vtrnq_u32(PP, PP).val[0]);
+	flippedL4 = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OH);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PH);
+	flippedH = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vorr_u32(vget_low_u32(flippedL4), vget_high_u32(flippedL4)), vget_high_u32(flippedH));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedH)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square G4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G4(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint64x2_t OO = vdupq_n_u64(O);
+	uint32x4_t PL = vtrnq_u32(vreinterpretq_u32_u64(PP), vreinterpretq_u32_u64(PP)).val[0];
+	uint32x4_t OL = vtrnq_u32(vreinterpretq_u32_u64(OO), vreinterpretq_u32_u64(OO)).val[0];
+	uint32x4_t outflankL;
+	uint64x2_t outflankH, flipped;
+	const uint64x2_t maskL = { 0x3f00000000404040, 0x0000000000201008 };
+	const uint64x2_t maskH = { 0x4040404000000000, 0x0408102000000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flipped = vpaddlq_u32(vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL))))));
+
+	outflankH = vbicq_u64(maskH, OO);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square H4.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H4(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint64x2_t OO = vdupq_n_u64(O);
+	uint32x4_t PL = vtrnq_u32(vreinterpretq_u32_u64(PP), vreinterpretq_u32_u64(PP)).val[0];
+	uint32x4_t OL = vtrnq_u32(vreinterpretq_u32_u64(OO), vreinterpretq_u32_u64(OO)).val[0];
+	uint32x4_t outflankL;
+	uint64x2_t outflankH, flipped;
+	const uint64x2_t maskL = { 0x7f00000000808080, 0x0000000000402010 };
+	const uint64x2_t maskH = { 0x8080808000000000, 0x0810204000000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flipped = vpaddlq_u32(vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL))))));
+
+	outflankH = vbicq_u64(maskH, OO);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square A5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A5(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PH = vtrnq_u32(PP, PP).val[1];
+	uint32x4_t OH = vtrnq_u32(OO, OO).val[1];
+	uint32x4_t outflankL, outflankH, flippedL, flippedH;
+	uint32x4x2_t flippedLH;
+	uint64x2_t flipped;
+	const uint64x2_t maskL = { 0x0000000001010101, 0x0000000002040810 };
+	const uint64x2_t maskH = { 0x01010100000000fe, 0x0804020000000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OO))))), PP);
+	flippedL = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OH);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PH);
+	flippedH = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrnq_u32(flippedL, flippedH);
+	flipped = vreinterpretq_u64_u32(vorrq_u32(flippedLH.val[0], flippedLH.val[1]));
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square B5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B5(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PH = vtrnq_u32(PP, PP).val[1];
+	uint32x4_t OH = vtrnq_u32(OO, OO).val[1];
+	uint32x4_t outflankL, outflankH, flippedL, flippedH;
+	uint32x4x2_t flippedLH;
+	uint64x2_t flipped;
+	const uint64x2_t maskL = { 0x0000000002020202, 0x0000000004081020 };
+	const uint64x2_t maskH = { 0x02020200000000fc, 0x1008040000000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OO))))), PP);
+	flippedL = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), OH);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), PH);
+	flippedH = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrnq_u32(flippedL, flippedH);
+	flipped = vreinterpretq_u64_u32(vorrq_u32(flippedLH.val[0], flippedLH.val[1]));
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square C5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C5(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PL = vsetq_lane_u32(vgetq_lane_u32(PP, 0), PP, 3);	// LLHL
+	uint32x4_t OL = vsetq_lane_u32(vgetq_lane_u32(OO, 0), OO, 3);
+	uint32x4_t outflankL, outflankH, flippedH4, flippedL;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x0000000304040404, 0x0810204002010000 };
+	const uint64x2_t maskH = { 0x000000f804040400, 0x0001020020100800 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flippedL = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), vtrnq_u32(OO, OO).val[1]);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), vtrnq_u32(PP, PP).val[1]);
+	flippedH4 = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vget_high_u32(flippedL), vorr_u32(vget_low_u32(flippedH4), vget_high_u32(flippedH4)));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedL)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square D5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D5(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PL = vsetq_lane_u32(vgetq_lane_u32(PP, 0), PP, 3);	// LLHL
+	uint32x4_t OL = vsetq_lane_u32(vgetq_lane_u32(OO, 0), OO, 3);
+	uint32x4_t outflankL, outflankH, flippedH4, flippedL;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x0000000708080808, 0x1020408004020100 };
+	const uint64x2_t maskH = { 0x000000f008080800, 0x0102040040201000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flippedL = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), vtrnq_u32(OO, OO).val[1]);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), vtrnq_u32(PP, PP).val[1]);
+	flippedH4 = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vget_high_u32(flippedL), vorr_u32(vget_low_u32(flippedH4), vget_high_u32(flippedH4)));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedL)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square E5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E5(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PL = vsetq_lane_u32(vgetq_lane_u32(PP, 0), PP, 3);	// LLHL
+	uint32x4_t OL = vsetq_lane_u32(vgetq_lane_u32(OO, 0), OO, 3);
+	uint32x4_t outflankL, outflankH, flippedH4, flippedL;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x0000000f10101010, 0x2040800008040201 };
+	const uint64x2_t maskH = { 0x000000e010101000, 0x0204080080402000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flippedL = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), vtrnq_u32(OO, OO).val[1]);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), vtrnq_u32(PP, PP).val[1]);
+	flippedH4 = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vget_high_u32(flippedL), vorr_u32(vget_low_u32(flippedH4), vget_high_u32(flippedH4)));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedL)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square F5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F5(const unsigned long long P, const unsigned long long O)
+{
+	uint32x4_t PP = vreinterpretq_u32_u64(vdupq_n_u64(P));
+	uint32x4_t OO = vreinterpretq_u32_u64(vdupq_n_u64(O));
+	uint32x4_t PL = vsetq_lane_u32(vgetq_lane_u32(PP, 0), PP, 3);	// LLHL
+	uint32x4_t OL = vsetq_lane_u32(vgetq_lane_u32(OO, 0), OO, 3);
+	uint32x4_t outflankL, outflankH, flippedH4, flippedL;
+	uint32x2x2_t flippedLH;
+	uint64x1_t flipped;
+	const uint64x2_t maskL = { 0x0000001f20202020, 0x4080000010080402 };
+	const uint64x2_t maskH = { 0x000000c020202000, 0x0408100000804000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint32x4_t one = vdupq_n_u32(1);
+
+	outflankL = vandq_u32(vshlq_u32(msb, vnegq_s32(vreinterpretq_s32_u32(
+		vclzq_u32(vbicq_u32(vreinterpretq_u32_u64(maskL), OL))))), PL);
+	flippedL = vandq_u32(vreinterpretq_u32_u64(maskL), vreinterpretq_u32_s32(
+		vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = vbicq_u32(vreinterpretq_u32_u64(maskH), vtrnq_u32(OO, OO).val[1]);
+	outflankH = vandq_u32(vbicq_u32(outflankH, vsubq_u32(outflankH, one)), vtrnq_u32(PP, PP).val[1]);
+	flippedH4 = vandq_u32(vreinterpretq_u32_u64(maskH), vqsubq_u32(outflankH, one));
+
+	flippedLH = vtrn_u32(vget_high_u32(flippedL), vorr_u32(vget_low_u32(flippedH4), vget_high_u32(flippedH4)));
+	flipped = vreinterpret_u64_u32(vorr_u32(vorr_u32(flippedLH.val[0], flippedLH.val[1]), vget_low_u32(flippedL)));
+
+	return vget_lane_u64(flipped, 0);
+}
+
+/**
+ * Compute flipped discs when playing on square G5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G5(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint32x4_t outflankL;
+	uint64x2_t flipped, outflankH;
+	const uint64x2_t maskL = { 0x0000003f40404040, 0x0000000020100804 };
+	const uint64x2_t maskH = { 0x4040400000000000, 0x0810200000000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vclzq_s32(vreinterpretq_s32_u64(not_O_in_mask(maskL, O)))));
+	outflankL = vandq_u32(outflankL, vreinterpretq_u32_u64(PP));
+	flipped = vandq_u64(maskL, vreinterpretq_u64_s32(vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = not_O_in_mask(maskH, O);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square H5.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H5(const unsigned long long P, const unsigned long long O)
+{
+	uint64x2_t PP = vdupq_n_u64(P);
+	uint32x4_t outflankL;
+	uint64x2_t flipped, outflankH;
+	const uint64x2_t maskL = { 0x0000007f80808080, 0x0000000040201008 };
+	const uint64x2_t maskH = { 0x8080800000000000, 0x1020400000000000 };
+	const uint32x4_t msb = vdupq_n_u32(0x80000000);
+	const uint64x2_t one = vdupq_n_u64(1);
+
+	outflankL = vshlq_u32(msb, vnegq_s32(vclzq_s32(vreinterpretq_s32_u64(not_O_in_mask(maskL, O)))));
+	outflankL = vandq_u32(outflankL, vreinterpretq_u32_u64(PP));
+	flipped = vandq_u64(maskL, vreinterpretq_u64_s32(vnegq_s32(vreinterpretq_s32_u32(vaddq_u32(outflankL, outflankL)))));
+
+	outflankH = not_O_in_mask(maskH, O);
+	outflankH = vandq_u64(vbicq_u64(outflankH, vsubq_u64(outflankH, one)), PP);
+	flipped = vbslq_u64(maskH, vqsubq_u64(outflankH, one), flipped);
+
+	return vget_lane_u64(vorr_u64(vget_low_u64(flipped), vget_high_u64(flipped)), 0);
+}
+
+/**
+ * Compute flipped discs when playing on square A6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0000000101010101) & P;
+	flipped  = (outflank_v * -2) & 0x0000000101010101;
+
+	outflank_d7 = outflank_right(O, 0x0000000204081020) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000000204081020;
+
+	outflank_h = ((unsigned int) (O >> 16) + 0x02000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x00007e0000000000;
+
+	flipped |= (((P >> 8) & 0x0001000000000000) | ((P >> 9) & 0x0002000000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square B6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0000000202020202) & P;
+	flipped  = (outflank_v * -2) & 0x0000000202020202;
+
+	outflank_d7 = outflank_right(O, 0x0000000408102040) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000000408102040;
+
+	outflank_h = ((unsigned int) (O >> 16) + 0x04000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x00007c0000000000;
+
+	flipped |= (((P >> 8) & 0x0002000000000000) | ((P >> 9) & 0x0004000000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square C6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0000000404040404) & P;
+	flipped  = (outflank_v * -2) & 0x0000000404040404;
+
+	outflank_d7 = outflank_right(O, 0x0000000810204080) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000000810204080;
+
+	outflank_h = ((unsigned int) (O >> 16) + 0x08000000) & (unsigned int) (P >> 16);
+	flipped |= (((unsigned long long) outflank_h << 16) - outflank_h) & 0x0000780000000000;
+
+	flipped |= ((((P >> 9) | (P << 9)) & 0x0008000200000000) | ((P >> 8) & 0x0004000000000000)
+		| ((P >> 7) & 0x0002000000000000) | ((P << 1) & 0x0000020000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square D6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d;
+
+	outflank_v = outflank_right(O, 0x0000000808080808) & P;
+	flipped  = (outflank_v * -2) & 0x0000000808080808;
+
+	outflank_h = OUTFLANK_3[(O >> 41) & 0x3f] & rotl8(P >> 40, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 40;
+
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 16) & 0x08142240) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000081422418000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0000081422400000;	// A3D6H2
+
+	flipped |= (((P >> 9) & 0x0010000000000000) | ((P >> 8) & 0x0008000000000000) | ((P >> 7) & 0x0004000000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square E6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d;
+
+	outflank_v = outflank_right(O, 0x0000001010101010) & P;
+	flipped  = (outflank_v * -2) & 0x0000001010101010;
+
+	outflank_h = OUTFLANK_4[(O >> 41) & 0x3f] & rotl8(P >> 40, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 40;
+
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 16) & 0x10284402) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0000102844820100) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0000102844020000;	// A2E6H3
+
+	flipped |= (((P >> 9) & 0x0020000000000000) | ((P >> 8) & 0x0010000000000000) | ((P >> 7) & 0x0008000000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square F6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0000002020202020) & P;
+	flipped  = (outflank_v * -2) & 0x0000002020202020;
+
+	outflank_d9 = outflank_right(O, 0x0000001008040201) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000001008040201;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 41) << 28) & (unsigned int) (P >> 13);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 13;
+
+	flipped |= ((((P >> 7) | (P << 7)) & 0x0010004000000000) | ((P >> 8) & 0x0020000000000000)
+		| ((P >> 9) & 0x0040000000000000) | ((P >> 1) & 0x0000400000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square G6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0000004040404040) & P;
+	flipped  = (outflank_v * -2) & 0x0000004040404040;
+
+	outflank_d9 = outflank_right(O, 0x0000002010080402) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000002010080402;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 41) << 27) & (unsigned int) (P >> 14);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 14;
+
+	flipped |= (((P >> 7) & 0x0020000000000000) | ((P >> 8) & 0x0040000000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square H6.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H6(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0000008080808080) & P;
+	flipped  = (outflank_v * -2) & 0x0000008080808080;
+
+	outflank_d9 = outflank_right(O, 0x0000004020100804) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000004020100804;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 41) << 26) & (unsigned int) (P >> 15);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 15;
+
+	flipped |= (((P >> 7) & 0x0040000000000000) | ((P >> 8) & 0x0080000000000000)) & O;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square A7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h;
+
+	outflank_v = outflank_right(O, 0x0000010101010101) & P;
+	flipped  = (outflank_v * -2) & 0x0000010101010101;
+
+	outflank_d7 = outflank_right(O, 0x0000020408102040) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000020408102040;
+
+	outflank_h = ((unsigned int) (O >> 24) + 0x02000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x007e000000000000;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square B7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h;
+
+	outflank_v = outflank_right(O, 0x0000020202020202) & P;
+	flipped  = (outflank_v * -2) & 0x0000020202020202;
+
+	outflank_d7 = outflank_right(O, 0x0000040810204080) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000040810204080;
+
+	outflank_h = ((unsigned int) (O >> 24) + 0x04000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x007c000000000000;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square C7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long flipped, outflank_v, outflank_d7;
+	unsigned int outflank_h;
+
+	outflank_v = outflank_right(O, 0x0000040404040404) & P;
+	flipped  = (outflank_v * -2) & 0x0000040404040404;
+
+	outflank_d7 = outflank_right(O, 0x0000081020408000) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000081020408000;
+
+	flipped |= (((P << 9) & 0x0000020000000000) | ((P << 1) & 0x0002000000000000)) & O;
+
+	outflank_h = ((unsigned int) (O >> 24) + 0x08000000) & (unsigned int) (P >> 24);
+	flipped |= (((unsigned long long) outflank_h << 24) - outflank_h) & 0x0078000000000000;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square D7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = outflank_right(O, 0x0000080808080808) & P;
+	flipped  = (outflank_v * -2) & 0x0000080808080808;
+
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 24) & 0x08142240) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0008142241800000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0008142240000000;	// A4D7H3
+
+	outflank_h = OUTFLANK_3[(O >> 49) & 0x3f] & rotl8(P >> 48, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 48;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square E7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = outflank_right(O, 0x0000101010101010) & P;
+	flipped  = (outflank_v * -2) & 0x0000101010101010;
+
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 24) & 0x10284402) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0010284482010000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x0010284402000000;	// A3E7H4
+
+	outflank_h = OUTFLANK_4[(O >> 49) & 0x3f] & rotl8(P >> 48, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 48;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square F7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0000202020202020) & P;
+	flipped  = (outflank_v * -2) & 0x0000202020202020;
+
+	outflank_d7 = outflank_right(O, 0x0000100804020100) & P;
+	flipped |= (outflank_d7 * -2) & 0x0000100804020100;
+
+	flipped |= (((P << 7) & 0x0000400000000000) | ((P >> 1) & 0x0040000000000000)) & O;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 49) << 28) & (unsigned int) (P >> 21);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 21;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square G7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0000404040404040) & P;
+	flipped  = (outflank_v * -2) & 0x0000404040404040;
+
+	outflank_d9 = outflank_right(O, 0x0000201008040201) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000201008040201;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 49) << 27) & (unsigned int) (P >> 22);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 22;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square H7.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H7(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0000808080808080) & P;
+	flipped  = (outflank_v * -2) & 0x0000808080808080;
+
+	outflank_d9 = outflank_right(O, 0x0000402010080402) & P;
+	flipped |= (outflank_d9 * -2) & 0x0000402010080402;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 49) << 26) & (unsigned int) (P >> 23);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 23;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square A8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_A8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0001010101010101) & P;
+	flipped  = (outflank_v * -2) & 0x0001010101010101;
+
+	outflank_d7 = outflank_right(O, 0x0002040810204080) & P;
+	flipped |= (outflank_d7 * -2) & 0x0002040810204080;
+
+	outflank_h = (O + 0x0200000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00000000000000;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square B8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_B8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0002020202020202) & P;
+	flipped  = (outflank_v * -2) & 0x0002020202020202;
+
+	outflank_d7 = outflank_right(O, 0x0004081020408000) & P;
+	flipped |= (outflank_d7 * -2) & 0x0004081020408000;
+
+	outflank_h = (O + 0x0400000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00000000000000;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square C8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_C8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0004040404040404) & P;
+	flipped  = (outflank_v * -2) & 0x0004040404040404;
+
+	outflank_d7 = outflank_right(O, 0x0008102040800000) & P;
+	flipped |= (outflank_d7 * -2) & 0x0008102040800000;
+
+	flipped |= (((P << 9) & 0x0002000000000000) | ((P << 1) & 0x0200000000000000)) & O;
+
+	outflank_h = (O + 0x0800000000000000) & P;
+	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7800000000000000;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square D8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_D8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = outflank_right(O, 0x0008080808080808) & P;
+	flipped  = (outflank_v * -2) & 0x0008080808080808;
+
+	outflank_d = OUTFLANK_3[(((unsigned int) (O >> 32) & 0x08142240) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x0814224180000000) * 0x0101010101010101) >> 53;	// hgfedc[bahgf]e0cba...
+	flipped |= FLIPPED_3_H[outflank_d] & 0x0814224000000000;	// A5D8H4
+
+	outflank_h = OUTFLANK_3[(O >> 57) & 0x3f] & rotl8(P >> 56, 3);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_3_H[outflank_h] << 56;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square E8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_E8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h, outflank_d;
+	unsigned long long flipped, outflank_v;
+
+	outflank_v = outflank_right(O, 0x0010101010101010) & P;
+	flipped  = (outflank_v * -2) & 0x0010101010101010;
+
+	outflank_d = OUTFLANK_4[(((unsigned int) (O >> 32) & 0x10284402) * 0x01010101) >> 25];
+	outflank_d &= ((P & 0x1028448201000000) * 0x0101010101010101) >> 54;	// hgfed[cbahg]f0dcba...
+	flipped |= FLIPPED_4_H[outflank_d] & 0x1028440200000000;	// A4E8H5
+
+	outflank_h = OUTFLANK_4[(O >> 57) & 0x3f] & rotl8(P >> 56, 2);
+	flipped |= (unsigned long long)(unsigned char) FLIPPED_4_H[outflank_h] << 56;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square F8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_F8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d7;
+
+	outflank_v = outflank_right(O, 0x0020202020202020) & P;
+	flipped  = (outflank_v * -2) & 0x0020202020202020;
+
+	outflank_d7 = outflank_right(O, 0x0010080402010000) & P;
+	flipped |= (outflank_d7 * -2) & 0x0010080402010000;
+
+	flipped |= (((P << 7) & 0x0040000000000000) | ((P >> 1) & 0x4000000000000000)) & O;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 57) << 28) & (unsigned int) (P >> 29);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 29;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square G8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_G8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0040404040404040) & P;
+	flipped  = (outflank_v * -2) & 0x0040404040404040;
+
+	outflank_d9 = outflank_right(O, 0x0020100804020100) & P;
+	flipped |= (outflank_d9 * -2) & 0x0020100804020100;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 57) << 27) & (unsigned int) (P >> 30);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 30;
+
+	return flipped;
+}
+
+/**
+ * Compute flipped discs when playing on square H8.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_H8(const unsigned long long P, const unsigned long long O)
+{
+	unsigned int outflank_h;
+	unsigned long long flipped, outflank_v, outflank_d9;
+
+	outflank_v = outflank_right(O, 0x0080808080808080) & P;
+	flipped  = (outflank_v * -2) & 0x0080808080808080;
+
+	outflank_d9 = outflank_right(O, 0x0040201008040201) & P;
+	flipped |= (outflank_d9 * -2) & 0x0040201008040201;
+
+	outflank_h = outflank_right_H((unsigned int) (O >> 57) << 26) & (unsigned int) (P >> 31);
+	flipped |= (unsigned long long) (outflank_h * (unsigned int) -2) << 31;
+
+	return flipped;
+}
+
+/**
+ * Compute (zero-) flipped discs when plassing.
+ *
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+static unsigned long long flip_pass(const unsigned long long P, const unsigned long long O)
+{
+	(void) P; // useless code to shut-up compiler warning
+	(void) O;
+	return 0;
+}
+
+/** Array of functions to compute flipped discs */
+unsigned long long (*flip_neon[])(const unsigned long long, const unsigned long long) = {
+	flip_A1, flip_B1, flip_C1, flip_D1, flip_E1, flip_F1, flip_G1, flip_H1,
+	flip_A2, flip_B2, flip_C2, flip_D2, flip_E2, flip_F2, flip_G2, flip_H2,
+	flip_A3, flip_B3, flip_C3, flip_D3, flip_E3, flip_F3, flip_G3, flip_H3,
+	flip_A4, flip_B4, flip_C4, flip_D4, flip_E4, flip_F4, flip_G4, flip_H4,
+	flip_A5, flip_B5, flip_C5, flip_D5, flip_E5, flip_F5, flip_G5, flip_H5,
+	flip_A6, flip_B6, flip_C6, flip_D6, flip_E6, flip_F6, flip_G6, flip_H6,
+	flip_A7, flip_B7, flip_C7, flip_D7, flip_E7, flip_F7, flip_G7, flip_H7,
+	flip_A8, flip_B8, flip_C8, flip_D8, flip_E8, flip_F8, flip_G8, flip_H8,
+	flip_pass, flip_pass
+};
+
+#endif
diff --git a/src/flip_neon_lzcnt.c b/src/flip_neon_lzcnt.c
new file mode 100644
index 00000000..d5cf0f4e
--- /dev/null
+++ b/src/flip_neon_lzcnt.c
@@ -0,0 +1,132 @@
+/**
+ * @file flip_neon_lzcnt.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, LZCNT is used to isolate MS1B.
+ *
+ * @date 2020
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include "arm_neon.h"
+
+static const uint64x2_t lrmask_v4[66][4] = {
+	{{ 0x00000000000000fe, 0x0101010101010100 }, { 0x8040201008040200, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200 }, { 0x0080402010080400, 0x0000000000000100 }, { 0x0000000000000001, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400 }, { 0x0000804020100800, 0x0000000000010200 }, { 0x0000000000000003, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800 }, { 0x0000008040201000, 0x0000000001020400 }, { 0x0000000000000007, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000 }, { 0x0000000080402000, 0x0000000102040800 }, { 0x000000000000000f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000 }, { 0x0000000000804000, 0x0000010204081000 }, { 0x000000000000001f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000 }, { 0x0000000000008000, 0x0001020408102000 }, { 0x000000000000003f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000 }, { 0x0000000000000000, 0x0102040810204000 }, { 0x000000000000007f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000 }, { 0x4020100804020000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000001 }, { 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000 }, { 0x8040201008040000, 0x0000000000010000 }, { 0x0000000000000100, 0x0000000000000002 }, { 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000 }, { 0x0080402010080000, 0x0000000001020000 }, { 0x0000000000000300, 0x0000000000000004 }, { 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000 }, { 0x0000804020100000, 0x0000000102040000 }, { 0x0000000000000700, 0x0000000000000008 }, { 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000 }, { 0x0000008040200000, 0x0000010204080000 }, { 0x0000000000000f00, 0x0000000000000010 }, { 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000 }, { 0x0000000080400000, 0x0001020408100000 }, { 0x0000000000001f00, 0x0000000000000020 }, { 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000 }, { 0x0000000000800000, 0x0102040810200000 }, { 0x0000000000003f00, 0x0000000000000040 }, { 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000 }, { 0x0000000000000000, 0x0204081020400000 }, { 0x0000000000007f00, 0x0000000000000080 }, { 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000 }, { 0x2010080402000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000101 }, { 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000 }, { 0x4020100804000000, 0x0000000001000000 }, { 0x0000000000010000, 0x0000000000000202 }, { 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000 }, { 0x8040201008000000, 0x0000000102000000 }, { 0x0000000000030000, 0x0000000000000404 }, { 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000 }, { 0x0080402010000000, 0x0000010204000000 }, { 0x0000000000070000, 0x0000000000000808 }, { 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000 }, { 0x0000804020000000, 0x0001020408000000 }, { 0x00000000000f0000, 0x0000000000001010 }, { 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000 }, { 0x0000008040000000, 0x0102040810000000 }, { 0x00000000001f0000, 0x0000000000002020 }, { 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000 }, { 0x0000000080000000, 0x0204081020000000 }, { 0x00000000003f0000, 0x0000000000004040 }, { 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000 }, { 0x0000000000000000, 0x0408102040000000 }, { 0x00000000007f0000, 0x0000000000008080 }, { 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000 }, { 0x1008040200000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000010101 }, { 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000 }, { 0x2010080400000000, 0x0000000100000000 }, { 0x0000000001000000, 0x0000000000020202 }, { 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000 }, { 0x4020100800000000, 0x0000010200000000 }, { 0x0000000003000000, 0x0000000000040404 }, { 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000 }, { 0x8040201000000000, 0x0001020400000000 }, { 0x0000000007000000, 0x0000000000080808 }, { 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000 }, { 0x0080402000000000, 0x0102040800000000 }, { 0x000000000f000000, 0x0000000000101010 }, { 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000 }, { 0x0000804000000000, 0x0204081000000000 }, { 0x000000001f000000, 0x0000000000202020 }, { 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000 }, { 0x0000008000000000, 0x0408102000000000 }, { 0x000000003f000000, 0x0000000000404040 }, { 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000 }, { 0x0000000000000000, 0x0810204000000000 }, { 0x000000007f000000, 0x0000000000808080 }, { 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000 }, { 0x0804020000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000001010101 }, { 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000 }, { 0x1008040000000000, 0x0000010000000000 }, { 0x0000000100000000, 0x0000000002020202 }, { 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000 }, { 0x2010080000000000, 0x0001020000000000 }, { 0x0000000300000000, 0x0000000004040404 }, { 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000 }, { 0x4020100000000000, 0x0102040000000000 }, { 0x0000000700000000, 0x0000000008080808 }, { 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000 }, { 0x8040200000000000, 0x0204080000000000 }, { 0x0000000f00000000, 0x0000000010101010 }, { 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000 }, { 0x0080400000000000, 0x0408100000000000 }, { 0x0000001f00000000, 0x0000000020202020 }, { 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000 }, { 0x0000800000000000, 0x0810200000000000 }, { 0x0000003f00000000, 0x0000000040404040 }, { 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000 }, { 0x0000000000000000, 0x1020400000000000 }, { 0x0000007f00000000, 0x0000000080808080 }, { 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000 }, { 0x0402000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000101010101 }, { 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000 }, { 0x0804000000000000, 0x0001000000000000 }, { 0x0000010000000000, 0x0000000202020202 }, { 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000 }, { 0x1008000000000000, 0x0102000000000000 }, { 0x0000030000000000, 0x0000000404040404 }, { 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000 }, { 0x2010000000000000, 0x0204000000000000 }, { 0x0000070000000000, 0x0000000808080808 }, { 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000 }, { 0x4020000000000000, 0x0408000000000000 }, { 0x00000f0000000000, 0x0000001010101010 }, { 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000 }, { 0x8040000000000000, 0x0810000000000000 }, { 0x00001f0000000000, 0x0000002020202020 }, { 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000 }, { 0x0080000000000000, 0x1020000000000000 }, { 0x00003f0000000000, 0x0000004040404040 }, { 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000 }, { 0x0000000000000000, 0x2040000000000000 }, { 0x00007f0000000000, 0x0000008080808080 }, { 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000 }, { 0x0200000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000010101010101 }, { 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000 }, { 0x0400000000000000, 0x0100000000000000 }, { 0x0001000000000000, 0x0000020202020202 }, { 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000 }, { 0x0800000000000000, 0x0200000000000000 }, { 0x0003000000000000, 0x0000040404040404 }, { 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000 }, { 0x1000000000000000, 0x0400000000000000 }, { 0x0007000000000000, 0x0000080808080808 }, { 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000 }, { 0x2000000000000000, 0x0800000000000000 }, { 0x000f000000000000, 0x0000101010101010 }, { 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000 }, { 0x4000000000000000, 0x1000000000000000 }, { 0x001f000000000000, 0x0000202020202020 }, { 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000 }, { 0x8000000000000000, 0x2000000000000000 }, { 0x003f000000000000, 0x0000404040404040 }, { 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000 }, { 0x0000000000000000, 0x4000000000000000 }, { 0x007f000000000000, 0x0000808080808080 }, { 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0001010101010101 }, { 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0100000000000000, 0x0002020202020202 }, { 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0300000000000000, 0x0004040404040404 }, { 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0700000000000000, 0x0008080808080808 }, { 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0f00000000000000, 0x0010101010101010 }, { 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x1f00000000000000, 0x0020202020202020 }, { 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x3f00000000000000, 0x0040404040404040 }, { 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x7f00000000000000, 0x0080808080808080 }, { 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+
+#ifndef HAS_CPU_64
+#define vceqzq_u32(x)	vmvnq_u32(vtstq_u32((x), (x)))
+#endif
+
+uint64x2_t mm_Flip(uint64x2_t OP, int pos)
+{
+	uint64x2_t	flip, oflank0, mask0;				uint64x2_t	oflank1, mask1;
+	int32x4_t	clz0;						int32x4_t	clz1;
+	uint32x4_t	msb0;						uint32x4_t	msb1;
+	const uint64x2_t one = vdupq_n_u64(1);
+	uint64x2_t PP = vdupq_lane_u64(vget_low_u64(OP), 0);
+	uint64x2_t OO = vdupq_lane_u64(vget_high_u64(OP), 0);
+
+	mask0 = lrmask_v4[pos][2];					mask1 = lrmask_v4[pos][3];
+		// isolate non-opponent MS1B
+	oflank0 = vbicq_u64(mask0, OO);					oflank1 = vbicq_u64(mask1, OO);
+		// outflank = (0x8000000000000000ULL >> lzcnt) & P
+	clz0 = vclzq_s32(vreinterpretq_s32_u64(oflank0));		clz1 = vclzq_s32(vreinterpretq_s32_u64(oflank1));
+		// set loword's MSB if hiword = 0
+	msb0 = vreinterpretq_u32_u64(vshrq_n_u64(oflank0, 32));		msb1 = vreinterpretq_u32_u64(vshrq_n_u64(oflank1, 32));
+	msb0 = vshlq_n_u32(vceqzq_u32(msb0), 31);			msb1 = vshlq_n_u32(vceqzq_u32(msb1), 31);
+	msb0 = vshlq_u32(msb0, vnegq_s32(clz0));			msb1 = vshlq_u32(msb1, vnegq_s32(clz1));
+		// 0 if outflank is P, otherwise oflank = msb
+	oflank0 = vbicq_u64(vreinterpretq_u64_u32(msb0), PP);		oflank1 = vbicq_u64(vreinterpretq_u64_u32(msb1), PP);
+		// set all bits higher than outflank
+	oflank0 = vsubq_u64(oflank0, vreinterpretq_u64_u32(msb0));	oflank1 = vsubq_u64(oflank1, vreinterpretq_u64_u32(msb1));
+	flip = vandq_u64(vbslq_u64(mask1, oflank1, vandq_u64(mask0, oflank0)), OO);
+
+	mask0 = lrmask_v4[pos][0];					mask1 = lrmask_v4[pos][1];
+		// get outflank with carry-propagation
+	oflank0 = vaddq_u64(vornq_u64(OO, mask0), one);			oflank1 = vaddq_u64(vornq_u64(OO, mask1), one);
+	oflank0 = vandq_u64(vandq_u64(PP, mask0), oflank0);		oflank1 = vandq_u64(vandq_u64(PP, mask1), oflank1);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	oflank0 = vqsubq_u64(oflank0, one);				oflank1 = vqsubq_u64(oflank1, one);
+	flip = vbslq_u64(mask1, oflank1, vbslq_u64(mask0, oflank0, flip));
+
+	return vorrq_u64(flip, vextq_u64(flip, flip, 1));
+}
diff --git a/src/flip_neon_ppfill.c b/src/flip_neon_ppfill.c
new file mode 100644
index 00000000..cd745131
--- /dev/null
+++ b/src/flip_neon_ppfill.c
@@ -0,0 +1,128 @@
+/**
+ * @file flip_neon_ppfill.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, parallel prefix fill is used to isolate
+ * MS1B.
+ *
+ * @date 2020
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include "arm_neon.h"
+
+static const uint64x2_t lrmask_v4[66][4] = {
+	{{ 0x00000000000000fe, 0x0101010101010100 }, { 0x8040201008040200, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200 }, { 0x0080402010080400, 0x0000000000000100 }, { 0x0000000000000001, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400 }, { 0x0000804020100800, 0x0000000000010200 }, { 0x0000000000000003, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800 }, { 0x0000008040201000, 0x0000000001020400 }, { 0x0000000000000007, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000 }, { 0x0000000080402000, 0x0000000102040800 }, { 0x000000000000000f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000 }, { 0x0000000000804000, 0x0000010204081000 }, { 0x000000000000001f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000 }, { 0x0000000000008000, 0x0001020408102000 }, { 0x000000000000003f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000 }, { 0x0000000000000000, 0x0102040810204000 }, { 0x000000000000007f, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000 }, { 0x4020100804020000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000001 }, { 0x0000000000000000, 0x0000000000000002 }},
+	{{ 0x000000000000fc00, 0x0202020202020000 }, { 0x8040201008040000, 0x0000000000010000 }, { 0x0000000000000100, 0x0000000000000002 }, { 0x0000000000000001, 0x0000000000000004 }},
+	{{ 0x000000000000f800, 0x0404040404040000 }, { 0x0080402010080000, 0x0000000001020000 }, { 0x0000000000000300, 0x0000000000000004 }, { 0x0000000000000002, 0x0000000000000008 }},
+	{{ 0x000000000000f000, 0x0808080808080000 }, { 0x0000804020100000, 0x0000000102040000 }, { 0x0000000000000700, 0x0000000000000008 }, { 0x0000000000000004, 0x0000000000000010 }},
+	{{ 0x000000000000e000, 0x1010101010100000 }, { 0x0000008040200000, 0x0000010204080000 }, { 0x0000000000000f00, 0x0000000000000010 }, { 0x0000000000000008, 0x0000000000000020 }},
+	{{ 0x000000000000c000, 0x2020202020200000 }, { 0x0000000080400000, 0x0001020408100000 }, { 0x0000000000001f00, 0x0000000000000020 }, { 0x0000000000000010, 0x0000000000000040 }},
+	{{ 0x0000000000008000, 0x4040404040400000 }, { 0x0000000000800000, 0x0102040810200000 }, { 0x0000000000003f00, 0x0000000000000040 }, { 0x0000000000000020, 0x0000000000000080 }},
+	{{ 0x0000000000000000, 0x8080808080800000 }, { 0x0000000000000000, 0x0204081020400000 }, { 0x0000000000007f00, 0x0000000000000080 }, { 0x0000000000000040, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000 }, { 0x2010080402000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000101 }, { 0x0000000000000000, 0x0000000000000204 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000 }, { 0x4020100804000000, 0x0000000001000000 }, { 0x0000000000010000, 0x0000000000000202 }, { 0x0000000000000100, 0x0000000000000408 }},
+	{{ 0x0000000000f80000, 0x0404040404000000 }, { 0x8040201008000000, 0x0000000102000000 }, { 0x0000000000030000, 0x0000000000000404 }, { 0x0000000000000201, 0x0000000000000810 }},
+	{{ 0x0000000000f00000, 0x0808080808000000 }, { 0x0080402010000000, 0x0000010204000000 }, { 0x0000000000070000, 0x0000000000000808 }, { 0x0000000000000402, 0x0000000000001020 }},
+	{{ 0x0000000000e00000, 0x1010101010000000 }, { 0x0000804020000000, 0x0001020408000000 }, { 0x00000000000f0000, 0x0000000000001010 }, { 0x0000000000000804, 0x0000000000002040 }},
+	{{ 0x0000000000c00000, 0x2020202020000000 }, { 0x0000008040000000, 0x0102040810000000 }, { 0x00000000001f0000, 0x0000000000002020 }, { 0x0000000000001008, 0x0000000000004080 }},
+	{{ 0x0000000000800000, 0x4040404040000000 }, { 0x0000000080000000, 0x0204081020000000 }, { 0x00000000003f0000, 0x0000000000004040 }, { 0x0000000000002010, 0x0000000000008000 }},
+	{{ 0x0000000000000000, 0x8080808080000000 }, { 0x0000000000000000, 0x0408102040000000 }, { 0x00000000007f0000, 0x0000000000008080 }, { 0x0000000000004020, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000 }, { 0x1008040200000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000010101 }, { 0x0000000000000000, 0x0000000000020408 }},
+	{{ 0x00000000fc000000, 0x0202020200000000 }, { 0x2010080400000000, 0x0000000100000000 }, { 0x0000000001000000, 0x0000000000020202 }, { 0x0000000000010000, 0x0000000000040810 }},
+	{{ 0x00000000f8000000, 0x0404040400000000 }, { 0x4020100800000000, 0x0000010200000000 }, { 0x0000000003000000, 0x0000000000040404 }, { 0x0000000000020100, 0x0000000000081020 }},
+	{{ 0x00000000f0000000, 0x0808080800000000 }, { 0x8040201000000000, 0x0001020400000000 }, { 0x0000000007000000, 0x0000000000080808 }, { 0x0000000000040201, 0x0000000000102040 }},
+	{{ 0x00000000e0000000, 0x1010101000000000 }, { 0x0080402000000000, 0x0102040800000000 }, { 0x000000000f000000, 0x0000000000101010 }, { 0x0000000000080402, 0x0000000000204080 }},
+	{{ 0x00000000c0000000, 0x2020202000000000 }, { 0x0000804000000000, 0x0204081000000000 }, { 0x000000001f000000, 0x0000000000202020 }, { 0x0000000000100804, 0x0000000000408000 }},
+	{{ 0x0000000080000000, 0x4040404000000000 }, { 0x0000008000000000, 0x0408102000000000 }, { 0x000000003f000000, 0x0000000000404040 }, { 0x0000000000201008, 0x0000000000800000 }},
+	{{ 0x0000000000000000, 0x8080808000000000 }, { 0x0000000000000000, 0x0810204000000000 }, { 0x000000007f000000, 0x0000000000808080 }, { 0x0000000000402010, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000 }, { 0x0804020000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000001010101 }, { 0x0000000000000000, 0x0000000002040810 }},
+	{{ 0x000000fc00000000, 0x0202020000000000 }, { 0x1008040000000000, 0x0000010000000000 }, { 0x0000000100000000, 0x0000000002020202 }, { 0x0000000001000000, 0x0000000004081020 }},
+	{{ 0x000000f800000000, 0x0404040000000000 }, { 0x2010080000000000, 0x0001020000000000 }, { 0x0000000300000000, 0x0000000004040404 }, { 0x0000000002010000, 0x0000000008102040 }},
+	{{ 0x000000f000000000, 0x0808080000000000 }, { 0x4020100000000000, 0x0102040000000000 }, { 0x0000000700000000, 0x0000000008080808 }, { 0x0000000004020100, 0x0000000010204080 }},
+	{{ 0x000000e000000000, 0x1010100000000000 }, { 0x8040200000000000, 0x0204080000000000 }, { 0x0000000f00000000, 0x0000000010101010 }, { 0x0000000008040201, 0x0000000020408000 }},
+	{{ 0x000000c000000000, 0x2020200000000000 }, { 0x0080400000000000, 0x0408100000000000 }, { 0x0000001f00000000, 0x0000000020202020 }, { 0x0000000010080402, 0x0000000040800000 }},
+	{{ 0x0000008000000000, 0x4040400000000000 }, { 0x0000800000000000, 0x0810200000000000 }, { 0x0000003f00000000, 0x0000000040404040 }, { 0x0000000020100804, 0x0000000080000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000 }, { 0x0000000000000000, 0x1020400000000000 }, { 0x0000007f00000000, 0x0000000080808080 }, { 0x0000000040201008, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000 }, { 0x0402000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000101010101 }, { 0x0000000000000000, 0x0000000204081020 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000 }, { 0x0804000000000000, 0x0001000000000000 }, { 0x0000010000000000, 0x0000000202020202 }, { 0x0000000100000000, 0x0000000408102040 }},
+	{{ 0x0000f80000000000, 0x0404000000000000 }, { 0x1008000000000000, 0x0102000000000000 }, { 0x0000030000000000, 0x0000000404040404 }, { 0x0000000201000000, 0x0000000810204080 }},
+	{{ 0x0000f00000000000, 0x0808000000000000 }, { 0x2010000000000000, 0x0204000000000000 }, { 0x0000070000000000, 0x0000000808080808 }, { 0x0000000402010000, 0x0000001020408000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000 }, { 0x4020000000000000, 0x0408000000000000 }, { 0x00000f0000000000, 0x0000001010101010 }, { 0x0000000804020100, 0x0000002040800000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000 }, { 0x8040000000000000, 0x0810000000000000 }, { 0x00001f0000000000, 0x0000002020202020 }, { 0x0000001008040201, 0x0000004080000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000 }, { 0x0080000000000000, 0x1020000000000000 }, { 0x00003f0000000000, 0x0000004040404040 }, { 0x0000002010080402, 0x0000008000000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000 }, { 0x0000000000000000, 0x2040000000000000 }, { 0x00007f0000000000, 0x0000008080808080 }, { 0x0000004020100804, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000 }, { 0x0200000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000010101010101 }, { 0x0000000000000000, 0x0000020408102040 }},
+	{{ 0x00fc000000000000, 0x0200000000000000 }, { 0x0400000000000000, 0x0100000000000000 }, { 0x0001000000000000, 0x0000020202020202 }, { 0x0000010000000000, 0x0000040810204080 }},
+	{{ 0x00f8000000000000, 0x0400000000000000 }, { 0x0800000000000000, 0x0200000000000000 }, { 0x0003000000000000, 0x0000040404040404 }, { 0x0000020100000000, 0x0000081020408000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000 }, { 0x1000000000000000, 0x0400000000000000 }, { 0x0007000000000000, 0x0000080808080808 }, { 0x0000040201000000, 0x0000102040800000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000 }, { 0x2000000000000000, 0x0800000000000000 }, { 0x000f000000000000, 0x0000101010101010 }, { 0x0000080402010000, 0x0000204080000000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000 }, { 0x4000000000000000, 0x1000000000000000 }, { 0x001f000000000000, 0x0000202020202020 }, { 0x0000100804020100, 0x0000408000000000 }},
+	{{ 0x0080000000000000, 0x4000000000000000 }, { 0x8000000000000000, 0x2000000000000000 }, { 0x003f000000000000, 0x0000404040404040 }, { 0x0000201008040201, 0x0000800000000000 }},
+	{{ 0x0000000000000000, 0x8000000000000000 }, { 0x0000000000000000, 0x4000000000000000 }, { 0x007f000000000000, 0x0000808080808080 }, { 0x0000402010080402, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0001010101010101 }, { 0x0000000000000000, 0x0002040810204080 }},
+	{{ 0xfc00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0100000000000000, 0x0002020202020202 }, { 0x0001000000000000, 0x0004081020408000 }},
+	{{ 0xf800000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0300000000000000, 0x0004040404040404 }, { 0x0002010000000000, 0x0008102040800000 }},
+	{{ 0xf000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0700000000000000, 0x0008080808080808 }, { 0x0004020100000000, 0x0010204080000000 }},
+	{{ 0xe000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0f00000000000000, 0x0010101010101010 }, { 0x0008040201000000, 0x0020408000000000 }},
+	{{ 0xc000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x1f00000000000000, 0x0020202020202020 }, { 0x0010080402010000, 0x0040800000000000 }},
+	{{ 0x8000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x3f00000000000000, 0x0040404040404040 }, { 0x0020100804020100, 0x0080000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x7f00000000000000, 0x0080808080808080 }, { 0x0040201008040201, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+
+uint64x2_t mm_Flip(uint64x2_t OP, int pos)
+{
+	uint64x2_t	flip, oflank0, eraser0, mask0;			uint64x2_t	oflank1, eraser1, mask1;
+	const int64x2_t lshift18 = { 1, 8 };				const int64x2_t lshift79 = { 9, 7 };
+	int64x2_t rshift18 = { -1, -8 };				int64x2_t rshift79 = { -9, -7 };
+	const uint64x2_t one = vdupq_n_u64(1);
+	uint64x2_t PP = vdupq_lane_u64(vget_low_u64(OP), 0);
+	uint64x2_t OO = vdupq_lane_u64(vget_high_u64(OP), 0);
+
+	mask0 = lrmask_v4[pos][2];					mask1 = lrmask_v4[pos][3];
+		// isolate non-opponent MS1B by clearing lower bits
+	eraser0 = vbicq_u64(mask0, OO);					eraser1 = vbicq_u64(mask1, OO);
+		// clear valid bits only using variable shift
+	oflank0 = vshlq_u64(vandq_u64(PP, mask0), lshift18);		oflank1 = vshlq_u64(vandq_u64(PP, mask1), lshift79);
+	eraser0 = vorrq_u64(eraser0, vshlq_u64(eraser0, rshift18));	eraser1 = vorrq_u64(eraser1, vshlq_u64(eraser1, rshift79));
+	rshift18 = vaddq_s64(rshift18, rshift18);			rshift79 = vaddq_s64(rshift79, rshift79);
+	eraser0 = vorrq_u64(eraser0, vshlq_u64(eraser0, rshift18));	eraser1 = vorrq_u64(eraser1, vshlq_u64(eraser1, rshift79));
+	eraser0 = vorrq_u64(eraser0, vshlq_u64(eraser0, rshift18));	eraser1 = vorrq_u64(eraser1, vshlq_u64(eraser1, rshift79));
+	oflank0 = vbicq_u64(oflank0, eraser0);				oflank1 = vbicq_u64(oflank1, eraser1);
+		// set mask bits higher than oflank
+	flip = vbicq_u64(mask0, vsubq_u64(oflank0, one));		flip = vorrq_u64(flip, vbicq_u64(mask1, vsubq_u64(oflank1, one)));
+
+	mask0 = lrmask_v4[pos][0];					mask1 = lrmask_v4[pos][1];
+		// get outflank with carry-propagation
+	oflank0 = vaddq_u64(vornq_u64(OO, mask0), one);			oflank1 = vaddq_u64(vornq_u64(OO, mask1), one);
+	oflank0 = vandq_u64(vandq_u64(PP, mask0), oflank0);		oflank1 = vandq_u64(vandq_u64(PP, mask1), oflank1);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	oflank0 = vqsubq_u64(oflank0, one);				oflank1 = vqsubq_u64(oflank1, one);
+	flip = vbslq_u64(mask1, oflank1, vbslq_u64(mask0, oflank0, flip));
+
+	return vorrq_u64(flip, vextq_u64(flip, flip, 1));
+}
+
diff --git a/src/flip_neon_rbit.c b/src/flip_neon_rbit.c
new file mode 100644
index 00000000..a7f075f9
--- /dev/null
+++ b/src/flip_neon_rbit.c
@@ -0,0 +1,121 @@
+/**
+ * @file flip_neon_rbit.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, carry propagation can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, rev64/rbit is used to use carry propagation.
+ *
+ * @date 2020
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include "arm_neon.h"
+
+static const uint64x2_t lrmask_v4[66][4] = {
+	{{ 0x00000000000000fe, 0x0101010101010100 }, { 0x8040201008040200, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000fc, 0x0202020202020200 }, { 0x0080402010080400, 0x0000000000000100 }, { 0x8000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f8, 0x0404040404040400 }, { 0x0000804020100800, 0x0000000000010200 }, { 0xc000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000f0, 0x0808080808080800 }, { 0x0000008040201000, 0x0000000001020400 }, { 0xe000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000e0, 0x1010101010101000 }, { 0x0000000080402000, 0x0000000102040800 }, { 0xf000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x00000000000000c0, 0x2020202020202000 }, { 0x0000000000804000, 0x0000010204081000 }, { 0xf800000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000080, 0x4040404040404000 }, { 0x0000000000008000, 0x0001020408102000 }, { 0xfc00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080808000 }, { 0x0000000000000000, 0x0102040810204000 }, { 0xfe00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},
+	{{ 0x000000000000fe00, 0x0101010101010000 }, { 0x4020100804020000, 0x0000000000000000 }, { 0x0000000000000000, 0x8000000000000000 }, { 0x0000000000000000, 0x4000000000000000 }},
+	{{ 0x000000000000fc00, 0x0202020202020000 }, { 0x8040201008040000, 0x0000000000010000 }, { 0x0080000000000000, 0x4000000000000000 }, { 0x8000000000000000, 0x2000000000000000 }},
+	{{ 0x000000000000f800, 0x0404040404040000 }, { 0x0080402010080000, 0x0000000001020000 }, { 0x00c0000000000000, 0x2000000000000000 }, { 0x4000000000000000, 0x1000000000000000 }},
+	{{ 0x000000000000f000, 0x0808080808080000 }, { 0x0000804020100000, 0x0000000102040000 }, { 0x00e0000000000000, 0x1000000000000000 }, { 0x2000000000000000, 0x0800000000000000 }},
+	{{ 0x000000000000e000, 0x1010101010100000 }, { 0x0000008040200000, 0x0000010204080000 }, { 0x00f0000000000000, 0x0800000000000000 }, { 0x1000000000000000, 0x0400000000000000 }},
+	{{ 0x000000000000c000, 0x2020202020200000 }, { 0x0000000080400000, 0x0001020408100000 }, { 0x00f8000000000000, 0x0400000000000000 }, { 0x0800000000000000, 0x0200000000000000 }},
+	{{ 0x0000000000008000, 0x4040404040400000 }, { 0x0000000000800000, 0x0102040810200000 }, { 0x00fc000000000000, 0x0200000000000000 }, { 0x0400000000000000, 0x0100000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080800000 }, { 0x0000000000000000, 0x0204081020400000 }, { 0x00fe000000000000, 0x0100000000000000 }, { 0x0200000000000000, 0x0000000000000000 }},
+	{{ 0x0000000000fe0000, 0x0101010101000000 }, { 0x2010080402000000, 0x0000000000000000 }, { 0x0000000000000000, 0x8080000000000000 }, { 0x0000000000000000, 0x2040000000000000 }},
+	{{ 0x0000000000fc0000, 0x0202020202000000 }, { 0x4020100804000000, 0x0000000001000000 }, { 0x0000800000000000, 0x4040000000000000 }, { 0x0080000000000000, 0x1020000000000000 }},
+	{{ 0x0000000000f80000, 0x0404040404000000 }, { 0x8040201008000000, 0x0000000102000000 }, { 0x0000c00000000000, 0x2020000000000000 }, { 0x8040000000000000, 0x0810000000000000 }},
+	{{ 0x0000000000f00000, 0x0808080808000000 }, { 0x0080402010000000, 0x0000010204000000 }, { 0x0000e00000000000, 0x1010000000000000 }, { 0x4020000000000000, 0x0408000000000000 }},
+	{{ 0x0000000000e00000, 0x1010101010000000 }, { 0x0000804020000000, 0x0001020408000000 }, { 0x0000f00000000000, 0x0808000000000000 }, { 0x2010000000000000, 0x0204000000000000 }},
+	{{ 0x0000000000c00000, 0x2020202020000000 }, { 0x0000008040000000, 0x0102040810000000 }, { 0x0000f80000000000, 0x0404000000000000 }, { 0x1008000000000000, 0x0102000000000000 }},
+	{{ 0x0000000000800000, 0x4040404040000000 }, { 0x0000000080000000, 0x0204081020000000 }, { 0x0000fc0000000000, 0x0202000000000000 }, { 0x0804000000000000, 0x0001000000000000 }},
+	{{ 0x0000000000000000, 0x8080808080000000 }, { 0x0000000000000000, 0x0408102040000000 }, { 0x0000fe0000000000, 0x0101000000000000 }, { 0x0402000000000000, 0x0000000000000000 }},
+	{{ 0x00000000fe000000, 0x0101010100000000 }, { 0x1008040200000000, 0x0000000000000000 }, { 0x0000000000000000, 0x8080800000000000 }, { 0x0000000000000000, 0x1020400000000000 }},
+	{{ 0x00000000fc000000, 0x0202020200000000 }, { 0x2010080400000000, 0x0000000100000000 }, { 0x0000008000000000, 0x4040400000000000 }, { 0x0000800000000000, 0x0810200000000000 }},
+	{{ 0x00000000f8000000, 0x0404040400000000 }, { 0x4020100800000000, 0x0000010200000000 }, { 0x000000c000000000, 0x2020200000000000 }, { 0x0080400000000000, 0x0408100000000000 }},
+	{{ 0x00000000f0000000, 0x0808080800000000 }, { 0x8040201000000000, 0x0001020400000000 }, { 0x000000e000000000, 0x1010100000000000 }, { 0x8040200000000000, 0x0204080000000000 }},
+	{{ 0x00000000e0000000, 0x1010101000000000 }, { 0x0080402000000000, 0x0102040800000000 }, { 0x000000f000000000, 0x0808080000000000 }, { 0x4020100000000000, 0x0102040000000000 }},
+	{{ 0x00000000c0000000, 0x2020202000000000 }, { 0x0000804000000000, 0x0204081000000000 }, { 0x000000f800000000, 0x0404040000000000 }, { 0x2010080000000000, 0x0001020000000000 }},
+	{{ 0x0000000080000000, 0x4040404000000000 }, { 0x0000008000000000, 0x0408102000000000 }, { 0x000000fc00000000, 0x0202020000000000 }, { 0x1008040000000000, 0x0000010000000000 }},
+	{{ 0x0000000000000000, 0x8080808000000000 }, { 0x0000000000000000, 0x0810204000000000 }, { 0x000000fe00000000, 0x0101010000000000 }, { 0x0804020000000000, 0x0000000000000000 }},
+	{{ 0x000000fe00000000, 0x0101010000000000 }, { 0x0804020000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x8080808000000000 }, { 0x0000000000000000, 0x0810204000000000 }},
+	{{ 0x000000fc00000000, 0x0202020000000000 }, { 0x1008040000000000, 0x0000010000000000 }, { 0x0000000080000000, 0x4040404000000000 }, { 0x0000008000000000, 0x0408102000000000 }},
+	{{ 0x000000f800000000, 0x0404040000000000 }, { 0x2010080000000000, 0x0001020000000000 }, { 0x00000000c0000000, 0x2020202000000000 }, { 0x0000804000000000, 0x0204081000000000 }},
+	{{ 0x000000f000000000, 0x0808080000000000 }, { 0x4020100000000000, 0x0102040000000000 }, { 0x00000000e0000000, 0x1010101000000000 }, { 0x0080402000000000, 0x0102040800000000 }},
+	{{ 0x000000e000000000, 0x1010100000000000 }, { 0x8040200000000000, 0x0204080000000000 }, { 0x00000000f0000000, 0x0808080800000000 }, { 0x8040201000000000, 0x0001020400000000 }},
+	{{ 0x000000c000000000, 0x2020200000000000 }, { 0x0080400000000000, 0x0408100000000000 }, { 0x00000000f8000000, 0x0404040400000000 }, { 0x4020100800000000, 0x0000010200000000 }},
+	{{ 0x0000008000000000, 0x4040400000000000 }, { 0x0000800000000000, 0x0810200000000000 }, { 0x00000000fc000000, 0x0202020200000000 }, { 0x2010080400000000, 0x0000000100000000 }},
+	{{ 0x0000000000000000, 0x8080800000000000 }, { 0x0000000000000000, 0x1020400000000000 }, { 0x00000000fe000000, 0x0101010100000000 }, { 0x1008040200000000, 0x0000000000000000 }},
+	{{ 0x0000fe0000000000, 0x0101000000000000 }, { 0x0402000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x8080808080000000 }, { 0x0000000000000000, 0x0408102040000000 }},
+	{{ 0x0000fc0000000000, 0x0202000000000000 }, { 0x0804000000000000, 0x0001000000000000 }, { 0x0000000000800000, 0x4040404040000000 }, { 0x0000000080000000, 0x0204081020000000 }},
+	{{ 0x0000f80000000000, 0x0404000000000000 }, { 0x1008000000000000, 0x0102000000000000 }, { 0x0000000000c00000, 0x2020202020000000 }, { 0x0000008040000000, 0x0102040810000000 }},
+	{{ 0x0000f00000000000, 0x0808000000000000 }, { 0x2010000000000000, 0x0204000000000000 }, { 0x0000000000e00000, 0x1010101010000000 }, { 0x0000804020000000, 0x0001020408000000 }},
+	{{ 0x0000e00000000000, 0x1010000000000000 }, { 0x4020000000000000, 0x0408000000000000 }, { 0x0000000000f00000, 0x0808080808000000 }, { 0x0080402010000000, 0x0000010204000000 }},
+	{{ 0x0000c00000000000, 0x2020000000000000 }, { 0x8040000000000000, 0x0810000000000000 }, { 0x0000000000f80000, 0x0404040404000000 }, { 0x8040201008000000, 0x0000000102000000 }},
+	{{ 0x0000800000000000, 0x4040000000000000 }, { 0x0080000000000000, 0x1020000000000000 }, { 0x0000000000fc0000, 0x0202020202000000 }, { 0x4020100804000000, 0x0000000001000000 }},
+	{{ 0x0000000000000000, 0x8080000000000000 }, { 0x0000000000000000, 0x2040000000000000 }, { 0x0000000000fe0000, 0x0101010101000000 }, { 0x2010080402000000, 0x0000000000000000 }},
+	{{ 0x00fe000000000000, 0x0100000000000000 }, { 0x0200000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x8080808080800000 }, { 0x0000000000000000, 0x0204081020400000 }},
+	{{ 0x00fc000000000000, 0x0200000000000000 }, { 0x0400000000000000, 0x0100000000000000 }, { 0x0000000000008000, 0x4040404040400000 }, { 0x0000000000800000, 0x0102040810200000 }},
+	{{ 0x00f8000000000000, 0x0400000000000000 }, { 0x0800000000000000, 0x0200000000000000 }, { 0x000000000000c000, 0x2020202020200000 }, { 0x0000000080400000, 0x0001020408100000 }},
+	{{ 0x00f0000000000000, 0x0800000000000000 }, { 0x1000000000000000, 0x0400000000000000 }, { 0x000000000000e000, 0x1010101010100000 }, { 0x0000008040200000, 0x0000010204080000 }},
+	{{ 0x00e0000000000000, 0x1000000000000000 }, { 0x2000000000000000, 0x0800000000000000 }, { 0x000000000000f000, 0x0808080808080000 }, { 0x0000804020100000, 0x0000000102040000 }},
+	{{ 0x00c0000000000000, 0x2000000000000000 }, { 0x4000000000000000, 0x1000000000000000 }, { 0x000000000000f800, 0x0404040404040000 }, { 0x0080402010080000, 0x0000000001020000 }},
+	{{ 0x0080000000000000, 0x4000000000000000 }, { 0x8000000000000000, 0x2000000000000000 }, { 0x000000000000fc00, 0x0202020202020000 }, { 0x8040201008040000, 0x0000000000010000 }},
+	{{ 0x0000000000000000, 0x8000000000000000 }, { 0x0000000000000000, 0x4000000000000000 }, { 0x000000000000fe00, 0x0101010101010000 }, { 0x4020100804020000, 0x0000000000000000 }},
+	{{ 0xfe00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x8080808080808000 }, { 0x0000000000000000, 0x0102040810204000 }},
+	{{ 0xfc00000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000080, 0x4040404040404000 }, { 0x0000000000008000, 0x0001020408102000 }},
+	{{ 0xf800000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x00000000000000c0, 0x2020202020202000 }, { 0x0000000000804000, 0x0000010204081000 }},
+	{{ 0xf000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x00000000000000e0, 0x1010101010101000 }, { 0x0000000080402000, 0x0000000102040800 }},
+	{{ 0xe000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x00000000000000f0, 0x0808080808080800 }, { 0x0000008040201000, 0x0000000001020400 }},
+	{{ 0xc000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x00000000000000f8, 0x0404040404040400 }, { 0x0000804020100800, 0x0000000000010200 }},
+	{{ 0x8000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x00000000000000fc, 0x0202020202020200 }, { 0x0080402010080400, 0x0000000000000100 }},
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x00000000000000fe, 0x0101010101010100 }, { 0x8040201008040200, 0x0000000000000000 }},
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }},	// pass
+	{{ 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }, { 0x0000000000000000, 0x0000000000000000 }}
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+
+uint64x2_t mm_Flip(uint64x2_t OP, int pos)
+{
+	uint64x2_t	flip, oflank0, mask0, oflank1, mask1;
+	const uint64x2_t one = vdupq_n_u64(1);
+	uint64x2_t rOP = vreinterpretq_u64_u8(vrev64q_u8(vrbitq_u8(vreinterpretq_u8_u64(OP))));
+	uint64x2_t PP = vdupq_lane_u64(vget_low_u64(OP), 0);	uint64x2_t rPP = vdupq_lane_u64(vget_low_u64(rOP), 0);
+	uint64x2_t OO = vdupq_lane_u64(vget_high_u64(OP), 0);	uint64x2_t rOO = vdupq_lane_u64(vget_high_u64(rOP), 0);
+
+	mask0 = lrmask_v4[pos][2];				mask1 = lrmask_v4[pos][3];
+		// get outflank with carry-propagation
+	oflank0 = vaddq_u64(vornq_u64(rOO, mask0), one);	oflank1 = vaddq_u64(vornq_u64(rOO, mask1), one);
+	oflank0 = vandq_u64(vandq_u64(rPP, mask0), oflank0);	oflank1 = vandq_u64(vandq_u64(rPP, mask1), oflank1);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	oflank0 = vqsubq_u64(oflank0, one);			oflank1 = vqsubq_u64(oflank1, one);
+	flip = vbslq_u64(mask1, oflank1, vandq_u64(mask0, oflank0));
+	flip = vreinterpretq_u64_u8(vrev64q_u8(vrbitq_u8(vreinterpretq_u8_u64(flip))));
+
+	mask0 = lrmask_v4[pos][0];				mask1 = lrmask_v4[pos][1];
+		// get outflank with carry-propagation
+	oflank0 = vaddq_u64(vornq_u64(OO, mask0), one);		oflank1 = vaddq_u64(vornq_u64(OO, mask1), one);
+	oflank0 = vandq_u64(vandq_u64(PP, mask0), oflank0);	oflank1 = vandq_u64(vandq_u64(PP, mask1), oflank1);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	oflank0 = vqsubq_u64(oflank0, one);			oflank1 = vqsubq_u64(oflank1, one);
+	flip = vbslq_u64(mask1, oflank1, vbslq_u64(mask0, oflank0, flip));
+
+	return vorrq_u64(flip, vextq_u64(flip, flip, 1));
+}
diff --git a/src/flip_sse.c b/src/flip_sse.c
index 424dc175..20147793 100644
--- a/src/flip_sse.c
+++ b/src/flip_sse.c
@@ -23,7 +23,8 @@
  * Once we get our 8-bits disc patterns,a first array (OUTFLANK) is used to
  * get the player's discs that surround the opponent discs:
  *  - outflank = OUTFLANK[x][O] & P
- * (Only inner 6-bits of the P are in interest here.)
+ * Because neighbor-of-x bits in the P are not in interest here, outflank
+ * is stored in bitwise rotated form to reduce the table size.
  * The result is then used as an index to access a second array giving the
  * flipped discs according to the surrounding player's discs:
  *  - flipped = FLIPPED[x][outflank].
@@ -32,68 +33,48 @@
  * 64-bits disc pattern, and the flipped squares for each line are gathered and
  * returned to generate moves.
  *
- * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
+ * If the OUTFLANK search is in LSB to MSB direction, LS1B or carry propagation 
  * can be used to determine contiguous opponent discs.
- * If the OUTFLANK search is in MSB to LSB direction, CONTIG_X tables
- * are used to determine coutiguous opponent discs.
+ * If the OUTFLANK search is in MSB to LSB direction, MS1B using int-float
+ * conversion can be used.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @author Toshihiko Okuhara
  * @version 4.4
  */
 
-#include <x86intrin.h>
-
-/** outflank array (indexed with inner 6 bits) */
-/* static const unsigned char OUTFLANK_0[64] = {
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x40,
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x20,
-	0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x80
-}; */
-
-/* static const unsigned char OUTFLANK_1[64] = {
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00,
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
-	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0x00
-}; */
-
-static const unsigned char OUTFLANK_2[64] = {
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x41, 0x00, 0x00,
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x21, 0x00, 0x00,
-	0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00
-};
+#include "bit.h"
+#include <stdio.h>
 
-static const unsigned char OUTFLANK_3[64] = {
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x22, 0x21, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00
+/** rotated outflank array (indexed with inner 6 bits) */
+static const unsigned char OUTFLANK_2[64] = {	// ...ahgfe
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x12, 0x00, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x12, 0x00, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x18, 0x00, 0x00
 };
 
-static const unsigned char OUTFLANK_4[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x40, 0x40, 0x40, 0x40, 0x44, 0x44, 0x42, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x80, 0x80, 0x80, 0x84, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+static const unsigned char OUTFLANK_3[64] = {	// ...bahgf
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x12, 0x0a, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x14, 0x0c, 0x00, 0x00, 0x00, 0x00
 };
 
-static const unsigned char OUTFLANK_5[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x88, 0x88, 0x88, 0x88, 0x84, 0x84, 0x82, 0x81,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+static const unsigned char OUTFLANK_4[64] = {	// ...cbahg
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x01, 0x01, 0x01, 0x11, 0x11, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x02, 0x02, 0x02, 0x02, 0x12, 0x12, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
-/* static const unsigned char OUTFLANK_6[64] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01,
+static const unsigned char OUTFLANK_5[64] = {	// ...dcbah
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x11, 0x11, 0x11, 0x11, 0x09, 0x09, 0x05, 0x03,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-}; */
+};
 
 static const unsigned char OUTFLANK_7[64] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -102,203 +83,127 @@ static const unsigned char OUTFLANK_7[64] = {
 	0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x04, 0x04, 0x02, 0x01
 };
 
-/* (Count of leading 1 from bit 5) * 8 */
-static const unsigned char CONTIG_UP[64] = {
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
-	16, 16, 16, 16, 16, 16, 16, 16, 24, 24, 24, 24, 32, 32, 40, 48
+/** flip array (indexed with rotated outflank, returns inner 6 bits) */
+static const unsigned long long FLIPPED_2_V[25] = {	// ...ahgfe
+	0x0000000000000000, 0x00000000ff000000, 0x000000ffff000000, 0x0000000000000000,
+	0x0000ffffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000ff00, 0x00000000ff00ff00, 0x000000ffff00ff00, 0x0000000000000000,
+	0x0000ffffff00ff00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffffff00ff00
 };
 
-/* (Count of leading 1 from bit 5) * 9 */
-static const unsigned char CONTIG_UPLEFT[64] = {
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-	 9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
-	18, 18, 18, 18, 18, 18, 18, 18, 27, 27, 27, 27, 36, 36, 45, 54
+static const unsigned long long FLIPPED_3_H[21] = {	// ...bahgf
+	0x0000000000000000, 0x1010101010101010, 0x3030303030303030, 0x0000000000000000,
+	0x7070707070707070, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0606060606060606, 0x1616161616161616, 0x3636363636363636, 0x0000000000000000,
+	0x7676767676767676, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0404040404040404, 0x1414141414141414, 0x3434343434343434, 0x0000000000000000,
+	0x7474747474747474
 };
 
-/* (Count of trailing 1) * 7 */
-static const unsigned char CONTIG_UPRIGHT[64] = {
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 28,
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 35,
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 28,
-	 0,  7,  0, 14,  0,  7,  0, 21,  0,  7,  0, 14,  0,  7,  0, 42
+static const unsigned long long FLIPPED_4_H[19] = {	// ...cbahg
+	0x0000000000000000, 0x2020202020202020, 0x6060606060606060, 0x0000000000000000,
+	0x0e0e0e0e0e0e0e0e, 0x2e2e2e2e2e2e2e2e, 0x6e6e6e6e6e6e6e6e, 0x0000000000000000,
+	0x0c0c0c0c0c0c0c0c, 0x2c2c2c2c2c2c2c2c, 0x6c6c6c6c6c6c6c6c, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0808080808080808, 0x2828282828282828, 0x6868686868686868
 };
 
-/** flip array (indexed with outflank, returns inner 6 bits) */
-static const unsigned long long FLIPPED_2_H[130] = {
-	0x0000000000000000ULL, 0x0202020202020202ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0808080808080808ULL, 0x0a0a0a0a0a0a0a0aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1818181818181818ULL, 0x1a1a1a1a1a1a1a1aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3838383838383838ULL, 0x3a3a3a3a3a3a3a3aULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7878787878787878ULL, 0x7a7a7a7a7a7a7a7aULL
+static const unsigned long long FLIPPED_4_V[19] = {
+	0x0000000000000000, 0x0000ff0000000000, 0x00ffff0000000000, 0x0000000000000000,
+	0x00000000ffffff00, 0x0000ff00ffffff00, 0x00ffff00ffffff00, 0x0000000000000000,
+	0x00000000ffff0000, 0x0000ff00ffff0000, 0x00ffff00ffff0000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00000000ff000000, 0x0000ff00ff000000, 0x00ffff00ff000000
 };
 
-static const unsigned long long FLIPPED_3_H[131] = {
-	0x0000000000000000ULL, 0x0606060606060606ULL, 0x0404040404040404ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x1616161616161616ULL, 0x1414141414141414ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x3030303030303030ULL, 0x3636363636363636ULL, 0x3434343434343434ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x7070707070707070ULL, 0x7676767676767676ULL, 0x7474747474747474ULL
+static const unsigned long long FLIPPED_7_V[38] = {
+	0x0000000000000000, 0x00ffffffffffff00, 0x00ffffffffff0000, 0x0000000000000000,
+	0x00ffffffff000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffffff00000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ffff0000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	// static const unsigned long long FLIPPED_5_V[18] = {	// ...dcbah
+		0x0000000000000000, 0x00ff000000000000, 0x000000ffffffff00, 0x00ff00ffffffff00,
+		0x000000ffffff0000, 0x00ff00ffffff0000, 0x0000000000000000, 0x0000000000000000,
+		0x000000ffff000000, 0x00ff00ffff000000, 0x0000000000000000, 0x0000000000000000,
+	0x00ff000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+		0x000000ff00000000, 0x00ff00ff00000000
 };
 
-static const unsigned long long FLIPPED_4_H[133] = {
-	0x0000000000000000ULL, 0x0e0e0e0e0e0e0e0eULL, 0x0c0c0c0c0c0c0c0cULL, 0x0000000000000000ULL, 0x0808080808080808ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x2020202020202020ULL, 0x2e2e2e2e2e2e2e2eULL, 0x2c2c2c2c2c2c2c2cULL, 0x0000000000000000ULL, 0x2828282828282828ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x6060606060606060ULL, 0x6e6e6e6e6e6e6e6eULL, 0x6c6c6c6c6c6c6c6cULL, 0x0000000000000000ULL, 0x6868686868686868ULL
-};
+static const unsigned long long *FLIPPED_5_V = FLIPPED_7_V + 20;
 
-static const unsigned long long FLIPPED_5_H[137] = {
-	0x0000000000000000ULL, 0x1e1e1e1e1e1e1e1eULL, 0x1c1c1c1c1c1c1c1cULL, 0x0000000000000000ULL, 0x1818181818181818ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x1010101010101010ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x4040404040404040ULL, 0x5e5e5e5e5e5e5e5eULL, 0x5c5c5c5c5c5c5c5cULL, 0x0000000000000000ULL, 0x5858585858585858ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x5050505050505050ULL
-};
 
-static const unsigned long long FLIPPED_3_V[131] = {
-	0x0000000000000000ULL, 0x0000000000ffff00ULL, 0x0000000000ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x000000ff00ffff00ULL, 0x000000ff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ffff00000000ULL, 0x0000ffff00ffff00ULL, 0x0000ffff00ff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffffff00000000ULL, 0x00ffffff00ffff00ULL, 0x00ffffff00ff0000ULL
-};
+#define minusone	_mm_set1_epi32(-1)
 
-static const unsigned long long FLIPPED_4_V[133] = {
-	0x0000000000000000ULL, 0x00000000ffffff00ULL, 0x00000000ffff0000ULL, 0x0000000000000000ULL, 0x00000000ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000ff0000000000ULL, 0x0000ff00ffffff00ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ffff0000000000ULL, 0x00ffff00ffffff00ULL, 0x00ffff00ffff0000ULL, 0x0000000000000000ULL, 0x00ffff00ff000000ULL
-};
+#define	SWAP64	0x4e	// for _mm_shuffle_epi32
+#define	SWAP32	0xb1
+#define	DUPLO	0x44
+#define	DUPHI	0xee
 
-static const unsigned long long  FLIPPED_5_V[137] = {
-	0x0000000000000000ULL, 0x000000ffffffff00ULL, 0x000000ffffff0000ULL, 0x0000000000000000ULL, 0x000000ffff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x000000ff00000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ff000000000000ULL, 0x00ff00ffffffff00ULL, 0x00ff00ffffff0000ULL, 0x0000000000000000ULL, 0x00ff00ffff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00ff00ff00000000ULL
-};
 
-static const unsigned long long FLIPPED_3_U[131] = {
-	0x0000000000000000ULL, 0x00ffff0000000000ULL, 0x0000ff0000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ff000000ULL, 0x00ffff00ff000000ULL, 0x0000ff00ff000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ffff0000ULL, 0x00ffff00ffff0000ULL, 0x0000ff00ffff0000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL,
-	0x00000000ffffff00ULL, 0x00ffff00ffffff00ULL, 0x0000ff00ffffff00ULL
-};
+/*
+ * Extract most significant bit set from 4 x u31 (3 inst)
+ * valid only for x < 0x7fffff80
+ */
+static inline __m128i MS1B_epu31(const __m128i x) {
+	const __m128 exp_mask = _mm_castsi128_ps(_mm_set1_epi32(0xff800000));
+	return _mm_cvtps_epi32(_mm_and_ps(_mm_cvtepi32_ps(x), exp_mask));	// clear mantissa = non msb bits
+}
+
+/*
+ * Extract most significant bit set from 4 x u32 (7 inst)
+ * cf. http://umezawa.dyndns.info/wordpress/?p=3743
+ */
+static inline __m128i MS1B_epu32(const __m128i x) {
+	__m128i y = MS1B_epu31(x);
+	return _mm_andnot_si128(_mm_srli_epi32(_mm_srai_epi32(y, 31), 1), y);	// clear except sign if negative
+}
+
+/*
+ * Extract most significant bit set from 2 x u64 (12 inst)
+ */
+static inline __m128i MS1B_epu64(const __m128i x) {
+	__m128i y = MS1B_epu32(x);
+	return _mm_and_si128(y, _mm_cmpeq_epi32(_mm_srli_epi64(y, 32), _mm_setzero_si128()));	// clear low if high != 0
+}
 
+/*
+ * Extract most significant bit set (6 inst)
+ * valid only for x < 0x000fffffffffffffULL
+ *
+ * https://software.intel.com/en-us/forums/intel-isa-extensions/topic/301988
+ * https://stackoverflow.com/questions/41144668/how-to-efficiently-perform-double-int64-conversions-with-sse-avx/41148578#41148578
+ */
+ static inline __m128i MS1B_epu52(const __m128i x) {
+	const __m128d k1e52 = _mm_set1_pd(0x0010000000000000);
+	const __m128d exp_mask = _mm_castsi128_pd(_mm_set1_epi64x(0xfff0000000000000));
+	__m128d f;
+	f = _mm_or_pd(_mm_castsi128_pd(x), k1e52);	// construct double x + 2^52
+	f = _mm_sub_pd(f, k1e52);	// extract 2^52 from double -- mantissa will be automatically normalized
+	f = _mm_and_pd(f, exp_mask);	// clear mantissa = non msb bits
+	f = _mm_add_pd(f, k1e52);	// add 2^52 to push back the msb
+	f = _mm_xor_pd(f, k1e52);	// remove exponent
+	return _mm_castpd_si128(f);
+}
 
 /**
  * Make inverted flip mask if opponent's disc are surrounded by player's.
  *
- * 0xffffffffffffffffULL if outflank is 0
- * 0xffffffff00000000ULL if a 1 is in lower 32 bit
- * 0x0000000000000000ULL if a 1 is in higher 32 bit
+ * 0xffffffffffffffffULL (-1) if outflank is 0
+ * 0x0000000000000000ULL ( 0) if a 1 is in 64 bit
  */
-static inline __v2di flipmask (__v2di outflank) {
-	return _mm_cmpeq_epi32(_mm_srli_epi64(outflank, 32), outflank);
+static inline __m128i flipmask (const __m128i outflank) {
+	return _mm_cmpeq_epi32(_mm_shuffle_epi32(outflank, SWAP32), outflank);
+}
+
+/**
+ * Load 2 unsigned long longs into xmm.
+ */
+static inline __m128i load64x2 (const unsigned long long *x0, const unsigned long long *x1) {
+	return _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(_mm_loadl_epi64((__m128i *) x0)), (__m64 *) x1));
 }
 
 /**
@@ -308,24 +213,23 @@ static inline __v2di flipmask (__v2di outflank) {
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-
-static unsigned long long flip_A1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A1(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0101010101010100ULL, ~0x8040201008040200ULL };
-	static const __v2di next = { 0x0000000000000100ULL, 0x0000000000000200ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
+	const __m128i mask = _mm_set_epi64x(0x8040201008040200, 0x0101010101010100);
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[1]);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_h = ((O & 0x7e) + 0x02) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x7e;
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -335,23 +239,23 @@ static unsigned long long flip_A1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B1(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0202020202020200ULL, ~0x0080402010080400ULL };
-	static const __v2di next = { 0x0000000000000200ULL, 0x0000000000000400ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
+	const __m128i mask = _mm_set_epi64x(0x0080402010080400, 0x0202020202020200);
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[2]);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_h = ((O & 0x7c) + 0x04) & P;
-	flipped |= (outflank_h - (unsigned int) (outflank_h != 0)) & 0x7c;
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -361,25 +265,24 @@ static unsigned long long flip_B1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C1(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0404040404040400ULL, ~0x0000804020100800ULL };
-	static const __v2di next = { 0x0000000000000400ULL, 0x0000000000000800ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, flipped_h_b1b2;
+	const __m128i mask = _mm_set_epi64x(0x0000804020100800, 0x0404040404040400);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_h = OUTFLANK_2[(O >> 1) & 0x3f] & P;
-	flipped |= (unsigned char) FLIPPED_2_H[outflank_h];
+	flipped_h_b1b2 = _mm_and_si128(_mm_adds_epu8(OO, _mm_set_epi8(0, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0x08)), PP);
+	flipped_h_b1b2 = _mm_srli_epi64(_mm_mullo_epi16(flipped_h_b1b2, _mm_set_epi16(0, 0, 0x0002, 0x0200, 0, 0, 0, 0x00ff)), 8);
+	flipped_h_b1b2 = _mm_and_si128(_mm_and_si128(flipped_h_b1b2, OO), _mm_set_epi16(0, 0, 0, 0x0202, 0, 0, 0, 0x0078));
+	flipped = _mm_or_si128(flipped, flipped_h_b1b2);
 
-	flipped |= (((unsigned int) P >> 7) & 0x00000200u & (unsigned int) O);
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -389,26 +292,27 @@ static unsigned long long flip_C1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D1(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d7;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0808080808080800ULL, ~0x0000008040201000ULL };
-	static const __v2di next = { 0x0000000000000800ULL, 0x0000000000001000ULL };
+	__m128i	outflank_v, flipped, index_d;
+	unsigned int outflank_h, outflank_d;
+	const __m128i mask = _mm_set_epi64x(0x0000008041221408, 0x0808080808080800);	// A4D1H5
+
+	outflank_v = _mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask);
+	outflank_v = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_v, minusone), outflank_v), OP);
+	outflank_v = _mm_add_epi64(outflank_v, minusone);
+	flipped = _mm_add_epi64(outflank_v, _mm_srli_epi64(outflank_v, 63));
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
 
-	outflank_h = OUTFLANK_3[(O >> 1) & 0x3f] & P;
-	flipped |= (unsigned char) FLIPPED_3_H[outflank_h];
+	flipped = _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(flipped), (__m64 *) &FLIPPED_3_H[outflank_d]));
+	flipped = _mm_and_si128(mask, flipped);
 
-	outflank_d7 = ((O | ~0x01020400u) + 0x00000400u) & P & 0x01020000u;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x00020400u;
+	outflank_h = OUTFLANK_3[(_mm_extract_epi16(OP, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si64(OP), 3);
+	flipped = _mm_or_si128(flipped, _mm_srli_epi64(_mm_loadl_epi64((__m128i *) &FLIPPED_3_H[outflank_h]), 56));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -418,26 +322,27 @@ static unsigned long long flip_D1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E1(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d9;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x1010101010101000ULL, ~0x0000000102040800ULL };
-	static const __v2di next = { 0x0000000000001000ULL, 0x0000000000000800ULL };
+	__m128i	outflank_v, flipped, index_d;
+	unsigned int outflank_h, outflank_d;
+	const __m128i mask = _mm_set_epi64x(0x0000000182442810, 0x1010101010101000);	// A5E1H4
+
+	outflank_v = _mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask);
+	outflank_v = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_v, minusone), outflank_v), OP);
+	outflank_v = _mm_add_epi64(outflank_v, minusone);
+	flipped = _mm_add_epi64(outflank_v, _mm_srli_epi64(outflank_v, 63));
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 2);
 
-	outflank_h = OUTFLANK_4[(O >> 1) & 0x3f] & P;
-	flipped |= (unsigned char) FLIPPED_4_H[outflank_h];
+	flipped = _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(flipped), (__m64 *) &FLIPPED_4_H[outflank_d]));
+	flipped = _mm_and_si128(mask, flipped);
 
-	outflank_d9 = ((O | ~0x80402000u) + 0x00002000u) & P & 0x80400000u;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x00402000u;
+	outflank_h = OUTFLANK_4[(_mm_extract_epi16(OP, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si64(OP), 2);
+	flipped = _mm_or_si128(flipped, _mm_srli_epi64(_mm_loadl_epi64((__m128i *) &FLIPPED_4_H[outflank_h]), 56));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -447,25 +352,25 @@ static unsigned long long flip_E1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F1(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x2020202020202000ULL, ~0x0000010204081000ULL };
-	static const __v2di next = { 0x0000000000002000ULL, 0x0000000000001000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, outflank_h, flipped_h_g1g2;
+	const __m128i mask = _mm_set_epi64x(0x0000010204081000, 0x2020202020202000);
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x0000001f))), PP);
 
-	outflank_h = OUTFLANK_5[(O >> 1) & 0x3f] & P;
-	flipped |= (unsigned char) FLIPPED_5_H[outflank_h];
+	flipped_h_g1g2 = _mm_unpacklo_epi64(outflank_h, PP);
+	flipped_h_g1g2 = _mm_srli_epi64(_mm_mullo_epi16(flipped_h_g1g2, _mm_set_epi16(0, 0, 1, 0x0100, 0, 0, 0, -0x0400)), 9);
+	flipped_h_g1g2 = _mm_and_si128(_mm_and_si128(flipped_h_g1g2, OO), _mm_set_epi16(0, 0, 0, 0x4040, 0, 0, 0, 0x001f));
 
-	flipped |= (((unsigned int) P >> 9) & 0x00004000u & (unsigned int) O);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_or_si128(flipped_h_g1g2, _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63))));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -475,23 +380,21 @@ static unsigned long long flip_F1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G1(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x4040404040404000ULL, ~0x0001020408102000ULL };
-	static const __v2di next = { 0x0000000000004000ULL, 0x0000000000002000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_vd = _mm_andnot_si128(OO, _mm_set_epi64x(0x0001020408102000, 0x4040404040404000));
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);
+	flipped = _mm_sub_epi64(outflank_vd, _mm_andnot_si128(flipmask(outflank_vd), _mm_set1_epi64x(0x0000000000000100)));
 
-	outflank_h = OUTFLANK_7[O & 0x3e] & (P << 1);
-	flipped |= (outflank_h * 0x0000001fu) & 0x0000003eu;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x0000003f))), PP);
+	flipped = _mm_sub_epi8(flipped, _mm_add_epi8(outflank_h, outflank_h));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0001020408102000, 0x404040404040403e));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -501,23 +404,21 @@ static unsigned long long flip_G1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H1(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H1(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x8080808080808000ULL, ~0x0102040810204000ULL };
-	static const __v2di next = { 0x0000000000008000ULL, 0x0000000000004000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_vd = _mm_andnot_si128(OO, _mm_set_epi64x(0x0102040810204000, 0x8080808080808000));
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);
+	flipped = _mm_sub_epi64(outflank_vd, _mm_andnot_si128(flipmask(outflank_vd), _mm_set1_epi64x(0x0000000000000100)));
 
-	outflank_h = OUTFLANK_7[(O >> 1) & 0x3f] & P;
-	flipped |= (outflank_h * 0x0000007eu) & 0x0000007eu;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x0000007f))), PP);
+	flipped = _mm_sub_epi8(flipped, _mm_add_epi8(outflank_h, outflank_h));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0102040810204000, 0x808080808080807e));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -527,23 +428,23 @@ static unsigned long long flip_H1(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0101010101010000ULL, ~0x4020100804020000ULL };
-	static const __v2di next = { 0x0000000000010000ULL, 0x0000000000020000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
+	const __m128i mask = _mm_set_epi64x(0x4020100804020000, 0x0101010101010000);
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[9]);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_h = ((O & 0x00007e00u) + 0x00000200u) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007e00u;
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -553,23 +454,23 @@ static unsigned long long flip_A2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0202020202020000ULL, ~0x8040201008040000ULL };
-	static const __v2di next = { 0x0000000000020000ULL, 0x0000000000040000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
+	const __m128i mask = _mm_set_epi64x(0x8040201008040000, 0x0202020202020000);
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[10]);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_h = ((O & 0x00007c00u) + 0x00000400u) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007c00u;
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -579,25 +480,24 @@ static unsigned long long flip_B2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0404040404040000ULL, ~0x0080402010080000ULL };
-	static const __v2di next = { 0x0000000000040000ULL, 0x0000000000080000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, flipped_h_b2b3;
+	const __m128i mask = _mm_set_epi64x(0x0080402010080000, 0x0404040404040000);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_h = OUTFLANK_2[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x000000000000ff00ULL;
+	flipped_h_b2b3 = _mm_and_si128(_mm_adds_epu8(OO, _mm_set_epi8(0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0x08, 0)), PP);
+	flipped_h_b2b3 = _mm_mullo_epi16(_mm_srli_epi64(flipped_h_b2b3, 8), _mm_set_epi16(0, 0, 0x0002, 0x0200, 0, 0, 0, 0x00ff));
+	flipped_h_b2b3 = _mm_and_si128(_mm_and_si128(flipped_h_b2b3, OO), _mm_set_epi16(0, 0, 0x0002, 0x0200, 0, 0, 0, 0x7800));
+	flipped = _mm_or_si128(flipped, flipped_h_b2b3);
 
-	flipped |= (((unsigned int) P >> 7) & 0x00020000u & (unsigned int) O);
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -607,26 +507,27 @@ static unsigned long long flip_C2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_d7;
-	__v2di	outflank_v_d9;
-	static const __v2di mask = { ~0x0808080808080000ULL, ~0x0000804020100000ULL };
-	static const __v2di next = { 0x0000000000080000ULL, 0x0000000000100000ULL };
+	__m128i	outflank_v, flipped, index_d;
+	unsigned int outflank_h, outflank_d;
+	const __m128i mask = _mm_set_epi64x(0x000080412214ff00, 0x0808080808080000);
 
-	outflank_v_d9 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d9 = ~mask & (~flipmask(outflank_v_d9) & (outflank_v_d9 - next));
-	outflank_v_d9 |= _mm_unpackhi_epi64(outflank_v_d9, outflank_v_d9);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d9);
+	outflank_v = _mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask);
+	outflank_v = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_v, minusone), outflank_v), OP);
+	outflank_v = _mm_add_epi64(outflank_v, minusone);
+	flipped = _mm_add_epi64(outflank_v, _mm_srli_epi64(outflank_v, 63));
 
-	outflank_h = OUTFLANK_3[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000000000ff00ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_set1_epi64x(0x0000804122140800)), _mm_setzero_si128());	// A5D2H6
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
 
-	outflank_d7 = ((O | ~0x0000000102040000ULL) + 0x0000000000040000ULL) & P & 0x0000000102000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0000000002040000ULL;
+	flipped = _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(flipped), (__m64 *) &FLIPPED_3_H[outflank_d]));
 
-	return flipped;
+	outflank_h = OUTFLANK_3[(_mm_extract_epi16(OP, 4) >> 9) & 0x3f] & rotl8(_mm_cvtsi128_si64(OP) >> 8, 3);
+	flipped = _mm_insert_epi16(flipped, FLIPPED_3_H[outflank_h], 4);
+	flipped = _mm_and_si128(flipped, mask);
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -636,26 +537,27 @@ static unsigned long long flip_D2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_d9;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x1010101010100000ULL, ~0x0000010204080000ULL };
-	static const __v2di next = { 0x0000000000100000ULL, 0x0000000000080000ULL };
+	__m128i	outflank_v, flipped, index_d;
+	unsigned int outflank_h, outflank_d;
+	const __m128i mask = _mm_set_epi64x(0x000001824428ff00, 0x1010101010100000);
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_v = _mm_andnot_si128(_mm_shuffle_epi32(OP, DUPHI), mask);
+	outflank_v = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_v, minusone), outflank_v), OP);
+	outflank_v = _mm_add_epi64(outflank_v, minusone);
+	flipped = _mm_add_epi64(outflank_v, _mm_srli_epi64(outflank_v, 63));
 
-	outflank_h = OUTFLANK_4[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000000000ff00ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_set1_epi64x(0x0000018244281000)), _mm_setzero_si128());	// A6E2H5
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 2);
 
-	outflank_d9 = ((O | ~0x0000008040200000ULL) + 0x0000000000200000ULL) & P & 0x0000008040000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0000000040200000ULL;
+	flipped = _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(flipped), (__m64 *) &FLIPPED_4_H[outflank_d]));
 
-	return flipped;
+	outflank_h = OUTFLANK_4[(_mm_extract_epi16(OP, 4) >> 9) & 0x3f] & rotl8(_mm_cvtsi128_si64(OP) >> 8, 2);
+	flipped = _mm_insert_epi16(flipped, FLIPPED_4_H[outflank_h], 4);
+	flipped = _mm_and_si128(flipped, mask);
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -665,25 +567,25 @@ static unsigned long long flip_E2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x2020202020200000ULL, ~0x0001020408100000ULL };
-	static const __v2di next = { 0x0000000000200000ULL, 0x0000000000100000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, outflank_h, flipped_h_g2g3;
+	const __m128i mask = _mm_set_epi64x(0x0001020408100000, 0x2020202020200000);
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x00001f00))), PP);
 
-	outflank_h = OUTFLANK_5[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x000000000000ff00ULL;
+	flipped_h_g2g3 = _mm_unpacklo_epi64(outflank_h, _mm_srli_epi64(PP, 9));
+	flipped_h_g2g3 = _mm_mullo_epi16(flipped_h_g2g3, _mm_set_epi16(0, 0, 1, 0x0100, 0, 0, 0, -2));
+	flipped_h_g2g3 = _mm_and_si128(_mm_and_si128(flipped_h_g2g3, OO), _mm_set_epi16(0, 0, 0x0040, 0x4000, 0, 0, 0, 0x1f00));
 
-	flipped |= (((unsigned int) P >> 9) & 0x00400000u & (unsigned int) O);
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_or_si128(flipped_h_g2g3, _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63))));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -693,23 +595,21 @@ static unsigned long long flip_F2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x4040404040400000ULL, ~0x0102040810200000ULL };
-	static const __v2di next = { 0x0000000000400000ULL, 0x0000000000200000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_vd = _mm_andnot_si128(OO, _mm_set_epi64x(0x0102040810200000, 0x4040404040400000));
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);
+	flipped = _mm_sub_epi64(outflank_vd, _mm_andnot_si128(flipmask(outflank_vd), _mm_set1_epi64x(0x0000000000010000)));
 
-	outflank_h = OUTFLANK_7[(O >> 8) & 0x3e] & ((unsigned int) P >> 7);
-	flipped |= (outflank_h * 0x00001f00u) & 0x00003e00u;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x00003f00))), PP);
+	flipped = _mm_sub_epi8(flipped, _mm_add_epi8(outflank_h, outflank_h));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0102040810200000, 0x4040404040403e00));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -719,23 +619,21 @@ static unsigned long long flip_G2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H2(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H2(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped;
-	__v2di	outflank_v_d7;
-	static const __v2di mask = { ~0x8080808080800000ULL, ~0x0204081020400000ULL };
-	static const __v2di next = { 0x0000000000800000ULL, 0x0000000000400000ULL };
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped;
 
-	outflank_v_d7 = ~mask & (((_mm_set1_epi64x(O) | mask) + next) & _mm_set1_epi64x(P));
-	outflank_v_d7 = ~mask & (~flipmask(outflank_v_d7) & (outflank_v_d7 - next));
-	outflank_v_d7 |= _mm_unpackhi_epi64(outflank_v_d7, outflank_v_d7);
-	flipped = (unsigned long long) _mm_movepi64_pi64(outflank_v_d7);
+	outflank_vd = _mm_andnot_si128(OO, _mm_set_epi64x(0x0204081020400000, 0x8080808080800000));
+	outflank_vd = _mm_and_si128(_mm_and_si128(outflank_vd, _mm_sub_epi64(_mm_setzero_si128(), outflank_vd)), PP);
+	flipped = _mm_sub_epi64(outflank_vd, _mm_andnot_si128(flipmask(outflank_vd), _mm_set1_epi64x(0x0000000000010000)));
 
-	outflank_h = OUTFLANK_7[(O >> 9) & 0x3f] & ((unsigned int) P >> 8);
-	flipped |= (outflank_h * 0x00007e00u) & 0x00007e00u;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x00007f00))), PP);
+	flipped = _mm_sub_epi8(flipped, _mm_add_epi8(outflank_h, outflank_h));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0204081020400000, 0x8080808080807e00));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -745,22 +643,24 @@ static unsigned long long flip_H2(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A3(const __m128i OP)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
-
-	outflank_v = ((O | ~0x0101010101000000ULL) + 0x0000000001000000ULL) & P & 0x0101010101000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0101010101000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped, flipped_h_a2b2;
+	const __m128i mask = _mm_set_epi64x(0x2010080402000000, 0x0101010101000000);
 
-	outflank_h = ((O & 0x00000000007e0000ULL) + 0x0000000000020000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00000000007e0000ULL;
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_d9 = ((O | ~0x2010080402000000ULL) + 0x0000000002000000ULL) & P & 0x2010080402000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x2010080402000000ULL;
+	outflank_h = _mm_and_si128(PP, _mm_adds_epu8(OO, _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 2, 0, -1)));
+	flipped_h_a2b2 = _mm_srli_epi16(_mm_mullo_epi16(outflank_h, _mm_set_epi16(0, 0, 0, 0x2000, 0, 0, 0x003f, 0x4000)), 6);
+	flipped_h_a2b2 = _mm_and_si128(flipped_h_a2b2, _mm_set_epi64x(0x0000000000000200, 0x00000000007e0100));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(flipped_h_a2b2, OO));
 
-	flipped |= (((P << 8) & 0x0000000000000100ULL) | ((P << 7) & 0x0000000000000200ULL)) & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -770,22 +670,24 @@ static unsigned long long flip_A3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B3(const __m128i OP)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d9;
-
-	outflank_v = ((O | ~0x0202020202000000ULL) + 0x0000000002000000ULL) & P & 0x0202020202000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0202020202000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped, flipped_h_b2c2;
+	const __m128i mask = _mm_set_epi64x(0x4020100804000000, 0x0202020202000000);
 
-	outflank_h = ((O & 0x00000000007c0000ULL) + 0x0000000000040000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00000000007c0000ULL;
+	outflank_vd = _mm_andnot_si128(OO, mask);
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(_mm_add_epi64(outflank_vd, minusone), outflank_vd), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_and_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_d9 = ((O | ~0x4020100804000000ULL) + 0x0000000004000000ULL) & P & 0x4020100804000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x4020100804000000ULL;
+	outflank_h = _mm_and_si128(PP, _mm_adds_epu8(OO, _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 4, 0, -1)));
+	flipped_h_b2c2 = _mm_srli_epi16(_mm_mullo_epi16(outflank_h, _mm_set_epi16(0, 0, 0, 0x1000, 0, 0, 0x001f, 0x2000)), 5);
+	flipped_h_b2c2 = _mm_and_si128(flipped_h_b2c2, _mm_set_epi64x(0x0000000000000400, 0x00000000007c0200));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(flipped_h_b2c2, OO));
 
-	flipped |= (((P << 8) & 0x0000000000000200ULL) | ((P << 7) & 0x0000000000000400ULL)) & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -795,23 +697,26 @@ static unsigned long long flip_B3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C3(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = ((O | ~0x0404040404000000ULL) + 0x0000000004000000ULL) & P & 0x0404040404000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0404040404000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped, flipped_b4b3b2c2d2;
+	const __m128i mask = _mm_set_epi64x(~0x8040201008000000ULL, ~0x0404040404000000ULL);
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[19]);
 
-	outflank_h = OUTFLANK_2[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x0000000000ff0000ULL;
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(mask, _mm_sub_epi64(_mm_or_si128(OO, mask), minusone)), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped = _mm_andnot_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
 
-	outflank_d9 = ((O | ~0x8040201008000000ULL) + 0x0000000008000000ULL) & P & 0x8040201008000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x8040201008000000ULL;
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	flipped |= (((P << 8) & 0x0000000000000400ULL) | ((P << 9) & 0x0000000000000200ULL) | (((P >> 7) | (P << 7)) & 0x000000002000800ULL)) & O;
+	flipped_b4b3b2c2d2 = _mm_and_si128(_mm_shufflelo_epi16(PP, 0x90), _mm_set_epi16(0, 0, 0, 0x0001, 0x0001, 0x0001, 0x0004, 0x0010));	// ...a1a5a3c1e1
+	flipped_b4b3b2c2d2 = _mm_madd_epi16(flipped_b4b3b2c2d2, _mm_set_epi16(0, 0, 0, 0x0200, 0x0200, 0x0002, 0x0100, 0x0080));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_shufflelo_epi16(flipped_b4b3b2c2d2, 0xf8), OO));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -821,26 +726,29 @@ static unsigned long long flip_C3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D3(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	__m128i	flipped, flipped_h_c2e2, index_d;
+	unsigned int outflank_h, outflank_v, outflank_d, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0080412214080000, 0x0808080808080808);	// A6D3H7
 
-	outflank_v = ((O | ~0x0808080808000000ULL) + 0x0000000008000000ULL) & P & 0x0808080808000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x0808080808000000ULL;
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = OUTFLANK_2[(index_v >> 9) & 0x3f] & rotl8(index_v, 4);
 
-	outflank_h = OUTFLANK_3[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000000000ff0000ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
 
-	outflank_d7 = ((O | ~0x0000010204000000ULL) + 0x0000000004000000ULL) & P & 0x0000010204000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 24)) & 0x0000010204000000ULL;
+	flipped = _mm_and_si128(load64x2(&FLIPPED_2_V[outflank_v], &FLIPPED_3_H[outflank_d]), mask);
 
-	outflank_d9 = ((O | ~0x0080402010000000ULL) + 0x0000000010000000ULL) & P & 0x0080402010000000ULL;
-	flipped |= (outflank_d9 - (unsigned int) (outflank_d9 != 0)) & 0x0080402010000000ULL;
+	outflank_h = OUTFLANK_3[(_mm_extract_epi16(OP, 5) >> 1) & 0x3f] & rotl8(_mm_extract_epi16(OP, 1), 3);
 
-	flipped |= (((P << 8) & 0x0000000000000800ULL) | ((P << 7) & 0x0000000000001000ULL) | ((P << 9) & 0x000000000000400ULL)) & O;
+	flipped_h_c2e2 = _mm_unpacklo_epi64(_mm_slli_epi64(OP, 9), _mm_slli_epi64(OP, 7));
+	flipped_h_c2e2 = _mm_and_si128(flipped_h_c2e2, _mm_shuffle_epi32(OP, DUPHI));
+	flipped_h_c2e2 = _mm_insert_epi16(flipped_h_c2e2, FLIPPED_3_H[outflank_h], 1);
+	flipped_h_c2e2 = _mm_and_si128(flipped_h_c2e2, _mm_set_epi64x(0x0000000000001000, 0x0000000000ff0400));
+	flipped = _mm_or_si128(flipped, flipped_h_c2e2);
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -850,26 +758,29 @@ static unsigned long long flip_D3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E3(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7, outflank_d9;
+	__m128i	flipped, flipped_h_d2f2, index_d;
+	unsigned int outflank_h, outflank_v, outflank_d, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0001824428100000, 0x1010101010101010);	// A7E3H6
 
-	outflank_v = ((O | ~0x1010101010000000ULL) + 0x0000000010000000ULL) & P & 0x1010101010000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x1010101010000000ULL;
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = OUTFLANK_2[(index_v >> 9) & 0x3f] & rotl8(index_v, 4);
 
-	outflank_h = OUTFLANK_4[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000000000ff0000ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 2);
 
-	outflank_d7 = ((O | ~0x0001020408000000ULL) + 0x0000000008000000ULL) & P & 0x0001020408000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0001020408000000ULL;
+	flipped = _mm_and_si128(load64x2(&FLIPPED_2_V[outflank_v], &FLIPPED_4_H[outflank_d]), mask);
 
-	outflank_d9 = ((O | ~0x0000804020000000ULL) + 0x0000000020000000ULL) & P & 0x0000804020000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 24)) & 0x0000804020000000ULL;
+	outflank_h = OUTFLANK_4[(_mm_extract_epi16(OP, 5) >> 1) & 0x3f] & rotl8(_mm_extract_epi16(OP, 1), 2);
 
-	flipped |= (((P << 8) & 0x0000000000001000ULL) | ((P << 7) & 0x0000000000002000ULL) | ((P << 9) & 0x000000000000800ULL)) & O;
+	flipped_h_d2f2 = _mm_unpacklo_epi64(_mm_slli_epi64(OP, 9), _mm_slli_epi64(OP, 7));
+	flipped_h_d2f2 = _mm_and_si128(flipped_h_d2f2, _mm_shuffle_epi32(OP, DUPHI));
+	flipped_h_d2f2 = _mm_insert_epi16(flipped_h_d2f2, FLIPPED_4_H[outflank_h], 1);
+	flipped_h_d2f2 = _mm_and_si128(flipped_h_d2f2, _mm_set_epi64x(0x0000000000002000, 0x0000000000ff0800));
+	flipped = _mm_or_si128(flipped, flipped_h_d2f2);
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -879,23 +790,26 @@ static unsigned long long flip_E3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F3(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_h, outflank_vd, flipped, flipped_vd, flipped_g4g3g2f2e2;
+	const __m128i mask = _mm_set_epi64x(~0x0102040810000000ULL, ~0x2020202020000000ULL);
 
-	outflank_v = ((O | ~0x2020202020000000ULL) + 0x0000000020000000ULL) & P & 0x2020202020000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x2020202020000000ULL;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x001f0000))), PP);
+	flipped = _mm_srli_epi16(_mm_mullo_epi16(outflank_h, _mm_set_epi16(0, 0, 0, 0, 0, 0, -0x1000, 0)), 11);
 
-	outflank_h = OUTFLANK_5[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x0000000000ff0000ULL;
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(mask, _mm_sub_epi64(_mm_or_si128(OO, mask), minusone)), PP);
+	outflank_vd = _mm_add_epi64(outflank_vd, minusone);
+	flipped_vd = _mm_andnot_si128(mask, _mm_add_epi64(outflank_vd, _mm_srli_epi64(outflank_vd, 63)));
+	flipped = _mm_or_si128(flipped, flipped_vd);
 
-	outflank_d7 = ((O | ~0x0102040810000000ULL) + 0x0000000010000000ULL) & P & 0x0102040810000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0102040810000000ULL;
+	flipped_g4g3g2f2e2 = _mm_and_si128(_mm_shufflelo_epi16(PP, 0x90), _mm_set_epi16(0, 0, 0, 0x0080, 0x0080, 0x0080, 0x0020, 0x0008));	// ...h1h5h3f1d1
+	flipped_g4g3g2f2e2 = _mm_srli_epi16(_mm_madd_epi16(flipped_g4g3g2f2e2, _mm_set_epi16(0, 0, 0, 0x0100, 0x0100, 0x0001, 0x0200, 0x0400)), 1);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_shufflelo_epi16(flipped_g4g3g2f2e2, 0xf8), OO));
 
-	flipped |= (((P << 8) & 0x0000000000002000ULL) | ((P << 7) & 0x0000000000004000ULL) | (((P >> 9) | (P << 9)) & 0x0000000040001000ULL)) & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -905,23 +819,23 @@ static unsigned long long flip_F3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G3(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x4040404040000000ULL) + 0x0000000040000000ULL) & P & 0x4040404040000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x4040404040000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped, flipped_g2f2;
+	const __m128i mask = _mm_set_epi64x(~0x0204081020000000, ~0x4040404040000000);
 
-	outflank_h = OUTFLANK_7[(O >> 16) & 0x3e] & (P >> 15);
-	flipped |= ((-outflank_h) & 0x3e) << 16;
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(mask, _mm_sub_epi64(_mm_or_si128(OO, mask), minusone)), PP);
+	flipped = _mm_sub_epi64(outflank_vd, _mm_andnot_si128(flipmask(outflank_vd), _mm_set1_epi64x(0x0000000001000000)));
 
-	outflank_d7 = ((O | ~0x0204081020000000ULL) + 0x0000000020000000ULL) & P & 0x0204081020000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0204081020000000ULL;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x003f0000))), PP);
+	flipped = _mm_sub_epi8(flipped, _mm_add_epi8(outflank_h, outflank_h));
 
-	flipped |= (((P << 8) & 0x0000000000004000ULL) | ((P << 9) & 0x0000000000002000ULL)) & O;
+	flipped_g2f2 = _mm_and_si128(_mm_mullo_epi16(PP, _mm_set_epi16(0, 0, 0, 0x0200, 0, 0, 0, 0x0100)), OO);
+	flipped = _mm_and_si128(_mm_or_si128(flipped, flipped_g2f2), _mm_set_epi64x(0x0204081020002000, 0x40404040403f4000));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -931,23 +845,23 @@ static unsigned long long flip_G3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H3(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H3(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d7;
-
-	outflank_v = ((O | ~0x8080808080000000ULL) + 0x0000000080000000ULL) & P & 0x8080808080000000ULL;
-	flipped = (outflank_v - (unsigned int) (outflank_v != 0)) & 0x8080808080000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped, flipped_h2g2;
+	const __m128i mask = _mm_set_epi64x(~0x0408102040000000, ~0x8080808080000000);
 
-	outflank_h = OUTFLANK_7[(O >> 17) & 0x3f] & (P >> 16);
-	flipped |= ((-outflank_h) & 0x3f) << 17;
+	outflank_vd = _mm_and_si128(_mm_andnot_si128(mask, _mm_sub_epi64(_mm_or_si128(OO, mask), minusone)), PP);
+	flipped = _mm_sub_epi64(outflank_vd, _mm_andnot_si128(flipmask(outflank_vd), _mm_set1_epi64x(0x0000000001000000)));
 
-	outflank_d7 = ((O | ~0x0408102040000000ULL) + 0x0000000040000000ULL) & P & 0x0408102040000000ULL;
-	flipped |= (outflank_d7 - (unsigned int) (outflank_d7 != 0)) & 0x0408102040000000ULL;
+	outflank_h = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0, 0x007f0000))), PP);
+	flipped = _mm_sub_epi8(flipped, _mm_add_epi8(outflank_h, outflank_h));
 
-	flipped |= (((P << 8) & 0x0000000000008000ULL) | ((P << 9) & 0x0000000000004000ULL)) & O;
+	flipped_h2g2 = _mm_and_si128(_mm_mullo_epi16(PP, _mm_set_epi16(0, 0, 0, 0x0200, 0, 0, 0, 0x0100)), OO);
+	flipped = _mm_and_si128(_mm_or_si128(flipped, flipped_h2g2), _mm_set_epi64x(0x0408102040004000, 0x80808080807f8000));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -957,25 +871,23 @@ static unsigned long long flip_H3(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A4(const __m128i OP)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7, outflank_d9;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflankL, outflankH, flipped;
+	const __m128i maskL = _mm_set_epi32(0, 0x00020408, 0, 0x00010101);
+	const __m128i maskH = _mm_set_epi32(0x10080402, 0, 0x01010101, 0xfe000000);
 
-	outflank_v = OUTFLANK_3[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57] & (((P & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0001010101010100ULL;
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, maskL)), PP);
+	flipped = _mm_and_si128(maskL, _mm_mul_epu32(outflankL, _mm_set1_epi32(-2)));
 
-	outflank_h = ((O & 0x000000007e000000ULL) + 0x0000000002000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x000000007e000000ULL;
+	outflankH = _mm_andnot_si128(OO, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PP);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31))));
 
-	flip_d7 = O & 0x0000000000020000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
-
-	outflank_d9 = ((O | ~0x1008040200000000ULL) + 0x0000000200000000ULL) & P & 0x1008040200000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x1008040200000000ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -985,25 +897,23 @@ static unsigned long long flip_A4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B4(const __m128i OP)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57] & (((P & 0x0202020202020202ULL) * 0x0081020408102040ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0002020202020200ULL;
-
-	outflank_h = ((O & 0x000000007c000000ULL) + 0x0000000004000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x000000007c000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflankL, outflankH, flipped;
+	const __m128i maskL = _mm_set_epi32(0, 0x00040810, 0, 0x00020202);
+	const __m128i maskH = _mm_set_epi32(0x20100804, 0, 0x02020202, 0xfc000000);
 
-	flip_d7 = O & 0x0000000000040000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, maskL)), PP);
+	flipped = _mm_and_si128(maskL, _mm_mul_epu32(outflankL, _mm_set1_epi32(-2)));
 
-	outflank_d9 = ((O | ~0x2010080400000000ULL) + 0x0000000400000000ULL) & P & 0x2010080400000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x2010080400000000ULL;
+	outflankH = _mm_andnot_si128(OO, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PP);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31))));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1013,27 +923,27 @@ static unsigned long long flip_B4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C4(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d7, outflank_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57] & (((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0004040404040400ULL;
-
-	outflank_h = OUTFLANK_2[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x00000000ff000000ULL;
-
-	flip_d7 = O & 0x0000000000080000ULL;
-	flip_d7 |= (flip_d7 >> 7) & O;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x00081020, 0x00020100, 0x00040404, 0x03000000);
+	const __m128i maskH = _mm_set_epi32(0x00000102, 0x40201008, 0x04040404, 0xf8000000);
 
-	outflank_d9 = ((O | ~0x4020100800000000ULL) + 0x0000000800000000ULL) & P & 0x4020100800000000ULL;
-	flipped |= (outflank_d9 - (outflank_d9 >> 32)) & 0x4020100800000000ULL;
+	OH = _mm_shuffle_epi32(OP, 0xfe);
+	PH = _mm_shuffle_epi32(OP, 0x54);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(_mm_move_epi64(flippedH), _mm_shuffle_epi32(flippedH, 0xc8));
 
-	flipped |= (((P << 9) & 0x00000000000020000ULL) | ((P >> 7) & 0x00000000200000000ULL)) & O;
+	OL = _mm_shuffle_epi32(OP, 0xaa);
+	PL = _mm_shuffle_epi32(OP, 0x00);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedL, _mm_shuffle_epi32(flippedL, 0xf5)));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1043,51 +953,57 @@ static unsigned long long flip_C4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D4(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
-	unsigned long long flipped;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x00102040, 0x00040201, 0x00080808, 0x07000000);
+	const __m128i maskH = _mm_set_epi32(0x00010204, 0x80402010, 0x08080808, 0xf0000000);
 
-	outflank_v = OUTFLANK_3[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0008080808080800ULL;
+	OH = _mm_shuffle_epi32(OP, 0xfe);
+	PH = _mm_shuffle_epi32(OP, 0x54);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(_mm_move_epi64(flippedH), _mm_shuffle_epi32(flippedH, 0xc8));
 
-	outflank_h = OUTFLANK_3[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00000000ff000000ULL;
+	OL = _mm_shuffle_epi32(OP, 0xaa);
+	PL = _mm_shuffle_epi32(OP, 0x00);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedL, _mm_shuffle_epi32(flippedL, 0xf5)));
 
-	outflank_d7 = OUTFLANK_3[((O & 0x0000020408102000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0001020408102040ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0000020408102000ULL;
-
-	outflank_d9 = OUTFLANK_3[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0040201008040200ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
- * Compute flipped discs when playing on square E3.
+ * Compute flipped discs when playing on square E4.
  *
  * @param P player's disc pattern.
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E4(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
-	unsigned long long flipped;
-
-	outflank_v = OUTFLANK_3[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0010101010101000ULL;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x00204080, 0x00080402, 0x00101010, 0x0f000000);
+	const __m128i maskH = _mm_set_epi32(0x01020408, 0x00804020, 0x10101010, 0xe0000000);
 
-	outflank_h = OUTFLANK_4[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00000000ff000000ULL;
+	OH = _mm_shuffle_epi32(OP, 0xfe);
+	PH = _mm_shuffle_epi32(OP, 0x54);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(_mm_move_epi64(flippedH), _mm_shuffle_epi32(flippedH, 0xc8));
 
-	outflank_d7 = OUTFLANK_4[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0002040810204000ULL;
+	OL = _mm_shuffle_epi32(OP, 0xaa);
+	PL = _mm_shuffle_epi32(OP, 0x00);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedL, _mm_shuffle_epi32(flippedL, 0xf5)));
 
-	outflank_d9 = OUTFLANK_4[((O & 0x0000402010080400ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0080402010080402ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0000402010080400ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1097,27 +1013,27 @@ static unsigned long long flip_E4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F4(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57] & (((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0020202020202000ULL;
-
-	outflank_h = OUTFLANK_5[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x00000000ff000000ULL;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x00408000, 0x00100804, 0x00202020, 0x1f000000);
+	const __m128i maskH = _mm_set_epi32(0x02040810, 0x00008040, 0x20202020, 0xc0000000);
 
-	outflank_d7 = ((O | ~0x0204081000000000ULL) + 0x0000001000000000ULL) & P & 0x0204081000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0204081000000000ULL;
+	OH = _mm_shuffle_epi32(OP, 0xfe);
+	PH = _mm_shuffle_epi32(OP, 0x54);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(_mm_move_epi64(flippedH), _mm_shuffle_epi32(flippedH, 0xc8));
 
-	flip_d9 = O & 0x0000000000100000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
+	OL = _mm_shuffle_epi32(OP, 0xaa);
+	PL = _mm_shuffle_epi32(OP, 0x00);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedL, _mm_shuffle_epi32(flippedL, 0xf5)));
 
-	flipped |= (((P << 7) & 0x0000000000400000ULL) | ((P >> 9) & 0x0000004000000000ULL)) & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1127,25 +1043,24 @@ static unsigned long long flip_F4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G4(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57] & (((P & 0x4040404040404040ULL) * 0x0004081020408102ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0040404040404000ULL;
+	__m128i	OO, PP, OL, PL, outflankH, outflankL, flipped, flippedL;
+	const __m128i maskL = _mm_set_epi32(0, 0x3f000000, 0x00201008, 0x00404040);
+	const __m128i maskH = _mm_set_epi64x(~0x0408102000000000ULL, ~0x4040404000000000ULL);
 
-	outflank_h = OUTFLANK_7[(O >> 24) & 0x3e] & (P >> 23);
-	flipped |= ((-outflank_h) & 0x3e) << 24;
+	OL = _mm_shuffle_epi32(OP, 0xaa);
+	PL = _mm_shuffle_epi32(OP, 0x00);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_and_si128(_mm_sub_epi32(_mm_setzero_si128(), _mm_add_epi32(outflankL, outflankL)), maskL);
+	flipped = _mm_xor_si128(flippedL, _mm_shuffle_epi32(flippedL, 0xf5));
 
-	outflank_d7 = ((O | ~0x0408102000000000ULL) + 0x0000002000000000ULL) & P & 0x0408102000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0408102000000000ULL;
+	OO = _mm_shuffle_epi32(OP, DUPHI);
+	PP = _mm_shuffle_epi32(OP, DUPLO);
+	outflankH = _mm_and_si128(_mm_andnot_si128(maskH, _mm_sub_epi64(_mm_or_si128(OO, maskH), minusone)), PP);
+	flipped = _mm_or_si128(flipped, _mm_andnot_si128(maskH, _mm_sub_epi64(outflankH, _mm_shuffle_epi32(outflankH, SWAP32))));
 
-	flip_d9 = O & 0x0000000000200000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1155,25 +1070,24 @@ static unsigned long long flip_G4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H4(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H4(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, outflank_d7, flip_d9;
-
-	outflank_v = OUTFLANK_3[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57] & (((P & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56);
-	flipped = FLIPPED_3_V[outflank_v] & 0x0080808080808000ULL;
+	__m128i	OO, PP, OL, PL, outflankH, outflankL, flipped, flippedL;
+	const __m128i maskL = _mm_set_epi32(0, 0x7f000000, 0x00402010, 0x00808080);
+	const __m128i maskH = _mm_set_epi64x(~0x0810204000000000ULL, ~0x8080808000000000ULL);
 
-	outflank_h = OUTFLANK_7[(O >> 25) & 0x3f] & (P >> 24);
-	flipped |= ((-outflank_h) & 0x3f) << 25;
+	OL = _mm_shuffle_epi32(OP, 0xaa);
+	PL = _mm_shuffle_epi32(OP, 0x00);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_and_si128(_mm_sub_epi32(_mm_setzero_si128(), _mm_add_epi32(outflankL, outflankL)), maskL);
+	flipped = _mm_xor_si128(flippedL, _mm_shuffle_epi32(flippedL, 0xf5));
 
-	outflank_d7 = ((O | ~0x0810204000000000ULL) + 0x0000004000000000ULL) & P & 0x0810204000000000ULL;
-	flipped |= (outflank_d7 - (outflank_d7 >> 32)) & 0x0810204000000000ULL;
+	OO = _mm_shuffle_epi32(OP, DUPHI);
+	PP = _mm_shuffle_epi32(OP, DUPLO);
+	outflankH = _mm_and_si128(_mm_andnot_si128(maskH, _mm_sub_epi64(_mm_or_si128(OO, maskH), minusone)), PP);
+	flipped = _mm_or_si128(flipped, _mm_andnot_si128(maskH, _mm_sub_epi64(outflankH, _mm_shuffle_epi32(outflankH, SWAP32))));
 
-	flip_d9 = O & 0x0000000000400000ULL;
-	flip_d9 |= (flip_d9 >> 9) & O;
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1183,21 +1097,26 @@ static unsigned long long flip_H4(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A5(const __m128i OP)
 {
-	unsigned int outflank_a1a5d8, outflank_a8a5e1;
-	unsigned long long flipped, outflank_h;
-
-	outflank_a1a5d8 = OUTFLANK_4[((O & 0x0004020101010100ULL) * 0x0102040810101010ULL) >> 57] & (((P & 0x0804020101010101ULL) * 0x0102040810101010ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_a1a5d8] & 0x0004020101010100ULL;
+	__m128i	OO, PP, OH, PH, outflankL, outflankH, flipped, flippedH;
+	const __m128i maskL = _mm_set_epi32(0, 0x02040810, 0, 0x01010101);
+	const __m128i maskH = _mm_set_epi32(0x08040200, 0, 0x01010100, 0x000000fe);
 
-	outflank_a8a5e1 = OUTFLANK_3[((O & 0x0001010102040800ULL) * 0x0808080808040201ULL) >> 57] & (((P & 0x0101010102040810ULL) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_a8a5e1] & 0x0001010102040800ULL;
+	OH = _mm_shuffle_epi32(OP, 0xef);
+	PH = _mm_shuffle_epi32(OP, 0x45);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_and_si128(outflankH, _mm_sub_epi32(_mm_setzero_si128(), outflankH)), PH);
+	flippedH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(flippedH, _mm_srli_epi32(flippedH, 31)));
+	flipped = _mm_xor_si128(flippedH, _mm_shuffle_epi32(flippedH, 0xa0));
 
-	outflank_h = ((O & 0x0000007e00000000ULL) + 0x0000000200000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000007e00000000ULL;
+	OO = _mm_shuffle_epi32(OP, DUPHI);
+	PP = _mm_shuffle_epi32(OP, DUPLO);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, maskL)), PP);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(maskL, _mm_mul_epu32(outflankL, _mm_set1_epi32(-2))));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1207,21 +1126,26 @@ static unsigned long long flip_A5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B5(const __m128i OP)
 {
-	unsigned int outflank_b1b5e8, outflank_b8b5f1;
-	unsigned long long flipped, outflank_h;
+	__m128i	OO, PP, OH, PH, outflankL, outflankH, flipped, flippedH;
+	const __m128i maskL = _mm_set_epi32(0, 0x04081020, 0, 0x02020202);
+	const __m128i maskH = _mm_set_epi32(0x10080400, 0, 0x02020200, 0x000000fc);
 
-	outflank_b1b5e8 = OUTFLANK_4[((O & 0x0008040202020200ULL) * 0x0081020408080808ULL) >> 57] & (((P & 0x1008040202020202ULL) * 0x0081020408080808ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_b1b5e8] & 0x0008040202020200ULL;
+	OH = _mm_shuffle_epi32(OP, 0xef);
+	PH = _mm_shuffle_epi32(OP, 0x45);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_and_si128(outflankH, _mm_sub_epi32(_mm_setzero_si128(), outflankH)), PH);
+	flippedH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(flippedH, _mm_srli_epi32(flippedH, 31)));
+	flipped = _mm_xor_si128(flippedH, _mm_shuffle_epi32(flippedH, 0xa0));
 
-	outflank_b8b5f1 = OUTFLANK_3[((O & 0x0002020204081000ULL) * 0x0808080808040201ULL) >> 58] & ((((P & 0x0202020204081020ULL) >> 1) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_b8b5f1] & 0x0002020204081000ULL;
+	OO = _mm_shuffle_epi32(OP, DUPHI);
+	PP = _mm_shuffle_epi32(OP, DUPLO);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, maskL)), PP);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(maskL, _mm_mul_epu32(outflankL, _mm_set1_epi32(-2))));
 
-	outflank_h = ((O & 0x0000007c00000000ULL) + 0x0000000400000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x0000007c00000000ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1231,23 +1155,27 @@ static unsigned long long flip_B5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C5(const __m128i OP)
 {
-	unsigned int outflank_c1c5f8, outflank_c8c5g1;
-	unsigned long long flipped, outflank_h;
-
-	outflank_c1c5f8 = OUTFLANK_4[((O & 0x0010080404040400ULL) * 0x0040810204040404ULL) >> 57] & (((P & 0x2010080404040404ULL) * 0x0040810204040404ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_c1c5f8] & 0x0010080404040400ULL;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x08102040, 0x02010000, 0x00000003, 0x04040404);
+	const __m128i maskH = _mm_set_epi32(0x00010200, 0x20100800, 0x000000f8, 0x04040400);
 
-	outflank_c8c5g1 = OUTFLANK_3[((O & 0x0004040408102000ULL) * 0x0002020202010080ULL) >> 57] & ((((P & 0x0404040408102040ULL) >> 2) * 0x0808080808040201ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_c8c5g1] & 0x0004040408102000ULL;
+	OL = _mm_shuffle_epi32(OP, 0xae);
+	PL = _mm_shuffle_epi32(OP, 0x04);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(_mm_move_epi64(flippedL), _mm_shuffle_epi32(flippedL, 0x76));
 
-	outflank_h = OUTFLANK_2[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x000000ff00000000ULL;
+	OH = _mm_shuffle_epi32(OP, 0xff);
+	PH = _mm_shuffle_epi32(OP, 0x55);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedH, _mm_shuffle_epi32(flippedH, 0xa0)));
 
-	flipped |= (((P << 9) & 0x0000000002000000ULL) | ((P >> 7) & 0x0000020000000000ULL)) & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1257,24 +1185,27 @@ static unsigned long long flip_C5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D5(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
-	unsigned long long flipped;
-
-	outflank_v = OUTFLANK_4[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0008080808080800ULL;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x10204080, 0x04020100, 0x00000007, 0x08080808);
+	const __m128i maskH = _mm_set_epi32(0x01020400, 0x40201000, 0x000000f0, 0x08080800);
 
-	outflank_h = OUTFLANK_3[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x000000ff00000000ULL;
+	OL = _mm_shuffle_epi32(OP, 0xae);
+	PL = _mm_shuffle_epi32(OP, 0x04);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(_mm_move_epi64(flippedL), _mm_shuffle_epi32(flippedL, 0x76));
 
-	outflank_d7 = OUTFLANK_3[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d7] & 0x0002040810204000ULL;
+	OH = _mm_shuffle_epi32(OP, 0xff);
+	PH = _mm_shuffle_epi32(OP, 0x55);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedH, _mm_shuffle_epi32(flippedH, 0xa0)));
 
-	outflank_d9 = OUTFLANK_3[((O & 0x0020100804020000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x4020100804020100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d9] & 0x0020100804020000ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1284,24 +1215,27 @@ static unsigned long long flip_D5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E5(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7, outflank_d9;
-	unsigned long long flipped;
-
-	outflank_v = OUTFLANK_4[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_v] & 0x0010101010101000ULL;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x20408000, 0x08040201, 0x0000000f, 0x10101010);
+	const __m128i maskH = _mm_set_epi32(0x02040800, 0x80402000, 0x000000e0, 0x10101000);
 
-	outflank_h = OUTFLANK_4[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x000000ff00000000ULL;
+	OL = _mm_shuffle_epi32(OP, 0xae);
+	PL = _mm_shuffle_epi32(OP, 0x04);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(_mm_move_epi64(flippedL), _mm_shuffle_epi32(flippedL, 0x76));
 
-	outflank_d7 = OUTFLANK_4[((O & 0x0004081020400000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0204081020408000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d7] & 0x0004081020400000ULL;
+	OH = _mm_shuffle_epi32(OP, 0xff);
+	PH = _mm_shuffle_epi32(OP, 0x55);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedH, _mm_shuffle_epi32(flippedH, 0xa0)));
 
-	outflank_d9 = OUTFLANK_4[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d9] & 0x0040201008040200ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1311,23 +1245,27 @@ static unsigned long long flip_E5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F5(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_b1f5f8, outflank_c8f5f1;
-	unsigned long long flipped;
-
-	outflank_b1f5f8 = OUTFLANK_4[((O & 0x0020202010080400ULL) * 0x0080808080810204ULL) >> 57] & (((P & 0x2020202010080402ULL) * 0x0080808080810204ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_b1f5f8] & 0x0020202010080400ULL;
-
-	outflank_c8f5f1 = OUTFLANK_3[((O & 0x0008102020202000ULL) * 0x0002010080404040ULL) >> 57] & ((((P & 0x0408102020202020ULL) >> 2) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_c8f5f1] & 0x0008102020202000ULL;
+	__m128i OL, OH, PL, PH, outflankL, outflankH, flippedL, flippedH, flipped;
+	const __m128i maskL = _mm_set_epi32(0x40800000, 0x10080402, 0x0000001f, 0x20202020);
+	const __m128i maskH = _mm_set_epi32(0x04081000, 0x00804000, 0x000000c0, 0x20202000);
 
-	outflank_h = OUTFLANK_5[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x000000ff00000000ULL;
+	OL = _mm_shuffle_epi32(OP, 0xae);
+	PL = _mm_shuffle_epi32(OP, 0x04);
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OL, maskL)), PL);
+	flippedL = _mm_andnot_si128(_mm_add_epi32(_mm_add_epi32(outflankL, outflankL), minusone), maskL);
+	flipped = _mm_or_si128(_mm_move_epi64(flippedL), _mm_shuffle_epi32(flippedL, 0x76));
 
-	flipped |= (((P << 7) & 0x0000000040000000ULL) | ((P >> 9) & 0x0000400000000000ULL)) & O;
+	OH = _mm_shuffle_epi32(OP, 0xff);
+	PH = _mm_shuffle_epi32(OP, 0x55);
+	outflankH = _mm_andnot_si128(OH, maskH);
+	outflankH = _mm_and_si128(_mm_andnot_si128(_mm_add_epi32(outflankH, minusone), outflankH), PH);
+	outflankH = _mm_add_epi32(outflankH, minusone);
+	flippedH = _mm_and_si128(maskH, _mm_add_epi32(outflankH, _mm_srli_epi32(outflankH, 31)));
+	flipped = _mm_or_si128(flipped, _mm_xor_si128(flippedH, _mm_shuffle_epi32(flippedH, 0xa0)));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1337,21 +1275,21 @@ static unsigned long long flip_F5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G5(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_c1g5g8, outflank_d8g5g1;
-	unsigned long long flipped;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflankH, outflankL, flipped;
+	const __m128i maskL = _mm_set_epi32(0, 0x20100804, 0x0000003f, 0x40404040);
+	const __m128i maskH = _mm_set_epi64x(~0x0810200000000000ULL, ~0x4040400000000000ULL);
 
-	outflank_c1g5g8 = OUTFLANK_4[((O & 0x0040404020100800ULL) * 0x0040404040408102ULL) >> 57] & (((P & 0x4040404020100804ULL) * 0x0040404040408102ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_c1g5g8] & 0x0040404020100800ULL;
+	outflankH = _mm_and_si128(_mm_andnot_si128(maskH, _mm_sub_epi64(_mm_or_si128(OO, maskH), minusone)), PP);
+	flipped = _mm_andnot_si128(maskH, _mm_sub_epi64(outflankH, _mm_shuffle_epi32(outflankH, SWAP32)));
 
-	outflank_d8g5g1 = OUTFLANK_3[((O & 0x0010204040404000ULL) * 0x0001008040202020ULL) >> 57] & ((((P & 0x0810204040404040ULL) >> 3) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_d8g5g1] & 0x0010204040404000ULL;
+	outflankL = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, maskL)), PP);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_sub_epi32(_mm_setzero_si128(), _mm_add_epi32(outflankL, outflankL)), maskL));
 
-	outflank_h = OUTFLANK_7[(O >> 32) & 0x3e] & (P >> 31);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 32;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1361,21 +1299,21 @@ static unsigned long long flip_G5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H5(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H5(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d1h5h8, outflank_e8h5h1;
-	unsigned long long flipped;
-
-	outflank_d1h5h8 = OUTFLANK_4[((O & 0x0080808040201000ULL) * 0x0020202020204081ULL) >> 57] & (((P & 0x8080808040201008ULL) * 0x0020202020204081ULL) >> 56);
-	flipped = FLIPPED_4_V[outflank_d1h5h8] & 0x0080808040201000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflankH, outflankL, flipped;
+	const __m128i maskL = _mm_set_epi32(0, 0x40201008, 0x0000007f, 0x80808080);
+	const __m128i maskH = _mm_set_epi64x(~0x1020400000000000ULL, ~0x8080800000000000ULL);
 
-	outflank_e8h5h1 = OUTFLANK_3[((O & 0x0020408080808000ULL) * 0x0000804020101010ULL) >> 57] & ((((P & 0x1020408080808080ULL) >> 4) * 0x1008040201010101ULL) >> 56);
-	flipped |= FLIPPED_3_U[outflank_e8h5h1] & 0x0020408080808000ULL;
+	outflankH = _mm_and_si128(_mm_andnot_si128(maskH, _mm_sub_epi64(_mm_or_si128(OO, maskH), minusone)), PP);
+	flipped = _mm_andnot_si128(maskH, _mm_sub_epi64(outflankH, _mm_shuffle_epi32(outflankH, SWAP32)));
 
-	outflank_h = OUTFLANK_7[(O >> 33) & 0x3f] & (P >> 32);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 33;
+	outflankL = _mm_and_si128(MS1B_epu32(_mm_andnot_si128(OO, maskL)), PP);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_sub_epi32(_mm_setzero_si128(), _mm_add_epi32(outflankL, outflankL)), maskL));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1385,25 +1323,22 @@ static unsigned long long flip_H5(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A6(const __m128i OP)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7;
-
-	outflank_v = OUTFLANK_5[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57] & (((P & 0x0101010101010101ULL) * 0x0102040810204080ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0001010101010100ULL;
-
-	outflank_h = ((O & 0x00007e0000000000ULL) + 0x0000020000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007e0000000000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h_a7b7, flipped;
+	const __m128i mask1 = _mm_set_epi64x(0x0000000204081020, 0x0000000101010101);
+	const __m128i mask2 = _mm_set_epi64x(~0x0402000000000000ULL, ~0x0101fe0000000000ULL);
 
-	flip_d7 = O | 0x0040810000000000ULL;
-	flip_d7 &= flip_d7 >> 7;
-	flip_d7 &= (flip_d7 >> 14) & 0x0000000204081000ULL;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
+	outflank_h_a7b7 = _mm_and_si128(_mm_andnot_si128(mask2, _mm_sub_epi16(_mm_or_si128(OO, mask2), minusone)), PP);
+	flipped = _mm_andnot_si128(mask2, _mm_mulhi_epu16(outflank_h_a7b7, minusone));
 
-	flipped |= (P >> 9) & 0x0002000000000000ULL & O;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask1)), PP);
+	outflank_vd = _mm_add_epi64(_mm_add_epi64(outflank_vd, outflank_vd), minusone);
+	flipped = _mm_or_si128(flipped, _mm_andnot_si128(outflank_vd, mask1));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1413,25 +1348,22 @@ static unsigned long long flip_A6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B6(const __m128i OP)
 {
-	unsigned int outflank_v;
-	unsigned long long flipped, outflank_h, flip_d7;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h_b7c7, flipped;
+	const __m128i mask1 = _mm_set_epi64x(0x0000000408102040, 0x0000000202020202);
+	const __m128i mask2 = _mm_set_epi64x(~0x0804000000000000ULL, ~0x0202fc0000000000ULL);
 
-	outflank_v = OUTFLANK_5[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57] & (((P & 0x0202020202020202ULL) * 0x0081020408102040ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0002020202020200ULL;
+	outflank_h_b7c7 = _mm_and_si128(_mm_andnot_si128(mask2, _mm_sub_epi16(_mm_or_si128(OO, mask2), minusone)), PP);
+	flipped = _mm_andnot_si128(mask2, _mm_mulhi_epu16(outflank_h_b7c7, minusone));
 
-	outflank_h = ((O & 0x00007c0000000000ULL) + 0x0000040000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x00007c0000000000ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask1)), PP);
+	outflank_vd = _mm_add_epi64(_mm_add_epi64(outflank_vd, outflank_vd), minusone);
+	flipped = _mm_or_si128(flipped, _mm_andnot_si128(outflank_vd, mask1));
 
-	flip_d7 = O | 0x0081020000000000ULL;
-	flip_d7 &= flip_d7 >> 7;
-	flip_d7 &= (flip_d7 >> 14) & 0x0000000408102000ULL;
-	flipped |= flip_d7 & -(flip_d7 & (P << 7));
-
-	flipped |= (P >> 9) & 0x0004000000000000ULL & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1441,23 +1373,25 @@ static unsigned long long flip_B6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C6(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d7;
-	unsigned long long flipped;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, outflank_h, flipped, flipped_b5b6b7c7d7;
+	const __m128i mask = _mm_set_epi64x(0x0000000810204080, 0x0000000404040404);
+	const __m128i next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[43]);
 
-	outflank_v = OUTFLANK_5[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57] & (((P & 0x0404040404040404ULL) * 0x0040810204081020ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0004040404040400ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask);
 
-	outflank_h = OUTFLANK_2[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x0000ff0000000000ULL;
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	outflank_d7 = OUTFLANK_2[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x0102040810204080ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_2_H[outflank_d7] & 0x0002040810204000ULL;
+	flipped_b5b6b7c7d7 = _mm_and_si128(_mm_shufflehi_epi16(PP, 0xf4), _mm_set_epi64x(0x0400100001000000, 0x0100010000000000));	// c8e8a4.a8a6..
+	flipped_b5b6b7c7d7 = _mm_madd_epi16(flipped_b5b6b7c7d7, _mm_set_epi16(0x0100, 0x0080, 0x0200, 0, 0x0200, 2, 0, 0));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_shufflehi_epi16(flipped_b5b6b7c7d7, 0xd0), OO));
 
-	flipped |= ((P >> 9) | (P << 9)) & 0x0008000200000000ULL & O;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1467,24 +1401,29 @@ static unsigned long long flip_C6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D6(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d;
-	unsigned long long flipped;
+	__m128i	flipped, flipped_c7e7, index_d;
+	unsigned int outflank_h, outflank_v, outflank_d, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0000081422418000, 0x0808080808080808);	// A3D6H2
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = OUTFLANK_5[(index_v >> 9) & 0x3f] & rotl8(index_v, 1);
 
-	outflank_v = OUTFLANK_5[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57] & (((P & 0x0808080808080808ULL) * 0x0020408102040810ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0008080808080800ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
 
-	outflank_h = OUTFLANK_3[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x0000ff0000000000ULL;
+	flipped = _mm_and_si128(load64x2(&FLIPPED_5_V[outflank_v], &FLIPPED_3_H[outflank_d]), mask);
 
-	outflank_d = OUTFLANK_3[((O & 0x0000001422400000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000001422418000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000001422400000ULL;	// A3D6H2
+	outflank_h = OUTFLANK_3[(_mm_extract_epi16(OP, 6) >> 9) & 0x3f] & rotl8(_mm_extract_epi16(OP, 2) >> 8, 3);
 
-	flipped |= (((P >> 9) & 0x0010000000000000ULL) | ((P >> 7) & 0x0004000000000000ULL)) & O;
+	flipped_c7e7 = _mm_shuffle_epi32(OP, 0xf5);
+	flipped_c7e7 = _mm_and_si128(flipped_c7e7, _mm_set_epi32(0x00100000, 0x00040000, 0x20000000, 0x02000000));
+	flipped_c7e7 = _mm_min_epi16(flipped_c7e7, _mm_shuffle_epi32(flipped_c7e7, SWAP64));
+	flipped = _mm_or_si128(flipped, _mm_unpacklo_epi16(
+		_mm_slli_epi64(_mm_loadl_epi64((__m128i *) &FLIPPED_3_H[outflank_h]), 56), flipped_c7e7));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1494,24 +1433,29 @@ static unsigned long long flip_D6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E6(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d;
-	unsigned long long flipped;
+	__m128i	flipped, flipped_d7f7, index_d;
+	unsigned int outflank_h, outflank_v, outflank_d, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0000102844820100, 0x1010101010101010);	// A2E6H3
 
-	outflank_v = OUTFLANK_5[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57] & (((P & 0x1010101010101010ULL) * 0x0010204081020408ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0010101010101000ULL;
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = OUTFLANK_5[(index_v >> 9) & 0x3f] & rotl8(index_v, 1);
 
-	outflank_h = OUTFLANK_4[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x0000ff0000000000ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPHI)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 2);
 
-	outflank_d = OUTFLANK_4[((O & 0x0000002844020000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000002844820100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000002844020000ULL;	// A2E6H3
+	flipped = _mm_and_si128(load64x2(&FLIPPED_5_V[outflank_v], &FLIPPED_4_H[outflank_d]), mask);
 
-	flipped |= (((P >> 9) & 0x0020000000000000ULL) | ((P >> 7) & 0x0008000000000000ULL)) & O;
+	outflank_h = OUTFLANK_4[(_mm_extract_epi16(OP, 6) >> 9) & 0x3f] & rotl8(_mm_extract_epi16(OP, 2) >> 8, 2);
 
-	return flipped;
+	flipped_d7f7 = _mm_shuffle_epi32(OP, 0xf5);
+	flipped_d7f7 = _mm_and_si128(flipped_d7f7, _mm_set_epi32(0x00200000, 0x00080000, 0x40000000, 0x04000000));
+	flipped_d7f7 = _mm_min_epi16(flipped_d7f7, _mm_shuffle_epi32(flipped_d7f7, SWAP64));
+	flipped = _mm_or_si128(flipped, _mm_unpacklo_epi16(
+		_mm_slli_epi64(_mm_loadl_epi64((__m128i *) &FLIPPED_4_H[outflank_h]), 56), flipped_d7f7));
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1521,23 +1465,24 @@ static unsigned long long flip_E6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F6(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v, outflank_d9;
-	unsigned long long flipped;
-
-	outflank_v = OUTFLANK_5[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57] & (((P & 0x2020202020202020ULL) * 0x0008102040810204ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0020202020202000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank, flipped, flipped_g5g6g7f7e7;
 
-	outflank_h = OUTFLANK_5[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= (FLIPPED_5_H[outflank_h] & 0x0000ff0000000000ULL);
+	outflank = MS1B_epu52(_mm_andnot_si128(OO, _mm_set_epi64x(0x0000002020202020, 0x0000001008040201)));
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x00001f00, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	flipped |= ((P >> 7) | (P << 7)) & 0x0010004000000000ULL & O;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[39]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0000002020202020, 0x00001e1008040201));
 
-	outflank_d9 = OUTFLANK_5[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57] & (((P & 0x8040201008040201ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_5_H[outflank_d9] & 0x0040201008040200ULL;
+	flipped_g5g6g7f7e7 = _mm_and_si128(_mm_shufflehi_epi16(PP, 0xf9), _mm_set_epi64x(0x2000080080008000, 0x8000000000000000));	// f8d8h6h4h8...
+	flipped_g5g6g7f7e7 = _mm_madd_epi16(flipped_g5g6g7f7e7, _mm_set_epi16(0x0100, 0x0200, -0x8000, -0x0080, -0x0080, 0, 0, 0));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_shufflehi_epi16(flipped_g5g6g7f7e7, 0xd0), OO));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1547,24 +1492,21 @@ static unsigned long long flip_F6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G6(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d9;
-
-	outflank_v = OUTFLANK_5[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57] & (((P & 0x4040404040404040ULL) * 0x0004081020408102ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0040404040404000ULL;
-
-	outflank_h = OUTFLANK_7[(O >> 40) & 0x3e] & (P >> 39);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 40;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank, flipped;
 
-	flipped |= (P >> 7) & 0x0020000000000000ULL & O;
+	outflank = MS1B_epu52(_mm_andnot_si128(OO, _mm_set_epi64x(0x0000004040404040, 0x0000002010080402)));
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x00003f00, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	flip_d9 = O & ((O >> 9) | 0x0000002000000000ULL);
-	flip_d9 &= (((flip_d9 & 0x0000002010000000ULL) >> 18) | 0x0000002010000000ULL);
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
+	flipped = _mm_sub_epi64(_mm_set_epi64x(0x0000800000000000, 0x0000808000000000), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_mulhi_epu16(PP, _mm_set_epi16(0x0100, 0, 0, 0, 0x0200, 0, 0, 0)), OO));	// g7f7
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0040004040404040, 0x00203e2010080402));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1574,24 +1516,21 @@ static unsigned long long flip_G6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H6(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H6(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_v;
-	unsigned long long flipped, flip_d9;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank, flipped;
 
-	outflank_v = OUTFLANK_5[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57] & (((P & 0x8080808080808080ULL) * 0x0002040810204081ULL) >> 56);
-	flipped = FLIPPED_5_V[outflank_v] & 0x0080808080808000ULL;
+	outflank = MS1B_epu52(_mm_andnot_si128(OO, _mm_set_epi64x(0x0000008080808080, 0x0000004020100804)));
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x00007f00, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_h = OUTFLANK_7[(O >> 41) & 0x3f] & (P >> 40);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 41;
+	flipped = _mm_sub_epi64(_mm_set_epi64x(0x0000800000000000, 0x0000808000000000), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_mulhi_epu16(PP, _mm_set_epi16(0x0100, 0, 0, 0, 0x0200, 0, 0, 0)), OO));	// h7g7
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0080008080808080, 0x00407e4020100804));
 
-	flipped |= (P >> 7) & 0x0040000000000000ULL & O;
-
-	flip_d9 = O & ((O >> 9) | 0x0000004000000000ULL);
-	flip_d9 &= (((flip_d9 & 0x0000004020000000ULL) >> 18) | 0x0000004020000000ULL);
-	flipped |= flip_d9 & -(flip_d9 & (P << 9));
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1601,20 +1540,21 @@ static unsigned long long flip_H6(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A7(const __m128i OP)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
-
-	outflank_v = (0x0000010000000000ULL >> CONTIG_UP[((O & 0x0000010101010100ULL) * 0x0102040810204080ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000010101010100ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, outflank_h, next_h;
+	const __m128i mask = _mm_set_epi64x(0x0000020408102040, 0x0000010101010101);
 
-	outflank_h = ((O & 0x007e000000000000ULL) + 0x0002000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007e000000000000ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_andnot_si128(_mm_add_epi64(_mm_add_epi64(outflank_vd, outflank_vd), minusone), mask);
 
-	outflank_d7 = (0x0000020000000000ULL >> CONTIG_UPRIGHT[((O & 0x0000020408102000ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000020408102000ULL;
+	next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[49]);
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1624,20 +1564,21 @@ static unsigned long long flip_A7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B7(const __m128i OP)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, outflank_h, next_h;
+	const __m128i mask = _mm_set_epi64x(0x0000040810204080, 0x0000020202020202);
 
-	outflank_v = (0x0000020000000000ULL >> CONTIG_UP[((O & 0x0000020202020200ULL) * 0x0081020408102040ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000020202020200ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_andnot_si128(_mm_add_epi64(_mm_add_epi64(outflank_vd, outflank_vd), minusone), mask);
 
-	outflank_h = ((O & 0x007c000000000000ULL) + 0x0004000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x007c000000000000ULL;
+	next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[50]);
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	outflank_d7 = (0x0000040000000000ULL >> CONTIG_UPRIGHT[((O & 0x0000040810204000ULL) * 0x0101010101010101ULL) >> 58]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0000040810204000ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1647,22 +1588,21 @@ static unsigned long long flip_B7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C7(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	flipped, outflank_vd, flipped_h_b6b7;
+	const __m128i mask = _mm_set_epi64x(0x0000081020408000, 0x0000040404040404);
 
-	outflank_v = (0x0000040000000000ULL >> CONTIG_UP[((O & 0x0000040404040400ULL) * 0x0040810204081020ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000040404040400ULL;
+	flipped_h_b6b7 = _mm_and_si128(_mm_adds_epu8(OO, _mm_set_epi8(0, -1, 0, -1, 0, 0, 0, 0, 0, 0x08, 0, 0, 0, 0, 0, 0)), PP);
+	flipped_h_b6b7 = _mm_srli_epi64(_mm_mullo_epi16(flipped_h_b6b7, _mm_set_epi16(0x0020, 0x2000, 0, 0, 0x000f, 0, 0, 0)), 4);
+	flipped_h_b6b7 = _mm_and_si128(_mm_and_si128(flipped_h_b6b7, OO), _mm_set_epi16(0x0002, 0x0200, 0, 0, 0x0078, 0, 0, 0));
 
-	outflank_h = OUTFLANK_2[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_2_H[outflank_h] & 0x00ff000000000000ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_or_si128(flipped_h_b6b7, _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask));
 
-	outflank_d = OUTFLANK_2[((O & 0x00000a1020400000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x00000a1120408000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_2_H[outflank_d] & 0x00000a1020400000ULL;	// A5C7H2
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1672,22 +1612,24 @@ static unsigned long long flip_C7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D7(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	__m128i	flipped, index_d;
+	unsigned int outflank_h, outflank_d, outflank_v, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0000080808080808, 0x00ff142241800000);
 
-	outflank_v = (0x0000080000000000ULL >> CONTIG_UP[((O & 0x0000080808080800ULL) * 0x0020408102040810ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000080808080800ULL;
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = OUTFLANK_7[((index_v >> 9) & 0x1f) + 32] & index_v;
 
-	outflank_h = OUTFLANK_3[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_3_H[outflank_h] & 0x00ff000000000000ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_set1_epi64x(0x0008142241800000)), _mm_setzero_si128());	// A4D7H3
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
 
-	outflank_d = OUTFLANK_3[((O & 0x0000142240000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000142241800000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0000142240000000ULL;	// A4D7H3
+	flipped = load64x2(&FLIPPED_3_H[outflank_d], &FLIPPED_7_V[outflank_v]);
 
-	return flipped;
+	outflank_h = OUTFLANK_3[(_mm_extract_epi16(OP, 7) >> 1) & 0x3f] & rotl8(_mm_extract_epi16(OP, 3), 3);
+	flipped = _mm_and_si128(_mm_insert_epi16(flipped, FLIPPED_3_H[outflank_h], 3), mask);
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1697,22 +1639,24 @@ static unsigned long long flip_D7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E7(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	__m128i	flipped, index_d;
+	unsigned int outflank_h, outflank_d, outflank_v, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0000101010101010, 0x00ff284482010000);
 
-	outflank_v = (0x0000100000000000ULL >> CONTIG_UP[((O & 0x0000101010101000ULL) * 0x0010204081020408ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000101010101000ULL;
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = OUTFLANK_7[((index_v >> 9) & 0x1f) + 32] & index_v;
 
-	outflank_h = OUTFLANK_4[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_4_H[outflank_h] & 0x00ff000000000000ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_set1_epi64x(0x0010284482010000)), _mm_setzero_si128());	// A3E7H4
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 2);
 
-	outflank_d = OUTFLANK_4[((O & 0x0000284402000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000284482010000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0000284402000000ULL;	// A3E7H4
+	flipped = load64x2(&FLIPPED_4_H[outflank_d], &FLIPPED_7_V[outflank_v]);
 
-	return flipped;
+	outflank_h = OUTFLANK_4[(_mm_extract_epi16(OP, 7) >> 1) & 0x3f] & rotl8(_mm_extract_epi16(OP, 3), 2);
+	flipped = _mm_and_si128(_mm_insert_epi16(flipped, FLIPPED_4_H[outflank_h], 3), mask);
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1722,22 +1666,23 @@ static unsigned long long flip_E7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F7(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank, flipped, flipped_g6g7;
 
-	outflank_v = (0x0000200000000000ULL >> CONTIG_UP[((O & 0x0000202020202000ULL) * 0x0008102040810204ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000202020202000ULL;
+	outflank = MS1B_epu52(_mm_andnot_si128(OO, _mm_set_epi64x(0x0000202020202020, 0x0000100804020100)));
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x001f0000, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_h = OUTFLANK_5[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= FLIPPED_5_H[outflank_h] & 0x00ff000000000000ULL;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[47]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0000202020202020, 0x001e100804020100));
 
-	outflank_d = OUTFLANK_5[((O & 0x0000500804020000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0000508804020100ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_5_H[outflank_d] & 0x0000500804020000ULL;	// A2F7H5
+	flipped_g6g7 = _mm_srli_epi64(_mm_and_si128(PP, _mm_set_epi64x(0x0080008000000000, 0)), 17);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_packus_epi16(flipped_g6g7, flipped_g6g7), OO));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1747,21 +1692,20 @@ static unsigned long long flip_F7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G7(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i outflank, flipped;
 
-	outflank_v = (0x0000400000000000ULL >> CONTIG_UP[((O & 0x0000404040404000ULL) * 0x0004081020408102ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000404040404000ULL;
+	outflank = MS1B_epu52(_mm_andnot_si128(OO, _mm_set_epi64x(0x0000404040404040, 0x0000201008040201)));
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x003f0000, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_h = OUTFLANK_7[(O >> 48) & 0x3e] & (P >> 47);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 48;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[47]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0000404040404040, 0x003e201008040201));
 
-	outflank_d9 = (0x0000200000000000ULL >> CONTIG_UPLEFT[((O & 0x0000201008040200ULL) * 0x0101010101010101ULL) >> 56]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000201008040200ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1771,21 +1715,20 @@ static unsigned long long flip_G7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H7(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H7(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = (0x0000800000000000ULL >> CONTIG_UP[((O & 0x0000808080808000ULL) * 0x0002040810204081ULL) >> 56]) & P;
-	flipped  = (-outflank_v * 2) & 0x0000808080808000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i outflank, flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 49) & 0x3f] & (P >> 48);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 49;
+	outflank = MS1B_epu52(_mm_andnot_si128(OO, _mm_set_epi64x(0x0000808080808080, 0x0000402010080402)));
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x007f0000, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_d9 = (0x0000400000000000ULL >> CONTIG_UPLEFT[((O & 0x0000402010080400ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0000402010080400ULL;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[47]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0000808080808080, 0x007e402010080402));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1795,20 +1738,21 @@ static unsigned long long flip_H7(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_A8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_A8(const __m128i OP)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, outflank_h, next_h;
+	const __m128i mask = _mm_set_epi64x(0x0002040810204080, 0x0001010101010101);
 
-	outflank_v = (0x0001000000000000ULL >> CONTIG_UP[((O & 0x0001010101010100ULL) * 0x0102040810204080ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0001010101010100ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_andnot_si128(_mm_add_epi64(_mm_add_epi64(outflank_vd, outflank_vd), minusone), mask);
 
-	outflank_h = ((O & 0x7e00000000000000ULL) + 0x0200000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7e00000000000000ULL;
+	next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[57]);
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	outflank_d7 = (0x0002000000000000ULL >> CONTIG_UPRIGHT[((O & 0x0002040810204000ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0002040810204000ULL;
-
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1818,20 +1762,21 @@ static unsigned long long flip_A8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_B8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_B8(const __m128i OP)
 {
-	unsigned long long flipped, outflank_v, outflank_h, outflank_d7;
-
-	outflank_v = (0x0002000000000000ULL >> CONTIG_UP[((O & 0x0002020202020200ULL) * 0x0081020408102040ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0002020202020200ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank_vd, flipped, outflank_h, next_h;
+	const __m128i mask = _mm_set_epi64x(0x0004081020408000, 0x0002020202020202);
 
-	outflank_h = ((O & 0x7c00000000000000ULL) + 0x0400000000000000ULL) & P;
-	flipped |= (outflank_h - (outflank_h >> 8)) & 0x7c00000000000000ULL;
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_andnot_si128(_mm_add_epi64(_mm_add_epi64(outflank_vd, outflank_vd), minusone), mask);
 
-	outflank_d7 = (0x0004000000000000ULL >> CONTIG_UPRIGHT[((O & 0x0004081020400000ULL) * 0x0101010101010101ULL) >> 58]) & P;
-	flipped |= (-outflank_d7 * 2) & 0x0004081020400000ULL;
+	next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[58]);
+	outflank_h = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank_h, next_h));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1841,22 +1786,21 @@ static unsigned long long flip_B8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_C8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_C8(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
-
-	outflank_v = (0x0004000000000000ULL >> CONTIG_UP[((O & 0x0004040404040400ULL) * 0x0040810204081020ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0004040404040400ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	flipped, outflank_vd, flipped_h_b7b8;
+	const __m128i mask = _mm_set_epi64x(0x0008102040800000, 0x0004040404040404);
 
-	outflank_h = OUTFLANK_2[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_2_H[outflank_h] & 0xff00000000000000ULL;
+	flipped_h_b7b8 = _mm_and_si128(_mm_adds_epu8(OO, _mm_set_epi8(-1, 0, -1, 0, 0, 0, 0, 0, 0x08, 0, 0, 0, 0, 0, 0, 0)), PP);
+	flipped_h_b7b8 = _mm_slli_epi64(_mm_mullo_epi16(_mm_srli_epi64(flipped_h_b7b8, 8), _mm_set_epi16(0x0020, 0x2000, 0, 0, 0x000f, 0, 0, 0)), 4);
+	flipped_h_b7b8 = _mm_and_si128(_mm_and_si128(flipped_h_b7b8, OO), _mm_set_epi16(0x0202, 0, 0, 0, 0x7800, 0, 0, 0));
 
-	outflank_d = OUTFLANK_2[((O & 0x000a102040000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x000a112040800000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_2_H[outflank_d] & 0x000a102040000000ULL;	// A6C8H3
+	outflank_vd = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OO, mask)), PP);
+	flipped = _mm_or_si128(flipped_h_b7b8, _mm_and_si128(_mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank_vd, outflank_vd)), mask));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1866,23 +1810,61 @@ static unsigned long long flip_C8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_D8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_D8(const __m128i OP)
 {
+	__m128i	flipped, index_d;
 	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	const __m128i mask = _mm_set_epi64x(0x0008080808080808, 0x0814224180000000);	// A5D8H4
+#if 1	// TLU x 2 - 42(gcc)/45(VC)
+	unsigned int outflank_v, index_v;
+
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 4));
+	outflank_v = OUTFLANK_7[(index_v >> 9) & 0x3f] & index_v;
 
-	outflank_v = (0x0008000000000000ULL >> CONTIG_UP[((O & 0x0008080808080800ULL) * 0x0020408102040810ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0008080808080800ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPLO)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
 
-	outflank_h = OUTFLANK_3[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_3_H[outflank_h] & 0xff00000000000000ULL;
+	flipped = _mm_and_si128(mask, load64x2(&FLIPPED_3_H[outflank_d], &FLIPPED_7_V[outflank_v]));
 
-	outflank_d = OUTFLANK_3[((O & 0x0014224000000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0014224180000000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_3_H[outflank_d] & 0x0014224000000000ULL;	// A5D8H4
+#else	// TLU + MS1B - 45(gcc)/52(VC)
+	__m128i	outflank_v;
 
-	return flipped;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPLO)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_3[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 3);
+	flipped = _mm_loadl_epi64((__m128i *) &FLIPPED_3_H[outflank_d]);
+
+	outflank_v = _mm_and_si128(MS1B_epu52(_mm_andnot_si128(OP, mask)), _mm_slli_si128(OP, 8));
+	flipped = _mm_and_si128(mask, _mm_sub_epi64(flipped, _mm_add_epi64(outflank_v, outflank_v)));
+#endif
+
+	outflank_h = OUTFLANK_3[(_mm_extract_epi16(OP, 7) >> 9) & 0x3f] & rotl8(_mm_extract_epi16(OP, 3) >> 8, 3);
+	flipped = _mm_or_si128(flipped, _mm_slli_epi64(_mm_loadl_epi64((__m128i *) &FLIPPED_3_H[outflank_h]), 56));
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
+}
+
+#if 0	// MS1B x 2 - 51(gcc)/52(VC)
+static __m128i vectorcall flip_D8(const __m128i OP)
+{
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	flipped, outflank, next_h;
+	const __m128i mask1 = _mm_set_epi64x(0x0008080808080808, 0x0010204080000000);
+	const __m128i mask2 = _mm_set_epi64x(0x0700000000000000, 0x0004020100000000);
+
+	outflank = _mm_and_si128(_mm_slli_epi64(MS1B_epu52(_mm_srli_epi64(_mm_andnot_si128(OO, mask1), 1)), 1), PP);
+	flipped = _mm_and_si128(mask1, _mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank, outflank)));
+
+	outflank = _mm_and_si128(MS1B_epu31(_mm_andnot_si128(OO, mask2)), PP);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(mask2, _mm_sub_epi64(_mm_setzero_si128(), _mm_add_epi64(outflank, outflank))));
+
+	next_h = _mm_loadl_epi64((__m128i *) &X_TO_BIT[60]);
+	outflank = _mm_and_si128(_mm_add_epi8(OO, next_h), PP);
+	flipped = _mm_or_si128(flipped, _mm_subs_epu8(outflank, next_h));
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
+#endif
 
 /**
  * Compute flipped discs when playing on square E8.
@@ -1891,22 +1873,24 @@ static unsigned long long flip_D8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_E8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_E8(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	__m128i	flipped, index_d;
+	unsigned int outflank_h, outflank_d, outflank_v, index_v;
+	const __m128i mask = _mm_set_epi64x(0x0010101010101010, 0x1028448201000000);	// A4E8H5
 
-	outflank_v = (0x0010000000000000ULL >> CONTIG_UP[((O & 0x0010101010101000ULL) * 0x0010204081020408ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0010101010101000ULL;
+	index_v = _mm_movemask_epi8(_mm_slli_epi64(OP, 3));
+	outflank_v = OUTFLANK_7[(index_v >> 9) & 0x3f] & index_v;
 
-	outflank_h = OUTFLANK_4[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_4_H[outflank_h] & 0xff00000000000000ULL;
+	index_d = _mm_sad_epu8(_mm_and_si128(OP, _mm_shuffle_epi32(mask, DUPLO)), _mm_setzero_si128());
+	outflank_d = OUTFLANK_4[(_mm_extract_epi16(index_d, 4) >> 1) & 0x3f] & rotl8(_mm_cvtsi128_si32(index_d), 2);
 
-	outflank_d = OUTFLANK_4[((O & 0x0028440200000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0028448201000000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_4_H[outflank_d] & 0x0028440200000000ULL;	// A4E8H5
+	flipped = _mm_and_si128(mask, load64x2(&FLIPPED_4_H[outflank_d], &FLIPPED_7_V[outflank_v]));
 
-	return flipped;
+	outflank_h = OUTFLANK_4[(_mm_extract_epi16(OP, 7) >> 9) & 0x3f] & rotl8(_mm_extract_epi16(OP, 3) >> 8, 2);
+	flipped = _mm_or_si128(flipped, _mm_slli_epi64(_mm_loadl_epi64((__m128i *) &FLIPPED_4_H[outflank_h]), 56));
+
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1916,22 +1900,24 @@ static unsigned long long flip_E8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_F8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_F8(const __m128i OP)
 {
-	unsigned int outflank_h, outflank_d;
-	unsigned long long flipped, outflank_v;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i	outflank, flipped, flipped_g7g8;
 
-	outflank_v = (0x0020000000000000ULL >> CONTIG_UP[((O & 0x0020202020202000ULL) * 0x0008102040810204ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0020202020202000ULL;
+	outflank = _mm_andnot_si128(OO, _mm_set_epi64x(0x0020202020202020, 0x0010080402010000));
+	outflank = _mm_slli_epi64(MS1B_epu52(_mm_srli_epi64(outflank, 4)), 4);
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x1f000000, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_h = OUTFLANK_5[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= FLIPPED_5_H[outflank_h] & 0xff00000000000000ULL;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[55]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0020202020202020, 0x1e10080402010000));
 
-	outflank_d = OUTFLANK_5[((O & 0x0050080402000000ULL) * 0x0101010101010101ULL) >> 57]
-		& (((P & 0x0050880402010000ULL) * 0x0101010101010101ULL) >> 56);
-	flipped |= FLIPPED_5_H[outflank_d] & 0x0050080402000000ULL;	// A3F8H6
+	flipped_g7g8 = _mm_srli_epi64(_mm_and_si128(PP, _mm_set_epi64x(0x8000800000000000, 0)), 9);
+	flipped = _mm_or_si128(flipped, _mm_and_si128(_mm_packus_epi16(flipped_g7g8, flipped_g7g8), OO));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1941,21 +1927,21 @@ static unsigned long long flip_F8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_G8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_G8(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
-
-	outflank_v = (0x0040000000000000ULL >> CONTIG_UP[((O & 0x0040404040404000ULL) * 0x0004081020408102ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0040404040404000ULL;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i outflank, flipped;
 
-	outflank_h = OUTFLANK_7[(O >> 56) & 0x3e] & (P >> 55);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3e) << 56;
+	outflank = _mm_andnot_si128(OO, _mm_set_epi64x(0x0040404040404040, 0x0020100804020100));
+	outflank = _mm_slli_epi64(MS1B_epu52(_mm_srli_epi64(outflank, 4)), 4);
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x3f000000, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_d9 = (0x0020000000000000ULL >> CONTIG_UPLEFT[((O & 0x0020100804020000ULL) * 0x0101010101010101ULL) >> 56]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0020100804020000ULL;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[55]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, _mm_set_epi64x(0x0040404040404040, 0x3e20100804020100));
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1965,21 +1951,25 @@ static unsigned long long flip_G8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_H8(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_H8(const __m128i OP)
 {
-	unsigned int outflank_h;
-	unsigned long long flipped, outflank_v, outflank_d9;
+	__m128i PP = _mm_shuffle_epi32(OP, DUPLO);
+	__m128i OO = _mm_shuffle_epi32(OP, DUPHI);
+	__m128i outflank, flipped;
+	__m128i mask = _mm_set_epi64x(0x0080808080808080, 0x7e40201008040201);
 
-	outflank_v = (0x0080000000000000ULL >> CONTIG_UP[((O & 0x0080808080808000ULL) * 0x0002040810204081ULL) >> 57]) & P;
-	flipped  = (-outflank_v * 2) & 0x0080808080808000ULL;
+	// outflank = MS1B_epu64(_mm_andnot_si128(OO, _mm_set_epi64x(0x0080808080808080, 0x0040201008040201)));
+	outflank = _mm_andnot_si128(OO, mask);
+	outflank = _mm_min_epu8(outflank, _mm_set_epi64x(0x0008080808080808, 0x0004020108040201));	// pack to 52 bits
+	outflank = _mm_mullo_epi16(MS1B_epu52(outflank), _mm_set_epi16(16, 16, 16, 16, 16, 16, 1, 1));	// unpack
 
-	outflank_h = OUTFLANK_7[(O >> 57) & 0x3f] & (P >> 56);
-	flipped |= (unsigned long long) ((-outflank_h) & 0x3f) << 57;
+	outflank = _mm_or_si128(outflank, MS1B_epu31(_mm_andnot_si128(OO, _mm_set_epi32(0, 0, 0x7f000000, 0))));
+	outflank = _mm_and_si128(outflank, PP);
 
-	outflank_d9 = (0x0040000000000000ULL >> CONTIG_UPLEFT[((O & 0x0040201008040200ULL) * 0x0101010101010101ULL) >> 57]) & P;
-	flipped |= (-outflank_d9 * 2) & 0x0040201008040200ULL;
+	flipped = _mm_sub_epi64(_mm_loadl_epi64((__m128i *) &X_TO_BIT[55]), _mm_add_epi64(outflank, outflank));
+	flipped = _mm_and_si128(flipped, mask);
 
-	return flipped;
+	return _mm_or_si128(flipped, _mm_shuffle_epi32(flipped, SWAP64));
 }
 
 /**
@@ -1989,32 +1979,23 @@ static unsigned long long flip_H8(const unsigned long long P, const unsigned lon
  * @param O opponent's disc pattern.
  * @return flipped disc pattern.
  */
-static unsigned long long flip_pass(const unsigned long long P, const unsigned long long O)
+static __m128i vectorcall flip_pass(const __m128i OP)
 {
-	(void) P; // useless code to shut-up compiler warning
-	(void) O;
-	return 0;
+	(void) OP; // useless code to shut-up compiler warning
+	return _mm_setzero_si128();
 }
 
 
 /** Array of functions to compute flipped discs */
-unsigned long long (*flip[])(const unsigned long long, const unsigned long long) = {
-	flip_A1, flip_B1, flip_C1, flip_D1,
-	flip_E1, flip_F1, flip_G1, flip_H1,
-	flip_A2, flip_B2, flip_C2, flip_D2,
-	flip_E2, flip_F2, flip_G2, flip_H2,
-	flip_A3, flip_B3, flip_C3, flip_D3,
-	flip_E3, flip_F3, flip_G3, flip_H3,
-	flip_A4, flip_B4, flip_C4, flip_D4,
-	flip_E4, flip_F4, flip_G4, flip_H4,
-	flip_A5, flip_B5, flip_C5, flip_D5,
-	flip_E5, flip_F5, flip_G5, flip_H5,
-	flip_A6, flip_B6, flip_C6, flip_D6,
-	flip_E6, flip_F6, flip_G6, flip_H6,
-	flip_A7, flip_B7, flip_C7, flip_D7,
-	flip_E7, flip_F7, flip_G7, flip_H7,
-	flip_A8, flip_B8, flip_C8, flip_D8,
-	flip_E8, flip_F8, flip_G8, flip_H8,
+__m128i (vectorcall *mm_flip[])(const __m128i) = {
+	flip_A1, flip_B1, flip_C1, flip_D1, flip_E1, flip_F1, flip_G1, flip_H1,
+	flip_A2, flip_B2, flip_C2, flip_D2, flip_E2, flip_F2, flip_G2, flip_H2,
+	flip_A3, flip_B3, flip_C3, flip_D3, flip_E3, flip_F3, flip_G3, flip_H3,
+	flip_A4, flip_B4, flip_C4, flip_D4, flip_E4, flip_F4, flip_G4, flip_H4,
+	flip_A5, flip_B5, flip_C5, flip_D5, flip_E5, flip_F5, flip_G5, flip_H5,
+	flip_A6, flip_B6, flip_C6, flip_D6, flip_E6, flip_F6, flip_G6, flip_H6,
+	flip_A7, flip_B7, flip_C7, flip_D7, flip_E7, flip_F7, flip_G7, flip_H7,
+	flip_A8, flip_B8, flip_C8, flip_D8, flip_E8, flip_F8, flip_G8, flip_H8,
 	flip_pass, flip_pass
 };
 
diff --git a/src/flip_sse_bitscan.c b/src/flip_sse_bitscan.c
new file mode 100644
index 00000000..e084fbcc
--- /dev/null
+++ b/src/flip_sse_bitscan.c
@@ -0,0 +1,306 @@
+/**
+ * @file flip_sse_bitscan.c
+ *
+ * This module deals with flipping discs.
+ *
+ * A function is provided for each square of the board. These functions are
+ * gathered into an array of functions, so that a fast access to each function
+ * is allowed. The generic form of the function take as input the player and
+ * the opponent bitboards and return the flipped squares into a bitboard.
+ *
+ * Given the following notation:
+ *  - x = square where we play,
+ *  - P = player's disc pattern,
+ *  - O = opponent's disc pattern,
+ * the basic principle is to read into an array the result of a move. Doing
+ * this is easier for a single line ; so we can use arrays of the form:
+ *  - ARRAY[x][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by a simple
+ * multiplication and to right-shift the result to scale it into a number
+ * between 0 and 255.
+ * Once we get our 8-bits disc patterns,a first array (OUTFLANK) is used to
+ * get the player's discs that surround the opponent discs:
+ *  - outflank = OUTFLANK[x][O] & P
+ * (Only inner 6-bits of the P are in interest here.)
+ * The result is then used as an index to access a second array giving the
+ * flipped discs according to the surrounding player's discs:
+ *  - flipped = FLIPPED[x][outflank].
+ * (Flipped discs fall into inner 6-bits.)
+ * Finally, a precomputed array transform the inner 6-bits disc pattern back into a
+ * 64-bits disc pattern, and the flipped squares for each line are gathered and
+ * returned to generate moves.
+ *
+ * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
+ * can be used to determine contiguous opponent discs.
+ * If the OUTFLANK search is in MSB to LSB direction, CONTIG_X tables
+ * are used to determine coutiguous opponent discs.
+ *
+ * @date 1998 - 2020
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include "bit.h"
+
+static const V2DI maskl[64][2] = {
+	{ {{ ~0x00000000000000fe, ~0x0000000000000000 }}, {{ ~0x0101010101010100, ~0x8040201008040200 }} },
+	{ {{ ~0x00000000000000fc, ~0x0000000000000100 }}, {{ ~0x0202020202020200, ~0x0080402010080400 }} },
+	{ {{ ~0x00000000000000f8, ~0x0000000000010200 }}, {{ ~0x0404040404040400, ~0x0000804020100800 }} },
+	{ {{ ~0x00000000000000f0, ~0x0000000001020400 }}, {{ ~0x0808080808080800, ~0x0000008040201000 }} },
+	{ {{ ~0x00000000000000e0, ~0x0000000102040800 }}, {{ ~0x1010101010101000, ~0x0000000080402000 }} },
+	{ {{ ~0x00000000000000c0, ~0x0000010204081000 }}, {{ ~0x2020202020202000, ~0x0000000000804000 }} },
+	{ {{ ~0x0000000000000080, ~0x0001020408102000 }}, {{ ~0x4040404040404000, ~0x0000000000008000 }} },
+	{ {{ ~0x0000000000000000, ~0x0102040810204000 }}, {{ ~0x8080808080808000, ~0x0000000000000000 }} },
+	{ {{ ~0x000000000000fe00, ~0x0000000000000000 }}, {{ ~0x0101010101010000, ~0x4020100804020000 }} },
+	{ {{ ~0x000000000000fc00, ~0x0000000000010000 }}, {{ ~0x0202020202020000, ~0x8040201008040000 }} },
+	{ {{ ~0x000000000000f800, ~0x0000000001020000 }}, {{ ~0x0404040404040000, ~0x0080402010080000 }} },
+	{ {{ ~0x000000000000f000, ~0x0000000102040000 }}, {{ ~0x0808080808080000, ~0x0000804020100000 }} },
+	{ {{ ~0x000000000000e000, ~0x0000010204080000 }}, {{ ~0x1010101010100000, ~0x0000008040200000 }} },
+	{ {{ ~0x000000000000c000, ~0x0001020408100000 }}, {{ ~0x2020202020200000, ~0x0000000080400000 }} },
+	{ {{ ~0x0000000000008000, ~0x0102040810200000 }}, {{ ~0x4040404040400000, ~0x0000000000800000 }} },
+	{ {{ ~0x0000000000000000, ~0x0204081020400000 }}, {{ ~0x8080808080800000, ~0x0000000000000000 }} },
+	{ {{ ~0x0000000000fe0000, ~0x0000000000000000 }}, {{ ~0x0101010101000000, ~0x2010080402000000 }} },
+	{ {{ ~0x0000000000fc0000, ~0x0000000001000000 }}, {{ ~0x0202020202000000, ~0x4020100804000000 }} },
+	{ {{ ~0x0000000000f80000, ~0x0000000102000000 }}, {{ ~0x0404040404000000, ~0x8040201008000000 }} },
+	{ {{ ~0x0000000000f00000, ~0x0000010204000000 }}, {{ ~0x0808080808000000, ~0x0080402010000000 }} },
+	{ {{ ~0x0000000000e00000, ~0x0001020408000000 }}, {{ ~0x1010101010000000, ~0x0000804020000000 }} },
+	{ {{ ~0x0000000000c00000, ~0x0102040810000000 }}, {{ ~0x2020202020000000, ~0x0000008040000000 }} },
+	{ {{ ~0x0000000000800000, ~0x0204081020000000 }}, {{ ~0x4040404040000000, ~0x0000000080000000 }} },
+	{ {{ ~0x0000000000000000, ~0x0408102040000000 }}, {{ ~0x8080808080000000, ~0x0000000000000000 }} },
+	{ {{ ~0x00000000fe000000, ~0x0000000000000000 }}, {{ ~0x0101010100000000, ~0x1008040200000000 }} },
+	{ {{ ~0x00000000fc000000, ~0x0000000100000000 }}, {{ ~0x0202020200000000, ~0x2010080400000000 }} },
+	{ {{ ~0x00000000f8000000, ~0x0000010200000000 }}, {{ ~0x0404040400000000, ~0x4020100800000000 }} },
+	{ {{ ~0x00000000f0000000, ~0x0001020400000000 }}, {{ ~0x0808080800000000, ~0x8040201000000000 }} },
+	{ {{ ~0x00000000e0000000, ~0x0102040800000000 }}, {{ ~0x1010101000000000, ~0x0080402000000000 }} },
+	{ {{ ~0x00000000c0000000, ~0x0204081000000000 }}, {{ ~0x2020202000000000, ~0x0000804000000000 }} },
+	{ {{ ~0x0000000080000000, ~0x0408102000000000 }}, {{ ~0x4040404000000000, ~0x0000008000000000 }} },
+	{ {{ ~0x0000000000000000, ~0x0810204000000000 }}, {{ ~0x8080808000000000, ~0x0000000000000000 }} },
+	{ {{ ~0x000000fe00000000, ~0x0000000000000000 }}, {{ ~0x0101010000000000, ~0x0804020000000000 }} },
+	{ {{ ~0x000000fc00000000, ~0x0000010000000000 }}, {{ ~0x0202020000000000, ~0x1008040000000000 }} },
+	{ {{ ~0x000000f800000000, ~0x0001020000000000 }}, {{ ~0x0404040000000000, ~0x2010080000000000 }} },
+	{ {{ ~0x000000f000000000, ~0x0102040000000000 }}, {{ ~0x0808080000000000, ~0x4020100000000000 }} },
+	{ {{ ~0x000000e000000000, ~0x0204080000000000 }}, {{ ~0x1010100000000000, ~0x8040200000000000 }} },
+	{ {{ ~0x000000c000000000, ~0x0408100000000000 }}, {{ ~0x2020200000000000, ~0x0080400000000000 }} },
+	{ {{ ~0x0000008000000000, ~0x0810200000000000 }}, {{ ~0x4040400000000000, ~0x0000800000000000 }} },
+	{ {{ ~0x0000000000000000, ~0x1020400000000000 }}, {{ ~0x8080800000000000, ~0x0000000000000000 }} },
+	{ {{ ~0x0000fe0000000000, ~0x0000000000000000 }}, {{ ~0x0101000000000000, ~0x0402000000000000 }} },
+	{ {{ ~0x0000fc0000000000, ~0x0001000000000000 }}, {{ ~0x0202000000000000, ~0x0804000000000000 }} },
+	{ {{ ~0x0000f80000000000, ~0x0102000000000000 }}, {{ ~0x0404000000000000, ~0x1008000000000000 }} },
+	{ {{ ~0x0000f00000000000, ~0x0204000000000000 }}, {{ ~0x0808000000000000, ~0x2010000000000000 }} },
+	{ {{ ~0x0000e00000000000, ~0x0408000000000000 }}, {{ ~0x1010000000000000, ~0x4020000000000000 }} },
+	{ {{ ~0x0000c00000000000, ~0x0810000000000000 }}, {{ ~0x2020000000000000, ~0x8040000000000000 }} },
+	{ {{ ~0x0000800000000000, ~0x1020000000000000 }}, {{ ~0x4040000000000000, ~0x0080000000000000 }} },
+	{ {{ ~0x0000000000000000, ~0x2040000000000000 }}, {{ ~0x8080000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0x00fe000000000000, ~0x0000000000000000 }}, {{ ~0x0100000000000000, ~0x0200000000000000 }} },
+	{ {{ ~0x00fc000000000000, ~0x0100000000000000 }}, {{ ~0x0200000000000000, ~0x0400000000000000 }} },
+	{ {{ ~0x00f8000000000000, ~0x0200000000000000 }}, {{ ~0x0400000000000000, ~0x0800000000000000 }} },
+	{ {{ ~0x00f0000000000000, ~0x0400000000000000 }}, {{ ~0x0800000000000000, ~0x1000000000000000 }} },
+	{ {{ ~0x00e0000000000000, ~0x0800000000000000 }}, {{ ~0x1000000000000000, ~0x2000000000000000 }} },
+	{ {{ ~0x00c0000000000000, ~0x1000000000000000 }}, {{ ~0x2000000000000000, ~0x4000000000000000 }} },
+	{ {{ ~0x0080000000000000, ~0x2000000000000000 }}, {{ ~0x4000000000000000, ~0x8000000000000000 }} },
+	{ {{ ~0x0000000000000000, ~0x4000000000000000 }}, {{ ~0x8000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0xfe00000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0xfc00000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0xf800000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0xf000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0xe000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0xc000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0x8000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} },
+	{ {{ ~0x0000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }} }
+};
+
+#if !defined(__LZCNT__) || !defined(__x86_64__)
+
+static const unsigned long long masko[64][4] = {
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000002, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000006, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000000e, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000001e, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000003e, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000007e, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000600, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000e00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000001e00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000003e00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000007e00, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000200, 0x0000000000000100, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000400, 0x0000000000000200, 0x0000000000000000,
+	0x0000000000020000, 0x0000000000000800, 0x0000000000000400, 0x0000000000000200,
+	0x0000000000060000, 0x0000000000001000, 0x0000000000000800, 0x0000000000000400,
+	0x00000000000e0000, 0x0000000000002000, 0x0000000000001000, 0x0000000000000800,
+	0x00000000001e0000, 0x0000000000004000, 0x0000000000002000, 0x0000000000001000,
+	0x00000000003e0000, 0x0000000000000000, 0x0000000000004000, 0x0000000000002000,
+	0x00000000007e0000, 0x0000000000000000, 0x0000000000008000, 0x0000000000004000,
+	0x0000000000000000, 0x0000000000020400, 0x0000000000010100, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000040800, 0x0000000000020200, 0x0000000000000000,
+	0x0000000002000000, 0x0000000000081000, 0x0000000000040400, 0x0000000000020000,
+	0x0000000006000000, 0x0000000000102000, 0x0000000000080800, 0x0000000000040200,
+	0x000000000e000000, 0x0000000000204000, 0x0000000000101000, 0x0000000000080400,
+	0x000000001e000000, 0x0000000000400000, 0x0000000000202000, 0x0000000000100800,
+	0x000000003e000000, 0x0000000000000000, 0x0000000000404000, 0x0000000000201000,
+	0x000000007e000000, 0x0000000000000000, 0x0000000000808000, 0x0000000000402000,
+	0x0000000000000000, 0x0000000002040800, 0x0000000001010100, 0x0000000000000000,
+	0x0000000000000000, 0x0000000004081000, 0x0000000002020200, 0x0000000000000000,
+	0x0000000200000000, 0x0000000008102000, 0x0000000004040400, 0x0000000002000000,
+	0x0000000600000000, 0x0000000010204000, 0x0000000008080800, 0x0000000004020000,
+	0x0000000e00000000, 0x0000000020400000, 0x0000000010101000, 0x0000000008040200,
+	0x0000001e00000000, 0x0000000040000000, 0x0000000020202000, 0x0000000010080400,
+	0x0000003e00000000, 0x0000000000000000, 0x0000000040404000, 0x0000000020100800,
+	0x0000007e00000000, 0x0000000000000000, 0x0000000080808000, 0x0000000040201000,
+	0x0000000000000000, 0x0000000204081000, 0x0000000101010100, 0x0000000000000000,
+	0x0000000000000000, 0x0000000408102000, 0x0000000202020200, 0x0000000000000000,
+	0x0000020000000000, 0x0000000810204000, 0x0000000404040400, 0x0000000200000000,
+	0x0000060000000000, 0x0000001020400000, 0x0000000808080800, 0x0000000402000000,
+	0x00000e0000000000, 0x0000002040000000, 0x0000001010101000, 0x0000000804020000,
+	0x00001e0000000000, 0x0000004000000000, 0x0000002020202000, 0x0000001008040200,
+	0x00003e0000000000, 0x0000000000000000, 0x0000004040404000, 0x0000002010080400,
+	0x00007e0000000000, 0x0000000000000000, 0x0000008080808000, 0x0000004020100800,
+	0x0000000000000000, 0x0000020408102000, 0x0000010101010100, 0x0000000000000000,
+	0x0000000000000000, 0x0000040810204000, 0x0000020202020200, 0x0000000000000000,
+	0x0002000000000000, 0x0000081020400000, 0x0000040404040400, 0x0000020000000000,
+	0x0006000000000000, 0x0000102040000000, 0x0000080808080800, 0x0000040200000000,
+	0x000e000000000000, 0x0000204000000000, 0x0000101010101000, 0x0000080402000000,
+	0x001e000000000000, 0x0000400000000000, 0x0000202020202000, 0x0000100804020000,
+	0x003e000000000000, 0x0000000000000000, 0x0000404040404000, 0x0000201008040200,
+	0x007e000000000000, 0x0000000000000000, 0x0000808080808000, 0x0000402010080400,
+	0x0000000000000000, 0x0002040810204000, 0x0001010101010100, 0x0000000000000000,
+	0x0000000000000000, 0x0004081020400000, 0x0002020202020200, 0x0000000000000000,
+	0x0200000000000000, 0x0008102040000000, 0x0004040404040400, 0x0002000000000000,
+	0x0600000000000000, 0x0010204000000000, 0x0008080808080800, 0x0004020000000000,
+	0x0e00000000000000, 0x0020400000000000, 0x0010101010101000, 0x0008040200000000,
+	0x1e00000000000000, 0x0040000000000000, 0x0020202020202000, 0x0010080402000000,
+	0x3e00000000000000, 0x0000000000000000, 0x0040404040404000, 0x0020100804020000,
+	0x7e00000000000000, 0x0000000000000000, 0x0080808080808000, 0x0040201008040200
+};
+#endif
+
+static const unsigned long long maskr[64][4] = {
+	0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+	0x0000000000000000, 0x0000000000000002, 0x0000000000000001, 0x0000000000000000,
+	0x0000000000000100, 0x0000000000000004, 0x0000000000000002, 0x0000000000000001,
+	0x0000000000000300, 0x0000000000000008, 0x0000000000000004, 0x0000000000000002,
+	0x0000000000000700, 0x0000000000000010, 0x0000000000000008, 0x0000000000000004,
+	0x0000000000000f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000008,
+	0x0000000000001f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000010,
+	0x0000000000003f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000020,
+	0x0000000000007f00, 0x0000000000000000, 0x0000000000000080, 0x0000000000000040,
+	0x0000000000000000, 0x0000000000000204, 0x0000000000000101, 0x0000000000000000,
+	0x0000000000010000, 0x0000000000000408, 0x0000000000000202, 0x0000000000000100,
+	0x0000000000030000, 0x0000000000000810, 0x0000000000000404, 0x0000000000000201,
+	0x0000000000070000, 0x0000000000001020, 0x0000000000000808, 0x0000000000000402,
+	0x00000000000f0000, 0x0000000000002040, 0x0000000000001010, 0x0000000000000804,
+	0x00000000001f0000, 0x0000000000004080, 0x0000000000002020, 0x0000000000001008,
+	0x00000000003f0000, 0x0000000000008000, 0x0000000000004040, 0x0000000000002010,
+	0x00000000007f0000, 0x0000000000000000, 0x0000000000008080, 0x0000000000004020,
+	0x0000000000000000, 0x0000000000020408, 0x0000000000010101, 0x0000000000000000,
+	0x0000000001000000, 0x0000000000040810, 0x0000000000020202, 0x0000000000010000,
+	0x0000000003000000, 0x0000000000081020, 0x0000000000040404, 0x0000000000020100,
+	0x0000000007000000, 0x0000000000102040, 0x0000000000080808, 0x0000000000040201,
+	0x000000000f000000, 0x0000000000204080, 0x0000000000101010, 0x0000000000080402,
+	0x000000001f000000, 0x0000000000408000, 0x0000000000202020, 0x0000000000100804,
+	0x000000003f000000, 0x0000000000800000, 0x0000000000404040, 0x0000000000201008,
+	0x000000007f000000, 0x0000000000000000, 0x0000000000808080, 0x0000000000402010,
+	0x0000000000000000, 0x0000000002040810, 0x0000000001010101, 0x0000000000000000,
+	0x0000000100000000, 0x0000000004081020, 0x0000000002020202, 0x0000000001000000,
+	0x0000000300000000, 0x0000000008102040, 0x0000000004040404, 0x0000000002010000,
+	0x0000000700000000, 0x0000000010204080, 0x0000000008080808, 0x0000000004020100,
+	0x0000000f00000000, 0x0000000020408000, 0x0000000010101010, 0x0000000008040201,
+	0x0000001f00000000, 0x0000000040800000, 0x0000000020202020, 0x0000000010080402,
+	0x0000003f00000000, 0x0000000080000000, 0x0000000040404040, 0x0000000020100804,
+	0x0000007f00000000, 0x0000000000000000, 0x0000000080808080, 0x0000000040201008,
+	0x0000000000000000, 0x0000000204081020, 0x0000000101010101, 0x0000000000000000,
+	0x0000010000000000, 0x0000000408102040, 0x0000000202020202, 0x0000000100000000,
+	0x0000030000000000, 0x0000000810204080, 0x0000000404040404, 0x0000000201000000,
+	0x0000070000000000, 0x0000001020408000, 0x0000000808080808, 0x0000000402010000,
+	0x00000f0000000000, 0x0000002040800000, 0x0000001010101010, 0x0000000804020100,
+	0x00001f0000000000, 0x0000004080000000, 0x0000002020202020, 0x0000001008040201,
+	0x00003f0000000000, 0x0000008000000000, 0x0000004040404040, 0x0000002010080402,
+	0x00007f0000000000, 0x0000000000000000, 0x0000008080808080, 0x0000004020100804,
+	0x0000000000000000, 0x0000020408102040, 0x0000010101010101, 0x0000000000000000,
+	0x0001000000000000, 0x0000040810204080, 0x0000020202020202, 0x0000010000000000,
+	0x0003000000000000, 0x0000081020408000, 0x0000040404040404, 0x0000020100000000,
+	0x0007000000000000, 0x0000102040800000, 0x0000080808080808, 0x0000040201000000,
+	0x000f000000000000, 0x0000204080000000, 0x0000101010101010, 0x0000080402010000,
+	0x001f000000000000, 0x0000408000000000, 0x0000202020202020, 0x0000100804020100,
+	0x003f000000000000, 0x0000800000000000, 0x0000404040404040, 0x0000201008040201,
+	0x007f000000000000, 0x0000000000000000, 0x0000808080808080, 0x0000402010080402,
+	0x0000000000000000, 0x0002040810204080, 0x0001010101010101, 0x0000000000000000,
+	0x0100000000000000, 0x0004081020408000, 0x0002020202020202, 0x0001000000000000,
+	0x0300000000000000, 0x0008102040800000, 0x0004040404040404, 0x0002010000000000,
+	0x0700000000000000, 0x0010204080000000, 0x0008080808080808, 0x0004020100000000,
+	0x0f00000000000000, 0x0020408000000000, 0x0010101010101010, 0x0008040201000000,
+	0x1f00000000000000, 0x0040800000000000, 0x0020202020202020, 0x0010080402010000,
+	0x3f00000000000000, 0x0080000000000000, 0x0040404040404040, 0x0020100804020100,
+	0x7f00000000000000, 0x0000000000000000, 0x0080808080808080, 0x0040201008040201
+};
+
+#if ((defined(__x86_64__) || defined(USE_GAS_X86)) && defined(__LZCNT__)) || defined(_MSC_VER)
+#define	count_opp_reverse(O,masko,maskr)	lzcnt_u64(~(O) & (maskr))
+#else
+// with guardian bit to avoid __builtin_clz(0)
+#define	count_opp_reverse(O,masko,maskr)	__builtin_clzll(((O) & (masko)) ^ (maskr))
+#endif
+
+#define	SWAP64	0x4e	// for _mm_shuffle_epi32
+#define	SWAP32	0xb1
+
+/**
+ * Make inverted flip mask if opponent's disc are surrounded by player's.
+ *
+ * 0xffffffffffffffffULL (-1) if outflank is 0
+ * 0x0000000000000000ULL ( 0) if a 1 is in 64 bit
+ */
+static inline __m128i flipmask (__m128i outflank) {
+	return _mm_cmpeq_epi32(_mm_shuffle_epi32(outflank, SWAP32), outflank);
+}
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+unsigned long long flip(const unsigned long long P, const unsigned long long O, int pos)
+{
+	__m128i	outflank17, outflank89, PP, OO;
+	unsigned long long flipped, outflankr1, outflankr7, outflankr8, outflankr9;
+	const __m128i minusone = _mm_set1_epi32(-1);
+
+	outflankr1 = (0x8000000000000000ULL >> count_opp_reverse(O, masko[pos][0], maskr[pos][0])) & P;
+	flipped  = (-outflankr1 * 2) & maskr[pos][0];
+	outflankr7 = (0x8000000000000000ULL >> count_opp_reverse(O, masko[pos][1], maskr[pos][1])) & P;
+	flipped |= (-outflankr7 * 2) & maskr[pos][1];
+	outflankr8 = (0x8000000000000000ULL >> count_opp_reverse(O, masko[pos][2], maskr[pos][2])) & P;
+	flipped |= (-outflankr8 * 2) & maskr[pos][2];
+	outflankr9 = (0x8000000000000000ULL >> count_opp_reverse(O, masko[pos][3], maskr[pos][3])) & P;
+	flipped |= (-outflankr9 * 2) & maskr[pos][3];
+
+	PP = _mm_set1_epi64x(P);
+	OO = _mm_and_si128(_mm_set1_epi64x(O), _mm_set_epi32(0x7e7e7e7e, 0x7e7e7e7e, -1, -1));
+	outflank89 = _mm_and_si128(_mm_andnot_si128(maskl[pos][1].v2, _mm_sub_epi64(_mm_or_si128(OO, maskl[pos][1].v2), minusone)), PP);
+	OO = _mm_unpackhi_epi64(OO, OO);
+	outflank17 = _mm_and_si128(_mm_andnot_si128(maskl[pos][0].v2, _mm_sub_epi64(_mm_or_si128(OO, maskl[pos][0].v2), minusone)), PP);
+	outflank89 = _mm_andnot_si128(maskl[pos][1].v2, _mm_sub_epi64(outflank89, _mm_sub_epi64(flipmask(outflank89), minusone)));
+	outflank17 = _mm_andnot_si128(maskl[pos][0].v2, _mm_sub_epi64(outflank17, _mm_sub_epi64(flipmask(outflank17), minusone)));
+	outflank17 = _mm_or_si128(outflank17, outflank89);
+	outflank17 = _mm_or_si128(outflank17, _mm_shuffle_epi32(outflank17, SWAP64));
+
+	return flipped | _mm_cvtsi128_si64(outflank17);
+}
diff --git a/src/flip_sse_bswap.c b/src/flip_sse_bswap.c
new file mode 100644
index 00000000..bbed27d8
--- /dev/null
+++ b/src/flip_sse_bswap.c
@@ -0,0 +1,435 @@
+/**
+ * @file flip_sse_bswap.c
+ *
+ * This module deals with flipping discs.
+ *
+ * A function is provided for each square of the board. These functions are
+ * gathered into an array of functions, so that a fast access to each function
+ * is allowed. The generic form of the function take as input the player and
+ * the opponent bitboards and return the flipped squares into a bitboard.
+ *
+ * Given the following notation:
+ *  - x = square where we play,
+ *  - P = player's disc pattern,
+ *  - O = opponent's disc pattern,
+ * the basic principle is to read into an array the result of a move. Doing
+ * this is easier for a single line ; so we can use arrays of the form:
+ *  - ARRAY[x][8-bits disc pattern].
+ * The problem is thus to convert any line of a 64-bits disc pattern into an
+ * 8-bits disc pattern. A fast way to do this is to select the right line,
+ * with a bit-mask, to gather the masked-bits into a continuous set by a simple
+ * multiplication and to right-shift the result to scale it into a number
+ * between 0 and 255.
+ * Once we get our 8-bits disc patterns,a first array (OUTFLANK) is used to
+ * get the player's discs that surround the opponent discs:
+ *  - outflank = OUTFLANK[x][O] & P
+ * (Only inner 6-bits of the P are in interest here.)
+ * The result is then used as an index to access a second array giving the
+ * flipped discs according to the surrounding player's discs:
+ *  - flipped = FLIPPED[x][outflank].
+ * (Flipped discs fall into inner 6-bits.)
+ * Finally, a precomputed array transform the inner 6-bits disc pattern back into a
+ * 64-bits disc pattern, and the flipped squares for each line are gathered and
+ * returned to generate moves.
+ *
+ * If the OUTFLANK search is in LSB to MSB direction, carry propagation 
+ * can be used to determine contiguous opponent discs.
+ * If the OUTFLANK search is in MSB to LSB direction, CONTIG_X tables
+ * are used to determine coutiguous opponent discs.
+ *
+ * @date 1998 - 2018
+ * @author Richard Delorme
+ * @author Toshihiko Okuhara
+ * @version 4.4
+ */
+
+#include "bit.h"
+
+/** outflank array (indexed with inner 6 bits) */
+static const unsigned char OUTFLANK[64][8] = {
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00 },
+	{ 0x04, 0x00, 0x11, 0x00, 0x04, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x10, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00 },
+	{ 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x00 },
+	{ 0x04, 0x00, 0x01, 0x20, 0x00, 0x08, 0x00, 0x00 },
+	{ 0x00, 0x08, 0x00, 0x22, 0x00, 0x08, 0x00, 0x00 },
+	{ 0x08, 0x00, 0x00, 0x21, 0x00, 0x08, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00 },
+	{ 0x04, 0x00, 0x21, 0x00, 0x00, 0x04, 0x00, 0x00 },
+	{ 0x00, 0x20, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00 },
+	{ 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x10, 0x00 },
+	{ 0x04, 0x00, 0x01, 0x00, 0x40, 0x00, 0x10, 0x00 },
+	{ 0x00, 0x08, 0x00, 0x02, 0x40, 0x00, 0x10, 0x00 },
+	{ 0x08, 0x00, 0x00, 0x01, 0x40, 0x00, 0x10, 0x00 },
+	{ 0x00, 0x00, 0x10, 0x00, 0x44, 0x00, 0x10, 0x00 },
+	{ 0x04, 0x00, 0x11, 0x00, 0x44, 0x00, 0x10, 0x00 },
+	{ 0x00, 0x10, 0x00, 0x00, 0x42, 0x00, 0x10, 0x00 },
+	{ 0x10, 0x00, 0x00, 0x00, 0x41, 0x00, 0x10, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, 0x00 },
+	{ 0x04, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00 },
+	{ 0x00, 0x08, 0x00, 0x42, 0x00, 0x00, 0x08, 0x00 },
+	{ 0x08, 0x00, 0x00, 0x41, 0x00, 0x00, 0x08, 0x00 },
+	{ 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00 },
+	{ 0x04, 0x00, 0x41, 0x00, 0x00, 0x00, 0x04, 0x00 },
+	{ 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00 },
+	{ 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x20 },
+	{ 0x04, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x20 },
+	{ 0x00, 0x08, 0x00, 0x02, 0x00, 0x80, 0x00, 0x20 },
+	{ 0x08, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00, 0x20 },
+	{ 0x00, 0x00, 0x10, 0x00, 0x04, 0x80, 0x00, 0x20 },
+	{ 0x04, 0x00, 0x11, 0x00, 0x04, 0x80, 0x00, 0x20 },
+	{ 0x00, 0x10, 0x00, 0x00, 0x02, 0x80, 0x00, 0x20 },
+	{ 0x10, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x20 },
+	{ 0x00, 0x00, 0x00, 0x20, 0x00, 0x88, 0x00, 0x20 },
+	{ 0x04, 0x00, 0x01, 0x20, 0x00, 0x88, 0x00, 0x20 },
+	{ 0x00, 0x08, 0x00, 0x22, 0x00, 0x88, 0x00, 0x20 },
+	{ 0x08, 0x00, 0x00, 0x21, 0x00, 0x88, 0x00, 0x20 },
+	{ 0x00, 0x00, 0x20, 0x00, 0x00, 0x84, 0x00, 0x20 },
+	{ 0x04, 0x00, 0x21, 0x00, 0x00, 0x84, 0x00, 0x20 },
+	{ 0x00, 0x20, 0x00, 0x00, 0x00, 0x82, 0x00, 0x20 },
+	{ 0x20, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x20 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x10 },
+	{ 0x04, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x10 },
+	{ 0x00, 0x08, 0x00, 0x02, 0x80, 0x00, 0x00, 0x10 },
+	{ 0x08, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x10 },
+	{ 0x00, 0x00, 0x10, 0x00, 0x84, 0x00, 0x00, 0x10 },
+	{ 0x04, 0x00, 0x11, 0x00, 0x84, 0x00, 0x00, 0x10 },
+	{ 0x00, 0x10, 0x00, 0x00, 0x82, 0x00, 0x00, 0x10 },
+	{ 0x10, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x10 },
+	{ 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x08 },
+	{ 0x04, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x08 },
+	{ 0x00, 0x08, 0x00, 0x82, 0x00, 0x00, 0x00, 0x08 },
+	{ 0x08, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x08 },
+	{ 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04 },
+	{ 0x04, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x04 },
+	{ 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 },
+	{ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }
+};
+
+/** flip array (indexed with outflank) */
+static const unsigned char FLIPPED[137][8] = {
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x02, 0x06, 0x0e, 0x1e, 0x3e, 0x7e },
+	{ 0x00, 0x00, 0x00, 0x04, 0x0c, 0x1c, 0x3c, 0x7c },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x02, 0x00, 0x00, 0x00, 0x08, 0x18, 0x38, 0x78 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x06, 0x04, 0x00, 0x00, 0x00, 0x10, 0x30, 0x70 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x0e, 0x0c, 0x08, 0x00, 0x00, 0x00, 0x20, 0x60 },
+	{ 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x1e, 0x1c, 0x18, 0x10, 0x00, 0x00, 0x00, 0x40 },
+	{ 0x00, 0x00, 0x1a, 0x16, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x3e, 0x3c, 0x38, 0x30, 0x20, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x3a, 0x36, 0x2e, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x34, 0x2c, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x7e, 0x7c, 0x78, 0x70, 0x60, 0x40, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x7a, 0x76, 0x6e, 0x5e, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x74, 0x6c, 0x5c, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x68, 0x58, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00 }
+};
+
+static const V2DI mask[3][64] = { {
+	{{ ~0x0000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000100, ~0x0000000000000000 }},
+	{{ ~0x0000000000010200, ~0x0000000000000000 }}, {{ ~0x0000000001020400, ~0x0000000000000000 }},
+	{{ ~0x0000000102040800, ~0x0000000000000000 }}, {{ ~0x0000010204081000, ~0x0000000000000000 }},
+	{{ ~0x0001020408102000, ~0x0000000000000000 }}, {{ ~0x0102040810204000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x0200000000000000 }}, {{ ~0x0000000000010000, ~0x0400000000000000 }},
+	{{ ~0x0000000001020000, ~0x0800000000000000 }}, {{ ~0x0000000102040000, ~0x1000000000000000 }},
+	{{ ~0x0000010204080000, ~0x2000000000000000 }}, {{ ~0x0001020408100000, ~0x4000000000000000 }},
+	{{ ~0x0102040810200000, ~0x8000000000000000 }}, {{ ~0x0204081020400000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x0402000000000000 }}, {{ ~0x0000000001000000, ~0x0804000000000000 }},
+	{{ ~0x0000000102000000, ~0x1008000000000000 }}, {{ ~0x0000010204000000, ~0x2010000000000000 }},
+	{{ ~0x0001020408000000, ~0x4020000000000000 }}, {{ ~0x0102040810000000, ~0x8040000000000000 }},
+	{{ ~0x0204081020000000, ~0x0080000000000000 }}, {{ ~0x0408102040000000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x0804020000000000 }}, {{ ~0x0000000100000000, ~0x1008040000000000 }},
+	{{ ~0x0000010200000000, ~0x2010080000000000 }}, {{ ~0x0001020400000000, ~0x4020100000000000 }},
+	{{ ~0x0102040800000000, ~0x8040200000000000 }}, {{ ~0x0204081000000000, ~0x0080400000000000 }},
+	{{ ~0x0408102000000000, ~0x0000800000000000 }}, {{ ~0x0810204000000000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x1008040200000000 }}, {{ ~0x0000010000000000, ~0x2010080400000000 }},
+	{{ ~0x0001020000000000, ~0x4020100800000000 }}, {{ ~0x0102040000000000, ~0x8040201000000000 }},
+	{{ ~0x0204080000000000, ~0x0080402000000000 }}, {{ ~0x0408100000000000, ~0x0000804000000000 }},
+	{{ ~0x0810200000000000, ~0x0000008000000000 }}, {{ ~0x1020400000000000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x2010080402000000 }}, {{ ~0x0001000000000000, ~0x4020100804000000 }},
+	{{ ~0x0102000000000000, ~0x8040201008000000 }}, {{ ~0x0204000000000000, ~0x0080402010000000 }},
+	{{ ~0x0408000000000000, ~0x0000804020000000 }}, {{ ~0x0810000000000000, ~0x0000008040000000 }},
+	{{ ~0x1020000000000000, ~0x0000000080000000 }}, {{ ~0x2040000000000000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x4020100804020000 }}, {{ ~0x0100000000000000, ~0x8040201008040000 }},
+	{{ ~0x0200000000000000, ~0x0080402010080000 }}, {{ ~0x0400000000000000, ~0x0000804020100000 }},
+	{{ ~0x0800000000000000, ~0x0000008040200000 }}, {{ ~0x1000000000000000, ~0x0000000080400000 }},
+	{{ ~0x2000000000000000, ~0x0000000000800000 }}, {{ ~0x4000000000000000, ~0x0000000000000000 }},
+	{{ ~0x0000000000000000, ~0x8040201008040200 }}, {{ ~0x0000000000000000, ~0x0080402010080400 }},
+	{{ ~0x0000000000000000, ~0x0000804020100800 }}, {{ ~0x0000000000000000, ~0x0000008040201000 }},
+	{{ ~0x0000000000000000, ~0x0000000080402000 }}, {{ ~0x0000000000000000, ~0x0000000000804000 }},
+	{{ ~0x0000000000000000, ~0x0000000000008000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }}
+}, {
+	{{ ~0x0101010101010100, ~0x0000000000000000 }}, {{ ~0x0202020202020200, ~0x0000000000000000 }},
+	{{ ~0x0404040404040400, ~0x0000000000000000 }}, {{ ~0x0808080808080800, ~0x0000000000000000 }},
+	{{ ~0x1010101010101000, ~0x0000000000000000 }}, {{ ~0x2020202020202000, ~0x0000000000000000 }},
+	{{ ~0x4040404040404000, ~0x0000000000000000 }}, {{ ~0x8080808080808000, ~0x0000000000000000 }},
+	{{ ~0x0101010101010000, ~0x0100000000000000 }}, {{ ~0x0202020202020000, ~0x0200000000000000 }},
+	{{ ~0x0404040404040000, ~0x0400000000000000 }}, {{ ~0x0808080808080000, ~0x0800000000000000 }},
+	{{ ~0x1010101010100000, ~0x1000000000000000 }}, {{ ~0x2020202020200000, ~0x2000000000000000 }},
+	{{ ~0x4040404040400000, ~0x4000000000000000 }}, {{ ~0x8080808080800000, ~0x8000000000000000 }},
+	{{ ~0x0101010101000000, ~0x0101000000000000 }}, {{ ~0x0202020202000000, ~0x0202000000000000 }},
+	{{ ~0x0404040404000000, ~0x0404000000000000 }}, {{ ~0x0808080808000000, ~0x0808000000000000 }},
+	{{ ~0x1010101010000000, ~0x1010000000000000 }}, {{ ~0x2020202020000000, ~0x2020000000000000 }},
+	{{ ~0x4040404040000000, ~0x4040000000000000 }}, {{ ~0x8080808080000000, ~0x8080000000000000 }},
+	{{ ~0x0101010100000000, ~0x0101010000000000 }}, {{ ~0x0202020200000000, ~0x0202020000000000 }},
+	{{ ~0x0404040400000000, ~0x0404040000000000 }}, {{ ~0x0808080800000000, ~0x0808080000000000 }},
+	{{ ~0x1010101000000000, ~0x1010100000000000 }}, {{ ~0x2020202000000000, ~0x2020200000000000 }},
+	{{ ~0x4040404000000000, ~0x4040400000000000 }}, {{ ~0x8080808000000000, ~0x8080800000000000 }},
+	{{ ~0x0101010000000000, ~0x0101010100000000 }}, {{ ~0x0202020000000000, ~0x0202020200000000 }},
+	{{ ~0x0404040000000000, ~0x0404040400000000 }}, {{ ~0x0808080000000000, ~0x0808080800000000 }},
+	{{ ~0x1010100000000000, ~0x1010101000000000 }}, {{ ~0x2020200000000000, ~0x2020202000000000 }},
+	{{ ~0x4040400000000000, ~0x4040404000000000 }}, {{ ~0x8080800000000000, ~0x8080808000000000 }},
+	{{ ~0x0101000000000000, ~0x0101010101000000 }}, {{ ~0x0202000000000000, ~0x0202020202000000 }},
+	{{ ~0x0404000000000000, ~0x0404040404000000 }}, {{ ~0x0808000000000000, ~0x0808080808000000 }},
+	{{ ~0x1010000000000000, ~0x1010101010000000 }}, {{ ~0x2020000000000000, ~0x2020202020000000 }},
+	{{ ~0x4040000000000000, ~0x4040404040000000 }}, {{ ~0x8080000000000000, ~0x8080808080000000 }},
+	{{ ~0x0100000000000000, ~0x0101010101010000 }}, {{ ~0x0200000000000000, ~0x0202020202020000 }},
+	{{ ~0x0400000000000000, ~0x0404040404040000 }}, {{ ~0x0800000000000000, ~0x0808080808080000 }},
+	{{ ~0x1000000000000000, ~0x1010101010100000 }}, {{ ~0x2000000000000000, ~0x2020202020200000 }},
+	{{ ~0x4000000000000000, ~0x4040404040400000 }}, {{ ~0x8000000000000000, ~0x8080808080800000 }},
+	{{ ~0x0000000000000000, ~0x0101010101010100 }}, {{ ~0x0000000000000000, ~0x0202020202020200 }},
+	{{ ~0x0000000000000000, ~0x0404040404040400 }}, {{ ~0x0000000000000000, ~0x0808080808080800 }},
+	{{ ~0x0000000000000000, ~0x1010101010101000 }}, {{ ~0x0000000000000000, ~0x2020202020202000 }},
+	{{ ~0x0000000000000000, ~0x4040404040404000 }}, {{ ~0x0000000000000000, ~0x8080808080808000 }}
+}, {
+	{{ ~0x8040201008040200, ~0x0000000000000000 }}, {{ ~0x0080402010080400, ~0x0000000000000000 }},
+	{{ ~0x0000804020100800, ~0x0000000000000000 }}, {{ ~0x0000008040201000, ~0x0000000000000000 }},
+	{{ ~0x0000000080402000, ~0x0000000000000000 }}, {{ ~0x0000000000804000, ~0x0000000000000000 }},
+	{{ ~0x0000000000008000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000000 }},
+	{{ ~0x4020100804020000, ~0x0000000000000000 }}, {{ ~0x8040201008040000, ~0x0100000000000000 }},
+	{{ ~0x0080402010080000, ~0x0200000000000000 }}, {{ ~0x0000804020100000, ~0x0400000000000000 }},
+	{{ ~0x0000008040200000, ~0x0800000000000000 }}, {{ ~0x0000000080400000, ~0x1000000000000000 }},
+	{{ ~0x0000000000800000, ~0x2000000000000000 }}, {{ ~0x0000000000000000, ~0x4000000000000000 }},
+	{{ ~0x2010080402000000, ~0x0000000000000000 }}, {{ ~0x4020100804000000, ~0x0001000000000000 }},
+	{{ ~0x8040201008000000, ~0x0102000000000000 }}, {{ ~0x0080402010000000, ~0x0204000000000000 }},
+	{{ ~0x0000804020000000, ~0x0408000000000000 }}, {{ ~0x0000008040000000, ~0x0810000000000000 }},
+	{{ ~0x0000000080000000, ~0x1020000000000000 }}, {{ ~0x0000000000000000, ~0x2040000000000000 }},
+	{{ ~0x1008040200000000, ~0x0000000000000000 }}, {{ ~0x2010080400000000, ~0x0000010000000000 }},
+	{{ ~0x4020100800000000, ~0x0001020000000000 }}, {{ ~0x8040201000000000, ~0x0102040000000000 }},
+	{{ ~0x0080402000000000, ~0x0204080000000000 }}, {{ ~0x0000804000000000, ~0x0408100000000000 }},
+	{{ ~0x0000008000000000, ~0x0810200000000000 }}, {{ ~0x0000000000000000, ~0x1020400000000000 }},
+	{{ ~0x0804020000000000, ~0x0000000000000000 }}, {{ ~0x1008040000000000, ~0x0000000100000000 }},
+	{{ ~0x2010080000000000, ~0x0000010200000000 }}, {{ ~0x4020100000000000, ~0x0001020400000000 }},
+	{{ ~0x8040200000000000, ~0x0102040800000000 }}, {{ ~0x0080400000000000, ~0x0204081000000000 }},
+	{{ ~0x0000800000000000, ~0x0408102000000000 }}, {{ ~0x0000000000000000, ~0x0810204000000000 }},
+	{{ ~0x0402000000000000, ~0x0000000000000000 }}, {{ ~0x0804000000000000, ~0x0000000001000000 }},
+	{{ ~0x1008000000000000, ~0x0000000102000000 }}, {{ ~0x2010000000000000, ~0x0000010204000000 }},
+	{{ ~0x4020000000000000, ~0x0001020408000000 }}, {{ ~0x8040000000000000, ~0x0102040810000000 }},
+	{{ ~0x0080000000000000, ~0x0204081020000000 }}, {{ ~0x0000000000000000, ~0x0408102040000000 }},
+	{{ ~0x0200000000000000, ~0x0000000000000000 }}, {{ ~0x0400000000000000, ~0x0000000000010000 }},
+	{{ ~0x0800000000000000, ~0x0000000001020000 }}, {{ ~0x1000000000000000, ~0x0000000102040000 }},
+	{{ ~0x2000000000000000, ~0x0000010204080000 }}, {{ ~0x4000000000000000, ~0x0001020408100000 }},
+	{{ ~0x8000000000000000, ~0x0102040810200000 }}, {{ ~0x0000000000000000, ~0x0204081020400000 }},
+	{{ ~0x0000000000000000, ~0x0000000000000000 }}, {{ ~0x0000000000000000, ~0x0000000000000100 }},
+	{{ ~0x0000000000000000, ~0x0000000000010200 }}, {{ ~0x0000000000000000, ~0x0000000001020400 }},
+	{{ ~0x0000000000000000, ~0x0000000102040800 }}, {{ ~0x0000000000000000, ~0x0000010204081000 }},
+	{{ ~0x0000000000000000, ~0x0001020408102000 }}, {{ ~0x0000000000000000, ~0x0102040810204000 }}
+} };
+
+#define	SWAP64	0x4e	// for _mm_shuffle_epi32
+#define	SWAP32	0xb1
+
+/**
+ * Make inverted flip mask if opponent's disc are surrounded by player's.
+ *
+ * -1 if outflank is 0
+ *  0 if a 1 is in 64 bit
+ */
+static inline __m128i flipmask (__m128i outflank) {
+	return _mm_cmpeq_epi32(_mm_shuffle_epi32(outflank, SWAP32), outflank);
+}
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+
+unsigned long long Flip(int pos, unsigned long long P, unsigned long long O)
+{
+	__m128i	outflank7, outflank8, outflank9, PP, OO;
+	int	x, y8, index_h;
+	unsigned long long	flipped;
+	static const V2DI minusone = {{ -1LL, -1LL }};
+
+	if (pos >= 64)	// pass
+		return 0;
+
+#ifdef __x86_64__
+	PP = _mm_set_epi64x(vertical_mirror(P), P);
+	OO = _mm_set_epi64x(vertical_mirror(O), O);
+#else
+	PP = _mm_set_epi32(bswap_int(P), bswap_int(P >> 32), (P >> 32), P);
+	OO = _mm_set_epi32(bswap_int(O), bswap_int(O >> 32), (O >> 32), O);
+#endif
+
+#if (defined (USE_GAS_X64) || defined(USE_GAS_X86)) && !defined(__AVX__)
+	__asm__ (
+						"movdqa	%4, %1\n\t"		"movdqa	%4, %2\n\t"
+		"movdqa	(%5), %0\n\t"		"movdqa	1024(%5), %%xmm3\n\t"	"movdqa	2048(%5), %%xmm5\n\t"
+		"por	%0, %4\n\t"		"por	%%xmm3, %1\n\t"		"por	%%xmm5, %2\n\t"
+		"psubq	%6, %4\n\t"		"psubq	%6, %1\n\t"		"psubq	%6, %2\n\t"
+		"pand	%3, %4\n\t"		"pand	%3, %1\n\t"		"pand	%3, %2\n\t"
+		"movdqa	%0, %3\n\t"
+		"pandn	%4, %3\n\t"		"pandn	%1, %%xmm3\n\t"		"pandn	%2, %%xmm5\n\t"
+		"pshufd	$177, %3, %4\n\t"	"pshufd	$177, %%xmm3, %1\n\t"	"pshufd	$177, %%xmm5, %2\n\t"
+		"pcmpeqd %3, %4\n\t"		"pcmpeqd %%xmm3, %1\n\t"	"pcmpeqd %%xmm5, %2\n\t"
+		"paddq	%6, %3\n\t"		"paddq	%6, %%xmm3\n\t"		"paddq	%6, %%xmm5\n\t"
+		"psubq	%4, %3\n\t"		"psubq	%1, %%xmm3\n\t"		"psubq	%2, %%xmm5\n\t"
+						"movdqa	1024(%5), %1\n\t"	"movdqa	2048(%5), %2\n\t"
+		"pandn	%3, %0\n\t"		"pandn	%%xmm3, %1\n\t"		"pandn	%%xmm5, %2\n\t"
+						"por	%1, %0\n\t"		"por	%2, %0"
+	: "=&x" (outflank7), "=&x" (outflank8), "=&x" (outflank9)
+	: "x" (PP), "x" (OO), "r" (&mask[0][pos]), "xm" (minusone)
+	: "xmm3", "xmm5");
+
+#else
+	outflank7 = _mm_andnot_si128(mask[0][pos].v2, _mm_and_si128(_mm_sub_epi64(_mm_or_si128(OO, mask[0][pos].v2), minusone.v2), PP));
+	outflank8 = _mm_andnot_si128(mask[1][pos].v2, _mm_and_si128(_mm_sub_epi64(_mm_or_si128(OO, mask[1][pos].v2), minusone.v2), PP));
+	outflank9 = _mm_andnot_si128(mask[2][pos].v2, _mm_and_si128(_mm_sub_epi64(_mm_or_si128(OO, mask[2][pos].v2), minusone.v2), PP));
+	outflank7 = _mm_andnot_si128(mask[0][pos].v2, _mm_sub_epi64(outflank7, _mm_sub_epi64(flipmask(outflank7), minusone.v2)));
+	outflank8 = _mm_andnot_si128(mask[1][pos].v2, _mm_sub_epi64(outflank8, _mm_sub_epi64(flipmask(outflank8), minusone.v2)));
+	outflank9 = _mm_andnot_si128(mask[2][pos].v2, _mm_sub_epi64(outflank9, _mm_sub_epi64(flipmask(outflank9), minusone.v2)));
+	outflank7 = _mm_or_si128(_mm_or_si128(outflank7, outflank8), outflank9);
+#endif
+	flipped = _mm_cvtsi128_si64(outflank7) | vertical_mirror(_mm_cvtsi128_si64(_mm_unpackhi_epi64(outflank7, outflank7)));
+
+	x = pos & 7;
+	y8 = pos & 0x38;
+	index_h = OUTFLANK[((unsigned int) (O >> y8) & 0x7E) >> 1][x] & (P >> y8);
+	flipped |= ((unsigned long long) FLIPPED[index_h][x]) << y8;
+
+	return flipped;
+}
diff --git a/src/flip_sve_lzcnt.c b/src/flip_sve_lzcnt.c
new file mode 100644
index 00000000..d4d1cf3a
--- /dev/null
+++ b/src/flip_sve_lzcnt.c
@@ -0,0 +1,148 @@
+/**
+ * @file flip_sve_lzcnt.c
+ *
+ * This module deals with flipping discs.
+ *
+ * For LSB to MSB directions, isolate LS1B can be used to determine
+ * contiguous opponent discs.
+ * For MSB to LSB directions, CLZ is used to isolate MS1B.
+ *
+ * @date 2024
+ * @author Toshihiko Okuhara
+ * @version 4.5
+ */
+
+#include "arm_sve.h"
+#include "arm_neon.h"
+
+const uint64_t lrmask[66][8] = {
+	{ 0x00000000000000fe, 0x0101010101010100, 0x8040201008040200, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x00000000000000fc, 0x0202020202020200, 0x0080402010080400, 0x0000000000000100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x00000000000000f8, 0x0404040404040400, 0x0000804020100800, 0x0000000000010200, 0x0000000000000003, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x00000000000000f0, 0x0808080808080800, 0x0000008040201000, 0x0000000001020400, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x00000000000000e0, 0x1010101010101000, 0x0000000080402000, 0x0000000102040800, 0x000000000000000f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x00000000000000c0, 0x2020202020202000, 0x0000000000804000, 0x0000010204081000, 0x000000000000001f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x0000000000000080, 0x4040404040404000, 0x0000000000008000, 0x0001020408102000, 0x000000000000003f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x0000000000000000, 0x8080808080808000, 0x0000000000000000, 0x0102040810204000, 0x000000000000007f, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },
+	{ 0x000000000000fe00, 0x0101010101010000, 0x4020100804020000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000002 },
+	{ 0x000000000000fc00, 0x0202020202020000, 0x8040201008040000, 0x0000000000010000, 0x0000000000000100, 0x0000000000000002, 0x0000000000000001, 0x0000000000000004 },
+	{ 0x000000000000f800, 0x0404040404040000, 0x0080402010080000, 0x0000000001020000, 0x0000000000000300, 0x0000000000000004, 0x0000000000000002, 0x0000000000000008 },
+	{ 0x000000000000f000, 0x0808080808080000, 0x0000804020100000, 0x0000000102040000, 0x0000000000000700, 0x0000000000000008, 0x0000000000000004, 0x0000000000000010 },
+	{ 0x000000000000e000, 0x1010101010100000, 0x0000008040200000, 0x0000010204080000, 0x0000000000000f00, 0x0000000000000010, 0x0000000000000008, 0x0000000000000020 },
+	{ 0x000000000000c000, 0x2020202020200000, 0x0000000080400000, 0x0001020408100000, 0x0000000000001f00, 0x0000000000000020, 0x0000000000000010, 0x0000000000000040 },
+	{ 0x0000000000008000, 0x4040404040400000, 0x0000000000800000, 0x0102040810200000, 0x0000000000003f00, 0x0000000000000040, 0x0000000000000020, 0x0000000000000080 },
+	{ 0x0000000000000000, 0x8080808080800000, 0x0000000000000000, 0x0204081020400000, 0x0000000000007f00, 0x0000000000000080, 0x0000000000000040, 0x0000000000000000 },
+	{ 0x0000000000fe0000, 0x0101010101000000, 0x2010080402000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000101, 0x0000000000000000, 0x0000000000000204 },
+	{ 0x0000000000fc0000, 0x0202020202000000, 0x4020100804000000, 0x0000000001000000, 0x0000000000010000, 0x0000000000000202, 0x0000000000000100, 0x0000000000000408 },
+	{ 0x0000000000f80000, 0x0404040404000000, 0x8040201008000000, 0x0000000102000000, 0x0000000000030000, 0x0000000000000404, 0x0000000000000201, 0x0000000000000810 },
+	{ 0x0000000000f00000, 0x0808080808000000, 0x0080402010000000, 0x0000010204000000, 0x0000000000070000, 0x0000000000000808, 0x0000000000000402, 0x0000000000001020 },
+	{ 0x0000000000e00000, 0x1010101010000000, 0x0000804020000000, 0x0001020408000000, 0x00000000000f0000, 0x0000000000001010, 0x0000000000000804, 0x0000000000002040 },
+	{ 0x0000000000c00000, 0x2020202020000000, 0x0000008040000000, 0x0102040810000000, 0x00000000001f0000, 0x0000000000002020, 0x0000000000001008, 0x0000000000004080 },
+	{ 0x0000000000800000, 0x4040404040000000, 0x0000000080000000, 0x0204081020000000, 0x00000000003f0000, 0x0000000000004040, 0x0000000000002010, 0x0000000000008000 },
+	{ 0x0000000000000000, 0x8080808080000000, 0x0000000000000000, 0x0408102040000000, 0x00000000007f0000, 0x0000000000008080, 0x0000000000004020, 0x0000000000000000 },
+	{ 0x00000000fe000000, 0x0101010100000000, 0x1008040200000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000010101, 0x0000000000000000, 0x0000000000020408 },
+	{ 0x00000000fc000000, 0x0202020200000000, 0x2010080400000000, 0x0000000100000000, 0x0000000001000000, 0x0000000000020202, 0x0000000000010000, 0x0000000000040810 },
+	{ 0x00000000f8000000, 0x0404040400000000, 0x4020100800000000, 0x0000010200000000, 0x0000000003000000, 0x0000000000040404, 0x0000000000020100, 0x0000000000081020 },
+	{ 0x00000000f0000000, 0x0808080800000000, 0x8040201000000000, 0x0001020400000000, 0x0000000007000000, 0x0000000000080808, 0x0000000000040201, 0x0000000000102040 },
+	{ 0x00000000e0000000, 0x1010101000000000, 0x0080402000000000, 0x0102040800000000, 0x000000000f000000, 0x0000000000101010, 0x0000000000080402, 0x0000000000204080 },
+	{ 0x00000000c0000000, 0x2020202000000000, 0x0000804000000000, 0x0204081000000000, 0x000000001f000000, 0x0000000000202020, 0x0000000000100804, 0x0000000000408000 },
+	{ 0x0000000080000000, 0x4040404000000000, 0x0000008000000000, 0x0408102000000000, 0x000000003f000000, 0x0000000000404040, 0x0000000000201008, 0x0000000000800000 },
+	{ 0x0000000000000000, 0x8080808000000000, 0x0000000000000000, 0x0810204000000000, 0x000000007f000000, 0x0000000000808080, 0x0000000000402010, 0x0000000000000000 },
+	{ 0x000000fe00000000, 0x0101010000000000, 0x0804020000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000001010101, 0x0000000000000000, 0x0000000002040810 },
+	{ 0x000000fc00000000, 0x0202020000000000, 0x1008040000000000, 0x0000010000000000, 0x0000000100000000, 0x0000000002020202, 0x0000000001000000, 0x0000000004081020 },
+	{ 0x000000f800000000, 0x0404040000000000, 0x2010080000000000, 0x0001020000000000, 0x0000000300000000, 0x0000000004040404, 0x0000000002010000, 0x0000000008102040 },
+	{ 0x000000f000000000, 0x0808080000000000, 0x4020100000000000, 0x0102040000000000, 0x0000000700000000, 0x0000000008080808, 0x0000000004020100, 0x0000000010204080 },
+	{ 0x000000e000000000, 0x1010100000000000, 0x8040200000000000, 0x0204080000000000, 0x0000000f00000000, 0x0000000010101010, 0x0000000008040201, 0x0000000020408000 },
+	{ 0x000000c000000000, 0x2020200000000000, 0x0080400000000000, 0x0408100000000000, 0x0000001f00000000, 0x0000000020202020, 0x0000000010080402, 0x0000000040800000 },
+	{ 0x0000008000000000, 0x4040400000000000, 0x0000800000000000, 0x0810200000000000, 0x0000003f00000000, 0x0000000040404040, 0x0000000020100804, 0x0000000080000000 },
+	{ 0x0000000000000000, 0x8080800000000000, 0x0000000000000000, 0x1020400000000000, 0x0000007f00000000, 0x0000000080808080, 0x0000000040201008, 0x0000000000000000 },
+	{ 0x0000fe0000000000, 0x0101000000000000, 0x0402000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000101010101, 0x0000000000000000, 0x0000000204081020 },
+	{ 0x0000fc0000000000, 0x0202000000000000, 0x0804000000000000, 0x0001000000000000, 0x0000010000000000, 0x0000000202020202, 0x0000000100000000, 0x0000000408102040 },
+	{ 0x0000f80000000000, 0x0404000000000000, 0x1008000000000000, 0x0102000000000000, 0x0000030000000000, 0x0000000404040404, 0x0000000201000000, 0x0000000810204080 },
+	{ 0x0000f00000000000, 0x0808000000000000, 0x2010000000000000, 0x0204000000000000, 0x0000070000000000, 0x0000000808080808, 0x0000000402010000, 0x0000001020408000 },
+	{ 0x0000e00000000000, 0x1010000000000000, 0x4020000000000000, 0x0408000000000000, 0x00000f0000000000, 0x0000001010101010, 0x0000000804020100, 0x0000002040800000 },
+	{ 0x0000c00000000000, 0x2020000000000000, 0x8040000000000000, 0x0810000000000000, 0x00001f0000000000, 0x0000002020202020, 0x0000001008040201, 0x0000004080000000 },
+	{ 0x0000800000000000, 0x4040000000000000, 0x0080000000000000, 0x1020000000000000, 0x00003f0000000000, 0x0000004040404040, 0x0000002010080402, 0x0000008000000000 },
+	{ 0x0000000000000000, 0x8080000000000000, 0x0000000000000000, 0x2040000000000000, 0x00007f0000000000, 0x0000008080808080, 0x0000004020100804, 0x0000000000000000 },
+	{ 0x00fe000000000000, 0x0100000000000000, 0x0200000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000010101010101, 0x0000000000000000, 0x0000020408102040 },
+	{ 0x00fc000000000000, 0x0200000000000000, 0x0400000000000000, 0x0100000000000000, 0x0001000000000000, 0x0000020202020202, 0x0000010000000000, 0x0000040810204080 },
+	{ 0x00f8000000000000, 0x0400000000000000, 0x0800000000000000, 0x0200000000000000, 0x0003000000000000, 0x0000040404040404, 0x0000020100000000, 0x0000081020408000 },
+	{ 0x00f0000000000000, 0x0800000000000000, 0x1000000000000000, 0x0400000000000000, 0x0007000000000000, 0x0000080808080808, 0x0000040201000000, 0x0000102040800000 },
+	{ 0x00e0000000000000, 0x1000000000000000, 0x2000000000000000, 0x0800000000000000, 0x000f000000000000, 0x0000101010101010, 0x0000080402010000, 0x0000204080000000 },
+	{ 0x00c0000000000000, 0x2000000000000000, 0x4000000000000000, 0x1000000000000000, 0x001f000000000000, 0x0000202020202020, 0x0000100804020100, 0x0000408000000000 },
+	{ 0x0080000000000000, 0x4000000000000000, 0x8000000000000000, 0x2000000000000000, 0x003f000000000000, 0x0000404040404040, 0x0000201008040201, 0x0000800000000000 },
+	{ 0x0000000000000000, 0x8000000000000000, 0x0000000000000000, 0x4000000000000000, 0x007f000000000000, 0x0000808080808080, 0x0000402010080402, 0x0000000000000000 },
+	{ 0xfe00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0001010101010101, 0x0000000000000000, 0x0002040810204080 },
+	{ 0xfc00000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0100000000000000, 0x0002020202020202, 0x0001000000000000, 0x0004081020408000 },
+	{ 0xf800000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0300000000000000, 0x0004040404040404, 0x0002010000000000, 0x0008102040800000 },
+	{ 0xf000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0700000000000000, 0x0008080808080808, 0x0004020100000000, 0x0010204080000000 },
+	{ 0xe000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0f00000000000000, 0x0010101010101010, 0x0008040201000000, 0x0020408000000000 },
+	{ 0xc000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x1f00000000000000, 0x0020202020202020, 0x0010080402010000, 0x0040800000000000 },
+	{ 0x8000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x3f00000000000000, 0x0040404040404040, 0x0020100804020100, 0x0080000000000000 },
+	{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x7f00000000000000, 0x0080808080808080, 0x0040201008040201, 0x0000000000000000 },
+	{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 },	// pass
+	{ 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }
+};
+
+/**
+ * Compute flipped discs when playing on square pos.
+ *
+ * @param pos player's move.
+ * @param P player's disc pattern.
+ * @param O opponent's disc pattern.
+ * @return flipped disc pattern.
+ */
+
+#ifndef __ARM_FEATURE_SVE2
+	// equivalent only if no intersection between masks
+#define svbsl_u64(op1,op2,op3)	svorr_u64_m(pg, (op2), svand_u64_x(pg, (op3), (op1)))
+#endif
+
+uint64_t Flip(int pos, uint64_t P, uint64_t O)
+{
+	svuint64_t	PP, OO, flip, oflank, mask, msb;
+	svbool_t	pg;
+	const uint64_t	(*pmask)[8];
+
+	PP = svdup_u64(P);
+	OO = svdup_u64(O);
+	msb = svdup_u64(0x8000000000000000);
+	pmask = &lrmask[pos];
+	pg = svwhilelt_b64(0, 4);
+
+	mask = svld1_u64(pg, *pmask + 4);
+		// right: isolate non-opponent MS1B
+	oflank = svbic_u64_x(pg, mask, OO);
+		// outflank = (0x8000000000000000ULL >> lzcnt) & P
+	oflank = svand_u64_x(pg, svlsr_u64_x(pg, msb, svclz_u64_x(pg, oflank)), PP);
+		// set all bits higher than outflank
+	oflank = svreinterpret_u64_s64(svneg_s64_x(pg, svreinterpret_s64_u64(oflank)));
+	flip = svand_u64_x(pg, mask, oflank);
+
+	mask = svld1_u64(pg, *pmask + 0);
+		// left: look for non-opponent LS1B
+	oflank = svbic_u64_x(pg, mask, OO);
+	oflank = svand_u64_x(pg, svbic_u64_x(pg, oflank, svsub_n_u64_x(pg, oflank, 1)), PP);
+		// set all bits lower than oflank, using satulation if oflank = 0
+	flip = svbsl_u64(svqsub_n_u64(oflank, 1), flip, mask);
+
+	if (svcntd() == 2) {	// sve128 only
+		mask = svld1_u64(pg, *pmask + 6);
+			// right: isolate non-opponent MS1B
+		oflank = svbic_u64_x(pg, mask, OO);
+			// outflank = (0x8000000000000000ULL >> lzcnt) & P
+		oflank = svand_u64_x(pg, svlsr_u64_x(pg, msb, svclz_u64_x(pg, oflank)), PP);
+			// set all bits higher than outflank
+		oflank = svreinterpret_u64_s64(svneg_s64_x(pg, svreinterpret_s64_u64(oflank)));
+  		flip = svbsl_u64(oflank, flip, mask);
+
+		mask = svld1_u64(pg, *pmask + 2);
+			// left: look for non-opponent LS1B
+		oflank = svbic_u64_x(pg, mask, OO);
+		oflank = svand_u64_x(pg, svbic_u64_x(pg, oflank, svsub_n_u64_x(pg, oflank, 1)), PP);
+			// set all bits lower than oflank, using satulation if oflank = 0
+		flip = svbsl_u64(svqsub_n_u64(oflank, 1), flip, mask);
+	}
+
+	return svorv_u64(pg, svand_u64_x(pg, flip, OO));
+}
diff --git a/src/game.c b/src/game.c
index 8a27cc5b..9b6261dd 100644
--- a/src/game.c
+++ b/src/game.c
@@ -3,9 +3,9 @@
  *
  * Game management
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "bit.h"
@@ -83,7 +83,7 @@ static int move_from_oko(int x)
 void game_init(Game *game)
 {
 	char name[2] = "?";
-	board_init(game->initial_board);
+	board_init(&game->initial_board);
 	memset(game->move, NOMOVE, 60);
 	game->player = BLACK;
 	memcpy(game->name[0], name, 2);
@@ -152,14 +152,14 @@ bool wthor_equals(const WthorGame *game_1, const WthorGame *game_2)
  */
 bool game_update_board(Board *board, int x)
 {
-	Move move[1];
+	Move move;
 
 	if (x < A1 || x > H8 || board_is_occupied(board, x)) return false;
 	if (!can_move(board->player, board->opponent)) {
 		board_pass(board);
 	}
-	if (board_get_move(board, x, move) == 0) return false;
-	board_update(board, move);
+	if (board_get_move_flip(board, x, &move) == 0) return false;
+	board_update(board, &move);
 
 	return true;
 }
@@ -170,7 +170,7 @@ bool game_update_board(Board *board, int x)
  */
 static bool game_update_player(Board *board, int x)
 {
-	Move move[1];
+	Move move;
 	bool swap = false;
 	
 	if (A1 <= x && x <= H8 && !board_is_occupied(board, x)) {
@@ -178,7 +178,7 @@ static bool game_update_player(Board *board, int x)
 			board_pass(board);
 			swap = !swap;
 		}
-		if (board_get_move(board, x, move) == 0) swap = !swap;
+		if (board_get_move_flip(board, x, &move) == 0) swap = !swap;
 	}
 	
 	return swap;
@@ -196,7 +196,7 @@ bool game_get_board(const Game *game, const int ply, Board *board)
 {
 	int i;
 
-	*board = *game->initial_board;
+	*board = game->initial_board;
 	for (i = 0; i < ply; i++) {
 		if (!game_update_board(board, game->move[i])) return false;
 	}
@@ -212,12 +212,12 @@ bool game_get_board(const Game *game, const int ply, Board *board)
  */
 bool game_check(Game *game)
 {
-	Board board[1];
+	Board board;
 	int i;
 
-	*board = *game->initial_board;
+	board = game->initial_board;
 	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		if (!game_update_board(board, game->move[i])) {
+		if (!game_update_board(&board, game->move[i])) {
 			return false;
 		}
 	}
@@ -234,21 +234,21 @@ int game_score(const Game *game)
 {
 	int n_discs_p, n_discs_o, n_empties;
 	int i, player, score;
-	Board board[1];
+	Board board;
 
-	*board = *game->initial_board;
+	board = game->initial_board;
 	player = game->player;
 	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		player ^= game_update_player(board, game->move[i]);
-		if (!game_update_board(board, game->move[i])) {
+		player ^= game_update_player(&board, game->move[i]);
+		if (!game_update_board(&board, game->move[i])) {
 			return -SCORE_INF;
 		}
 	}
 
-	if (!board_is_game_over(board)) return -SCORE_INF;
+	if (!board_is_game_over(&board)) return -SCORE_INF;
 
-	n_discs_p = bit_count(board->player);
-	n_discs_o = bit_count(board->opponent);
+	n_discs_p = bit_count(board.player);
+	n_discs_o = bit_count(board.opponent);
 	n_empties = 64 - n_discs_p - n_discs_o;
 	score = n_discs_p - n_discs_o;
 
@@ -267,21 +267,21 @@ int game_score(const Game *game)
 void text_to_game(const char *line, Game *game)
 {
 	int i;
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 	char *s;
 
-	board_init(game->initial_board);
+	board_init(&game->initial_board);
 	game_init(game);
-	*board = *game->initial_board;
+	board = game->initial_board;
 	for (i = 0; i < 60 && *line;) {
-		s = parse_move(line, board, move);
-		if (s == line && move->x == NOMOVE) return;
-		if (move->x != PASS) {
-			game->hash ^= hash_move[move->x][i];
-			game->move[i++] = move->x;
+		s = parse_move(line, &board, &move);
+		if (s == line && move.x == NOMOVE) return;
+		if (move.x != PASS) {
+			game->hash = crc32c_u8(game->hash, move.x);
+			game->move[i++] = move.x;
 		}
-		board_update(board, move);
+		board_update(&board, &move);
 		line = s;
 	}
 }
@@ -313,17 +313,17 @@ void game_to_text(const Game *game, char *line)
 void oko_to_game(const OkoGame *oko, Game *game)
 {
 	int i;
-	Board board[1];
+	Board board;
 
 	game_init(game);
-	*board = *game->initial_board;
+	board = game->initial_board;
 	for (i = 0; i < 60; i++) {
 		game->move[i] = move_from_oko(oko->move[i]);
-		if (!game_update_board(board, game->move[i])) {
+		if (!game_update_board(&board, game->move[i])) {
 			game->move[i] = NOMOVE;
 			break;
 		}
-		game->hash ^= hash_move[(int)game->move[i]][i];
+		game->hash = crc32c_u8(game->hash, game->move[i]);
 	}
 }
 
@@ -340,17 +340,17 @@ void oko_to_game(const OkoGame *oko, Game *game)
 void wthor_to_game(const WthorGame *thor, Game *game)
 {
 	int i;
-	Board board[1];
+	Board board;
 
 	game_init(game);
-	*board = *game->initial_board;
+	board = game->initial_board;
 	for (i = 0; i < 60; i++) {
 		game->move[i] = move_from_wthor(thor->x[i]);
-		if (!game_update_board(board, game->move[i])) {
+		if (!game_update_board(&board, game->move[i])) {
 			game->move[i] = NOMOVE;
 			break;
 		}
-		game->hash ^= hash_move[(int)game->move[i]][i];
+		game->hash = crc32c_u8(game->hash, game->move[i]);
 	}
 }
 
@@ -388,13 +388,13 @@ void game_to_wthor(const Game *game, WthorGame *thor)
 void game_append_line(Game *game, const Line *line, const int from)
 {
 	int i, j;
-	Board board[1];
+	Board board;
 
-	if (game_get_board(game, from, board)) {
+	if (game_get_board(game, from, &board)) {
 		for (i = 0, j = from; i < line->n_moves && j < 60; ++i) {
 			if (line->move[i] != PASS) {
-				if (game_update_board(board, line->move[i])) {
-					game->hash ^= hash_move[(int)line->move[i]][j];
+				if (game_update_board(&board, line->move[i])) {
+					game->hash = crc32c_u8(game->hash, line->move[i]);
 					game->move[j++] = line->move[i];
 				} else {
 					break;
@@ -415,7 +415,7 @@ void game_append_line(Game *game, const Line *line, const int from)
 void line_to_game(const Board *initial_board, const Line *line, Game *game)
 {
 	game_init(game);
-	*game->initial_board = *initial_board;
+	game->initial_board = *initial_board;
 	game->player = line->color;
 	game_append_line(game, line, 0);
 }
@@ -467,11 +467,11 @@ void game_import_text(Game *game, FILE *f)
 void game_export_text(const Game *game, FILE *f)
 {
 	char s_game[128], s_board[80];
-	Board board[1];
+	Board board;
 
-	board_init(board);
-	if (!board_equal(board, game->initial_board)) {
-		board_to_string(game->initial_board, game->player, s_board);
+	board_init(&board);
+	if (!board_equal(&board, &game->initial_board)) {
+		board_to_string(&game->initial_board, game->player, s_board);
 		fprintf(f, "%s;", s_board);
 	}
 	game_to_text(game, s_game);
@@ -597,7 +597,7 @@ void game_import_ggf(Game* game, FILE* f)
 			if (strcmp(tag,"GM") == 0 && strcmp(value, "othello") != 0) break;
 			if (strcmp(tag, "BO") == 0) {
 				if (value[0] != '8') break;
-				game->player = board_set(game->initial_board, value + 2);
+				game->player = board_set(&game->initial_board, value + 2);
 			} else if (strcmp(tag, "PB") == 0) {
 				memcpy(game->name[BLACK], value, 31);
 				game->name[BLACK][31] = '\0';
@@ -612,7 +612,7 @@ void game_import_ggf(Game* game, FILE* f)
 			} else if (i < 60 && (strcmp(tag, "B") == 0 || strcmp(tag, "W") == 0)) {
 				if (strncmp("pa", value, 2) == 0) continue;
 				game->move[i] = string_to_coordinate(value);
-				game->hash ^= hash_move[(int)game->move[i]][i];
+				game->hash = crc32c_u8(game->hash, game->move[i]);
 				i++;
 			}
 		}
@@ -659,14 +659,15 @@ static const char* parse_tag(const char *string, char *tag, char *value)
  *
  * @param game The output game.
  * @param string An input string.
- * @return The unprocessed remaining part of the string.
+ * @return The Last move played, -1 on error.
  */
-char* parse_ggf(Game *game, const char *string)
+int parse_ggf(Game *game, const char *string)
 {
 	const char *s = string;
 	const char *next;
 	char tag[4], value[256];
 	int i = 0;
+	int lastmove = NOMOVE;
 
 	game_init(game);
 
@@ -678,14 +679,12 @@ char* parse_ggf(Game *game, const char *string)
 			s = next;
 
 			if (strcmp(tag, "GM") == 0 && strcmp(value, "othello") != 0) {
-				s = string;
-				break;
+				return -1;
 			} else if (strcmp(tag, "BO") == 0) {
 				if (value[0] != '8') {
-					s = string;
-					break;
+					return -1;
 				}
-				game->player = board_set(game->initial_board, value + 2);
+				game->player = board_set(&game->initial_board, value + 2);
 			} else if (strcmp(tag, "PB") == 0) {
 				memcpy(game->name[BLACK], value, 31);
 				game->name[BLACK][31] = '\0';
@@ -693,15 +692,16 @@ char* parse_ggf(Game *game, const char *string)
 				memcpy(game->name[WHITE], value, 31);
 				game->name[WHITE][31] = '\0';
 			} else if (i < 60 && (strcmp(tag, "B") == 0 || strcmp(tag, "W") == 0)) {
-				if (strncmp("pa", value, 2) == 0) continue;
-				game->move[i++] = string_to_coordinate(value);
+				lastmove = string_to_coordinate(value);
+				if (lastmove != PASS)
+					game->move[i++] = lastmove;
 			}
 		}
 	}
 
-	if (!game_check(game)) s = string;
+	if (!game_check(game)) return -1;
 
-	return (char*) s;
+	return lastmove;
 }
 
 /**
@@ -712,8 +712,9 @@ char* parse_ggf(Game *game, const char *string)
  */
 void game_export_ggf(const Game *game, FILE *f)
 {
-	Board board[1];
+	Board board;
 	int player;
+	unsigned long long bk, wh;
 	static const char board_color[] = "*O-?";
 	int i, x, square;
 //	time_t t:
@@ -728,21 +729,31 @@ void game_export_ggf(const Game *game, FILE *f)
 	fprintf(f, "PB[%s]PW[%s]", game->name[BLACK], game->name[WHITE]);
 	fprintf(f, "RE[%+d.000]", game_score(game));
 	fputs("BO[8 ", f);
+
+	if (game->player == BLACK) {
+		bk = game->initial_board.player;
+		wh = game->initial_board.opponent;
+	} else {
+		bk = game->initial_board.opponent;
+		wh = game->initial_board.player;
+	}
 	for (x = 0; x < 64; ++x) {
-		if (game->player == BLACK) square = 2 - ((game->initial_board->opponent >> x) & 1) - 2 * ((game->initial_board->player >> x) & 1);
-		else square = 2 - ((game->initial_board->player >> x) & 1) - 2 * ((game->initial_board->opponent >> x) & 1);
-		putc(board_color[square], f); if ((x & 7) == 7) putc(' ', f);
+		square = 2 - (wh & 1) - 2 * (bk & 1);
+		putc(board_color[square], f);
+		if ((x & 7) == 7) putc(' ', f);
+		bk >>= 1;
+		wh >>= 1;
 	}
 	putc(board_color[(int) game->player], f); fputc(']', f);
 
-	*board = *game->initial_board;
+	board = game->initial_board;
 	player = game->player;
 	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			fprintf(f, "%c[PA]", move_color[player]);
 			player = !player;
 		}
-		if (game_update_board(board, game->move[i])) {
+		if (game_update_board(&board, game->move[i])) {
 			fprintf(f, "%c[%s]", move_color[player], move_to_string(game->move[i], 0, move_string));
 			player = !player;
 		}
@@ -847,7 +858,7 @@ void game_import_sgf(Game *game, FILE *f)
 				game->name[WHITE][31] = '\0';
 			} else if (i < 60 && (strcmp(tag,"B") == 0 || strcmp(tag, "W") == 0)) {
 				game->move[i] = string_to_coordinate(value);
-				game->hash ^= hash_move[(int)game->move[i]][i];
+				game->hash = crc32c_u8(game->hash, game->move[i]);
 				i++;
 
 			}
@@ -869,7 +880,7 @@ void game_import_sgf(Game *game, FILE *f)
  */
 void game_save_sgf(const Game *game, FILE *f, const bool multiline)
 {
-	Board board[1];
+	Board board;
 	int player;
 	static const char color[2] = {'B', 'W'};
 	char s[8];
@@ -890,23 +901,23 @@ void game_save_sgf(const Game *game, FILE *f, const bool multiline)
 
 	// initial board
 	if (game->player == BLACK) {
-		black = game->initial_board->player;
-		white = game->initial_board->opponent;
+		black = game->initial_board.player;
+		white = game->initial_board.opponent;
 	} else {
-		white = game->initial_board->player;
-		black = game->initial_board->opponent;
+		white = game->initial_board.player;
+		black = game->initial_board.opponent;
 	}
 	fputs("SZ[8]",f);
 	if (black) {
 		fputs("AB", f);
 		for (i = A1; i <= H8; i++){
-			if (black & x_to_bit(i)) fprintf(f, "[%s]", move_to_string(i, WHITE, s));
+			if (black & (1ULL << i)) fprintf(f, "[%s]", move_to_string(i, WHITE, s));
 		}
 	}
 	if (white) {
 		fputs("AW", f);
 		for (i = A1; i <= H8; i++){
-			if (white & x_to_bit(i)) fprintf(f, "[%s]", move_to_string(i, WHITE, s));
+			if (white & (1ULL << i)) fprintf(f, "[%s]", move_to_string(i, WHITE, s));
 		}
 	}
 	fprintf(f, "PL[%c]", color[(int) game->player]);
@@ -923,15 +934,15 @@ void game_save_sgf(const Game *game, FILE *f, const bool multiline)
 	if (multiline) fputc('\n', f);
 
 	/* moves */
-	*board = *game->initial_board;
+	board = game->initial_board;
 	player = game->player;
 	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			fprintf(f, "%c[PA];", color[player]);
 			player = !player;
 			if (multiline && player == game->player) fputc('\n', f);
 		}
-		if (game_update_board(board, game->move[i])) {
+		if (game_update_board(&board, game->move[i])) {
 			fprintf(f, "%c[%s];", color[player], move_to_string(game->move[i], WHITE, s));
 			player = !player;
 			if (multiline && player == game->player) fputc('\n', f);
@@ -987,7 +998,7 @@ void game_import_pgn(Game *game, FILE *f)
 		}  else  if  (c == '{') { // skip comments
 			do {
 				c = getc(f);
-			} while(c != EOF && c != '}');			
+			} while(c != EOF && c != '}');
 		}  else  if  (c == '[') {
 			switch(state) {
 			case STATE_START:
@@ -1038,7 +1049,7 @@ void game_import_pgn(Game *game, FILE *f)
 						sscanf(info_value, "%d:%d:%d", value, value + 1, value + 2);
 						game->date.hour = value[0]; game->date.minute = value[1]; game->date.second = value[2];
 					} else if (strcmp(info_tag, "FEN") == 0) {
-						game->player = board_from_FEN(game->initial_board, info_value);
+						game->player = board_from_FEN(&game->initial_board, info_value);
 					}
 					break;
 			}				
@@ -1059,7 +1070,7 @@ void game_import_pgn(Game *game, FILE *f)
 				state = STATE_END_MOVE;
 				move[k++] = c;
 				game->move[i] = string_to_coordinate(move);
-				game->hash ^= hash_move[(int)game->move[i]][i];
+				game->hash = crc32c_u8(game->hash, game->move[i]);
 				i++;
 				break;
 			case STATE_BEGIN_INFO:
@@ -1207,12 +1218,12 @@ void game_export_pgn(const Game *game, FILE *f)
 	int half_score = game_score(game) / 2;
 	const char *result = half_score < -32 ? "*" : (half_score < 0 ? "0-1" : (half_score > 0 ? "1-0" : "1/2-1/2"));
 	const char *winner = (half_score < 0 ?  game->name[WHITE]: (half_score > 0 ? game->name[BLACK] : NULL));
-	Board board[1];
+	Board board;
 	char s[80];
 	int i, j, k;
 	int player;
 
-	board_init(board);
+	board_init(&board);
 
 	fputs("[Event \"?\"]\n", f);
 	fputs("[Site \"edax\"]\n", f);
@@ -1225,18 +1236,18 @@ void game_export_pgn(const Game *game, FILE *f)
 	fprintf(f, "[Black \"%s\"]\n", game->name[BLACK]);
 	fprintf(f, "[White \"%s\"]\n", game->name[WHITE]);
 	fprintf(f, "[Result \"%s\"]\n", result);
-	if (!board_equal(game->initial_board, board)) {
-		fprintf(f, "[FEN \"%s\"]\n", board_to_FEN(game->initial_board, game->player, s));
-		*board = *game->initial_board;
+	if (!board_equal(&game->initial_board, &board)) {
+		fprintf(f, "[FEN \"%s\"]\n", board_to_FEN(&game->initial_board, game->player, s));
+		board = game->initial_board;
 	}
 	fputc('\n', f);
 
 	player = game->player;
 	for (i = j = k = 0; i < 60 && game->move[i] != NOMOVE; ++i, ++k) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			s[0] = 'p'; s[1] = 'a'; s[2] = 's'; s[3] = 's'; s[4] = '\0'; --i;
-			board_pass(board);
-		} else if (game_update_board(board, game->move[i])) {
+			board_pass(&board);
+		} else if (game_update_board(&board, game->move[i])) {
 			move_to_string(game->move[i], WHITE, s);
 		}
 		if ((j >= 78) || (player == game->player && j >= 74)) {
@@ -1265,175 +1276,175 @@ void game_export_eps(const Game *game, FILE *f)
 {
 	time_t t = time(NULL);
 	struct tm *date = localtime(&t);
-	Board board[1];
+	Board board;
 	int i, color, player;
 	char s_player[2][8] = {"black", "white"};
 	char s[8];
 
-	fputs("%!PS-Adobe-3.0 EPSF-3.0\n",f);
-	fputs("%%Creator: Edax-3.0\n",f);
+	fputs(	"%!PS-Adobe-3.0 EPSF-3.0\n"
+		"%%Creator: Edax-3.0\n", f);
 	fprintf(f, "%%%%CreationDate:  %d/%d/%d %d:%d:%d\n", date->tm_year + 1900, date->tm_mon + 1, date->tm_mday, date->tm_hour, date->tm_min, date->tm_sec);
-	fputs("%%BoundingBox: 0 0 200 200\n\n",f);
-	fputs("%%BeginProlog\n\n",f);
-	fputs("% othello coordinates\n",f);
-	fputs("/A1 {40 160} def /A2 {40 140} def /A3 {40 120} def /A4 {40 100} def /A5 {40 80} def /A6 {40 60} def /A7 {40 40} def /A8 {40 20} def\n",f);
-	fputs("/B1 {60 160} def /B2 {60 140} def /B3 {60 120} def /B4 {60 100} def /B5 {60 80} def /B6 {60 60} def /B7 {60 40} def /B8 {60 20} def\n",f);
-	fputs("/C1 {80 160} def /C2 {80 140} def /C3 {80 120} def /C4 {80 100} def /C5 {80 80} def /C6 {80 60} def /C7 {80 40} def /C8 {80 20} def\n",f);
-	fputs("/D1 {100 160} def /D2 {100 140} def /D3 {100 120} def /D4 {100 100} def /D5 {100 80} def /D6 {100 60} def /D7 {100 40} def /D8 {100 20} def\n",f);
-	fputs("/E1 {120 160} def /E2 {120 140} def /E3 {120 120} def /E4 {120 100} def /E5 {120 80} def /E6 {120 60} def /E7 {120 40} def /E8 {120 20} def\n",f);
-	fputs("/F1 {140 160} def /F2 {140 140} def /F3 {140 120} def /F4 {140 100} def /F5 {140 80} def /F6 {140 60} def /F7 {140 40} def /F8 {140 20} def\n",f);
-	fputs("/G1 {160 160} def /G2 {160 140} def /G3 {160 120} def /G4 {160 100} def /G5 {160 80} def /G6 {160 60} def /G7 {160 40} def /G8 {160 20} def\n",f);
-	fputs("/H1 {180 160} def /H2 {180 140} def /H3 {180 120} def /H4 {180 100} def /H5 {180 80} def /H6 {180 60} def /H7 {180 40} def /H8 {180 20} def\n\n",f);
-	fputs("% draw a black disc\n",f);
-	fputs("/disc_black{\n",f);
-	fputs("\tnewpath\n",f);
-	fputs("\t8.5 0 360 arc\n",f);
-	fputs("\tfill\n",f);
-	fputs("} def\n\n",f);
-	fputs("% draw a white disc\n",f);
-	fputs("/disc_white{\n",f);
-	fputs("\tnewpath\n",f);
-	fputs("\t0.5 setlinewidth\n",f);
-	fputs("\t8.5 0 360 arc\n",f);
-	fputs("\tstroke\n",f);
-	fputs("} def\n\n",f);
-	fputs("% draw a black move\n",f);
-	fputs("/move_black{\n",f);
-	fputs("\t/y exch def\n",f);
-	fputs("\t/x exch def\n",f);
-	fputs("\tnewpath\n",f);
-	fputs("\tx y 8.5 0 360 arc\n",f);
-	fputs("\tfill\n",f);
-	fputs("\t1 setgray\n",f);
-	fputs("\tx y moveto dup stringwidth pop 2 div neg -4.5 rmoveto\n",f);
-	fputs("\tshow\n",f);
-	fputs("\t0 setgray\n",f);
-	fputs("} def\n\n",f);
-	fputs("% draw a white move\n",f);
-	fputs("/move_white{\n",f);
-	fputs("\t/y exch def\n",f);
-	fputs("\t/x exch def\n",f);
-	fputs("\tnewpath\n",f);
-	fputs("\t0.5 setlinewidth\n",f);
-	fputs("\tx y 8.5 0 360 arc\n",f);
-	fputs("\tstroke\n",f);
-	fputs("\tx y moveto dup stringwidth pop 2 div neg -4.5 rmoveto\n",f);
-	fputs("\tshow\n",f);
-	fputs("} def\n\n",f);
-	fputs("% draw the grid\n",f);
-	fputs("/board_grid{\n",f);
-	fputs("\tnewpath\n\n",f);
-	fputs("\t%border\n",f);
-	fputs("\t1.5 setlinewidth\n",f);
-	fputs("\t  27   7 moveto\n",f);
-	fputs("\t 166   0 rlineto\n",f);
-	fputs("\t   0 166 rlineto\n",f);
-	fputs("\t-166   0 rlineto\n",f);
-	fputs("\tclosepath\n",f);
-	fputs("\tstroke\n\n",f);
-	fputs("\t%vertical lines\n",f);
-	fputs("\t0.5 setlinewidth\n",f);
-	fputs("\t30 10 moveto\n",f);
-	fputs("\t0 1 8{\n",f);
-	fputs("\t\t 0  160 rlineto\n",f);
-	fputs("\t\t20 -160 rmoveto\n",f);
-	fputs("\t}for\n\n",f);
-	fputs("\t%horizontal lines\n",f);
-	fputs("\t30 10 moveto\n",f);
-	fputs("\t0 1 8{\n",f);
-	fputs("\t\t 160  0 rlineto\n",f);
-	fputs("\t\t-160 20 rmoveto\n",f);
-	fputs("\t}for\n",f);
-	fputs("\tstroke\n\n",f);
-	fputs("\t%marks\n",f);
-	fputs("\t 70  50 2 0 360 arc fill\n",f);
-	fputs("\t150  50 2 0 360 arc fill\n",f);
-	fputs("\t 70 130 2 0 360 arc fill\n",f);
-	fputs("\t150 130 2 0 360 arc fill\n",f);
-	fputs("}def\n\n",f);
-	fputs("% draw coordinates\n",f);
-	fputs("/board_coord{\n",f);
-	fputs("\t/NewCenturySchoolbook-Roman findfont 15 scalefont setfont\n",f);
-	fputs("\tnewpath\n",f);
-	fputs("\t(a)  35 180 moveto show\n",f);
-	fputs("\t(b)  55 180 moveto show\n",f);
-	fputs("\t(c)  75 180 moveto show\n",f);
-	fputs("\t(d)  95 180 moveto show\n",f);
-	fputs("\t(e) 115 180 moveto show\n",f);
-	fputs("\t(f) 135 180 moveto show\n",f);
-	fputs("\t(g) 155 180 moveto show\n",f);
-	fputs("\t(h) 175 180 moveto show\n",f);
-	fputs("\t(1)  14 155 moveto show\n",f);
-	fputs("\t(2)  14 135 moveto show\n",f);
-	fputs("\t(3)  14 115 moveto show\n",f);
-	fputs("\t(4)  14  95 moveto show\n",f);
-	fputs("\t(5)  14  75 moveto show\n",f);
-	fputs("\t(6)  14  55 moveto show\n",f);
-	fputs("\t(7)  14  35 moveto show\n",f);
-	fputs("\t(8)  14  15 moveto show\n",f);
-	fputs("}def\n",f);
-	fputs("%%EndProlog\n\n",f);
-	
-	fputs("% do the drawing\n",f);
-	fputs("gsave\n",f);
-	fputs("\n\t% draw an empty board\n",f);
-	fputs("\tboard_coord\n",f);
-	fputs("\tboard_grid\n",f);
-	fputs("\n\t% draw the discs\n",f);
-
-	*board = *game->initial_board;
+	fputs(	"%%BoundingBox: 0 0 200 200\n\n"
+		"%%BeginProlog\n\n"
+		"% othello coordinates\n"
+		"/A1 {40 160} def /A2 {40 140} def /A3 {40 120} def /A4 {40 100} def /A5 {40 80} def /A6 {40 60} def /A7 {40 40} def /A8 {40 20} def\n"
+		"/B1 {60 160} def /B2 {60 140} def /B3 {60 120} def /B4 {60 100} def /B5 {60 80} def /B6 {60 60} def /B7 {60 40} def /B8 {60 20} def\n"
+		"/C1 {80 160} def /C2 {80 140} def /C3 {80 120} def /C4 {80 100} def /C5 {80 80} def /C6 {80 60} def /C7 {80 40} def /C8 {80 20} def\n"
+		"/D1 {100 160} def /D2 {100 140} def /D3 {100 120} def /D4 {100 100} def /D5 {100 80} def /D6 {100 60} def /D7 {100 40} def /D8 {100 20} def\n"
+		"/E1 {120 160} def /E2 {120 140} def /E3 {120 120} def /E4 {120 100} def /E5 {120 80} def /E6 {120 60} def /E7 {120 40} def /E8 {120 20} def\n"
+		"/F1 {140 160} def /F2 {140 140} def /F3 {140 120} def /F4 {140 100} def /F5 {140 80} def /F6 {140 60} def /F7 {140 40} def /F8 {140 20} def\n"
+		"/G1 {160 160} def /G2 {160 140} def /G3 {160 120} def /G4 {160 100} def /G5 {160 80} def /G6 {160 60} def /G7 {160 40} def /G8 {160 20} def\n"
+		"/H1 {180 160} def /H2 {180 140} def /H3 {180 120} def /H4 {180 100} def /H5 {180 80} def /H6 {180 60} def /H7 {180 40} def /H8 {180 20} def\n\n"
+		"% draw a black disc\n"
+		"/disc_black{\n"
+		"\tnewpath\n"
+		"\t8.5 0 360 arc\n"
+		"\tfill\n"
+		"} def\n\n"
+		"% draw a white disc\n"
+		"/disc_white{\n"
+		"\tnewpath\n"
+		"\t0.5 setlinewidth\n"
+		"\t8.5 0 360 arc\n"
+		"\tstroke\n"
+		"} def\n\n"
+		"% draw a black move\n"
+		"/move_black{\n"
+		"\t/y exch def\n"
+		"\t/x exch def\n"
+		"\tnewpath\n"
+		"\tx y 8.5 0 360 arc\n"
+		"\tfill\n"
+		"\t1 setgray\n"
+		"\tx y moveto dup stringwidth pop 2 div neg -4.5 rmoveto\n"
+		"\tshow\n"
+		"\t0 setgray\n"
+		"} def\n\n"
+		"% draw a white move\n"
+		"/move_white{\n"
+		"\t/y exch def\n"
+		"\t/x exch def\n"
+		"\tnewpath\n"
+		"\t0.5 setlinewidth\n"
+		"\tx y 8.5 0 360 arc\n"
+		"\tstroke\n"
+		"\tx y moveto dup stringwidth pop 2 div neg -4.5 rmoveto\n"
+		"\tshow\n"
+		"} def\n\n"
+		"% draw the grid\n"
+		"/board_grid{\n"
+		"\tnewpath\n\n"
+		"\t%border\n"
+		"\t1.5 setlinewidth\n"
+		"\t  27   7 moveto\n"
+		"\t 166   0 rlineto\n"
+		"\t   0 166 rlineto\n"
+		"\t-166   0 rlineto\n"
+		"\tclosepath\n"
+		"\tstroke\n\n"
+		"\t%vertical lines\n"
+		"\t0.5 setlinewidth\n"
+		"\t30 10 moveto\n"
+		"\t0 1 8{\n"
+		"\t\t 0  160 rlineto\n"
+		"\t\t20 -160 rmoveto\n"
+		"\t}for\n\n"
+		"\t%horizontal lines\n"
+		"\t30 10 moveto\n"
+		"\t0 1 8{\n"
+		"\t\t 160  0 rlineto\n"
+		"\t\t-160 20 rmoveto\n"
+		"\t}for\n"
+		"\tstroke\n\n"
+		"\t%marks\n"
+		"\t 70  50 2 0 360 arc fill\n"
+		"\t150  50 2 0 360 arc fill\n"
+		"\t 70 130 2 0 360 arc fill\n"
+		"\t150 130 2 0 360 arc fill\n"
+		"}def\n\n"
+		"% draw coordinates\n"
+		"/board_coord{\n"
+		"\t/NewCenturySchoolbook-Roman findfont 15 scalefont setfont\n"
+		"\tnewpath\n"
+		"\t(a)  35 180 moveto show\n"
+		"\t(b)  55 180 moveto show\n"
+		"\t(c)  75 180 moveto show\n"
+		"\t(d)  95 180 moveto show\n"
+		"\t(e) 115 180 moveto show\n"
+		"\t(f) 135 180 moveto show\n"
+		"\t(g) 155 180 moveto show\n"
+		"\t(h) 175 180 moveto show\n"
+		"\t(1)  14 155 moveto show\n"
+		"\t(2)  14 135 moveto show\n"
+		"\t(3)  14 115 moveto show\n"
+		"\t(4)  14  95 moveto show\n"
+		"\t(5)  14  75 moveto show\n"
+		"\t(6)  14  55 moveto show\n"
+		"\t(7)  14  35 moveto show\n"
+		"\t(8)  14  15 moveto show\n"
+		"}def\n"
+		"%%EndProlog\n\n"
+
+		"% do the drawing\n"
+		"gsave\n"
+		"\n\t% draw an empty board\n"
+		"\tboard_coord\n"
+		"\tboard_grid\n"
+		"\n\t% draw the discs\n", f);
+
+	board = game->initial_board;
 	for (i = A1; i <= H8; i++) {
-		color = board_get_square_color(board, i);
+		color = board_get_square_color(&board, i);
 		if (color != EMPTY) {
 			if (game->player == WHITE) color = !color;
 			fprintf(f, "\t%s disc_%s\n", move_to_string(i, 0, s), s_player[color]);
 		}
 	}
 
-	fputs("\n\t% draw the moves\n",f);
-	fputs("\t/Utopia-Bold findfont 12 scalefont setfont\n",f);
+	fputs(	"\n\t% draw the moves\n"
+		"\t/Utopia-Bold findfont 12 scalefont setfont\n", f);
 	player = game->player;
 	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			player = !player;
 		}
-		if (game_update_board(board, game->move[i])) {
+		if (game_update_board(&board, game->move[i])) {
 			fprintf(f, "\t(%d) %s move_%s\n", i + 1,  move_to_string(game->move[i], BLACK, s), s_player[player]);
 			player = !player;
 		}
 	}
-	fputc('\n',f);
-	fputs("grestore\n",f);
+	fputc('\n', f);
+	fputs("grestore\n", f);
 }
 
 void game_export_svg(const Game *game, FILE *f)
 {
 	int i, color, player;
 	char s_color[2][8] = {"black", "white"};
-	Board board[1];
+	Board board;
 	const char *style = "font-size:22px;text-align:center;text-anchor:middle;font-family:Times New Roman;font-weight:bold";
 
 	// prolog
-	fputs("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n", f);
-	fputs("<svg\n", f);
-		fputs("\txmlns=\"http://www.w3.org/2000/svg\"\n", f);
-		fputs("\tversion=\"1.1\"\n", f);
-		fputs("\twidth=\"440\"\n", f);
-		fputs("\theight=\"440\">\n", f);
-	fputs("\t<desc>Othello Game</desc>\n", f);
+	fputs(	"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+		"<svg\n"
+			"\txmlns=\"http://www.w3.org/2000/svg\"\n"
+			"\tversion=\"1.1\"\n"
+			"\twidth=\"440\"\n"
+			"\theight=\"440\">\n"
+		"\t<desc>Othello Game</desc>\n", f);
 
 	// board
-	fputs("\t<rect\n", f);
-		fputs("\t\twidth=\"332\" height=\"332\" ", f);
-		fputs("x=\"54\" y=\"54\" ", f);
-		fputs("stroke=\"black\" ", f);
-		fputs("stroke-width=\"2\" ", f);
-		fputs("fill=\"white\" />\n", f);
-	fputs("\t<rect\n", f);
-		fputs("\t\twidth=\"320\" height=\"320\" ", f);
-		fputs("x=\"60\" y=\"60\" ", f);
-		fputs("stroke=\"black\" ", f);
-		fputs("fill=\"green\" />\n", f);
+	fputs(	"\t<rect\n"
+			"\t\twidth=\"332\" height=\"332\" "
+			"x=\"54\" y=\"54\" "
+			"stroke=\"black\" "
+			"stroke-width=\"2\" "
+			"fill=\"white\" />\n"
+		"\t<rect\n"
+			"\t\twidth=\"320\" height=\"320\" "
+			"x=\"60\" y=\"60\" "
+			"stroke=\"black\" "
+			"fill=\"green\" />\n", f);
 	for (i = 1; i < 8; ++i) {
 		fputs("\t<line\n", f);
 			fprintf(f, "\t\tx1=\"60\" y1=\"%d\" ", 60 + 40 * i);
@@ -1444,10 +1455,10 @@ void game_export_svg(const Game *game, FILE *f)
 			fprintf(f, "x2=\"%d\" y2=\"380\" ", 60 + 40 * i);
 			fputs("stroke=\"black\" />\n", f);
 	}
-	fputs("\t<circle cx=\"140\" cy=\"140\" r=\"4\" fill=\"black\" />\n", f);
-	fputs("\t<circle cx=\"300\" cy=\"140\" r=\"4\" fill=\"black\" />\n", f);
-	fputs("\t<circle cx=\"140\" cy=\"300\" r=\"4\" fill=\"black\" />\n", f);
-	fputs("\t<circle cx=\"300\" cy=\"300\" r=\"4\" fill=\"black\" />\n", f);
+	fputs(	"\t<circle cx=\"140\" cy=\"140\" r=\"4\" fill=\"black\" />\n"
+		"\t<circle cx=\"300\" cy=\"140\" r=\"4\" fill=\"black\" />\n"
+		"\t<circle cx=\"140\" cy=\"300\" r=\"4\" fill=\"black\" />\n"
+		"\t<circle cx=\"300\" cy=\"300\" r=\"4\" fill=\"black\" />\n", f);
 
 	// coordinates
 	for (i = 0; i < 8; ++i) {
@@ -1457,7 +1468,7 @@ void game_export_svg(const Game *game, FILE *f)
 
 	// discs
 	for (i = A1; i <= H8; i++) {
-		color = board_get_square_color(game->initial_board, i);
+		color = board_get_square_color(&game->initial_board, i);
 		if (color != EMPTY) {
 			if (game->player == WHITE) color = !color;
 			fprintf(f, "\t<circle cx=\"%d\" cy=\"%d\"  r=\"17\" fill=\"%s\" stroke=\"%s\" />\n",
@@ -1466,13 +1477,13 @@ void game_export_svg(const Game *game, FILE *f)
 	}
 
 	// moves
-	*board = *game->initial_board;
+	board = game->initial_board;
 	player = game->player;
 	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			player = !player;
 		}
-		if (game_update_board(board, game->move[i])) {
+		if (game_update_board(&board, game->move[i])) {
 			fprintf(f, "\t<circle cx=\"%d\" cy=\"%d\" r=\"17\" fill=\"%s\" stroke=\"%s\" />\n",
 				 80 + 40 * (game->move[i] % 8), 80 + 40 * (game->move[i] / 8), s_color[player], s_color[!player]);
 			player = !player;
@@ -1496,26 +1507,26 @@ void game_export_svg(const Game *game, FILE *f)
  */
 void game_rand(Game *game, int n_ply, Random *r)
 {
-	Move move[1];
+	Move move;
 	unsigned long long moves;
 	int ply;
-	Board board[1];
+	Board board;
 
 	game_init(game);
-	board_init(board);
+	board_init(&board);
 	for (ply = 0; ply < n_ply; ply++) {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(&board);
 		if (!moves) {
-			board_pass(board);
-			moves = get_moves(board->player, board->opponent);
+			board_pass(&board);
+			moves = board_get_moves(&board);
 			if (!moves) {
 				break;
 			}
 		}
 		;
-		board_get_move(board, get_rand_bit(moves, r), move);
-		game->move[ply] = move->x;
-		board_update(board, move);
+		board_get_move_flip(&board, get_rand_bit(moves, r), &move);
+		game->move[ply] = move.x;
+		board_update(&board, &move);
 	}
 }
 
@@ -1531,11 +1542,11 @@ void game_rand(Game *game, int n_ply, Random *r)
  */
 int game_analyze(Game *game, Search *search, const int n_empties, const bool apply_correction)
 {
-	Board board[1];
+	Board board;
 	struct {
 		Move played;
 		Move best;
-		Line pv[1];
+		Line pv;
 		int n_empties;
 	} stack[99];
 	int n_error = 0;
@@ -1547,44 +1558,44 @@ int game_analyze(Game *game, Search *search, const int n_empties, const bool app
 
 	search->options.verbosity = 0;
 	search_cleanup(search);
-	*board = *game->initial_board;
+	board = game->initial_board;
 	player = game->player;
 	for (i = n_move = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-		if (!can_move(board->player, board->opponent)) {
+		if (!can_move(board.player, board.opponent)) {
 			stack[n_move].best = MOVE_INIT;
-			line_init(stack[n_move].pv, player);
+			line_init(&stack[n_move].pv, player);
 			stack[n_move++].played = MOVE_PASS;
-			board_pass(board);
+			board_pass(&board);
 			player = !player;
 		} 
-		if (!board_is_occupied(board, game->move[i]) && board_get_move(board, game->move[i], &stack[n_move].played)) {
+		if (!board_is_occupied(&board, game->move[i]) && board_get_move_flip(&board, game->move[i], &stack[n_move].played)) {
 			stack[n_move].best = MOVE_INIT;
-			line_init(stack[n_move].pv, player);
-			search_set_board(search, board, player);
-			search_set_level(search, 60, search->n_empties);
-			stack[n_move].n_empties = search->n_empties;
-			if (search->movelist->n_moves > 1 && search->n_empties <= n_empties) {
-				movelist_exclude(search->movelist, game->move[i]);
+			line_init(&stack[n_move].pv, player);
+			search_set_board(search, &board, player);
+			search_set_level(search, 60, search->eval.n_empties);
+			stack[n_move].n_empties = search->eval.n_empties;
+			if (search->movelist.n_moves > 1 && search->eval.n_empties <= n_empties) {
+				movelist_exclude(&search->movelist, game->move[i]);
 				search_run(search);
-				stack[n_move].best = *(movelist_first(search->movelist));
-				*stack[n_move].pv = *search->result->pv;
+				stack[n_move].best = *(movelist_first(&search->movelist));
+				stack[n_move].pv = search->result->pv;
 			}
-			board_update(board, &stack[n_move].played);
+			board_update(&board, &stack[n_move].played);
 			player = !player;
 			++n_move;
 		} else {
 			char s[4];
 			warn("\nillegal move %s in game:\n", move_to_string(game->move[i], player, s));			
 			game_export_text(game, stderr);
-			board_print(board, player, stderr);
+			board_print(&board, player, stderr);
 			fprintf(stderr, "\n\n");			
 			return 1; // stop, illegal moves
 		}
 	}
 
-	search_set_board(search, board, player);
-	if (search->n_empties <= n_empties) {
-		search_set_level(search, 60, search->n_empties);
+	search_set_board(search, &board, player);
+	if (search->eval.n_empties <= n_empties) {
+		search_set_level(search, 60, search->eval.n_empties);
 		search_run(search);
 		score = search->result->score;
 		
@@ -1601,7 +1612,7 @@ int game_analyze(Game *game, Search *search, const int n_empties, const bool app
 				if (apply_correction && stack[n_move].best.x != NOMOVE) {
 					for (i = 0; i < 60 && game->move[i] != 0; ++i) {
 						if (game->move[i] == stack[n_move].played.x) {
-							game_append_line(game, stack[n_move].pv, i);
+							game_append_line(game, &stack[n_move].pv, i);
 						}
 					}
 				}
@@ -1624,7 +1635,7 @@ int game_analyze(Game *game, Search *search, const int n_empties, const bool app
  */
 int game_complete(Game *game, Search *search) 
 {
-	Board board[1];
+	Board board;
 	const int verbosity = search->options.verbosity;
 	int i, n;
 	int player;
@@ -1634,24 +1645,24 @@ int game_complete(Game *game, Search *search)
 
 	player = game->player;
 	for (n = 0; n < 60; ++n) {
-		*board = *game->initial_board;
+		board = game->initial_board;
 		for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
-			player ^= game_update_player(board, game->move[i]);
-			if (!game_update_board(board, game->move[i])) {
+			player ^= game_update_player(&board, game->move[i]);
+			if (!game_update_board(&board, game->move[i])) {
 				break;
 			}
 		}
 
-		if (!can_move(board->player, board->opponent)) {
-			if (!can_move(board->opponent, board->player)) break;
+		if (!can_move(board.player, board.opponent)) {
+			if (!can_move(board.opponent, board.player)) break;
 			player ^= 1;
-			board_pass(board);
+			board_pass(&board);
 		}
 
-		search_set_board(search, board, player);
+		search_set_board(search, &board, player);
 		search_run(search);
-		if (search->result->depth == search->n_empties && search->result->selectivity == NO_SELECTIVITY) {
-			game_append_line(game, search->result->pv, i);
+		if (search->result->depth == search->eval.n_empties && search->result->selectivity == NO_SELECTIVITY) {
+			game_append_line(game, &search->result->pv, i);
 		} else {
 			game->move[i] = search->result->move;
 		}
diff --git a/src/game.h b/src/game.h
index 5b3aac72..b7b55caa 100644
--- a/src/game.h
+++ b/src/game.h
@@ -3,7 +3,7 @@
  *
  * Header file for game management
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -20,7 +20,7 @@
 struct Random;
 
 typedef struct Game {
-	Board initial_board[1];
+	Board initial_board;
 	struct {
 		short year;
 		signed char month;
@@ -63,7 +63,7 @@ void game_import_text(Game*, FILE*);
 void game_import_wthor(Game*, FILE*);
 void game_import_ggf(Game*, FILE*);
 void game_import_sgf(Game*, FILE *);
-char *parse_ggf(Game*, const char*);
+int parse_ggf(Game*, const char*);
 void game_import_pgn(Game*, FILE *);
 void game_export_text(const Game*, FILE*);
 void game_export_ggf(const Game*, FILE*);
diff --git a/src/ggs.c b/src/ggs.c
index ba203b99..c2f4c67a 100644
--- a/src/ggs.c
+++ b/src/ggs.c
@@ -3,7 +3,7 @@
  *
  *  A ggs client in C language.
  *
- * @date 2002 - 2017
+ * @date 2002 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -194,7 +194,7 @@ static void text_init(Text *text)
 static void text_add_line(Text *text, const char *line)
 {
 	++text->n_lines;
-	text->line = (const char**) realloc(text->line, text->n_lines * sizeof (const char*));
+	text->line = (const char**) realloc((void *) text->line, text->n_lines * sizeof (const char*));
 	if (text->line == NULL) fatal_error("Allocation error\n");
 	text->line[text->n_lines - 1] = line;
 	log_receive(ggs_log, "GGS ", "%s\n", line);
@@ -1142,7 +1142,7 @@ static void ui_login(UI *ui)
 static void ui_ggs_ponder(UI *ui, int turn) {
 	Play *play;
 
-	if (search_count_tasks(ui->play->search) == options.n_task) {
+	if (search_count_tasks(&ui->play->search) == options.n_task) {
 		play = ui->play;
 	} else  {
 		play = ui->play + turn;
@@ -1166,27 +1166,27 @@ static void ui_ggs_play(UI *ui, int turn) {
 	Play *play;
 	Result *result;
 	char move[4], line[32];
-	const char *(search_state_array[6]) = {"running", "interrupted", "stop pondering", "out of time", "stopped on user demand", "completed"};
+	static const char * const search_state_array[6] = {"running", "interrupted", "stop pondering", "out of time", "stopped on user demand", "completed"};
 	char search_state[32];
 
 	if (ui->is_same_play) {
 		play = ui->play;
-		if (search_count_tasks(ui->play->search) < options.n_task) {
+		if (search_count_tasks(&ui->play->search) < options.n_task) {
 			printf("<use a single %d tasks search while a single game is played>\n", options.n_task);
 			play_stop_pondering(ui->play);
-			search_set_task_number(ui->play[0].search, options.n_task);
+			search_set_task_number(&ui->play[0].search, options.n_task);
 			play_stop_pondering(ui->play + 1);
-			search_set_task_number(ui->play[1].search, 0);
+			search_set_task_number(&ui->play[1].search, 0);
 		}
 	} else {
 		play = ui->play + turn;
-		if (search_count_tasks(ui->play->search) == options.n_task && options.n_task > 1) {
+		if (search_count_tasks(&ui->play->search) == options.n_task && options.n_task > 1) {
 			printf("<split single %d tasks search into two %d task searches>\n", options.n_task, options.n_task / 2);
 			play_stop_pondering(ui->play);
-			search_set_task_number(ui->play[0].search, options.n_task / 2);
+			search_set_task_number(&ui->play[0].search, options.n_task / 2);
 			play_stop_pondering(ui->play + 1);
-			search_set_task_number(ui->play[1].search, options.n_task / 2);
-			search_share(ui->play[0].search, ui->play[1].search);
+			search_set_task_number(&ui->play[1].search, options.n_task / 2);
+			search_share(&ui->play[0].search, &ui->play[1].search);
 			ui_ggs_ponder(ui, turn ^ 1); // ponder opponent move
 		}
 	}
@@ -1197,7 +1197,7 @@ static void ui_ggs_play(UI *ui, int turn) {
 		return ;
 	}
 
-	result = play->result;
+	result = &play->result;
 	
 	if (remaining_time > 60000) remaining_time -= 10000; // keep 10s. for safety.
 	else if (remaining_time > 10000) remaining_time -= 2000; // keep 2s. for safety.
@@ -1222,7 +1222,7 @@ static void ui_ggs_play(UI *ui, int turn) {
 			ui->ggs->me, move, ui->ggs->board->id,
 			result->score
 		);
-	} else if (play->search->n_empties >= 15) { //avoid noisy display
+	} else if (play->search.eval.n_empties >= 15) { //avoid noisy display
 		const char *bound;
 		char s_nodes[16], s_speed[16];
 
@@ -1235,10 +1235,10 @@ static void ui_ggs_play(UI *ui, int turn) {
 			result->score, result->depth, selectivity_table[result->selectivity].percent,
 			result->n_nodes, 0.001 * real_time, (result->n_nodes / (0.001 * real_time + 0.001))
 		);
-		if (play->search->stop == STOP_TIMEOUT) {
-			sprintf(search_state, "%s at %d@%d%%", search_state_array[play->search->stop], play->search->depth, selectivity_table[play->search->selectivity].percent);
+		if (play->search.stop == STOP_TIMEOUT) {
+			sprintf(search_state, "%s at %d@%d%%", search_state_array[play->search.stop], play->search.depth, selectivity_table[play->search.selectivity].percent);
 		} else {
-			sprintf(search_state, "%s", search_state_array[play->search->stop]);
+			sprintf(search_state, "%s", search_state_array[play->search.stop]);
 		}
 		ggs_client_send(ui->ggs, "tell .%s -----------------------------------------"
 			"\\%s plays %s in game %s using %d thread%s"
@@ -1246,10 +1246,10 @@ static void ui_ggs_play(UI *ui, int turn) {
 			"\\nodes: %s ; time: search = %.1fs, move = %.1fs; speed: %s."
 			"\\search %s\n",
 			ui->ggs->me,
-			ui->ggs->me, move, ui->ggs->board->id, search_count_tasks(play->search), search_count_tasks(play->search) > 1 ? "s ;" : " ;",
+			ui->ggs->me, move, ui->ggs->board->id, search_count_tasks(&play->search), search_count_tasks(&play->search) > 1 ? "s ;" : " ;",
 			bound, result->score,
 			result->depth, selectivity_table[result->selectivity].percent,
-			line_to_string(result->pv, 8, " ", line),
+			line_to_string(&result->pv, 8, " ", line),
 			format_scientific(result->n_nodes, "N", s_nodes), 0.001 * result->time, 0.001 * real_time, format_scientific(result->n_nodes / (0.001 * result->time+ 0.001), "N/s", s_speed),
 			search_state
 		);
@@ -1266,7 +1266,7 @@ static void ui_ggs_play(UI *ui, int turn) {
  * @param ui User Interface.
  */
 static void ui_ggs_join(UI *ui) {
-	char buffer[256];
+	char buffer[258];
 	char s_move[4];
 	Play *play;
 	int edax_turn, i;
@@ -1299,9 +1299,9 @@ static void ui_ggs_join(UI *ui) {
 		}
 	}
 	printf("[%s's turn in game %s]\n", ui->ggs->board->player[play->player].name, ui->ggs->board->id);
-	board_print(play->board, play->player, stdout);
+	board_print(&play->board, play->player, stdout);
 
-	ui->is_same_play = (ui->ggs->board->move_list_n == 0 || board_equal(ui->play[0].board, ui->play[1].board) || !ui->ggs->board->match_type->is_synchro);
+	ui->is_same_play = (ui->ggs->board->move_list_n == 0 || board_equal(&ui->play[0].board, &ui->play[1].board) || !ui->ggs->board->match_type->is_synchro);
 	if (ui->is_same_play) printf("[Playing same game]\n");
 
 	// set time & start thinking
@@ -1324,10 +1324,10 @@ static void ui_ggs_join(UI *ui) {
  * @param ui User Interface.
  */
 static void ui_ggs_update(UI *ui) {
-	char buffer[256], s_move[4];
+	char buffer[258], s_move[4];
 	Play *play;
 	int edax_turn, turn;
-	Board board[1];
+	Board board;
 	
 	printf("[received GGS_BOARD_UPDATE]\n");
 
@@ -1346,16 +1346,16 @@ static void ui_ggs_update(UI *ui) {
 		
 	// set board as an edax's board
 	sprintf(buffer, "%s %c", ui->ggs->board->board, ui->ggs->board->turn);
-	turn = board_set(board, buffer);
+	turn = board_set(&board, buffer);
 
 	// update the board... if possible
 	if (!play_move(play, ui->ggs->board->move)) {
 		info("<Updating with bad move %s>\n", move_to_string(ui->ggs->board->move, play->player, s_move));
 	}
 
-	if (!board_equal(board, play->board)) { // may happens when game diverges
+	if (!board_equal(&board, &play->board)) { // may happens when game diverges
 		info("<Resynchronize boards: diverging games>\n");
-		*play->board = *board; play->player = turn;
+		play->board = board; play->player = turn;
 	}
 
 	if (turn != play->player) { // should never happen: TODO fatal error?
@@ -1366,7 +1366,7 @@ static void ui_ggs_update(UI *ui) {
 	printf("[%s's turn in game %s]\n", ui->ggs->board->player[play->player].name, ui->ggs->board->id);
 
 	// playing same game... ?
-	ui->is_same_play = (!ui->ggs->board->match_type->is_synchro || board_equal(ui->play[0].board, ui->play[1].board));
+	ui->is_same_play = (!ui->ggs->board->match_type->is_synchro || board_equal(&ui->play[0].board, &ui->play[1].board));
 	if (ui->is_same_play) printf("<Playing same game...>\n");
 
 	// set time & start thinking
@@ -1392,14 +1392,14 @@ void ui_init_ggs(UI *ui) {
 	ui->ggs = (GGSClient*) malloc (sizeof (GGSClient));
 	if (ui->ggs == NULL) fatal_error("ui_init_ggs: cannot allocate the GGS client\n");
 
-	play_init(ui->play, ui->book);
-	ui->book->search = ui->play->search;
-	book_load(ui->book, options.book_file);
+	play_init(ui->play, &ui->book);
+	ui->book.search = &ui->play->search;
+	book_load(&ui->book, options.book_file);
 
-	ui->play[0].search->id = 1;
+	ui->play[0].search.id = 1;
 	options.n_task = 1;
-	play_init(ui->play + 1, ui->book);
-	ui->play[1].search->id = 2;
+	play_init(ui->play + 1, &ui->book);
+	ui->play[1].search.id = 2;
 	options.n_task = n_task;
 	log_open(ggs_log, options.ggs_log_file);
 
@@ -1416,12 +1416,12 @@ void ui_init_ggs(UI *ui) {
  */
 void ui_loop_ggs(UI *ui) {
 	char *cmd = NULL, *param = NULL;
-	Text text[1];
-	GGSClient *client = ui->ggs;
+	Text text;
+	GGSClient *const client = ui->ggs;
 
 	ui->mode = 3;
 
-	text_init(text);
+	text_init(&text);
 	for (;;) {
 		relax(10);
 
@@ -1461,18 +1461,18 @@ void ui_loop_ggs(UI *ui) {
 		ggs_client_refresh(client);
 
 		/* look for a ggs event */
-		if (!ggs_event_peek(&client->event, text)) {
+		if (!ggs_event_peek(&client->event, &text)) {
 			continue;
 		}
 
-		text_print(text, stdout);
+		text_print(&text, stdout);
 
 		/* login */
-		if (ggs_login(text)) {
+		if (ggs_login(&text)) {
 			ggs_client_send(client, "%s\n", options.ggs_login);
 
 		/* password */
-		} else if (ggs_password(text)) {
+		} else if (ggs_password(&text)) {
 			ggs_client_send(client, "%s\n", options.ggs_password);
 
 			ggs_client_send(client, "vt100 -\n");
@@ -1484,7 +1484,7 @@ void ui_loop_ggs(UI *ui) {
 			ggs_client_send(client, "tell .%s Hello!\n", client->me);
 
 		/* os on */
-		} else if (ggs_os_on(text)) {
+		} else if (ggs_os_on(&text)) {
 			printf("[received GGS_OS_ON]\n");
 			ggs_client_send(client, "tell /os trust +\n" );
 			ggs_client_send(client, "tell /os rated +\n" );
@@ -1494,11 +1494,11 @@ void ui_loop_ggs(UI *ui) {
 			ggs_client_send(client, "mso\n" );
 	
 		/* os off */
-		} else if (ggs_os_off(text)) {
+		} else if (ggs_os_off(&text)) {
 			printf("[received GGS_OS_OFF]\n");
 
 		/* match on */
-		} else if (ggs_match_on(client->match_on, text)) {
+		} else if (ggs_match_on(client->match_on, &text)) {
 			if (ggs_has_player(client->match_on->player, client->me)) {
 				printf("[received GGS_MATCH_ON]\n");
 				client->is_playing = true;
@@ -1508,7 +1508,7 @@ void ui_loop_ggs(UI *ui) {
 			}
 
 		/* match off */
-		} else if (ggs_match_off(client->match_off, text)) {
+		} else if (ggs_match_off(client->match_off, &text)) {
 			if (ggs_has_player(client->match_off->player, client->me)) {
 				printf("[received GGS_MATCH_OFF]\n");
 
@@ -1522,9 +1522,9 @@ void ui_loop_ggs(UI *ui) {
 						printf("[store match]\n");
 						play_store(ui->play);
 					}
-					if (ui->book->need_saving) {
-						book_save(ui->book, options.book_file);
-						ui->book->need_saving = false;
+					if (ui->book.need_saving) {
+						book_save(&ui->book, options.book_file);
+						ui->book.need_saving = false;
 					}
 				}
 
@@ -1540,7 +1540,7 @@ void ui_loop_ggs(UI *ui) {
 			}
 
 		/* board join/update */
-		} else if (ggs_board(client->board,  text)) {
+		} else if (ggs_board(client->board, &text)) {
 			if (ggs_has_player(client->board->player, client->me)) {
 				if (client->board->is_join) ui_ggs_join(ui);
 				else ui_ggs_update(ui);
@@ -1549,17 +1549,17 @@ void ui_loop_ggs(UI *ui) {
 			}
 
 		/* request */
-		} else if (ggs_request(client->request, text)) {
+		} else if (ggs_request(client->request, &text)) {
 			printf("[received GGS_REQUEST]\n");
 
 		/* admin on */
-		} else if (ggs_admin(client->admin, text)) {
+		} else if (ggs_admin(client->admin, &text)) {
 			printf("[received GGS_ADMIN_CMD]\n");
 			ggs_client_send(client, client->admin->command);
 			ggs_client_send(client, "\ntell %s command processed\n", client->admin->name);
 
 		/* To request Saio a game later */
-		} else if (ggs_saio_delay(text, &client->once->delay)) {
+		} else if (ggs_saio_delay(&text, &client->once->delay)) {
 			printf("[received GGS_SAIO_DELAY]\n");
 			free(client->once->cmd); client->once->cmd = NULL;
 			if (cmd != NULL && param != NULL) {
@@ -1575,16 +1575,16 @@ void ui_loop_ggs(UI *ui) {
 			}
 
 		/* READY */
-		} else if (ggs_ready(text)) {
+		} else if (ggs_ready(&text)) {
 
 		/* ALERT */
-		} else if (ggs_alert(text)) {
+		} else if (ggs_alert(&text)) {
 			printf("[received ALERT]\n");
 
 		/* Other messages */
 		} else {
 		}
-		text_free(text);
+		text_free(&text);
 	}
 }
 
@@ -1598,8 +1598,8 @@ void ui_loop_ggs(UI *ui) {
 void ui_free_ggs(UI *ui) {
 	play_free(ui->play);
 	play_free(ui->play + 1);
-	if (ui->book->need_saving) book_save(ui->book, options.book_file);
-	book_free(ui->book);
+	if (ui->book.need_saving) book_save(&ui->book, options.book_file);
+	book_free(&ui->book);
 	ggs_client_free(ui->ggs);
 	free(ui->ggs->loop->cmd);
 	free(ui->ggs->once->cmd);
diff --git a/src/gpl-3.0.txt b/src/gpl-3.0.txt
deleted file mode 100644
index 94a9ed02..00000000
--- a/src/gpl-3.0.txt
+++ /dev/null
@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- 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.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    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 <http://www.gnu.org/licenses/>.
-
-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:
-
-    <program>  Copyright (C) <year>  <name of author>
-    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
-<http://www.gnu.org/licenses/>.
-
-  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
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/src/gtp.c b/src/gtp.c
index fd28cc2c..81e081e7 100644
--- a/src/gtp.c
+++ b/src/gtp.c
@@ -3,7 +3,7 @@
  *
  * Go Text Protocol
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -97,11 +97,11 @@ void ui_init_gtp(UI *ui)
 	options.verbosity = 0;
 	options.info = 0;
 
-	play_init(play, ui->book);
-	ui->book->search = play->search;
-	book_load(ui->book, options.book_file);
-	play->search->id = 1;
-	search_set_observer(play->search, gtp_observer);
+	play_init(play, &ui->book);
+	ui->book.search = &play->search;
+	book_load(&ui->book, options.book_file);
+	play->search.id = 1;
+	search_set_observer(&play->search, gtp_observer);
 	ui->mode = 3;
 	play->type = ui->type;
 
@@ -114,8 +114,8 @@ void ui_init_gtp(UI *ui)
  */
 void ui_free_gtp(UI *ui)
 {
-	if (ui->book->need_saving) book_save(ui->book, options.book_file);
-	book_free(ui->book);
+	if (ui->book.need_saving) book_save(&ui->book, options.book_file);
+	book_free(&ui->book);
 	play_free(ui->play);
 	log_close(gtp_log);
 }
@@ -322,7 +322,7 @@ void ui_loop_gtp(UI *ui)
 		} else if (strcmp(cmd, "showboard") == 0) {
 			printf("= ");
 			if (has_id) printf("%d\n", id);
-			board_print(play->board, play->player, stdout);
+			board_print(&play->board, play->player, stdout);
 			putchar('\n'); fflush(stdout);
 
 		// error: unknown message
diff --git a/src/hash-lock-free.c b/src/hash-lock-free.c
deleted file mode 100644
index 5caaee90..00000000
--- a/src/hash-lock-free.c
+++ /dev/null
@@ -1,680 +0,0 @@
-/**
- * @file hash.c
- *
- * @brief Lock-free transposition table.
- *
- * The hash table is an efficient memory system to remember the previously
- * analysed positions and re-use the collected data when needed.
- * The hash table contains entries of analysed data where the board is uniquely
- * identified through a 64-bit key and the results of the recorded analysis are
- * two score bounds, the level of the analysis and the best move found.
- * The implementation is now a multi-way hashtable. It both tries to keep the
- * deepest records and to always add the latest one.
- * The following implementation may suffer from hash collision: two different
- * positions may share the same hashcode. Fortunately, this is very unprobable
- * with hascode on 64 bits, and, thanks to alphabeta robustness, it propagates
- * even less often to the root.
- * When doing parallel search with a shared hashtable, a lockless implementation
- * [1] detects & eliminates concurrency collisions without much performance
- * impact.
- *
- * [1] http://www.cis.uab.edu/hyatt/hashing.html
- *
- * @date 1998 - 2012
- * @author Richard Delorme
- * @version 4.4
- */
-
-#include "bit.h"
-#include "hash.h"
-#include "options.h"
-#include "stats.h"
-#include "search.h"
-#include "util.h"
-#include "settings.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-
-/** hashing global data */
-unsigned long long hash_rank[16][256];
-
-/** hashing global data */
-unsigned long long hash_move[64][60];
-
-/** HashData init value */
-const HashData HASH_DATA_INIT = {0, 0, 0, 0, -SCORE_INF, SCORE_INF, {NOMOVE, NOMOVE}};
-
-/**
- * @brief Initialize global hash code data.
- */
-void hash_code_init(void)
-{
-	int i, j;
-	Random r;
-
-	random_seed(&r, 0x5DEECE66Dull);
-	for (i = 0; i < 16; ++i)
-	for (j = 0; j < 256; ++j) {
-		do {
-			hash_rank[i][j] = random_get(&r);
-		} while (bit_count(hash_rank[i][j]) < 8); 
-	}
-}
-
-
-/**
- * @brief Initialize global hash move data.
- */
-void hash_move_init(void)
-{
-	int i, j;
-	Random r;
-
-	random_seed(&r, 0x5DEECE66Dull);
-	for (i = 0; i < 64; ++i)
-	for (j = 0; j < 60; ++j) {
-		do {
-			hash_move[i][j] = random_get(&r);
-		} while (bit_count(hash_move[i][j]) < 8); 
-	}
-}
-
-
-/**
- * @brief Transform hash data into a 64 bits key.
- *
- * @param data Hash data.
- * @return a 64 bits key.
- */
-static inline unsigned long long hash_key(const HashData *data)
-{
-	if (USE_TYPE_PUNING) { // fast version using type puning.
-		union {
-			HashData data;
-			unsigned long long key;
-		} u;
-		u.data = *data;
-		return u.key;
-	} else { // more portable but slower version
-		unsigned long long pack;
-		pack  = ((unsigned long long) data->move[1]) << 56;
-		pack |= ((unsigned long long) data->move[0]) << 48;
-		pack |= (((unsigned long long) data->upper) & 0xff) << 40; // sign extension masked
-		pack |= (((unsigned long long) data->lower) & 0xff) << 32; // sign extension masked
-		pack |= ((unsigned long long) data->date) << 24;
-		pack |= ((unsigned long long) data->cost) << 16;
-		pack |= ((unsigned long long) data->selectivity) << 8;
-		pack |= ((unsigned long long) data->depth);
-
-		return pack;
-	}
-}
-
-/**
- * @brief Initialise the hashtable.
- *
- * Allocate the hash table entries and initialise the hash masks.
- *
- * @param hash_table Hash table to setup.
- * @param size Requested size for the hash table in number of bits.
- */
-void hash_init(HashTable *hash_table, const int size)
-{
-	int n_way;
-
-	for (n_way = 1; n_way < HASH_N_WAY; n_way <<= 1);
-
-	assert(hash_table != NULL && size > 0);
-	assert((n_way & -n_way) == n_way);
-
-	info("< init hashtable of %u entries>\n", size);
-	if (hash_table->hash != NULL) free(hash_table->memory);
-	hash_table->memory = malloc((size + n_way + 1) * sizeof (Hash));
-	if (hash_table->memory == NULL) {
-		fatal_error("hash_init: cannot allocate the hash table\n");
-	}
-
-	if (HASH_ALIGNED) {
-		const size_t alignment = n_way * sizeof (Hash) - 1;
-		hash_table->hash = (Hash*) (((size_t) hash_table->memory + alignment) & ~alignment);
-		hash_table->hash_mask = size - n_way;
-	} else {
-		hash_table->hash = (Hash*) hash_table->memory;
-		hash_table->hash_mask = size - 1;
-	}
-
-	for (hash_table->size = 1; (1 << hash_table->size) < size; ++hash_table->size);
-
-	hash_cleanup(hash_table);
-}
-
-/**
- * @brief Clear the hashtable.
- *
- * Set all hash table entries to zero.
- * @param hash_table Hash table to clear.
- */
-void hash_cleanup(HashTable *hash_table)
-{
-	register unsigned int i;
-
-	assert(hash_table != NULL && hash_table->hash != NULL);
-
-	info("< cleaning hashtable >\n");
-	for (i = 0; i <= hash_table->hash_mask + HASH_N_WAY; ++i) {
-		hash_table->hash[i].code = 0;
-		hash_table->hash[i].data = HASH_DATA_INIT;
-	}
-	hash_table->date = 0;
-}
-
-/**
- * @brief Clear the hashtable.
- *
- * Change the date of the hash table.
- * @param hash_table Hash table to clear.
- */
-void hash_clear(HashTable *hash_table)
-{
-	assert(hash_table != NULL);
-
-	if (hash_table->date == 127) hash_cleanup(hash_table);
-	++hash_table->date;
-	info("< clearing hashtable -> date = %d>\n", hash_table->date);
-	assert(hash_table->date > 0 && hash_table->date <= 127);
-}
-
-/**
- * @brief Free the hashtable.
- *
- * Free the memory allocated by the hash table entries
- * @param hash_table hash_table to free.
- */
-void hash_free(HashTable *hash_table)
-{
-	assert(hash_table != NULL && hash_table->hash != NULL);
-	free(hash_table->memory);
-	hash_table->hash = NULL;
-}
-
-/**
- * @brief make a level from date, cost, depth & selectivity.
- *
- * @param data Hash data.
- * @return A level.
- */
-inline unsigned int writeable_level(HashData *data)
-{
-	if (USE_TYPE_PUNING) { // HACK: depends on little endian.
-		return (*(unsigned int*) data);
-	} else { // slow but more portable implementation.
-		return (((unsigned)data->date) << 24) + (((unsigned)data->cost) << 16) + (data->selectivity << 8) + data->depth;
-	}
-}
-
-/**
- * @brief update an hash table item.
- *
- * This is done when the level is the same as the previous storage.
- * Best moves & bound scores are updated, other data are untouched.
- *
- * @param data Hash Data.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void data_update(HashData *data, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	if (score < beta && score < data->upper) data->upper = (signed char) score;
-	if (score > alpha && score > data->lower) data->lower = (signed char) score;
-	if ((score > alpha || score == SCORE_MIN) && data->move[0] != move) {
-		data->move[1] = data->move[0];
-		data->move[0] = (unsigned char) move;
-	}
-	data->cost = (unsigned char) MAX(cost, data->cost);
-	HASH_STATS(++statistics.n_hash_update;)
-}
-
-/**
- * @brief Upgrade an hash table item.
- *
- * Upgrade is done when the search level increases.
- * Best moves are updated, others data are reset to new value.
- *
- * @param data Hash Data.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void data_upgrade(HashData *data, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	if (score < beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
-	if (score > alpha) data->lower =(signed char) score; else data->lower = SCORE_MIN;
-	if ((score > alpha || score == SCORE_MIN) && data->move[0] != move) {
-		data->move[1] = data->move[0];
-		data->move[0] = (unsigned char) move;
-	}
-	data->depth = depth;
-	data->selectivity = selectivity;
-	data->cost = (unsigned char) MAX(cost, data->cost);  // this may not work well in parallel search.
-	HASH_STATS(++statistics.n_hash_upgrade;)
-
-	assert(data->upper >= data->lower);
-}
-
-static void data_new(HashData *data, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	if (score < beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
-	if (score > alpha) data->lower = (signed char) score; else data->lower = SCORE_MIN;
-	if (score > alpha || score == SCORE_MIN) data->move[0] = (unsigned char) move;
-	else data->move[0] = NOMOVE;
-	data->move[1] = NOMOVE;
-	data->depth = depth;
-	data->selectivity = selectivity;
-	data->cost = cost;
-	data->date = date;
-	assert(data->upper >= data->lower);
-}
-
-/**
- * @brief Initialize a new hash table item.
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost.
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void hash_new(Hash *hash, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	HashData data[1];
-
-	data_new(data, date, depth, selectivity, cost, alpha, beta, score, move);
-	HASH_STATS(if (date == hash->data.date) ++statistics.n_hash_remove;)
-	HASH_STATS(++statistics.n_hash_new;)
-	hash->data = *data;
-	hash->code = hash_code ^ hash_key(data);
-	LOCKFREE_STATS(bool ok = (hash->code == (hash_code ^ hash_key(&hash->data)));)
-	LOCKFREE_STATS(statistics.n_concurrent_garbage += !ok;)
-}
-
-/**
- * @brief Set a new hash table item.
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost.
- * @param lower Lower score bound.
- * @param upper Upper score bound.
- * @param move Best move.
- */
-void hash_set(Hash *hash, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int lower, const int upper, const int move)
-{
-	HashData data[1];
-	
-	data->upper = (signed char) upper;
-	data->lower = (signed char) lower;
-	data->move[0] = (unsigned char) move;
-	data->move[1] = NOMOVE;
-	data->depth = (unsigned char) depth;
-	data->selectivity = (unsigned char) selectivity;
-	data->cost = (unsigned char) cost;
-	data->date = (unsigned char) date;
-	assert(data->upper >= data->lower);
-	HASH_STATS(if (date == hash->data.date) ++statistics.n_hash_remove;)
-	HASH_STATS(++statistics.n_hash_new;)
-	hash->data = *data;
-	hash->code = hash_code ^ hash_key(data);
-	LOCKFREE_STATS(bool ok = (hash->code == (hash_code ^ hash_key(&hash->data)));)
-	LOCKFREE_STATS(statistics.n_concurrent_garbage += !ok;)
-}
-
-
-/**
- * @brief update the hash entry
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Hash Cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- * @return true if an entry has been updated, false otherwise.
- */
-static bool hash_update(Hash *hash, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	HashData data[1];
-	bool ok;
-
-	*data = hash->data;
-	if ((hash->code ^  hash_key(data)) == hash_code) {
-		if (data->selectivity == selectivity && data->depth == depth) data_update(data, cost, alpha, beta, score, move);
-		else data_upgrade(data, depth, selectivity, cost, alpha, beta, score, move);
-		data->date = (unsigned char) date;
-		if (data->lower > data->upper) { // reset the hash-table...
-			data_new(data, date, depth, selectivity, cost, alpha, beta, score, move);
-		}
-		hash->data = *data;
-		hash->code = hash_code ^ hash_key(data);
-		ok = (hash->code == (hash_code ^ hash_key(&hash->data)));
-		LOCKFREE_STATS(statistics.n_concurrent_garbage += !ok;)
-		return ok;
-	}
-	return false;
-}
-
-/**
- * @brief replace the hash entry.
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Hash Cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- * @return true if an entry has been replaced, false otherwise.
- */
-static bool hash_replace(Hash *hash, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	HashData data[1];
-	bool ok;
-	
-	*data = hash->data;
-	if ((hash->code ^  hash_key(data)) == hash_code) {
-		data_new(data, date, depth, selectivity, cost, alpha, beta, score, move);
-		hash->data = *data;
-		hash->code = hash_code ^ hash_key(data);
-		ok = (hash->code == (hash_code ^ hash_key(&hash->data)));
-		LOCKFREE_STATS(statistics.n_concurrent_garbage += !ok;)
-		return ok;
-	}
-	return false;
-}
-
-/**
- * @brief Reset an hash entry from new data values.
- *
- * @param hash Hash Entry.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param lower Lower score bound.
- * @param upper Upper score bound.
- * @param move Best move.
- */
-bool hash_reset(Hash *hash, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int lower, const int upper, const int move)
-{
-	HashData data[1];
-	bool ok;
-
-	*data = hash->data;
-	if ((hash->code ^  hash_key(data)) == hash_code) {
-		if (data->selectivity == selectivity && data->depth == depth) {
-			if (data->lower < lower) data->lower = (signed char) lower;
-			if (data->upper > upper) data->upper = (signed char) upper;
-		} else {
-			data->depth = (unsigned char) depth;
-			data->selectivity = (unsigned char) selectivity;
-			data->lower = (signed char) lower;
-			data->upper = (signed char) upper;		
-		}
-		data->cost = 0;
-		data->date = (unsigned char) date;
-		if (move != NOMOVE) {
-			if (data->move[0] != move) {
-				data->move[1] = data->move[0];
-				data->move[0] = (unsigned char) move;
-			} else {
-				data->move[1] = (unsigned char) move;
-			}
-		}
-		hash->data = *data;
-		hash->code = hash_code ^ hash_key(data);
-		ok = (hash->code == (hash_code ^ hash_key(&hash->data)));
-		LOCKFREE_STATS(statistics.n_concurrent_garbage += !ok;)
-		return ok;
-	}
-	return false;
-}
-
-/**
- * @brief Feed hash table (from Cassio).
- *
- * @param hash_table Hash Table.
- * @param hash_code Hash code.
- * @param depth Search depth.
- * @param selectivity Selectivity level.
- * @param lower Alpha bound.
- * @param upper Beta bound.
- * @param move best move.
- */
-void hash_feed(HashTable *hash_table, const unsigned long long hash_code, const int depth, const int selectivity, const int lower, const int upper, const int move)
-{
-	Hash *hash, *worst;
-	int i;
-	int date = hash_table->date ? hash_table->date : 1;
-
-	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	if (hash_reset(hash, hash_code, date, depth, selectivity, lower, upper, move)) return;
-
-	for (i = 1; i < HASH_N_WAY; ++i) {
-		++hash;
-		if (hash_reset(hash, hash_code, date, depth, selectivity, lower, upper, move)) return;
-		if (writeable_level(&worst->data) > writeable_level(&hash->data)) worst = hash;
-	}
-
-	// new entry
-	hash_set(worst, hash_code, date, depth, selectivity, 0, lower, upper, move);
-}
-
-/**
- * @brief Store an hashtable item
- *
- * Find an hash table entry according to the evaluated board hash codes. Then
- * update the entry if it already exists otherwise create a new one. Collisions
- * are managed in such a way that better existing entries are always preserved
- * and the new evaluated data is always added. Lower and  upper score bounds
- * are then updated/set from the alpha, beta and score values according to the
- * following alphabeta property (where alpha < beta):
- *     -if (score >= beta) score is a lower bound of the real score
- *     -if (score <= alpha) score is an upper bound of the real score
- *     -if (alpha < score && score < beta) score equals the real score
- * So:
- *     -if (score < beta) update the upper bound of the hash entry
- *     -if (score > alpha) update the lower bound of the hash entry
- * The best move is also stored, but only if score >= alpha. In case the entry
- * already exists with better data, nothing is stored.
- *
- * @param hash_table Hash table to update.
- * @param hash_code  Hash code of an othello board.
- * @param alpha      Alpha bound when calling the alphabeta function.
- * @param depth      Search depth.
- * @param selectivity   Search selectivity.
- * @param cost       Search cost (i.e. log2(node count)).
- * @param beta       Beta bound when calling the alphabeta function.
- * @param score      Best score found.
- * @param move       Best move found.
- */
-void hash_store(HashTable *hash_table, const unsigned long long hash_code, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	register int i;
-	Hash *worst, *hash;
-
-	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	if (hash_update(hash, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-
-	for (i = 1; i < HASH_N_WAY; ++i) {
-		++hash;
-		if (hash_update(hash, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-		if (writeable_level(&worst->data) > writeable_level(&hash->data)) worst = hash;
-	}
-
-	hash_new(worst, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-}
-
-/**
- * @brief Store an hashtable item.
- *
- * Does the same as hash_store() except it always store the current search state
- *
- * @param hash_table Hash table to update.
- * @param hash_code  Hash code of an othello board.
- * @param alpha      Alpha bound when calling the alphabeta function.
- * @param depth      Search depth.
- * @param selectivity   Search selectivity.
- * @param cost       Search cost (i.e. log2(node count)).
- * @param beta       Beta bound when calling the alphabeta function.
- * @param score      Best score found.
- * @param move       Best move found.
- */
-void hash_force(HashTable *hash_table, const unsigned long long hash_code, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	register int i;
-	Hash *worst, *hash;
-	
-	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	if (hash_replace(hash, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-	
-	for (i = 1; i < HASH_N_WAY; ++i) {
-		++hash;
-		if (hash_replace(hash, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-		if (writeable_level(&worst->data) > writeable_level(&hash->data)) worst = hash;
-	}
-	
-	hash_new(worst, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-}
-
-/**
- * @brief Find an hash table entry according to the evaluated board hash codes.
- *
- * @param hash_table Hash table.
- * @param hash_code Hash code of an othello board.
- * @param data Output hash data.
- * @return True the board was found, false otherwise.
- */
-bool hash_get(HashTable *hash_table, const unsigned long long hash_code, HashData *data)
-{
-	register int i;
-	const Hash *hash;
-	bool ok = false;
-
-	HASH_STATS(++statistics.n_hash_search;)
-	hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	for (i = 0; i < HASH_N_WAY; ++i) {
-		if ((hash->code ^ hash_key(&hash->data)) == hash_code) {
-			*data = hash->data;
-			ok = ((hash->code ^ hash_key(data)) == hash_code);
-			LOCKFREE_STATS(statistics.n_concurrent_garbage += !ok;)
-			HASH_STATS(++statistics.n_hash_found);
-			return ok && (data->date > 0);
-		}
-		++hash;
-	}
-	*data = HASH_DATA_INIT;
-	return false;
-}
-
-/**
- * @brief Erase an hash table entry.
- *
- * @param hash_table Hash table.
- * @param hash_code Hash code of an othello board.
- * @param move Move to exclude.
- */
-void hash_exclude_move(HashTable *hash_table, const unsigned long long hash_code, const int move)
-{
-	register int i;
-	Hash *hash;
-
-	hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	for (i = 0; i < HASH_N_WAY; ++i) {
-		if ((hash->code ^ hash_key(&hash->data)) == hash_code) {
-			if (hash->data.move[0] == move) hash->data.move[0] = hash->data.move[1];
-			hash->data.move[1] = NOMOVE;
-			hash->data.lower = SCORE_MIN;
-			return;
-		}
-		++hash;
-	}
-}
-
-/**
- * @brief Copy an hastable to another one.
- *
- * @param src Source hash table to copy.
- * @param dest Destination hash table.
- */
-void hash_copy(const HashTable *src, HashTable *dest)
-{
-	register unsigned int i;
-
-	assert(src->hash_mask == dest->hash_mask);
-	info("<hash copy>\n");
-	for (i = 0; i <= src->hash_mask + HASH_N_WAY; ++i) {
-		dest->hash[i] = src->hash[i];
-	}
-	dest->date = src->date;
-}
-
-/**
- * @brief print HashData content.
- *
- * @param data Hash Data
- * @param f Output stream
- */
-void hash_print(const HashData *data, FILE *f)
-{
-	char s_move[4];
-	int p_selectivity[] = {72, 87, 95, 98, 99, 100};
-
-	fprintf(f, "moves = %s, ", move_to_string(data->move[0], WHITE, s_move));
-	fprintf(f, "%s ; ", move_to_string(data->move[1], WHITE, s_move));
-	fprintf(f, "score = [%+02d, %+02d] ; ", data->lower, data->upper);
-	fprintf(f, "level = %2d:%2d:%2d@%3d%%", data->date, data->cost, data->depth, p_selectivity[data->selectivity]);
-}
-
diff --git a/src/hash-lock.c b/src/hash-lock.c
deleted file mode 100644
index 5ee9473e..00000000
--- a/src/hash-lock.c
+++ /dev/null
@@ -1,695 +0,0 @@
-/**
- * @file hash.c
- *
- * @brief Locked transposition table.
- *
- * The hash table is an efficient memory system to remember the previously
- * analysed positions and re-use the collected data when needed.
- * The hash table contains entries of analysed data where the board is uniquely
- * identified through a 64-bit key and the results of the recorded analysis are
- * two score bounds, the level of the analysis and the best move found.
- * The implementation is now a multi-way hashtable. It both tries to keep the
- * deepest records and to always add the latest one.
- * The following implementation may suffer from hash collision: two different
- * positions may share the same hashcode. Fortunately, this is very improbable
- * with hascode on 64 bits, and, thanks to alphabeta robustness, it propagates
- * even less often to the root.
- * When doing parallel search with a shared hashtable, a locked implementation
- * avoid concurrency collisions.
- *
- * @date 1998 - 2012
- * @author Richard Delorme
- * @version 4.4
- */
-
-#include "bit.h"
-#include "hash.h"
-#include "options.h"
-#include "stats.h"
-#include "search.h"
-#include "util.h"
-#include "settings.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-
-/** hashing global data */
-unsigned long long hash_rank[16][256];
-
-/** hashing global data */
-unsigned long long hash_move[64][60];
-
-/** HashData init value */
-const HashData HASH_DATA_INIT = {0, 0, 0, 0, -SCORE_INF, SCORE_INF, {NOMOVE, NOMOVE}};
-
-/**
- * @brief Initialize global hash code data.
- */
-void hash_code_init(void)
-{
-	int i, j;
-	Random r;
-
-	random_seed(&r, 0x5DEECE66Dull);
-	for (i = 0; i < 16; ++i)
-	for (j = 0; j < 256; ++j) {
-		do {
-			hash_rank[i][j] = random_get(&r);
-		} while (bit_count(hash_rank[i][j]) < 8); 
-	}
-}
-
-
-/**
- * @brief Initialize global hash move data.
- */
-void hash_move_init(void)
-{
-	int i, j;
-	Random r;
-
-	random_seed(&r, 0x5DEECE66Dull);
-	for (i = 0; i < 64; ++i)
-	for (j = 0; j < 60; ++j) {
-		do {
-			hash_move[i][j] = random_get(&r);
-		} while (bit_count(hash_move[i][j]) < 8); 
-	}
-}
-
-/**
- * @brief Initialise the hashtable.
- *
- * Allocate the hash table entries and initialise the hash masks.
- *
- * @param hash_table Hash table to setup.
- * @param size Requested size for the hash table in number of bits.
- */
-void hash_init(HashTable *hash_table, const int size)
-{
-	int i, n_way;
-
-	for (n_way = 1; n_way < HASH_N_WAY; n_way <<= 1);
-
-	assert(hash_table != NULL && size > 0);
-	assert((n_way & -n_way) == n_way);
-
-	info("< init hashtable of %u entries>\n", size);
-	if (hash_table->hash != NULL) free(hash_table->memory);
-	hash_table->memory = malloc((size + n_way + 1) * sizeof (Hash));
-	if (hash_table->memory == NULL) {
-		fatal_error("hash_init: cannot allocate the hash table\n");
-	}
-
-	if (HASH_ALIGNED) {
-		const size_t alignment = n_way * sizeof (Hash) - 1;
-		hash_table->hash = (Hash*) (((size_t) hash_table->memory + alignment) & ~alignment);
-		hash_table->hash_mask = size - n_way;
-	} else {
-		hash_table->hash = (Hash*) hash_table->memory;
-		hash_table->hash_mask = size - 1;
-	}
-
-	for (hash_table->size = 1; (1 << hash_table->size) < size; ++hash_table->size);
-
-	hash_cleanup(hash_table);
-
-	hash_table->n_lock = 256 * MAX(get_cpu_number(), 1);
-	hash_table->lock_mask = hash_table->n_lock - 1;
-	hash_table->n_lock += n_way + 1;
-	hash_table->lock = (HashLock*) malloc(hash_table->n_lock * sizeof (HashLock));
-
-	for (i = 0; i < hash_table->n_lock; ++i) spin_init(hash_table->lock + i);
-}
-
-/**
- * @brief Clear the hashtable.
- *
- * Set all hash table entries to zero.
- * @param hash_table Hash table to clear.
- */
-void hash_cleanup(HashTable *hash_table)
-{
-	register unsigned int i;
-
-	assert(hash_table != NULL && hash_table->hash != NULL);
-
-	info("< cleaning hashtable >\n");
-	for (i = 0; i <= hash_table->hash_mask + HASH_N_WAY; ++i) {
-		hash_table->hash[i].code = 0;
-		hash_table->hash[i].data = HASH_DATA_INIT;
-	}
-	hash_table->date = 0;
-}
-
-/**
- * @brief Clear the hashtable.
- *
- * Change the date of the hash table.
- * @param hash_table Hash table to clear.
- */
-void hash_clear(HashTable *hash_table)
-{
-	assert(hash_table != NULL);
-
-	if (hash_table->date == 127) hash_cleanup(hash_table);
-	++hash_table->date;
-	info("< clearing hashtable -> date = %d>\n", hash_table->date);
-	assert(hash_table->date > 0 && hash_table->date <= 127);
-}
-
-/**
- * @brief Free the hashtable.
- *
- * Free the memory allocated by the hash table entries
- * @param hash_table hash_table to free.
- */
-void hash_free(HashTable *hash_table)
-{
-	int i;
-	assert(hash_table != NULL && hash_table->hash != NULL);
-	free(hash_table->memory);
-	hash_table->hash = NULL;
-	for (i = 0; i < hash_table->n_lock; ++i) spin_free(hash_table->lock + i);
-	free(hash_table->lock);
-}
-
-/**
- * @brief make a level from date, cost, depth & selectivity.
- *
- * @param data Hash data.
- * @return A level.
- */
-inline unsigned int writeable_level(HashData *data)
-{
-	if (USE_TYPE_PUNING) { // HACK: depends on little endian.
-		return (*(unsigned int*) data);
-	} else { // slow but more portable implementation.
-		return (((unsigned)data->date) << 24) + (((unsigned)data->cost) << 16) + (data->selectivity << 8) + data->depth;
-	}
-}
-
-/**
- * @brief update an hash table item.
- *
- * This is done when the level is the same as the previous storage.
- * Best moves & bound scores are updated, other data are untouched.
- *
- * @param data Hash Data.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void data_update(HashData *data, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	if (score < beta && score < data->upper) data->upper = (signed char) score;
-	if (score > alpha && score > data->lower) data->lower = (signed char) score;
-	if ((score > alpha || score == SCORE_MIN) && data->move[0] != move) {
-		data->move[1] = data->move[0];
-		data->move[0] = (unsigned char) move;
-	}
-	data->cost = (unsigned char) MAX(cost, data->cost);
-	HASH_STATS(++statistics.n_hash_update;)
-}
-
-/**
- * @brief Upgrade an hash table data item.
- *
- * Upgrade is done when the search level increases.
- * Best moves are updated, others data are reset to new value.
- *
- * @param data Hash Data.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void data_upgrade(HashData *data, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	if (score < beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
-	if (score > alpha) data->lower =(signed char) score; else data->lower = SCORE_MIN;
-	if ((score > alpha || score == SCORE_MIN) && data->move[0] != move) {
-		data->move[1] = data->move[0];
-		data->move[0] = (unsigned char) move;
-	}
-	data->depth = depth;
-	data->selectivity = selectivity;
-	data->cost = (unsigned char) MAX(cost, data->cost);  // this may not work well in parallel search.
-	HASH_STATS(++statistics.n_hash_upgrade;)
-
-	assert(data->upper >= data->lower);
-}
-
-/**
- * @brief Set an hash table data item.
- *
- * @param data Hash Data.
- * @param date Search Date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void data_new(HashData *data, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	if (score < beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
-	if (score > alpha) data->lower = (signed char) score; else data->lower = SCORE_MIN;
-	if (score > alpha || score == SCORE_MIN) data->move[0] = (unsigned char) move;
-	else data->move[0] = NOMOVE;
-	data->move[1] = NOMOVE;
-	data->depth = depth;
-	data->selectivity = selectivity;
-	data->cost = cost;
-	data->date = date;
-	assert(data->upper >= data->lower);
-}
-
-/**
- * @brief Initialize a new hash table item.
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost.
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- */
-static void hash_new(Hash *hash, HashLock *lock, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	spin_lock(lock);
-	HASH_STATS(if (date == hash->data.date) ++statistics.n_hash_remove;)
-	HASH_STATS(++statistics.n_hash_new;)
-	hash->code = hash_code;
-	data_new(&hash->data, date, depth, selectivity, cost, alpha, beta, score, move);
-	spin_unlock(lock);
-}
-
-/**
- * @brief Set a new hash table item.
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost.
- * @param lower Lower score bound.
- * @param upper Upper score bound.
- * @param move Best move.
- */
-void hash_set(Hash *hash, HashLock *lock, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int lower, const int upper, const int move)
-{
-	spin_lock(lock);
-	HASH_STATS(if (date == hash->data.date) ++statistics.n_hash_remove;)
-	HASH_STATS(++statistics.n_hash_new;)
-	hash->code = hash_code;
-	hash->data.upper = (signed char) upper;
-	hash->data.lower = (signed char) lower;
-	hash->data.move[0] = (unsigned char) move;
-	hash->data.move[1] = NOMOVE;
-	hash->data.depth = (unsigned char) depth;
-	hash->data.selectivity = (unsigned char) selectivity;
-	hash->data.cost = (unsigned char) cost;
-	hash->data.date = (unsigned char) date;
-	assert(hash->data.upper >= hash->data.lower);
-	spin_unlock(lock);
-}
-
-
-/**
- * @brief update the hash entry
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Hash Cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- * @return true if an entry has been updated, false otherwise.
- */
-static bool hash_update(Hash *hash, HashLock *lock, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	bool ok;
-	HashData *data;
-
-	if (hash->code == hash_code) {
-		spin_lock(lock);
-		ok = (hash->code == hash_code);
-		if (ok) {
-			data = &hash->data;
-			if (data->selectivity == selectivity && data->depth == depth) data_update(data, cost, alpha, beta, score, move);
-			else data_upgrade(data, depth, selectivity, cost, alpha, beta, score, move);
-			data->date = (unsigned char) date;
-			if (data->lower > data->upper) { // reset the hash-table...
-				data_new(data, date, depth, selectivity, cost, alpha, beta, score, move);
-			}
-		} 
-		spin_unlock(lock);
-		return ok;
-	}
-	return false;
-}
-
-/**
- * @brief replace the hash entry.
- *
- * This implementation tries to be robust against concurrency. Data are first
- * set up in a local thread-safe structure, before being copied into the
- * hashtable entry. Then the hashcode of the entry is xored with the thread
- * safe structure ; so that any corrupted entry won't be readable.
- *
- * @param hash Hash Entry.
- * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Hash Cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
- * @return true if an entry has been replaced, false otherwise.
- */
-static bool hash_replace(Hash *hash, HashLock *lock, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	bool ok;
-	
-	if (hash->code == hash_code) {
-		spin_lock(lock);
-		ok = (hash->code == hash_code);
-		if (ok) {
-			data_new(&hash->data, date, depth, selectivity, cost, alpha, beta, score, move);
-		}
-		spin_unlock(lock);		
-		return ok;
-	}
-	return false;
-}
-
-/**
- * @brief Reset an hash entry from new data values.
- *
- * @param hash Hash Entry.
- * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param lower Lower score bound.
- * @param upper Upper score bound.
- * @param move Best move.
- */
-static bool hash_reset(Hash *hash, HashLock *lock, const unsigned long long hash_code, const int date, const int depth, const int selectivity, const int lower, const int upper, const int move)
-{
-	bool ok;
-	HashData *data;
-	
-	if (hash->code == hash_code) {
-		spin_lock(lock);
-		ok = (hash->code == hash_code);
-		if (ok) {
-			data = &hash->data;
-			if (data->selectivity == selectivity && data->depth == depth) {
-				if (data->lower < lower) data->lower = (signed char) lower;
-				if (data->upper > upper) data->upper = (signed char) upper;
-			} else {
-				data->depth = (unsigned char) depth;
-				data->selectivity = (unsigned char) selectivity;
-				data->lower = (signed char) lower;
-				data->upper = (signed char) upper;		
-			}
-			data->cost = 0;
-			data->date = (unsigned char) date;
-			if (move != NOMOVE) {
-				if (data->move[0] != move) {
-					data->move[1] = data->move[0];
-					data->move[0] = (unsigned char) move;
-				} else {
-					data->move[1] = (unsigned char) move;
-				}
-			}
-		}
-		spin_unlock(lock);
-		return ok;
-	}
-	return false;
-}
-
-
-/**
- * @brief feed hash table (from Cassio).
- *
- * @param hash_table Hash Table.
- * @param hash_code Hash code.
- * @param depth Search depth.
- * @param selectivity Selectivity level.
- * @param lower Alpha bound.
- * @param upper Beta bound.
- * @param move best move.
- */
-void hash_feed(HashTable *hash_table, const unsigned long long hash_code, const int depth, const int selectivity, const int lower, const int upper, const int move)
-{
-	Hash *hash, *worst;
-	HashLock *lock, *w_lock; 
-	int i;
-	int date = hash_table->date ? hash_table->date : 1;
-
-	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	w_lock = lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	if (hash_reset(hash, lock, hash_code, date, depth, selectivity, lower, upper, move)) return;
-
-	for (i = 1; i < HASH_N_WAY; ++i) {
-		++hash; ++lock;
-		if (hash_reset(hash, lock, hash_code, date, depth, selectivity, lower, upper, move)) return;
-		if (writeable_level(&worst->data) > writeable_level(&hash->data)) {
-			worst = hash;
-			w_lock = lock;
-		}
-	}
-
-	// new entry
-	hash_set(worst, w_lock, hash_code, date, depth, selectivity, 0, lower, upper, move);
-}
-
-/**
- * @brief Store an hashtable item
- *
- * Find an hash table entry according to the evaluated board hash codes. Then
- * update the entry if it already exists otherwise create a new one. Collisions
- * are managed in such a way that better existing entries are always preserved
- * and the new evaluated data is always added. Lower and  upper score bounds
- * are then updated/set from the alpha, beta and score values according to the
- * following alphabeta property (where alpha < beta):
- *     -if (score >= beta) score is a lower bound of the real score
- *     -if (score <= alpha) score is an upper bound of the real score
- *     -if (alpha < score && score < beta) score equals the real score
- * So:
- *     -if (score < beta) update the upper bound of the hash entry
- *     -if (score > alpha) update the lower bound of the hash entry
- * The best move is also stored, but only if score >= alpha. In case the entry
- * already exists with better data, nothing is stored.
- *
- * @param hash_table Hash table to update.
- * @param hash_code  Hash code of an othello board.
- * @param alpha      Alpha bound when calling the alphabeta function.
- * @param depth      Search depth.
- * @param selectivity   Search selectivity.
- * @param cost       Search cost (i.e. log2(node count)).
- * @param beta       Beta bound when calling the alphabeta function.
- * @param score      Best score found.
- * @param move       Best move found.
- */
-void hash_store(HashTable *hash_table, const unsigned long long hash_code, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	register int i;
-	Hash *worst, *hash;
-	HashLock *lock, *w_lock;
-
-	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	w_lock = lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	if (hash_update(hash, lock, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-
-	for (i = 1; i < HASH_N_WAY; ++i) {
-		++hash; ++lock;
-		if (hash_update(hash, lock, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-		if (writeable_level(&worst->data) > writeable_level(&hash->data)) {
-			worst = hash;
-			w_lock = lock;
-		}
-	}
-
-	hash_new(worst, w_lock, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-}
-
-/**
- * @brief Store an hashtable item.
- *
- * Does the same as hash_store() except it always store the current search state
- *
- * @param hash_table Hash table to update.
- * @param hash_code  Hash code of an othello board.
- * @param alpha      Alpha bound when calling the alphabeta function.
- * @param depth      Search depth.
- * @param selectivity   Search selectivity.
- * @param cost       Search cost (i.e. log2(node count)).
- * @param beta       Beta bound when calling the alphabeta function.
- * @param score      Best score found.
- * @param move       Best move found.
- */
-void hash_force(HashTable *hash_table, const unsigned long long hash_code, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-{
-	register int i;
-	Hash *worst, *hash;
-	HashLock *lock, *w_lock;
-	
-	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	w_lock = lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	if (hash_replace(hash, lock, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-	
-	for (i = 1; i < HASH_N_WAY; ++i) {
-		++hash; ++lock;
-		if (hash_replace(hash, lock, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-		if (writeable_level(&worst->data) > writeable_level(&hash->data)) {
-			worst = hash;
-			w_lock = lock;
-		}
-	}
-	
-	hash_new(worst, w_lock, hash_code, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-}
-
-/**
- * @brief Find an hash table entry according to the evaluated board hash codes.
- *
- * @param hash_table Hash table.
- * @param hash_code Hash code of an othello board.
- * @param data Output hash data.
- * @return True the board was found, false otherwise.
- */
-bool hash_get(HashTable *hash_table, const unsigned long long hash_code, HashData *data)
-{
-	register int i;
-	const Hash *hash;
-	HashLock *lock;
-	bool ok = false;
-
-	HASH_STATS(++statistics.n_hash_search;)
-	hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	for (i = 0; i < HASH_N_WAY; ++i) {
-		if (hash->code == hash_code) {
-			spin_lock(lock);
-			ok = (hash->code == hash_code);
-			if (ok) {
-				*data = hash->data;
-			}			
-			spin_unlock(lock);		
-			return ok && (data->date > 0);
-		}
-		++hash; ++lock;
-	}
-	*data = HASH_DATA_INIT;
-	return false;
-}
-
-/**
- * @brief Erase an hash table entry.
- *
- * @param hash_table Hash table.
- * @param hash_code Hash code of an othello board.
- * @param move Move to exclude.
- */
-void hash_exclude_move(HashTable *hash_table, const unsigned long long hash_code, const int move)
-{
-	register int i;
-	Hash *hash;
-	HashLock *lock;
-
-	hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	for (i = 0; i < HASH_N_WAY; ++i) {
-		if (hash->code == hash_code) {
-			spin_lock(lock);
-			if (hash->code == hash_code) {
-				if (hash->data.move[0] == move) hash->data.move[0] = hash->data.move[1];
-				hash->data.move[1] = NOMOVE;
-				hash->data.lower = SCORE_MIN;
-			}
-			spin_unlock(lock);
-			return;
-		}
-		++hash; ++lock;
-	}
-}
-
-/**
- * @brief Copy an hastable to another one.
- *
- * @param src Source hash table to copy.
- * @param dest Destination hash table.
- */
-void hash_copy(const HashTable *src, HashTable *dest)
-{
-	register unsigned int i;
-
-	assert(src->hash_mask == dest->hash_mask);
-	info("<hash copy>\n");
-	for (i = 0; i <= src->hash_mask + HASH_N_WAY; ++i) {
-		dest->hash[i] = src->hash[i];
-	}
-	dest->date = src->date;
-}
-
-/**
- * @brief print HashData content.
- *
- * @param data Hash Data
- * @param f Output stream
- */
-void hash_print(const HashData *data, FILE *f)
-{
-	char s_move[4];
-	int p_selectivity[] = {72, 87, 95, 98, 99, 100};
-
-	fprintf(f, "moves = %s, ", move_to_string(data->move[0], WHITE, s_move));
-	fprintf(f, "%s ; ", move_to_string(data->move[1], WHITE, s_move));
-	fprintf(f, "score = [%+02d, %+02d] ; ", data->lower, data->upper);
-	fprintf(f, "level = %2d:%2d:%2d@%3d%%", data->date, data->cost, data->depth, p_selectivity[data->selectivity]);
-}
-
diff --git a/src/hash.c b/src/hash.c
index 2c719ba7..2384d12c 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -14,9 +14,9 @@
  * When doing parallel search with a shared hashtable, a locked implementation
  * avoid concurrency collisions.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "bit.h"
@@ -31,49 +31,8 @@
 #include <stdio.h>
 #include <assert.h>
 
-/** hashing global data */
-unsigned long long hash_rank[16][256];
-
-/** hashing global data */
-unsigned long long hash_move[64][60];
-
 /** HashData init value */
-const HashData HASH_DATA_INIT = {0, 0, 0, 0, -SCORE_INF, SCORE_INF, {NOMOVE, NOMOVE}};
-
-/**
- * @brief Initialize global hash code data.
- */
-void hash_code_init(void)
-{
-	int i, j;
-	Random r;
-
-	random_seed(&r, 0x5DEECE66Dull);
-	for (i = 0; i < 16; ++i)
-	for (j = 0; j < 256; ++j) {
-		do {
-			hash_rank[i][j] = random_get(&r);
-		} while (bit_count(hash_rank[i][j]) < 8); 
-	}
-}
-
-
-/**
- * @brief Initialize global hash move data.
- */
-void hash_move_init(void)
-{
-	int i, j;
-	Random r;
-
-	random_seed(&r, 0x5DEECE66Dull);
-	for (i = 0; i < 64; ++i)
-	for (j = 0; j < 60; ++j) {
-		do {
-			hash_move[i][j] = random_get(&r);
-		} while (bit_count(hash_move[i][j]) < 8); 
-	}
-}
+const HashData HASH_DATA_INIT = {{{ 0, 0, 0, 0 }}, -SCORE_INF, SCORE_INF, { NOMOVE, NOMOVE }};
 
 /**
  * @brief Initialise the hashtable.
@@ -87,7 +46,7 @@ void hash_init(HashTable *hash_table, const unsigned long long size)
 {
 	int i, n_way;
 
-	for (n_way = 1; n_way < HASH_N_WAY; n_way <<= 1);
+	for (n_way = 1; n_way < HASH_N_WAY; n_way <<= 1);	// round up HASH_N_WAY to 2 ^ n
 
 	assert(hash_table != NULL);
 	assert((n_way & -n_way) == n_way);
@@ -100,7 +59,8 @@ void hash_init(HashTable *hash_table, const unsigned long long size)
 	}
 
 	if (HASH_ALIGNED) {
-		const size_t alignment = n_way * sizeof (Hash) - 1;
+		size_t alignment = n_way * sizeof (Hash);	// (4 * 24)
+		alignment = (alignment & -alignment) - 1;	// LS1B - 1 (0x1f)
 		hash_table->hash = (Hash*) (((size_t) hash_table->memory + alignment) & ~alignment);
 		hash_table->hash_mask = size - n_way;
 	} else {
@@ -110,9 +70,9 @@ void hash_init(HashTable *hash_table, const unsigned long long size)
 
 	hash_cleanup(hash_table);
 
-	hash_table->n_lock = 256 * MAX(get_cpu_number(), 1);
+	hash_table->n_lock = 1 << (31 - lzcnt_u32(get_cpu_number() | 1) + 8);	// round down to 2 ^ n, then * 256
 	hash_table->lock_mask = hash_table->n_lock - 1;
-	hash_table->n_lock += n_way + 1;
+	// hash_table->n_lock += n_way + 1;
 	hash_table->lock = (HashLock*) malloc(hash_table->n_lock * sizeof (HashLock));
 
 	for (i = 0; i < hash_table->n_lock; ++i) spin_init(hash_table->lock + i);
@@ -126,15 +86,46 @@ void hash_init(HashTable *hash_table, const unsigned long long size)
  */
 void hash_cleanup(HashTable *hash_table)
 {
-	register unsigned int i;
+	unsigned int i = 0, imax = hash_table->hash_mask + HASH_N_WAY;
+	Hash *pHash = hash_table->hash;
 
 	assert(hash_table != NULL && hash_table->hash != NULL);
 
 	info("< cleaning hashtable >\n");
-	for (i = 0; i <= hash_table->hash_mask + HASH_N_WAY; ++i) {
-		HASH_COLLISIONS(hash_table->hash[i].key = 0;)
-		hash_table->hash[i].board.player = hash_table->hash[i].board.opponent = 0; 
-		hash_table->hash[i].data = HASH_DATA_INIT;
+
+  #if defined(hasSSE2) || defined(USE_MSVC_X86)
+	if (hasSSE2 && (sizeof(Hash) == 24) && (((size_t) pHash & 0x1f) == 0) && (imax >= 7)) {
+		for (; i < 4; ++i, ++pHash) {
+			HASH_COLLISIONS(pHash->key = 0;)
+			pHash->board.player = pHash->board.opponent = 0;
+			pHash->data = HASH_DATA_INIT;
+		}
+    #ifdef __AVX__
+		__m256i d0 = _mm256_load_si256((__m256i *)(pHash - 4));
+		__m256i d1 = _mm256_load_si256((__m256i *)(pHash - 4) + 1);
+		__m256i d2 = _mm256_load_si256((__m256i *)(pHash - 4) + 2);
+		for (i = 4; i <= imax - 3; i += 4, pHash += 4) {
+			_mm256_stream_si256((__m256i *) pHash, d0);
+			_mm256_stream_si256((__m256i *) pHash + 1, d1);
+			_mm256_stream_si256((__m256i *) pHash + 2, d2);
+		}
+    #else
+		__m128i d0 = _mm_load_si128((__m128i *)(pHash - 4));
+		__m128i d1 = _mm_load_si128((__m128i *)(pHash - 4) + 1);
+		__m128i d2 = _mm_load_si128((__m128i *)(pHash - 4) + 2);
+		for (i = 4; i <= imax - 1; i += 2, pHash += 2) {
+			_mm_stream_si128((__m128i *) pHash, d0);
+			_mm_stream_si128((__m128i *) pHash + 1, d1);
+			_mm_stream_si128((__m128i *) pHash + 2, d2);
+		}
+    #endif
+		_mm_sfence();
+	}
+  #endif
+	for (; i <= imax; ++i, ++pHash) {
+		HASH_COLLISIONS(pHash->key = 0;)
+		pHash->board.player = pHash->board.opponent = 0; 
+		pHash->data = HASH_DATA_INIT;
 	}
 	hash_table->date = 0;
 }
@@ -164,6 +155,7 @@ void hash_clear(HashTable *hash_table)
 void hash_free(HashTable *hash_table)
 {
 	int i;
+
 	assert(hash_table != NULL && hash_table->hash != NULL);
 	free(hash_table->memory);
 	hash_table->hash = NULL;
@@ -179,11 +171,11 @@ void hash_free(HashTable *hash_table)
  */
 inline unsigned int writeable_level(HashData *data)
 {
-	if (USE_TYPE_PUNING) { // HACK: depends on little endian.
-		return (*(unsigned int*) data);
-	} else { // slow but more portable implementation.
-		return (((unsigned)data->date) << 24) + (((unsigned)data->cost) << 16) + (data->selectivity << 8) + data->depth;
-	}
+#if USE_TYPE_PUNING	// HACK
+	return (data->wl.ui);
+#else	// slow but more portable implementation.
+	return (data->wl.c.date << 24) + (data->wl.c.cost << 16) + (data->wl.c.selectivity << 8) + data->wl.c.depth;
+#endif
 }
 
 /**
@@ -193,21 +185,23 @@ inline unsigned int writeable_level(HashData *data)
  * Best moves & bound scores are updated, other data are untouched.
  *
  * @param data Hash Data.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
+ * @param storedata.data.cost Search cost (log2(node count)).
+ * @param storedata.alpha Alpha bound.
+ * @param storedata.beta Beta bound.
+ * @param storedata.score Best score.
+ * @param storedata.move Best move.
  */
-static void data_update(HashData *data, const int cost, const int alpha, const int beta, const int score, const int move)
+static void data_update(HashData *data, HashStoreData *storedata)
 {
-	if (score < beta && score < data->upper) data->upper = (signed char) score;
-	if (score > alpha && score > data->lower) data->lower = (signed char) score;
-	if ((score > alpha || score == SCORE_MIN) && data->move[0] != move) {
+	int score = storedata->score;
+
+	if (score < storedata->beta && score < data->upper) data->upper = (signed char) score;
+	if (score > storedata->alpha && score > data->lower) data->lower = (signed char) score;
+	if ((score > storedata->alpha || score == SCORE_MIN) && data->move[0] != storedata->data.move[0]) {
 		data->move[1] = data->move[0];
-		data->move[0] = (unsigned char) move;
+		data->move[0] = storedata->data.move[0];
 	}
-	data->cost = (unsigned char) MAX(cost, data->cost);
+	data->wl.c.cost = (unsigned char) MAX(storedata->data.wl.c.cost, data->wl.c.cost);
 	HASH_STATS(++statistics.n_hash_update;)
 }
 
@@ -218,25 +212,26 @@ static void data_update(HashData *data, const int cost, const int alpha, const i
  * Best moves are updated, others data are reset to new value.
  *
  * @param data Hash Data.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.cost Search cost (log2(node count)).
+ * @param storedata.alpha Alpha bound.
+ * @param storedata.beta Beta bound.
+ * @param storedata.score Best score.
+ * @param storedata.move Best move.
  */
-static void data_upgrade(HashData *data, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
+static void data_upgrade(HashData *data, HashStoreData *storedata)
 {
-	if (score < beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
-	if (score > alpha) data->lower =(signed char) score; else data->lower = SCORE_MIN;
-	if ((score > alpha || score == SCORE_MIN) && data->move[0] != move) {
+	int score = storedata->score;
+
+	if (score < storedata->beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
+	if (score > storedata->alpha) data->lower = (signed char) score; else data->lower = SCORE_MIN;
+	if ((score > storedata->alpha || score == SCORE_MIN) && data->move[0] != storedata->data.move[0]) {
 		data->move[1] = data->move[0];
-		data->move[0] = (unsigned char) move;
+		data->move[0] = storedata->data.move[0];
 	}
-	data->depth = depth;
-	data->selectivity = selectivity;
-	data->cost = (unsigned char) MAX(cost, data->cost);  // this may not work well in parallel search.
+	data->wl.us.selectivity_depth = storedata->data.wl.us.selectivity_depth;
+	data->wl.c.cost = (unsigned char) MAX(storedata->data.wl.c.cost, data->wl.c.cost);  // this may not work well in parallel search.
 	HASH_STATS(++statistics.n_hash_upgrade;)
 
 	assert(data->upper >= data->lower);
@@ -246,26 +241,25 @@ static void data_upgrade(HashData *data, const int depth, const int selectivity,
  * @brief Set an hash table data item.
  *
  * @param data Hash Data.
- * @param date Search Date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
+ * @param storedata.data.date Search Date.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.cost Search cost (log2(node count)).
+ * @param storedata.alpha Alpha bound.
+ * @param storedata.beta Beta bound.
+ * @param storedata.score Best score.
+ * @param storedata.move Best move.
  */
-static void data_new(HashData *data, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
+static void data_new(HashData *data, HashStoreData *storedata)
 {
-	if (score < beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
-	if (score > alpha) data->lower = (signed char) score; else data->lower = SCORE_MIN;
-	if (score > alpha || score == SCORE_MIN) data->move[0] = (unsigned char) move;
+	int score = storedata->score;
+
+	if (score < storedata->beta) data->upper = (signed char) score; else data->upper = SCORE_MAX;
+	if (score > storedata->alpha) data->lower = (signed char) score; else data->lower = SCORE_MIN;
+	if (score > storedata->alpha || score == SCORE_MIN) data->move[0] = storedata->data.move[0];
 	else data->move[0] = NOMOVE;
 	data->move[1] = NOMOVE;
-	data->depth = depth;
-	data->selectivity = selectivity;
-	data->cost = cost;
-	data->date = date;
+	data->wl = storedata->data.wl;
 	assert(data->upper >= data->lower);
 }
 
@@ -280,27 +274,23 @@ static void data_new(HashData *data, const int date, const int depth, const int
  * @param hash Hash Entry.
  * @param lock Lock.
  * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost.
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
+ * @param storedata.data.date Hash date.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.cost Search cost.
+ * @param storedata.alpha Alpha bound.
+ * @param storedata.beta Beta bound.
+ * @param storedata.score Best score.
+ * @param storedata.move Best move.
  */
-#if (HASH_COLLISIONS(1)+0)
-static void hash_new(Hash *hash, HashLock *lock, const unsigned long long hash_code, const Board* board, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-#else
-static void hash_new(Hash *hash, HashLock *lock, const Board* board, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
-#endif
+static void hash_new(Hash *hash, HashLock *lock, const Board *board, HashStoreData *storedata)
 {
 	spin_lock(lock);
 	HASH_STATS(if (date == hash->data.date) ++statistics.n_hash_remove;)
 	HASH_STATS(++statistics.n_hash_new;)
-	HASH_COLLISIONS(hash->key = hash_code;)
+	HASH_COLLISIONS(hash->key = storedata->hash_code;)
 	hash->board = *board;
-	data_new(&hash->data, date, depth, selectivity, cost, alpha, beta, score, move);
+	data_new(&hash->data, storedata);
 	spin_unlock(lock);
 }
 
@@ -314,34 +304,24 @@ static void hash_new(Hash *hash, HashLock *lock, const Board* board, const int d
  *
  * @param hash Hash Entry.
  * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Search cost.
- * @param lower Lower score bound.
- * @param upper Upper score bound.
- * @param move Best move.
+ * @param board Bitboard.
+ * @param storedata.data.date Hash date.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.cost Search cost.
+ * @param storedata.data.lower Lower score bound.
+ * @param storedata.data.upper Upper score bound.
+ * @param storedata.move Best move.
  */
-#if (HASH_COLLISIONS(1)+0)
-static void hash_set(Hash *hash, HashLock *lock, const unsigned long long hash_code, const Board *board, const int date, const int depth, const int selectivity, const int cost, const int lower, const int upper, const int move)
-#else
-static void hash_set(Hash *hash, HashLock *lock, const Board *board, const int date, const int depth, const int selectivity, const int cost, const int lower, const int upper, const int move)
-#endif
+static void hash_set(Hash *hash, HashLock *lock, const Board *board, HashStoreData *storedata)
 {
+	storedata->data.move[1] = NOMOVE;
 	spin_lock(lock);
 	HASH_STATS(if (date == hash->data.date) ++statistics.n_hash_remove;)
 	HASH_STATS(++statistics.n_hash_new;)
-	HASH_COLLISIONS(hash->key = hash_code;)
+	HASH_COLLISIONS(hash->key = storedata->hash_code;)
 	hash->board = *board;
-	hash->data.upper = (signed char) upper;
-	hash->data.lower = (signed char) lower;
-	hash->data.move[0] = (unsigned char) move;
-	hash->data.move[1] = NOMOVE;
-	hash->data.depth = (unsigned char) depth;
-	hash->data.selectivity = (unsigned char) selectivity;
-	hash->data.cost = (unsigned char) cost;
-	hash->data.date = (unsigned char) date;
+	hash->data = storedata->data;
 	assert(hash->data.upper >= hash->data.lower);
 	spin_unlock(lock);
 }
@@ -357,31 +337,30 @@ static void hash_set(Hash *hash, HashLock *lock, const Board *board, const int d
  *
  * @param hash Hash Entry.
  * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Hash Cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
+ * @param board Bitboard.
+ * @param storedata.data.date Hash date.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.cost Hash Cost (log2(node count)).
+ * @param storedata.alpha Alpha bound.
+ * @param storedata.beta Beta bound.
+ * @param storedata.score Best score.
+ * @param storedata.move Best move.
  * @return true if an entry has been updated, false otherwise.
  */
-static bool hash_update(Hash *hash, HashLock *lock, const Board *board, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
+static bool hash_update(Hash *hash, HashLock *lock, const Board *board, HashStoreData *storedata)
 {
 	bool ok = false;
-	HashData *data;
 
-	if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+	if (board_equal(&hash->board, board)) {
 		spin_lock(lock);
-		if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
-			data = &hash->data;
-			if (data->selectivity == selectivity && data->depth == depth) data_update(data, cost, alpha, beta, score, move);
-			else data_upgrade(data, depth, selectivity, cost, alpha, beta, score, move);
-			data->date = (unsigned char) date;
-			if (data->lower > data->upper) { // reset the hash-table...
-				data_new(data, date, depth, selectivity, cost, alpha, beta, score, move);
+		if (board_equal(&hash->board, board)) {
+			if (hash->data.wl.us.selectivity_depth == storedata->data.wl.us.selectivity_depth)
+				data_update(&hash->data, storedata);
+			else	data_upgrade(&hash->data, storedata);
+			hash->data.wl.c.date = storedata->data.wl.c.date;
+			if (hash->data.lower > hash->data.upper) { // reset the hash-table...
+				data_new(&hash->data, storedata);
 			}
 			ok = true;
 		} 
@@ -400,25 +379,25 @@ static bool hash_update(Hash *hash, HashLock *lock, const Board *board, const in
  *
  * @param hash Hash Entry.
  * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param cost Hash Cost (log2(node count)).
- * @param alpha Alpha bound.
- * @param beta Beta bound.
- * @param score Best score.
- * @param move Best move.
+ * @param board Bitboard.
+ * @param storedata.data.date Hash date.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.cost Hash Cost (log2(node count)).
+ * @param storedata.alpha Alpha bound.
+ * @param storedata.beta Beta bound.
+ * @param storedata.score Best score.
+ * @param storedata.move Best move.
  * @return true if an entry has been replaced, false otherwise.
  */
-static bool hash_replace(Hash *hash, HashLock *lock, const Board *board, const int date, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
+static bool hash_replace(Hash *hash, HashLock *lock, const Board *board, HashStoreData *storedata)
 {
 	bool ok = false;
-	
-	if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+
+	if (board_equal(&hash->board, board)) {
 		spin_lock(lock);
-		if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
-			data_new(&hash->data, date, depth, selectivity, cost, alpha, beta, score, move);
+		if (board_equal(&hash->board, board)) {
+			data_new(&hash->data, storedata);
 			ok = true;
 		}
 		spin_unlock(lock);
@@ -431,41 +410,36 @@ static bool hash_replace(Hash *hash, HashLock *lock, const Board *board, const i
  *
  * @param hash Hash Entry.
  * @param lock Lock.
- * @param hash_code Hash code.
- * @param date Hash date.
- * @param depth Search depth.
- * @param selectivity Search selectivity.
- * @param lower Lower score bound.
- * @param upper Upper score bound.
- * @param move Best move.
+ * @param board Bitboard.
+ * @param storedata.data.date Hash date.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Search selectivity.
+ * @param storedata.data.lower Lower score bound.
+ * @param storedata.data.upper Upper score bound.
+ * @param storedata.move Best move.
  */
-static bool hash_reset(Hash *hash, HashLock *lock, const Board *board, const int date, const int depth, const int selectivity, const int lower, const int upper, const int move)
+static bool hash_reset(Hash *hash, HashLock *lock, const Board *board, HashStoreData *storedata)
 {
 	bool ok = false;
-	HashData *data;
-	
-	if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+
+	if (board_equal(&hash->board, board)) {
 		spin_lock(lock);
-		if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
-			data = &hash->data;
-			if (data->selectivity == selectivity && data->depth == depth) {
-				if (data->lower < lower) data->lower = (signed char) lower;
-				if (data->upper > upper) data->upper = (signed char) upper;
+		if (board_equal(&hash->board, board)) {
+			if (hash->data.wl.us.selectivity_depth == storedata->data.wl.us.selectivity_depth) {
+				if (hash->data.lower < storedata->data.lower) hash->data.lower = storedata->data.lower;
+				if (hash->data.upper > storedata->data.upper) hash->data.upper = storedata->data.upper;
 			} else {
-				data->depth = (unsigned char) depth;
-				data->selectivity = (unsigned char) selectivity;
-				data->lower = (signed char) lower;
-				data->upper = (signed char) upper;		
+				hash->data.lower = storedata->data.lower;
+				hash->data.upper = storedata->data.upper;
 			}
-			data->cost = 0;
-			data->date = (unsigned char) date;
-			if (move != NOMOVE) {
-				if (data->move[0] != move) {
-					data->move[1] = data->move[0];
-					data->move[0] = (unsigned char) move;
-				} else {
-					data->move[1] = (unsigned char) move;
-				}
+			hash->data.wl = storedata->data.wl;
+			if (storedata->data.move[0] != NOMOVE) {
+				// if (hash->data.move[0] != storedata->data.move[0]) {
+					hash->data.move[1] = hash->data.move[0];
+					hash->data.move[0] = storedata->data.move[0];
+				// } else {
+				//	hash->data.move[1] = storedata->data.move[0];
+				// }
 			}
 			ok = true;
 		}
@@ -474,43 +448,41 @@ static bool hash_reset(Hash *hash, HashLock *lock, const Board *board, const int
 	return ok;
 }
 
-
 /**
  * @brief feed hash table (from Cassio).
  *
  * @param hash_table Hash Table.
- * @param hash_code Hash code.
- * @param depth Search depth.
- * @param selectivity Selectivity level.
- * @param lower Alpha bound.
- * @param upper Beta bound.
- * @param move best move.
+ * @param board Bitboard.
+ * @param storedata.data.depth Search depth.
+ * @param storedata.data.selectivity Selectivity level.
+ * @param storedata.data.lower Alpha bound.
+ * @param storedata.data.upper Beta bound.
+ * @param storedata.move best move.
  */
-void hash_feed(HashTable *hash_table, const Board *board, const unsigned long long hash_code, const int depth, const int selectivity, const int lower, const int upper, const int move)
+void hash_feed(HashTable *hash_table, const Board *board, const unsigned long long hash_code, HashStoreData *storedata)
 {
 	Hash *hash, *worst;
 	HashLock *lock; 
 	int i;
-	int date = hash_table->date ? hash_table->date : 1;
+
+	storedata->data.wl.c.date = hash_table->date ? hash_table->date : 1;
+	storedata->data.wl.c.cost = 0;
 
 	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
 	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	if (hash_reset(hash, lock, board, date, depth, selectivity, lower, upper, move)) return;
+	if (hash_reset(hash, lock, board, storedata)) return;
 
 	for (i = 1; i < HASH_N_WAY; ++i) {
 		++hash;
-		if (hash_reset(hash, lock, board, date, depth, selectivity, lower, upper, move)) return;
+		if (hash_reset(hash, lock, board, storedata)) return;
 		if (writeable_level(&worst->data) > writeable_level(&hash->data)) {
 			worst = hash;
 		}
 	}
 
 	// new entry
-#if (HASH_COLLISIONS(1)+0) 
-	hash_set(worst, lock, hash_code, board, date, depth, selectivity, 0, lower, upper, move);
-#else 
-	hash_set(worst, lock, board, date, depth, selectivity, 0, lower, upper, move);
-#endif
+	HASH_COLLISIONS(storedata->hash_code = hash_code;)
+	hash_set(worst, lock, board, storedata);
 }
 
 /**
@@ -532,37 +504,37 @@ void hash_feed(HashTable *hash_table, const Board *board, const unsigned long lo
  * already exists with better data, nothing is stored.
  *
  * @param hash_table Hash table to update.
+ * @param board Bitboard.
  * @param hash_code  Hash code of an othello board.
- * @param alpha      Alpha bound when calling the alphabeta function.
- * @param depth      Search depth.
- * @param selectivity   Search selectivity.
- * @param cost       Search cost (i.e. log2(node count)).
- * @param beta       Beta bound when calling the alphabeta function.
- * @param score      Best score found.
- * @param move       Best move found.
+ * @param storedata.data.depth      Search depth.
+ * @param storedata.data.selectivity   Search selectivity.
+ * @param storedata.data.cost       Search cost (i.e. log2(node count)).
+ * @param storedata.alpha      Alpha bound when calling the alphabeta function.
+ * @param storedata.beta       Beta bound when calling the alphabeta function.
+ * @param storedata.score      Best score found.
+ * @param storedata.move       Best move found.
  */
-void hash_store(HashTable *hash_table, const Board *board, const unsigned long long hash_code, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
+void hash_store(HashTable *hash_table, const Board *board, const unsigned long long hash_code, HashStoreData *storedata)
 {
-	register int i;
+	int i;
 	Hash *worst, *hash;
 	HashLock *lock;
 
 	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
 	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	if (hash_update(hash, lock, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
+	storedata->data.wl.c.date = hash_table->date;
+	if (hash_update(hash, lock, board, storedata)) return;
 
 	for (i = 1; i < HASH_N_WAY; ++i) {
 		++hash;
-		if (hash_update(hash, lock, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
+		if (hash_update(hash, lock, board, storedata)) return;
 		if (writeable_level(&worst->data) > writeable_level(&hash->data)) {
 			worst = hash;
 		}
 	}
-#if (HASH_COLLISIONS(1)+0) 
-	hash_new(worst, lock, hash_code, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-#else 
-	hash_new(worst, lock, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-#endif
+
+	HASH_COLLISIONS(storedata->hash_code = hash_code;)
+	hash_new(worst, lock, board, storedata);
 }
 
 /**
@@ -571,51 +543,51 @@ void hash_store(HashTable *hash_table, const Board *board, const unsigned long l
  * Does the same as hash_store() except it always store the current search state
  *
  * @param hash_table Hash table to update.
+ * @param board Bitboard.
  * @param hash_code  Hash code of an othello board.
- * @param alpha      Alpha bound when calling the alphabeta function.
- * @param depth      Search depth.
- * @param selectivity   Search selectivity.
- * @param cost       Search cost (i.e. log2(node count)).
- * @param beta       Beta bound when calling the alphabeta function.
- * @param score      Best score found.
- * @param move       Best move found.
+ * @param storedata.data.depth      Search depth.
+ * @param storedata.data.selectivity   Search selectivity.
+ * @param storedata.data.cost       Search cost (i.e. log2(node count)).
+ * @param storedata.alpha      Alpha bound when calling the alphabeta function.
+ * @param storedata.beta       Beta bound when calling the alphabeta function.
+ * @param storedata.score      Best score found.
+ * @param storedata.move       Best move found.
  */
-void hash_force(HashTable *hash_table, const Board *board, const unsigned long long hash_code, const int depth, const int selectivity, const int cost, const int alpha, const int beta, const int score, const int move)
+void hash_force(HashTable *hash_table, const Board *board, const unsigned long long hash_code, HashStoreData *storedata)
 {
-	register int i;
+	int i;
 	Hash *worst, *hash;
 	HashLock *lock;
-	
+
 	worst = hash = hash_table->hash + (hash_code & hash_table->hash_mask);
 	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
-	if (hash_replace(hash, lock, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
-	
+	storedata->data.wl.c.date = hash_table->date;
+	if (hash_replace(hash, lock, board, storedata)) return;
+
 	for (i = 1; i < HASH_N_WAY; ++i) {
 		++hash;
-		if (hash_replace(hash, lock, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move)) return;
+		if (hash_replace(hash, lock, board, storedata)) return;
 		if (writeable_level(&worst->data) > writeable_level(&hash->data)) {
 			worst = hash;
 		}
 	}
-	
-#if (HASH_COLLISIONS(1)+0) 
-	hash_new(worst, lock, hash_code, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-#else 
-	hash_new(worst, lock, board, hash_table->date, depth, selectivity, cost, alpha, beta, score, move);
-#endif
+
+	HASH_COLLISIONS(storedata->hash_code = hash_code;)
+	hash_new(worst, lock, board, storedata);
 }
 
 /**
  * @brief Find an hash table entry according to the evaluated board hash codes.
  *
  * @param hash_table Hash table.
+ * @param board Bitboard.
  * @param hash_code Hash code of an othello board.
  * @param data Output hash data.
  * @return True the board was found, false otherwise.
  */
 bool hash_get(HashTable *hash_table, const Board *board, const unsigned long long hash_code, HashData *data)
 {
-	register int i;
+	int i;
 	Hash *hash;
 	HashLock *lock;
 	bool ok = false;
@@ -623,11 +595,11 @@ bool hash_get(HashTable *hash_table, const Board *board, const unsigned long lon
 	HASH_STATS(++statistics.n_hash_search;)
 	HASH_COLLISIONS(++statistics.n_hash_n;)
 	hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
 	for (i = 0; i < HASH_N_WAY; ++i) {
 		HASH_COLLISIONS(if (hash->key == hash_code) {)
+		HASH_COLLISIONS(	lock = hash_table->lock + (hash_code & hash_table->lock_mask);)
 		HASH_COLLISIONS(	spin_lock(lock);)
-		HASH_COLLISIONS(	if (hash->key == hash_code && (hash->board.player != board->player || hash->board.opponent != board->opponent)) {)
+		HASH_COLLISIONS(	if (hash->key == hash_code && !vboard_equal(board, &hash->board)) {)
 		HASH_COLLISIONS(		++statistics.n_hash_collision;)
 		HASH_COLLISIONS(		printf("key = %llu\n", hash_code);)
 		HASH_COLLISIONS(		board_print(board, WHITE, stdout);)
@@ -635,12 +607,13 @@ bool hash_get(HashTable *hash_table, const Board *board, const unsigned long lon
 		HASH_COLLISIONS(	})
 		HASH_COLLISIONS(	spin_unlock(lock);)
 		HASH_COLLISIONS(})
-		if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+		if (board_equal(&hash->board, board)) {
+			lock = hash_table->lock + (hash_code & hash_table->lock_mask);
 			spin_lock(lock);
-			if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+			if (board_equal(&hash->board, board)) {
 				*data = hash->data;
 				HASH_STATS(++statistics.n_hash_found;)
-				hash->data.date = hash_table->date;
+				hash->data.wl.c.date = hash_table->date;
 				ok = true;
 			}
 			spin_unlock(lock);
@@ -652,25 +625,39 @@ bool hash_get(HashTable *hash_table, const Board *board, const unsigned long lon
 	return false;
 }
 
+/**
+ * @brief Find an hash table entry from the board.
+ *
+ * @param hash_table Hash table.
+ * @param board Bitboard.
+ * @param data Output hash data.
+ * @return True the board was found, false otherwise.
+ */
+bool hash_get_from_board(HashTable *hash_table, const Board *board, HashData *data)
+{
+	return hash_get(hash_table, board, board_get_hash_code(board), data);
+}
+
 /**
  * @brief Erase an hash table entry.
  *
  * @param hash_table Hash table.
+ * @param board Bitboard.
  * @param hash_code Hash code of an othello board.
  * @param move Move to exclude.
  */
 void hash_exclude_move(HashTable *hash_table, const Board *board, const unsigned long long hash_code, const int move)
 {
-	register int i;
+	int i;
 	Hash *hash;
 	HashLock *lock;
 
 	hash = hash_table->hash + (hash_code & hash_table->hash_mask);
-	lock = hash_table->lock + (hash_code & hash_table->lock_mask);
 	for (i = 0; i < HASH_N_WAY; ++i) {
-		if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+		if (board_equal(&hash->board, board)) {
+			lock = hash_table->lock + (hash_code & hash_table->lock_mask);
 			spin_lock(lock);
-			if (hash->board.player == board->player && hash->board.opponent == board->opponent) {
+			if (board_equal(&hash->board, board)) {
 				if (hash->data.move[0] == move) {
 					hash->data.move[0] = hash->data.move[1];
 					hash->data.move[1] = NOMOVE;
@@ -694,12 +681,13 @@ void hash_exclude_move(HashTable *hash_table, const Board *board, const unsigned
  */
 void hash_copy(const HashTable *src, HashTable *dest)
 {
-	register unsigned int i;
+	unsigned int i, imax = src->hash_mask + HASH_N_WAY;
+	Hash *pSrc = src->hash, *pDest = dest->hash;
 
 	assert(src->hash_mask == dest->hash_mask);
 	info("<hash copy>\n");
-	for (i = 0; i <= src->hash_mask + HASH_N_WAY; ++i) {
-		dest->hash[i] = src->hash[i];
+	for (i = 0; i <= imax; ++i) {
+		*pDest++ = *pSrc++;
 	}
 	dest->date = src->date;
 }
@@ -713,11 +701,9 @@ void hash_copy(const HashTable *src, HashTable *dest)
 void hash_print(const HashData *data, FILE *f)
 {
 	char s_move[4];
-	int p_selectivity[] = {72, 87, 95, 98, 99, 100};
 
 	fprintf(f, "moves = %s, ", move_to_string(data->move[0], WHITE, s_move));
 	fprintf(f, "%s ; ", move_to_string(data->move[1], WHITE, s_move));
 	fprintf(f, "score = [%+02d, %+02d] ; ", data->lower, data->upper);
-	fprintf(f, "level = %2d:%2d:%2d@%3d%%", data->date, data->cost, data->depth, p_selectivity[data->selectivity]);
+	fprintf(f, "level = %2d:%2d:%2d@%3d%%", data->wl.c.date, data->wl.c.cost, data->wl.c.depth, selectivity_table[data->wl.c.selectivity].percent);
 }
-
diff --git a/src/hash.h b/src/hash.h
index e9ab3045..d16c1705 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -3,9 +3,9 @@
  *
  * Hash table's header.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_HASH_H
@@ -16,22 +16,43 @@
 #include "util.h"
 #include "stats.h"
 
-
 #include <stdbool.h>
 #include <stdio.h>
 
 /** HashData : data stored in the hash table */
 typedef struct HashData {
-	unsigned char depth;      /*!< depth */
-	unsigned char selectivity;/*!< selectivity */
-	unsigned char cost;       /*!< search cost */
-	unsigned char date;       /*!< dating technique */
+	union {
+#ifdef __BIG_ENDIAN__
+		struct {
+			unsigned char date;       /*!< dating technique */
+			unsigned char cost;       /*!< search cost */
+			unsigned char selectivity;/*!< selectivity */
+			unsigned char depth;      /*!< depth */
+		} c;
+		struct {
+			unsigned short date_cost;
+			unsigned short selectivity_depth;
+		} us;
+#else
+		struct {
+			unsigned char depth;      /*!< depth */
+			unsigned char selectivity;/*!< selectivity */
+			unsigned char cost;       /*!< search cost */
+			unsigned char date;       /*!< dating technique */
+		} c;
+		struct {
+			unsigned short selectivity_depth;
+			unsigned short date_cost;
+		} us;
+#endif
+		unsigned int	ui;      /*!< as writable level */
+	} wl;
 	signed char lower;        /*!< lower bound of the position score */
 	signed char upper;        /*!< upper bound of the position score */
 	unsigned char move[2];    /*!< best moves */
 } HashData;
 
-/** Hash  : item stored in the hash table*/
+/** Hash  : item stored in the hash table */
 typedef struct Hash {
 	HASH_COLLISIONS(unsigned long long key;)
 	Board board;
@@ -46,7 +67,7 @@ typedef struct HashLock {
 /** HashTable: position storage */
 typedef struct HashTable {
 	void *memory;                 /*!< allocated memory */
-	Hash *hash;  				  /*!< hash table */
+	Hash *hash;                   /*!< hash table */
 	HashLock *lock;               /*!< table with locks */
 	unsigned long long hash_mask; /*!< a bit mask for hash entries */
 	unsigned int lock_mask;       /*!< a bit mask for lock entries */
@@ -55,25 +76,46 @@ typedef struct HashTable {
 	unsigned char date;           /*!< date */
 } HashTable;
 
+/** HashStoreData : data to store */
+typedef struct HashStoreData {
+	HashData data;
+	HASH_COLLISIONS(unsigned long long hash_code;)
+	int alpha;
+	int beta;
+	int score;
+} HashStoreData;
+
 /* declaration */
-void hash_code_init(void);
+
 void hash_move_init(void);
 void hash_init(HashTable*, const unsigned long long);
 void hash_cleanup(HashTable*);
 void hash_clear(HashTable*);
 void hash_free(HashTable*);
-void hash_store(HashTable*, const Board*, const unsigned long long, const int, const int, const int, const int, const int, const int, const int);
-void hash_force(HashTable*, const Board*, const unsigned long long, const int, const int, const int, const int, const int, const int, const int);
-bool hash_get(HashTable*, const Board*, const unsigned long long, HashData *);
+void hash_feed(HashTable*, const Board *, const unsigned long long, HashStoreData *);
+void hash_store(HashTable*, const Board *, const unsigned long long, HashStoreData *);
+void hash_force(HashTable*, const Board *, const unsigned long long, HashStoreData *);
+bool hash_get(HashTable*, const Board *, const unsigned long long, HashData *);
+bool hash_get_from_board(HashTable*, const Board *, HashData *);
+void hash_exclude_move(HashTable*, const Board *, const unsigned long long, const int);
 void hash_copy(const HashTable*, HashTable*);
 void hash_print(const HashData*, FILE*);
-void hash_feed(HashTable*, const Board*, const unsigned long long, const int, const int, const int, const int, const int);
-void hash_exclude_move(HashTable*, const Board*, const unsigned long long, const int);
 extern unsigned int writeable_level(HashData *data);
 
 extern const HashData HASH_DATA_INIT;
-extern unsigned long long hash_rank[16][256];
-extern unsigned long long hash_move[64][60];
 
-#endif
+inline void hash_prefetch(HashTable *hashtable, unsigned long long hashcode) {
+	Hash *p = hashtable->hash + (hashcode & hashtable->hash_mask);
+  #ifdef hasSSE2
+	_mm_prefetch((char const *) p, _MM_HINT_T0);
+	_mm_prefetch((char const *)(p + HASH_N_WAY - 1), _MM_HINT_T0);
+  #elif defined(__ARM_ACLE)
+	__pld(p);
+	__pld(p + HASH_N_WAY - 1);
+  #elif defined(__GNUC__)
+	__builtin_prefetch(p);
+	__builtin_prefetch(p + HASH_N_WAY - 1);
+  #endif
+}
 
+#endif
diff --git a/src/intro.h b/src/intro.h
index ed3d4340..e597d13e 100644
--- a/src/intro.h
+++ b/src/intro.h
@@ -145,4 +145,16 @@
  * Games in AI Research. p 77-96.
  * -# Feldmann R., Monien B., Mysliwietz P. Vornberger O. (1989) Distributed Game-Tree %Search. ICCA Journal, Vol. 12, No. 2, pp. 65-73.
  *
+ * \section edaxavx Edax-AVX
+ *
+ * This copy is SSE/AVX optimized version of Edax 4.4.0. Functionally equivalent to the parent project, provided no bugs are introduced.
+ * 64 bit version solves fforum-20-39 7% to 9% faster than the original 4.4.0 on my test.
+ * Thanks to AVX2, x64-modern build runs 14% faster on Haswell. 32 bit version runs 9% (Core2) to 20% (Athlon) faster than the original.
+ *
+ * - copyleft (c) 1998-2017
+ * - version: 4.4.5 (2017-7-20)
+ * - AVX2 optimization: Toshihiko Okuhara
+ * - email: okuhara@amy.hi-ho.ne.jp
+ * - web site (Japanese): http://www.amy.hi-ho.ne.jp/okuhara/edax.htm
+ * - source files: https://github.com/okuhara/edax-reversi-AVX
  */
diff --git a/src/main.c b/src/main.c
index 4b899a1c..55e8a44b 100644
--- a/src/main.c
+++ b/src/main.c
@@ -3,9 +3,9 @@
  *
  * @brief Main file.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2024
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "board.h"
@@ -26,19 +26,15 @@
  */
 void version(void)
 {
-	fprintf(stderr, "Edax version " VERSION_STRING " " __DATE__ " " __TIME__);
-
+	fprintf(stderr, "Edax version " VERSION_STRING " " __DATE__ " " __TIME__
 #if defined(__linux__)
-	fprintf(stderr, " for Linux\n");
+		" for Linux"
 #elif defined(_WIN32)
-	fprintf(stderr, " for Windows\n");
+		" for Windows"
 #elif defined(__APPLE__)
-	fprintf(stderr, " for Apple\n");
-#else
-	fprintf(stderr, "\n");
+		" for Apple"
 #endif
-
-	fprintf(stderr, "copyright 1998 - 2017 Richard Delorme\n\n");
+		"\ncopyright 1998 - 2018 Richard Delorme, 2014 - 24 Toshihiko Okuhara\n\n");
 }
 
 
@@ -47,17 +43,17 @@ void version(void)
  */
 void usage(void)
 {
-	fprintf(stderr, "Usage: edax <protocol> <options>\n");
-	fprintf(stderr,	"User Interface Protocols:\n");
-	fprintf(stderr, " -edax     Edax's user interface (default)\n");
-	fprintf(stderr, " -ggs      Generic Game Server interface (play through internet)\n");
-	fprintf(stderr, " -gtp      Go Text Protocol.\n");
-	fprintf(stderr, " -xboard xboard/winboard protocol.\n");
-	fprintf(stderr, " -nboard NBoard protocol.\n");
-	fprintf(stderr, " -cassio Cassio protocol.\n");
-	fprintf(stderr, " -solve <problem_file>    Automatic problem solver/checker.\n");
-	fprintf(stderr, " -wtest <wthor_file>      Test edax using WThor's theoric score.\n");
-	fprintf(stderr, " -count <level>           Count positions up to <level>.\n");
+	fprintf(stderr, "Usage: edax <protocol> <options>\n"
+		"User Interface Protocols:\n"
+		" -edax     Edax's user interface (default)\n"
+		" -ggs      Generic Game Server interface (play through internet)\n"
+		" -gtp      Go Text Protocol.\n"
+		" -xboard xboard/winboard protocol.\n"
+		" -nboard NBoard protocol.\n"
+		" -cassio Cassio protocol.\n"
+		" -solve <problem_file>    Automatic problem solver/checker.\n"
+		" -wtest <wthor_file>      Test edax using WThor's theoric score.\n"
+		" -count <level>           Count positions up to <level>.\n");
 	options_usage();
 }
 
@@ -85,7 +81,7 @@ int main(int argc, char **argv)
 	options_parse("edax.ini");
 
 	// allocate ui
-	ui = (UI*) malloc(sizeof *ui);
+	ui = (UI*) mm_malloc(sizeof *ui);	// Eval in Search in Play in UI
 	if (ui == NULL) fatal_error("Cannot allocate a user interface.\n");
 	ui->type = UI_EDAX;
 	ui->init = ui_init_edax;
@@ -117,31 +113,30 @@ int main(int argc, char **argv)
 	options_bound();
 
 	// initialize
+	bit_init();
 	edge_stability_init();
-	hash_code_init();
-	hash_move_init();
 	statistics_init();
 	eval_open(options.eval_file);
 	search_global_init();
 
 	// solver & tester
 	if (problem_file || wthor_file || n_bench) {
-		Search search[1];
-		search_init(search);
-		search->options.header = " depth|score|       time   |  nodes (N)  |   N/s    | principal variation";
-		search->options.separator = "------+-----+--------------+-------------+----------+---------------------";
+		Search search;
+		search_init(&search);
+		search.options.header = " depth|score|       time   |  nodes (N)  |   N/s    | principal variation";
+		search.options.separator = "------+-----+--------------+-------------+----------+---------------------";
 		if (options.verbosity) version();
-		if (problem_file) obf_test(search, problem_file, NULL);
-		if (wthor_file) wthor_test(wthor_file, search);
-		if (n_bench) obf_speed(search, n_bench);
-		search_free(search);
+		if (problem_file) obf_test(&search, problem_file, NULL);
+		if (wthor_file) wthor_test(wthor_file, &search);
+		if (n_bench) obf_speed(&search, n_bench);
+		search_free(&search);
 
 	} else if (count_type){
-		Board board[1];
-		board_init(board);
-		if (strcmp(count_type, "games") == 0) quick_count_games(board, level, size);		
-		else if (strcmp(count_type, "positions") == 0) count_positions(board, level, size);		
-		else if (strcmp(count_type, "shapes") == 0) count_shapes(board, level, size);		
+		Board board;
+		board_init(&board);
+		if (strcmp(count_type, "games") == 0) quick_count_games(&board, level, size);
+		else if (strcmp(count_type, "positions") == 0) count_positions(&board, level, size);
+		else if (strcmp(count_type, "shapes") == 0) count_shapes(&board, level, size);
 
 	} else if (ui->type == UI_CASSIO) {
 		engine_loop();
@@ -162,7 +157,7 @@ int main(int argc, char **argv)
 	// free;
 	eval_close();
 	options_free();
-	free(ui);
+	mm_free(ui);
 
 	return 0;
 }
diff --git a/src/midgame.c b/src/midgame.c
index c990be15..e944962e 100644
--- a/src/midgame.c
+++ b/src/midgame.c
@@ -3,9 +3,10 @@
  *
  * Search near the end of the game.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @author Toshihiko Okuhara
+ * @version 4.5
  */
 
 #include "search.h"
@@ -17,6 +18,7 @@
 #include "settings.h"
 
 #include <assert.h>
+#include <stddef.h>
 #include <math.h>
 
 #ifndef RCD
@@ -24,45 +26,102 @@
 #define RCD 0.5
 #endif
 
+/**
+ * @brief evaluate a midgame position with the evaluation function.
+ *
+ * @param ply	60 - n_empties
+ * @param eval	Evaluation function.
+ * @return An evaluated score.
+ */
+static int accumlate_eval(int ply, Eval *eval)
+{
+	unsigned short *f = eval->feature.us;
+	const Eval_weight *w;
+	int sum;
+
+	if (ply >= EVAL_N_PLY)
+		ply = EVAL_N_PLY - 2 + (ply & 1);
+	ply -= 2;
+	if (ply < 0)
+		ply &= 1;
+	w = &(*EVAL_WEIGHT)[ply];
+
+#if defined(__AVX2__) && !defined(__bdver4__) && !defined(__znver1__) && !defined(__znver2__)
+	enum {
+		W_C9 = offsetof(Eval_weight, C9) / sizeof(short) - 1,	// -1 to load the data into hi-word
+		W_C10 = offsetof(Eval_weight, C10) / sizeof(short) - 1,
+		W_S100 = offsetof(Eval_weight, S100) / sizeof(short) - 1,
+		W_S101 = offsetof(Eval_weight, S101) / sizeof(short) - 1
+	};
+
+	__m256i FF = _mm256_add_epi32(_mm256_cvtepu16_epi32(eval->feature.v8[0]),
+		_mm256_set_epi32(W_C10, W_C10, W_C10, W_C10, W_C9, W_C9, W_C9, W_C9));
+	__m256i DD = _mm256_i32gather_epi32((int *) w, FF, 2);
+	__m256i SS = _mm256_srai_epi32(DD, 16);	// sign extend
+
+	FF = _mm256_add_epi32(_mm256_cvtepu16_epi32(eval->feature.v8[1]),
+		_mm256_set_epi32(W_S101, W_S101, W_S101, W_S101, W_S100, W_S100, W_S100, W_S100));
+	DD = _mm256_i32gather_epi32((int *) w, FF, 2);
+	SS = _mm256_add_epi32(SS, _mm256_srai_epi32(DD, 16));
+
+	DD = _mm256_i32gather_epi32((int *)((short *) w->S8x4 - 1), _mm256_cvtepu16_epi32(eval->feature.v8[2]), 2);
+	SS = _mm256_add_epi32(SS, _mm256_srai_epi32(DD, 16));
+
+	DD = _mm256_i32gather_epi32((int *)((short *) w->S7654 - 1), _mm256_cvtepu16_epi32(*(__m128i *) &f[30]), 2);
+	SS = _mm256_add_epi32(SS, _mm256_srai_epi32(DD, 16));
+
+	DD = _mm256_i32gather_epi32((int *)((short *) w->S7654 - 1), _mm256_cvtepu16_epi32(*(__m128i *) &f[38]), 2);
+	SS = _mm256_add_epi32(SS, _mm256_srai_epi32(DD, 16));
+	__m128i S = _mm_add_epi32(_mm256_castsi256_si128(SS), _mm256_extracti128_si256(SS, 1));
+
+	__m128i D = _mm_i32gather_epi32((int *)((short *) w->S8x4 - 1), _mm_cvtepu16_epi32(eval->feature.v8[3]), 2);
+	S = _mm_add_epi32(S, _mm_srai_epi32(D, 16));
+
+	S = _mm_hadd_epi32(S, S);
+	sum = _mm_cvtsi128_si32(S) + _mm_extract_epi32(S, 1);
+
+#else
+	sum = w->C9[f[ 0]] + w->C9[f[ 1]] + w->C9[f[ 2]] + w->C9[f[ 3]]
+	  + w->C10[f[ 4]] + w->C10[f[ 5]] + w->C10[f[ 6]] + w->C10[f[ 7]]
+	  + w->S100[f[ 8]] + w->S100[f[ 9]] + w->S100[f[10]] + w->S100[f[11]]
+	  + w->S101[f[12]] + w->S101[f[13]] + w->S101[f[14]] + w->S101[f[15]]
+	  + w->S8x4[f[16]] + w->S8x4[f[17]] + w->S8x4[f[18]] + w->S8x4[f[19]]
+	  + w->S8x4[f[20]] + w->S8x4[f[21]] + w->S8x4[f[22]] + w->S8x4[f[23]]
+	  + w->S8x4[f[24]] + w->S8x4[f[25]] + w->S8x4[f[26]] + w->S8x4[f[27]]
+	  + w->S7654[f[30]] + w->S7654[f[31]] + w->S7654[f[32]] + w->S7654[f[33]]
+	  + w->S7654[f[34]] + w->S7654[f[35]] + w->S7654[f[36]] + w->S7654[f[37]]
+	  + w->S7654[f[38]] + w->S7654[f[39]] + w->S7654[f[40]] + w->S7654[f[41]]
+	  + w->S7654[f[42]] + w->S7654[f[43]] + w->S7654[f[44]] + w->S7654[f[45]];
+#endif
+	return sum + w->S8x4[f[28]] + w->S8x4[f[29]] + w->S0;
+}
+
 /**
  * @brief evaluate a midgame position with the evaluation function.
  *
  * @param search Position to evaluate.
+ * @return An evaluated score.
  */
 int search_eval_0(Search *search)
 {
-	const short *w = EVAL_WEIGHT[search->eval->player][60 - search->n_empties];
-	int *f = search->eval->feature;
 	int score;
 
 	SEARCH_STATS(++statistics.n_search_eval_0);
-	SEARCH_UPDATE_EVAL_NODES();
-
-	score = w[f[ 0]] + w[f[ 1]] + w[f[ 2]] + w[f[ 3]]
-	  + w[f[ 4]] + w[f[ 5]] + w[f[ 6]] + w[f[ 7]]
-	  + w[f[ 8]] + w[f[ 9]] + w[f[10]] + w[f[11]]
-	  + w[f[12]] + w[f[13]] + w[f[14]] + w[f[15]]
-	  + w[f[16]] + w[f[17]] + w[f[18]] + w[f[19]]
-	  + w[f[20]] + w[f[21]] + w[f[22]] + w[f[23]]
-	  + w[f[24]] + w[f[25]]
-	  + w[f[26]] + w[f[27]] + w[f[28]] + w[f[29]]
-	  + w[f[30]] + w[f[31]] + w[f[32]] + w[f[33]]
-	  + w[f[34]] + w[f[35]] + w[f[36]] + w[f[37]]
-	  + w[f[38]] + w[f[39]] + w[f[40]] + w[f[41]]
-	  + w[f[42]] + w[f[43]] + w[f[44]] + w[f[45]]
-	  + w[f[46]];
+	SEARCH_UPDATE_EVAL_NODES(search->n_nodes);
+
+	score = accumlate_eval(60 - search->eval.n_empties,  &search->eval);
 
 	if (score > 0) score += 64;	else score -= 64;
 	score /= 128;
 
-	if (score <= SCORE_MIN) score = SCORE_MIN + 1;
-	else if (score >= SCORE_MAX) score = SCORE_MAX - 1;
+	if (score < SCORE_MIN + 1) score = SCORE_MIN + 1;
+	if (score > SCORE_MAX - 1) score = SCORE_MAX - 1;
 
 	return score;
 }
 
 /**
- * @brief Evaluate a position at depth 1.
+ * @brief Evaluate a position at depth 1. (min stage)
  *
  * As an optimization, the last move is used to only updates the evaluation
  * features.
@@ -70,64 +129,59 @@ int search_eval_0(Search *search)
  * @param search Position to evaluate.
  * @param alpha Alpha bound.
  * @param beta Beta bound.
+ * @param moves Next turn legal moves.
+ * @return An evaluated min score.
  */
-int search_eval_1(Search *search, const int alpha, int beta)
+int search_eval_1(Search *search, int alpha, int beta, unsigned long long moves)
 {
-	const short *w = EVAL_WEIGHT[search->eval->player ^ 1][61 - search->n_empties];
-	Move move[1];
-	SquareList *empty;
-	register int score, bestscore;
-	const Board *board = search->board;
-	Eval *eval = search->eval;
-	unsigned long long moves = get_moves(board->player, board->opponent);
-	int *f;
+	int x, score, bestscore, alphathres;
+	unsigned long long flipped;
+	Eval Ev;
+	V2DI board0;
 
 	SEARCH_STATS(++statistics.n_search_eval_1);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
 	if (moves) {
-		bestscore = -SCORE_INF;
-		if (beta >= SCORE_MAX) beta = SCORE_MAX - 1;
-		foreach_empty (empty, search->empties) {
-			if (moves & empty->b) {
-				board_get_move(board, empty->x, move);
-				if (move_wipeout(move, board)) return SCORE_MAX;
-				eval_update(eval, move);
-				f = eval->feature;
-				SEARCH_UPDATE_EVAL_NODES();
-					score = -w[f[ 0]] - w[f[ 1]] - w[f[ 2]] - w[f[ 3]]
-						- w[f[ 4]] - w[f[ 5]] - w[f[ 6]] - w[f[ 7]]
-						- w[f[ 8]] - w[f[ 9]] - w[f[10]] - w[f[11]]
-						- w[f[12]] - w[f[13]] - w[f[14]] - w[f[15]]
-						- w[f[16]] - w[f[17]] - w[f[18]] - w[f[19]]
-						- w[f[20]] - w[f[21]] - w[f[22]] - w[f[23]]
-						- w[f[24]] - w[f[25]]
-						- w[f[26]] - w[f[27]] - w[f[28]] - w[f[29]]
-						- w[f[30]] - w[f[31]] - w[f[32]] - w[f[33]]
-						- w[f[34]] - w[f[35]] - w[f[36]] - w[f[37]]
-						- w[f[38]] - w[f[39]] - w[f[40]] - w[f[41]]
-						- w[f[42]] - w[f[43]] - w[f[44]] - w[f[45]]
-						- w[f[46]];
-				eval_restore(eval, move);
-
-				if (score > 0) score += 64; else score -= 64;
-				score /= 128;
-
-				if (score > bestscore) {
-					bestscore = score;
-					if (bestscore >= beta) break;
-				}
-			}
-		}
-		if (bestscore <= SCORE_MIN) bestscore = SCORE_MIN + 1;
-		else if (bestscore >= SCORE_MAX) bestscore = SCORE_MAX - 1;
+		bestscore = SCORE_INF * 128;	// min stage
+		if (alpha < SCORE_MIN + 1) alphathres = ((SCORE_MIN + 1) * 128) + 64;
+		else alphathres = (alpha * 128) + 63 + (int) (alpha < 0);	// highest score rounded to alpha
+
+		board0.board = search->board;
+		x = NOMOVE;
+		do {
+			do {
+				x = search->empties[x].next;
+			} while (!(moves & x_to_bit(x)));
+
+			moves &= ~x_to_bit(x);
+			flipped = vboard_flip(board0, x);
+			if (flipped == search->board.opponent)
+				return SCORE_MIN;	// wipeout
+
+			eval_update_leaf(x, flipped, &Ev, &search->eval);
+			SEARCH_UPDATE_EVAL_NODES(search->n_nodes);
+
+			score = accumlate_eval(60 - search->eval.n_empties + 1, &Ev);
+
+			if (score < bestscore)
+				bestscore = score;
+		} while (moves && (bestscore > alphathres));
+
+		if (bestscore >= 0) bestscore += 64; else bestscore -= 64;
+		bestscore /= 128;
+
+		if (bestscore < SCORE_MIN + 1) bestscore = SCORE_MIN + 1;
+		if (bestscore > SCORE_MAX - 1) bestscore = SCORE_MAX - 1;
+
 	} else {
-		if (can_move(board->opponent, board->player)) {
-			search_update_pass_midgame(search);
-				bestscore = -search_eval_1(search, -beta, -alpha);
-			search_restore_pass_midgame(search);
+		moves = get_moves(search->board.opponent, search->board.player);
+		if (moves) {
+			search_update_pass_midgame(search, &Ev);
+			bestscore = -search_eval_1(search, -beta, -alpha, moves);
+			search_restore_pass_midgame(search, &Ev);
 		} else { // game over
-			bestscore = search_solve(search);
+			bestscore = -search_solve(search);
 		}
 	}
 
@@ -143,43 +197,58 @@ int search_eval_1(Search *search, const int alpha, int beta)
  * @param search Position to evaluate.
  * @param alpha Lower bound
  * @param beta  Upper bound
+ * @param moves Next turn legal moves.
+ * @return An evaluated best score.
  */
-int search_eval_2(Search *search, int alpha, const int beta)
+int search_eval_2(Search *search, int alpha, int beta, unsigned long long moves)
 {
-	register int bestscore, score;
-	SquareList *empty;
-	Move move[1];
-	const Board *board = search->board;
-	const unsigned long long moves = get_moves(board->player, board->opponent);
+	int x, bestscore, score;
+	unsigned long long flipped;
+	Eval eval0;
+	V2DI board0;
 
 	SEARCH_STATS(++statistics.n_search_eval_2);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	assert(-SCORE_MAX <= alpha && alpha <= SCORE_MAX);
-	assert(-SCORE_MAX <= beta && beta <= SCORE_MAX);
+	assert(-SCORE_MAX <= alpha);
+	assert(beta <= SCORE_MAX);
 	assert(alpha <= beta);
 
 	if (moves) {
 		bestscore = -SCORE_INF;
-		foreach_empty(empty, search->empties) {
-			if (moves & empty->b) {
-				board_get_move(board, empty->x, move);
-				search_update_midgame(search, move);
-					score = -search_eval_1(search, -beta, -alpha);
-				search_restore_midgame(search, move);
-				if (score > bestscore) {
-					bestscore = score;
-					if (bestscore >= beta) break;
-					else if (bestscore > alpha) alpha = bestscore;
-				}
+		eval0.feature = search->eval.feature;
+		eval0.n_empties = search->eval.n_empties--;
+		board0.board = search->board;
+		x = NOMOVE;
+		do {
+			do {
+				x = search->empties[x].next;
+			} while (!(moves & x_to_bit(x)));
+
+			moves &= ~x_to_bit(x);
+			// search->empties[prev].next = search->empties[x].next;	// let search_eval_1 skip the last occupied
+			flipped = vboard_next(board0, x, &search->board);
+			eval_update_leaf(x, flipped, &search->eval, &eval0);
+			score = search_eval_1(search, alpha, beta, board_get_moves(&search->board));
+			// search->empties[prev].next = x;	// restore
+
+			if (score > bestscore) {
+				bestscore = score;
+				if (bestscore >= beta) break;
+				else if (bestscore > alpha) alpha = bestscore;
 			}
-		}
+		} while (moves);
+		search->eval.feature = eval0.feature;
+		search->eval.n_empties = eval0.n_empties;
+		search->board = board0.board;
+
 	} else {
-		if (can_move(board->opponent, board->player)) {
-			search_update_pass_midgame(search);
-				bestscore = -search_eval_2(search, -beta, -alpha);
-			search_restore_pass_midgame(search);
-		} else {
+		moves = get_moves(search->board.opponent, search->board.player);
+		if (moves) {
+			search_update_pass_midgame(search, &eval0);
+			bestscore = -search_eval_2(search, -beta, -alpha, moves);
+			search_restore_pass_midgame(search, &eval0);
+		} else { // game over
 			bestscore = search_solve(search);
 		}
 	}
@@ -189,6 +258,18 @@ int search_eval_2(Search *search, int alpha, const int beta)
 	return bestscore;
 }
 
+/**
+ * @brief Probcut
+ *
+ * Check if a position is worth to analyze further.
+ *
+ * @param search Position to test.
+ * @param alpha Alpha lower bound.
+ * @param depth Search depth.
+ * @param parent Parent node.
+ * @param value Returned value.
+ * @return true if probable cutoff has been found, false otherwise.
+ */
 static inline void search_update_probcut(Search *search, const NodeType node_type) 
 {
 	search->node_type[search->height] = node_type;
@@ -197,26 +278,13 @@ static inline void search_update_probcut(Search *search, const NodeType node_typ
 }
 
 
-static inline void search_restore_probcut(Search *search, const  NodeType node_type, const int selectivity) 
+static inline void search_restore_probcut(Search *search, const NodeType node_type, const int selectivity) 
 {
 	search->node_type[search->height] = node_type;
 	if (!USE_RECURSIVE_PROBCUT) search->selectivity = selectivity;
 	LIMIT_RECURSIVE_PROBCUT(--search->probcut_level;)
 }
 
-/**
- * @brief Probcut
- *
- * Check if a position is worth to analyze further.
- *
- * @param search Position to test.
- * @param alpha Alpha lower bound.
- * @param depth Search depth.
- * @param parent Parent node.
- * @param value Returned value.
- *
- * @return true if probable cutoff has been found, false otherwise.
- */
 static bool search_probcut(Search *search, const int alpha, const int depth, Node *parent, int *value)
 {
 	// assertion 
@@ -230,7 +298,7 @@ static bool search_probcut(Search *search, const int alpha, const int depth, Nod
 		int probcut_error, eval_error;
 		int probcut_depth, probcut_beta, probcut_alpha;
 		int eval_score, eval_beta, eval_alpha;
-		register int score;
+		int score;
 		const int beta = alpha + 1;
 		double t = selectivity_table[search->selectivity].t;
 		const int saved_selectivity = search->selectivity;
@@ -242,11 +310,11 @@ static bool search_probcut(Search *search, const int alpha, const int depth, Nod
 		probcut_depth = 2 * floor(options.probcut_d * depth) + (depth & 1);
 		if (probcut_depth == 0) probcut_depth = depth - 2; 
 		assert(probcut_depth > 1 && probcut_depth <= depth - 2 && (probcut_depth & 1) == (depth & 1));
-		probcut_error = t * eval_sigma(search->n_empties, depth, probcut_depth) + RCD;
+		probcut_error = t * eval_sigma(search->eval.n_empties, depth, probcut_depth) + RCD;
 
 		// compute evaluation error (i.e. error at depth 0) averaged for both depths
 		eval_score = search_eval_0(search);
-		eval_error = t * 0.5 * (eval_sigma(search->n_empties, depth, 0) + eval_sigma(search->n_empties, depth, probcut_depth)) + RCD;
+		eval_error = t * 0.5 * (eval_sigma(search->eval.n_empties, depth, 0) + eval_sigma(search->eval.n_empties, depth, probcut_depth)) + RCD;
 	
 		// try a probable upper cut first
 		eval_beta = beta - eval_error;
@@ -255,7 +323,7 @@ static bool search_probcut(Search *search, const int alpha, const int depth, Nod
 		if (eval_score >= eval_beta && probcut_beta < SCORE_MAX) { 	// check if trying a beta probcut is worth
 			PROBCUT_STATS(++statistics.n_probcut_high_try);
 			search_update_probcut(search, CUT_NODE);
-				score = NWS_midgame(search, probcut_alpha, probcut_depth, parent);
+			score = NWS_midgame(search, probcut_alpha, probcut_depth, parent);
 			search_restore_probcut(search, node_type, saved_selectivity);
 			if (score >= probcut_beta) {
 				*value = beta;
@@ -270,7 +338,7 @@ static bool search_probcut(Search *search, const int alpha, const int depth, Nod
 		if (eval_score < eval_alpha && probcut_alpha > SCORE_MIN) { // check if trying an alpha probcut is worth
 			PROBCUT_STATS(++statistics.n_probcut_low_try);
 			search_update_probcut(search, ALL_NODE);
-				score = NWS_midgame(search, probcut_alpha, probcut_depth, parent);
+			score = NWS_midgame(search, probcut_alpha, probcut_depth, parent);
 			search_restore_probcut(search, node_type, saved_selectivity);
 			if (score <= probcut_alpha) {
 				*value = alpha;
@@ -284,12 +352,13 @@ static bool search_probcut(Search *search, const int alpha, const int depth, Nod
 }
 
 /**
- * @brief Evaluate a midgame position with a Null Window Search algorithm.
+ * @brief Evaluate a midgame position with a Null Window Search algorithm. (No probcut)
  *
  * This function is used when there are still many empty squares on the board. Move
  * ordering, hash table cutoff, enhanced transposition cutoff, etc. are used in
  * order to diminish the size of the tree to analyse, but at the expense of a
  * slower speed.
+ * (called from PVS_shallow and NWS_midgame @ depth <= 3)
  *
  * @param search     search.
  * @param alpha      lower bound.
@@ -297,80 +366,100 @@ static bool search_probcut(Search *search, const int alpha, const int depth, Nod
  * @param hash_table Hash Table to use.
  * @return An evaluated score, as a disc difference.
  */
-int NWS_shallow(Search *search, const int alpha, int depth, HashTable *hash_table)
+static int NWS_shallow(Search *search, const int alpha, int depth, HashTable *hash_table)
 {
-	int score;
+	int score, bestscore;
 	unsigned long long hash_code;
-	const int beta = alpha + 1;
-	HashData hash_data[1];
-	Board *board = search->board;
-	MoveList movelist[1];
+	// const int beta = alpha + 1;
+	HashStoreData hash_data;
+	MoveList movelist;
 	Move *move;
-	int bestscore, bestmove;
-	long long cost = -search->n_nodes;
+	Eval eval0;
+	V2DI board0;
+	long long nodes_org;
 
-	if (depth == 2) return search_eval_2(search, alpha, beta);
+	if (depth == 2) return search_eval_2(search, alpha, alpha + 1, board_get_moves(&search->board));
 
 	SEARCH_STATS(++statistics.n_NWS_midgame);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	assert(search->n_empties == bit_count(~(search->board->player|search->board->opponent)));
+	assert(search->eval.n_empties == bit_count(~(search->board.player | search->board.opponent)));
 	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
 	assert(depth > 2);
 	assert(hash_table != NULL);
 
+	hash_code = board_get_hash_code(&search->board);
+	hash_prefetch(hash_table, hash_code);
+
 	// stability cutoff
 	if (search_SC_NWS(search, alpha, &score)) return score;
 
-	// transposition cutoff
-	hash_code = board_get_hash_code(board);
-	if (hash_get(hash_table, board, hash_code, hash_data) && search_TC_NWS(hash_data, depth, search->selectivity, alpha, &score)) return score;
-	search_get_movelist(search, movelist);
-
-	if (movelist_is_empty(movelist)) { // no moves ?
-		if (can_move(board->opponent, board->player)) { // pass ?
-			search_update_pass_midgame(search);
-				bestscore = -NWS_shallow(search, -beta, depth, hash_table);
-				bestmove = PASS;
-			search_restore_pass_midgame(search);
-		} else { // game-over !
-			bestscore = search_solve(search);
-			bestmove = NOMOVE;
-		}
-	} else {
+	search_get_movelist(search, &movelist);
+	board0.board = search->board;
+	eval0 = search->eval;
+
+	if (movelist.n_moves > 1) {
+		// transposition cutoff
+		if (hash_get(hash_table, &search->board, hash_code, &hash_data.data) && search_TC_NWS(&hash_data.data, depth, NO_SELECTIVITY, alpha, &score))
+			return score;
+
 		// sort the list of moves
-		movelist_evaluate(movelist, search, hash_data, alpha, depth);
-		movelist_sort(movelist) ;
+		nodes_org = search->n_nodes;
+		movelist_evaluate(&movelist, search, &hash_data.data, alpha, depth);
 
 		// loop over all moves
-		bestscore = -SCORE_INF; bestmove = NOMOVE;
-		foreach_move(move, movelist) {
+		bestscore = -SCORE_INF;
+		foreach_best_move(move, movelist) {
 			search_update_midgame(search, move);
-				score = -NWS_shallow(search, -beta, depth - 1, hash_table);
-			search_restore_midgame(search, move);
+			score = -NWS_shallow(search, ~alpha, depth - 1, hash_table);
+			search_restore_midgame(search, move->x, &eval0);
+			search->board = board0.board;
 			if (score > bestscore) {
 				bestscore = score;
-				bestmove = move->x;
-				if (bestscore >= beta) break;
+				hash_data.data.move[0] = move->x;
+				if (score > alpha) break;
 			}
 		}
-	}
 
-	// save the best result in hash tables
-	cost += search->n_nodes;
-	hash_store(hash_table, board, hash_code, depth, search->selectivity, last_bit(cost), alpha, beta, bestscore, bestmove);
- 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+		// save the best result in hash tables
+		hash_data.data.wl.c.depth = depth;
+		hash_data.data.wl.c.selectivity = NO_SELECTIVITY;	// (4.5.1)
+		hash_data.data.wl.c.cost = last_bit(search->n_nodes - nodes_org);
+		// hash_data.data.move[0] = bestmove;
+		hash_data.alpha = alpha;
+		hash_data.beta = alpha + 1;
+		hash_data.score = bestscore;
+		hash_store(hash_table, &search->board, hash_code, &hash_data);
+
+	} else if (movelist.n_moves == 1) {
+		move = movelist_first(&movelist);
+		search_update_midgame(search, move);
+		bestscore = -NWS_shallow(search, ~alpha, depth - 1, hash_table);
+		search_restore_midgame(search, move->x, &eval0);
+		search->board = board0.board;
+
+	} else { // no moves
+		if (can_move(search->board.opponent, search->board.player)) { // pass ?
+			search_update_pass_midgame(search, &eval0);
+			bestscore = -NWS_shallow(search, ~alpha, depth, hash_table);
+			search_restore_pass_midgame(search, &eval0);
+		} else { // game-over !
+			bestscore = search_solve(search);
+		}
+	}
 
+	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
 	return bestscore;
 }
 
 /**
- * @brief Evaluate a midgame position at shallow depth.
+ * @brief Evaluate a midgame position at shallow depth. (No probcut)
  *
  * This function is used when there are still many empty squares on the board. Move
  * ordering, hash table cutoff, enhanced transposition cutoff, etc. are used in
  * order to diminish the size of the tree to analyse, but at the expense of a
  * slower speed.
+ * (called from guess_move @ depth <= 6 and movelist_evaluate @ depth > 2)
  *
  * @param search Search.
  * @param alpha Alpha bound.
@@ -380,78 +469,97 @@ int NWS_shallow(Search *search, const int alpha, int depth, HashTable *hash_tabl
  */
 int PVS_shallow(Search *search, int alpha, int beta, int depth)
 {
-	int score;
-	HashTable *hash_table = search->shallow_table;
-	unsigned long long hash_code;
-	HashData hash_data[1];
-	Board *board = search->board;
-	MoveList movelist[1];
+	int score, bestscore, lower;
+	// unsigned long long hash_code;
+	HashStoreData hash_data;
+	MoveList movelist;
 	Move *move;
-	int bestscore, bestmove;
-	long long cost = -search->n_nodes;
-	int lower;
+	Eval eval0;
+	Board board0;
+	long long nodes_org;
 
-	if (depth == 2) return search_eval_2(search, alpha, beta);
+	if (depth == 2) return search_eval_2(search, alpha, beta, board_get_moves(&search->board));
 
 	SEARCH_STATS(++statistics.n_PVS_shallow);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	assert(search->n_empties == bit_count(~(search->board->player|search->board->opponent)));
+	assert(search->eval.n_empties == bit_count(~(search->board.player | search->board.opponent)));
 	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
 
 	// stability cutoff
-	if (search_SC_PVS(search, &alpha, &beta, &score)) return score;
-
-	// transposition cutoff
-	hash_code = board_get_hash_code(board);
-//	if (hash_get(hash_table, board, hash_code, hash_data) && search_TC_PVS(hash_data, depth, search->selectivity, &alpha, &beta, &score)) return score;
-	hash_get(hash_table, board, hash_code, hash_data);
-
-	search_get_movelist(search, movelist);
-
-	if (movelist_is_empty(movelist)) { // no moves ?
-		if (can_move(board->opponent, board->player)) { // pass ?
-			search_update_pass_midgame(search);
-				bestscore = -PVS_shallow(search, -beta, -alpha, depth);
-				bestmove = PASS;
-			search_restore_pass_midgame(search);
-		} else { // game-over !
-			bestscore = search_solve(search);
-			bestmove = NOMOVE;
+	if (USE_SC && beta >= PVS_STABILITY_THRESHOLD[search->eval.n_empties]) {
+		CUTOFF_STATS(++statistics.n_stability_try;)
+		score = SCORE_MAX - 2 * get_stability(search->board.opponent, search->board.player);
+		if (score <= alpha) {
+			CUTOFF_STATS(++statistics.n_stability_low_cutoff;)
+			return score;
 		}
-	} else {
+		else if (score < beta) beta = score;
+	}
+
+	search_get_movelist(search, &movelist);
+	board0 = search->board;
+	eval0 = search->eval;
+
+	if (movelist.n_moves > 1) {
+		// transposition cutoff (unused, normally first searched position)
+		// hash_code = board_get_hash_code(&search->board);
+		// if (hash_get(&search->shallow_table, &search->board, hash_code, &hash_data.data) && search_TC_PVS(&hash_data.data, depth, NO_SELECTIVITY, &alpha, &beta, &score)) return score;
+
 		// sort the list of moves
-		movelist_evaluate(movelist, search, hash_data, alpha, depth);
-		movelist_sort(movelist) ;
+		nodes_org = search->n_nodes;
+		movelist_evaluate(&movelist, search, &HASH_DATA_INIT, alpha, depth);
 
 		// loop over all moves
-		bestscore = -SCORE_INF; bestmove = NOMOVE;
-		lower = alpha;
-		foreach_move(move, movelist) {
+		move = movelist_best(&movelist);
+		search_update_midgame(search, move);
+		bestscore = -PVS_shallow(search, -beta, -alpha, depth - 1);
+		hash_data.data.move[0] = move->x;
+		search_restore_midgame(search, move->x, &eval0);
+		search->board = board0;
+		lower = (bestscore > alpha) ? bestscore : alpha;
+
+		while ((bestscore < beta) && (move = move_next_best(move))) {
 			search_update_midgame(search, move);
-				if (bestscore == -SCORE_INF) {
-					score = -PVS_shallow(search, -beta, -lower, depth - 1);
-				} else {
-					score = -NWS_shallow(search, -lower - 1, depth - 1, hash_table);
-					if (alpha < score && score < beta) {
-						score = -PVS_shallow(search, -beta, -lower, depth - 1);
-					}
-				}
-			search_restore_midgame(search, move);
+			score = -NWS_shallow(search, ~lower, depth - 1, &search->shallow_table);
+			if (lower < score && score < beta)
+				lower = score = -PVS_shallow(search, -beta, -lower, depth - 1);
+			search_restore_midgame(search, move->x, &eval0);
+			search->board = board0;
 			if (score > bestscore) {
 				bestscore = score;
-				bestmove = move->x;
-				if (bestscore >= beta) break;
-				else if (bestscore > lower) lower = bestscore;
+				hash_data.data.move[0] = move->x;
 			}
 		}
-	}
 
-	// save the best result in hash tables
-	cost += search->n_nodes;
-	hash_store(hash_table, board, hash_code, depth, search->selectivity, last_bit(cost), alpha, beta, bestscore, bestmove);
- 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+		// save the best result in shallow hash
+		hash_data.data.wl.c.depth = depth;
+		hash_data.data.wl.c.selectivity = NO_SELECTIVITY;	// (4.5.1)
+		hash_data.data.wl.c.cost = last_bit(search->n_nodes - nodes_org);
+		// hash_data.data.move[0] = bestmove;
+		hash_data.alpha = alpha;
+		hash_data.beta = beta;
+		hash_data.score = bestscore;
+		hash_store(&search->shallow_table, &search->board, board_get_hash_code(&search->board), &hash_data);
+
+	} else if (movelist.n_moves == 1) {
+		move = movelist.move[0].next;
+		search_update_midgame(search, move);
+		bestscore = -PVS_shallow(search, -beta, -alpha, depth - 1);
+		search_restore_midgame(search, move->x, &eval0);
+		search->board = board0;
+
+	} else { // no moves
+		if (can_move(search->board.opponent, search->board.player)) { // pass ?
+			search_update_pass_midgame(search, &eval0);
+			bestscore = -PVS_shallow(search, -beta, -alpha, depth);
+			search_restore_pass_midgame(search, &eval0);
+		} else { // game-over !
+			bestscore = search_solve(search);
+		}
+	}
 
+	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
 	return bestscore;
 }
 
@@ -473,97 +581,121 @@ int PVS_shallow(Search *search, int alpha, int beta, int depth)
 int NWS_midgame(Search *search, const int alpha, int depth, Node *parent)
 {
 	int score;
-	HashTable *hash_table = search->hash_table;
-	HashTable *pv_table = search->pv_table;
 	unsigned long long hash_code;
-	const int beta = alpha + 1;
-	HashData hash_data[1];
-	Board *board = search->board;
-	MoveList movelist[1];
+	// const int beta = alpha + 1;
+	HashStoreData hash_data;
+	MoveList movelist;
 	Move *move;
-	Node node[1];
-	long long cost = -search->n_nodes - search->child_nodes;
-	int hash_selectivity;
+	Node node;
+	Eval eval0;
+	V2DI board0;
+	long long nodes_org;
 
-	assert(search->n_empties == bit_count(~(search->board->player|search->board->opponent)));
-	assert((2 <= depth && depth < search->n_empties) || depth == search->n_empties);
+	assert(search->eval.n_empties == bit_count(~(search->board.player | search->board.opponent)));
+	assert((2 <= depth && depth < search->eval.n_empties) || depth == search->eval.n_empties);
 	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
 	assert(parent != NULL);
 
 	search_check_timeout(search);
-	if (search->stop) return alpha;
-	else if (search->n_empties == 0) return search_solve_0(search);
-	else if (depth <= 3 && depth < search->n_empties) return NWS_shallow(search, alpha, depth, hash_table);
-	else if (search->n_empties <= depth && depth < DEPTH_MIDGAME_TO_ENDGAME) return NWS_endgame(search, alpha);
+	if (search->stop)
+		return alpha;
+
+	if (search->eval.n_empties == 0)
+		return search_solve_0(search);
+	else if (depth < search->eval.n_empties) {
+		if (depth <= 3)
+			return NWS_shallow(search, alpha, depth, &search->hash_table);
+	} else {
+		if (depth < DEPTH_MIDGAME_TO_ENDGAME)
+			return NWS_endgame(search, alpha);
+	}
 
 	SEARCH_STATS(++statistics.n_NWS_midgame);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
 	// stability cutoff
 	if (search_SC_NWS(search, alpha, &score)) return score;
 
-	// transposition cutoff
-	hash_code = board_get_hash_code(board);
-	if ((hash_get(hash_table, board, hash_code, hash_data) || hash_get(pv_table, board, hash_code, hash_data)) && search_TC_NWS(hash_data, depth, search->selectivity, alpha, &score)) return score;
+	hash_code = board_get_hash_code(&search->board);
+	hash_prefetch(&search->hash_table, hash_code);
+	hash_prefetch(&search->pv_table, hash_code);
 
-	search_get_movelist(search, movelist);
+	nodes_org = search->n_nodes + search->child_nodes;
+	search_get_movelist(search, &movelist);
 
-	if (movelist_is_empty(movelist)) { // no moves ?
-		node_init(node, search, alpha, beta, depth, movelist->n_moves, parent);
-		if (can_move(board->opponent, board->player)) { // pass ?
-			search_update_pass_midgame(search);
-				node->bestscore = -NWS_midgame(search, -node->beta, depth, node);
-			search_restore_pass_midgame(search);
+	// transposition cutoff
+	if (hash_get(&search->hash_table, &search->board, hash_code, &hash_data.data) || hash_get(&search->pv_table, &search->board, hash_code, &hash_data.data))
+		if (search_TC_NWS(&hash_data.data, depth, search->selectivity, alpha, &score)) return score;
+
+	if (movelist_is_empty(&movelist)) { // no moves ?
+		node_init(&node, search, alpha, alpha + 1, depth, movelist.n_moves, parent);
+		if (can_move(search->board.opponent, search->board.player)) { // pass ?
+			search_update_pass_midgame(search, &eval0);
+			node.bestscore = -NWS_midgame(search, -node.beta, depth, &node);
+			search_restore_pass_midgame(search, &eval0);
 		} else { // game-over !
-			node->bestscore = search_solve(search);
+			node.bestscore = search_solve(search);
 		}
+
 	} else {
 		// probcut
 		if (search_probcut(search, alpha, depth, parent, &score)) return score;
 
 		// sort the list of moves
-		if (movelist->n_moves > 1) {
-			if (hash_data->move[0] == NOMOVE) hash_get(hash_table, board, hash_code, hash_data);
-			movelist_evaluate(movelist, search, hash_data, alpha, depth + options.inc_sort_depth[search->node_type[search->height]]);
-			movelist_sort(movelist) ;
+		if (movelist.n_moves > 1) {
+			if (hash_data.data.move[0] == NOMOVE) hash_get(&search->hash_table, &search->board, hash_code, &hash_data.data);
+			movelist_evaluate(&movelist, search, &hash_data.data, alpha, depth + options.inc_sort_depth[search->node_type[search->height]]);
+			movelist_sort(&movelist);
 		}
 
 		// ETC
-		if (search_ETC_NWS(search, movelist, hash_code, depth, search->selectivity, alpha, &score)) return score;
+		if (search_ETC_NWS(search, &movelist, hash_code, depth, search->selectivity, alpha, &score)) return score;
 
-		node_init(node, search, alpha, beta, depth, movelist->n_moves, parent);
+		node_init(&node, search, alpha, alpha + 1, depth, movelist.n_moves, parent);
 
 		// loop over all moves
-		for (move = node_first_move(node, movelist); move; move = node_next_move(node)) {
-			if (!node_split(node, move)) {
+		board0.board = search->board;
+		eval0 = search->eval;
+		for (move = node_first_move(&node, &movelist); move; move = node_next_move(&node)) {
+			if (!node_split(&node, move)) {
 				search_update_midgame(search, move);
-					move->score = -NWS_midgame(search, -beta, depth - 1, node);
-				search_restore_midgame(search, move);
-				node_update(node, move);
+				move->score = -NWS_midgame(search, ~alpha, depth - 1, &node);
+				search_restore_midgame(search, move->x, &eval0);
+				search->board = board0.board;
+				node_update(&node, move);
 			}
 		}
-		node_wait_slaves(node);
+		node_wait_slaves(&node);
 	}
 
 	// save the best result in hash tables
 	if (!search->stop) {
-		cost += search->n_nodes + search->child_nodes;
-		if (search->n_empties < depth && depth <= DEPTH_MIDGAME_TO_ENDGAME) hash_selectivity = NO_SELECTIVITY; // hack
-		else hash_selectivity = search->selectivity;
-		if (search->height <= PV_HASH_HEIGHT) hash_store(pv_table, board, hash_code, depth, hash_selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
-		hash_store(hash_table, board, hash_code, depth, hash_selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
-		SQUARE_STATS(foreach_move(move, movelist))
-		SQUARE_STATS(++statistics.n_played_square[search->n_empties][SQUARE_TYPE[move->x]];)
-		SQUARE_STATS(if (node->bestscore > alpha) ++statistics.n_good_square[search->n_empties][SQUARE_TYPE[node->bestmove]];)
+		if (depth <= ((search->eval.n_empties <= depth) ? DEPTH_MIDGAME_TO_ENDGAME : 4))
+			hash_data.data.wl.c.selectivity = NO_SELECTIVITY; // hack
+		else hash_data.data.wl.c.selectivity = search->selectivity;
+		hash_data.data.wl.c.depth = depth;
+		hash_data.data.wl.c.cost = last_bit(search->n_nodes + search->child_nodes - nodes_org);
+		hash_data.data.move[0] = node.bestmove;
+		hash_data.alpha = alpha;
+		hash_data.beta = alpha + 1;
+		hash_data.score = node.bestscore;
+
+		if (search->height <= PV_HASH_HEIGHT) hash_store(&search->pv_table, &search->board, hash_code, &hash_data);
+		hash_store(&search->hash_table, &search->board, hash_code, &hash_data);
+
+		SQUARE_STATS(foreach_move(move, &movelist))
+		SQUARE_STATS(++statistics.n_played_square[search->eval.n_empties][SQUARE_TYPE[move->x]];)
+		SQUARE_STATS(if (node.bestscore > alpha) ++statistics.n_good_square[search->eval.n_empties][SQUARE_TYPE[node->bestmove]];)
+
+	 	assert(SCORE_MIN <= node.bestscore && node.bestscore <= SCORE_MAX);
 
-	 	assert(SCORE_MIN <= node->bestscore && node->bestscore <= SCORE_MAX);
 	} else {
-		node->bestscore = alpha;
+		node.bestscore = alpha;
 	}
 
-	node_free(node);
+	node_free(&node);
 
-	return node->bestscore;
+	return node.bestscore;
 }
 
 
@@ -585,22 +717,20 @@ int NWS_midgame(Search *search, const int alpha, int depth, Node *parent)
 int PVS_midgame(Search *search, const int alpha, const int beta, int depth, Node *parent)
 {
 	// declaration
-	HashTable *hash_table = search->hash_table;
-	HashTable *pv_table = search->pv_table;
-	unsigned long long hash_code;
-	HashData hash_data[1];
-	Board *board = search->board;
-	MoveList movelist[1];
+	unsigned long long hash_code, solid_opp;
+	HashStoreData hash_data;
+	MoveList movelist;
 	Move *move;
-	Node node[1];
-	long long cost;
-	int reduced_depth, depth_pv_extension, saved_selectivity;
-	int hash_selectivity;
+	Node node;
+	Eval eval0;
+	Board board0, hashboard;
+	long long nodes_org;
+	int reduced_depth, depth_pv_extension, saved_selectivity, ofssolid;
 
 	SEARCH_STATS(++statistics.n_PVS_midgame);
 
-	assert(search->n_empties == bit_count(~(search->board->player|search->board->opponent)));
-	assert(depth <= search->n_empties);
+	assert(search->eval.n_empties == bit_count(~(search->board.player | search->board.opponent)));
+	assert(depth <= search->eval.n_empties);
 	assert((-SCORE_MAX <= alpha && alpha <= SCORE_MAX) || printf("alpha = %d\n", alpha));
 	assert((-SCORE_MAX <= beta && beta <= SCORE_MAX) || printf("beta = %d\n", beta));
 	assert(alpha <= beta);
@@ -608,97 +738,129 @@ int PVS_midgame(Search *search, const int alpha, const int beta, int depth, Node
 	// end of search ?
 	search_check_timeout(search);
 	if (search->stop) return alpha;
-	else if (search->n_empties == 0) return search_solve_0(search);
-	else if (USE_PV_EXTENSION && depth < search->n_empties && search->n_empties <= search->depth_pv_extension) return PVS_midgame(search, alpha, beta, search->n_empties, parent);
-	else if (depth == 2 && search->n_empties > 2) return search_eval_2(search, alpha, beta);
+	else if (search->eval.n_empties == 0)
+		return search_solve_0(search);
+	else if (USE_PV_EXTENSION && search->eval.n_empties <= search->depth_pv_extension)
+		depth = search->eval.n_empties;
+	else if (depth == 2 && search->eval.n_empties > 2)
+		return search_eval_2(search, alpha, beta, board_get_moves(&search->board));
 
-	cost = -search_count_nodes(search);
-	SEARCH_UPDATE_INTERNAL_NODES();
+	nodes_org = search_count_nodes(search);
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	search_get_movelist(search, movelist);
-	node_init(node, search, alpha, beta, depth, movelist->n_moves, parent);
-	node->pv_node = true;
-	hash_code = board_get_hash_code(board);
+	search_get_movelist(search, &movelist);
+	node_init(&node, search, alpha, beta, depth, movelist.n_moves, parent);
+	node.pv_node = true;
+	hash_code = board_get_hash_code(&search->board);
 
 	// special cases
-	if (movelist_is_empty(movelist)) {
-		if (can_move(board->opponent, board->player)) {
-			search_update_pass_midgame(search); search->node_type[search->height] = PV_NODE;
-				node->bestscore = -PVS_midgame(search, -beta, -alpha, depth, node);
-			search_restore_pass_midgame(search);
-			node->bestmove = PASS;
+	if (movelist_is_empty(&movelist)) {
+		if (can_move(search->board.opponent, search->board.player)) {
+			search_update_pass_midgame(search, &eval0);
+			search->node_type[search->height] = PV_NODE;
+			node.bestscore = -PVS_midgame(search, -beta, -alpha, depth, &node);
+			search_restore_pass_midgame(search, &eval0);
+			node.bestmove = PASS;
 		} else {
-			node->alpha = -(node->beta = +SCORE_INF);
-			node->bestscore = search_solve(search);
-			node->bestmove = NOMOVE;
+			node.alpha = -(node.beta = +SCORE_INF);
+			node.bestscore = search_solve(search);
+			node.bestmove = NOMOVE;
 		}
+
 	} else { // normal PVS
-		if (movelist->n_moves > 1) {
+		if (movelist.n_moves > 1) {
 			//IID
-			if (!hash_get(pv_table, board, hash_code, hash_data)) hash_get(hash_table, board, hash_code, hash_data);
-			if (USE_IID && hash_data->move[0] == NOMOVE) {
-				if (depth == search->n_empties) reduced_depth = depth - ITERATIVE_MIN_EMPTIES;
+			if (!hash_get(&search->pv_table, &search->board, hash_code, &hash_data.data))
+				hash_get(&search->hash_table, &search->board, hash_code, &hash_data.data);
+
+			if (USE_IID && hash_data.data.move[0] == NOMOVE) {	// (unused)
+				if (depth == search->eval.n_empties) reduced_depth = depth - ITERATIVE_MIN_EMPTIES;
 				else reduced_depth = depth - 2;
 				if (reduced_depth >= 3) {
 					saved_selectivity = search->selectivity; search->selectivity = 0;
 					depth_pv_extension = search->depth_pv_extension;
 					search->depth_pv_extension = 0;
 					PVS_midgame(search, SCORE_MIN, SCORE_MAX, reduced_depth, parent);
-					hash_get(pv_table, board, hash_code, hash_data);
+					hash_get(&search->pv_table, &search->board, hash_code, &hash_data.data);
 					search->depth_pv_extension = depth_pv_extension;
 					search->selectivity = saved_selectivity;
 				}
 			}
 
 			// Evaluate moves for sorting. For a better ordering, the depth is artificially increased
-			movelist_evaluate(movelist, search, hash_data, node->alpha, depth + options.inc_sort_depth[PV_NODE]);
-			movelist_sort(movelist) ;
+			movelist_evaluate(&movelist, search, &hash_data.data, node.alpha, depth + options.inc_sort_depth[PV_NODE]);
+			movelist_sort(&movelist);
 		}
 
 		// first move
-		if ((move = node_first_move(node, movelist))) { // why if there ?
+		board0 = search->board;
+		eval0 = search->eval;
+		if ((move = node_first_move(&node, &movelist))) { // why if there ?
 			search_update_midgame(search, move); search->node_type[search->height] = PV_NODE;
-				move->score = -PVS_midgame(search, -beta, -alpha, depth - 1, node);
-			search_restore_midgame(search, move);
-			node_update(node, move);
+			move->score = -PVS_midgame(search, -beta, -alpha, depth - 1, &node);
+			search_restore_midgame(search, move->x, &eval0);
+			search->board = board0;
+			node_update(&node, move);
 
 			// other moves : try to refute the first/best one
-			while ((move = node_next_move(node))) {
-				if (!node_split(node, move)) {
-					const int alpha = node->alpha;
+			while ((move = node_next_move(&node))) {
+				if (!node_split(&node, move)) {
+					const int alpha = node.alpha;
 					search_update_midgame(search, move);
-						move->score = -NWS_midgame(search, -alpha - 1, depth - 1, node);
-						if (!search->stop && alpha < move->score && move->score < beta) {
-							search->node_type[search->height] = PV_NODE;
-							move->score = -PVS_midgame(search, -beta, -alpha, depth - 1, node);
-						}
-					search_restore_midgame(search, move);
-					node_update(node, move);
+					move->score = -NWS_midgame(search, -alpha - 1, depth - 1, &node);
+					if (!search->stop && alpha < move->score && move->score < beta) {
+						search->node_type[search->height] = PV_NODE;
+						move->score = -PVS_midgame(search, -beta, -alpha, depth - 1, &node);
+					}
+					search_restore_midgame(search, move->x, &eval0);
+					search->board = board0;
+					node_update(&node, move);
 				}
 			}
-			node_wait_slaves(node);
+			node_wait_slaves(&node);
 		}
 	}
 
 	// save the best result in hash tables
 	if (!search->stop) {
-		cost += search_count_nodes(search);
-		if (search->n_empties < depth && depth <= DEPTH_MIDGAME_TO_ENDGAME) hash_selectivity = NO_SELECTIVITY;
-		else hash_selectivity = search->selectivity;
-		hash_store(hash_table, board, hash_code, depth, hash_selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
-		hash_store(pv_table, board, hash_code, depth, hash_selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
+		if (depth <= ((search->eval.n_empties <= depth) ? DEPTH_MIDGAME_TO_ENDGAME : 4))
+			hash_data.data.wl.c.selectivity = NO_SELECTIVITY;
+		else	hash_data.data.wl.c.selectivity = search->selectivity;
+		hash_data.data.wl.c.depth = depth;
+		hash_data.data.wl.c.cost = last_bit(search_count_nodes(search) - nodes_org);
+		hash_data.data.move[0] = node.bestmove;
+		hash_data.alpha = alpha;
+		hash_data.beta = beta;
+		hash_data.score = node.bestscore;
+
+		hash_store(&search->hash_table, &search->board, hash_code, &hash_data);
+		hash_store(&search->pv_table, &search->board, hash_code, &hash_data);
+
+		// store solid-normalized for endgame TC
+		if (search->eval.n_empties <= depth && depth <= MASK_SOLID_DEPTH && depth > DEPTH_TO_SHALLOW_SEARCH) {
+			solid_opp = get_all_full_lines(search->board.player | search->board.opponent) & search->board.opponent;
+			if (solid_opp) {
+				hashboard.player = search->board.player ^ solid_opp;	// normalize solid to player
+				hashboard.opponent = search->board.opponent ^ solid_opp;
+				ofssolid = bit_count(solid_opp) * 2;	// hash score is ofssolid grater than real
+				hash_data.alpha += ofssolid;
+				hash_data.beta += ofssolid;
+				hash_data.score += ofssolid;
+				hash_store(&search->hash_table, &hashboard, board_get_hash_code(&hashboard), &hash_data);
+			}
+		}
 
 		SQUARE_STATS(foreach_move(move, movelist))
-			SQUARE_STATS(++statistics.n_played_square[search->n_empties][SQUARE_TYPE[move->x]];)
-		SQUARE_STATS(if (node->bestscore > alpha) ++statistics.n_good_square[search->n_empties][SQUARE_TYPE[node->bestmove]];)
+		SQUARE_STATS(++statistics.n_played_square[search->eval.n_empties][SQUARE_TYPE[move->x]];)
+		SQUARE_STATS(if (node.bestscore > alpha) ++statistics.n_good_square[search->eval.n_empties][SQUARE_TYPE[node.bestmove]];)
 
-	 	assert(SCORE_MIN <= node->bestscore && node->bestscore <= SCORE_MAX);
+	 	assert(SCORE_MIN <= node.bestscore && node.bestscore <= SCORE_MAX);
 
 	} else {
-		node->bestscore = alpha;
+		node.bestscore = alpha;
 	}
 
-	node_free(node);
+	node_free(&node);
 
-	return node->bestscore;
+	return node.bestscore;
 }
diff --git a/src/move.c b/src/move.c
index 62eb21a5..19b7c497 100644
--- a/src/move.c
+++ b/src/move.c
@@ -3,9 +3,9 @@
  *
  * @brief Move & list of moves management.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "move.h"
@@ -22,10 +22,10 @@
 #include <ctype.h>
 #include <string.h>
 
-const Move MOVE_INIT = {0, NOMOVE, -SCORE_INF, 0, NULL};
-const Move MOVE_PASS = {0, PASS, -SCORE_INF, 0, NULL};
+const Move MOVE_INIT = {NULL, 0, NOMOVE, -SCORE_INF, 0};
+const Move MOVE_PASS = {NULL, 0, PASS, -SCORE_INF, 0};
 
-const int SQUARE_VALUE[] = {
+const unsigned char SQUARE_VALUE[] = {
 	// JCW's score:
 	18,  4,  16, 12, 12, 16,  4, 18,
 	 4,  2,   6,  8,  8,  6,  2,  4,
@@ -48,13 +48,13 @@ int symetry(int x, const int sym)
 {
 	if (A1 <= x && x <= H8) {
 		if (sym & 1) {
-			x = ((x & 070) | (7 - (x & 7)));
+			x = x ^ 7;
 		}
 		if (sym & 2) {
-			x = ((070 - (x & 070)) | (x & 7));
+			x = x ^ 070;
 		}
 		if (sym & 4) {
-			x = (((x & 070) >> 3) | ((x & 7) << 3));
+			x = (x >> 3) + (x & 7) * 8;
 		}
 		assert(A1 <= x && x <= H8);
 	}
@@ -64,10 +64,10 @@ int symetry(int x, const int sym)
 
 
 /**
- * @brief Print out a move
+ * @brief Print a move to string
  *
  * Print the move, using letter case to distinguish player's color,
- * to an output stream.
+ * to a string.
  * @param x Square coordinate to print.
  * @param player Player color.
  * @param s Output string.
@@ -109,143 +109,17 @@ char* move_to_string(const int x, const int player, char *s)
  */
 void move_print(const int x, const int player, FILE *f)
 {
-	int s[2];
-
-	if (x == NOMOVE) {
-		s[0] = '-';
-		s[1] = '-';
-	} else if (x == PASS) {
-		s[0] = 'p';
-		s[1] = 's';
-	} else if (x >= A1 && x <= H8) {
-		s[0] = x % 8 + 'a';
-		s[1] = x / 8 + '1';
-	} else {
-		s[0] = '?';
-		s[1] = '?';
-	}
+	char s[3];
 
-	if (player == BLACK) {
-		s[0] = toupper(s[0]);
-		s[1] = toupper(s[1]);
+	move_to_string(x, player, s);
+	if (x == PASS) {
+		s[1] += 's' - 'a';	// ps/PS instead of pa/PA
 	}
 	fputc(s[0], f);
 	fputc(s[1], f);
 }
 
 
-
-
-/**
- * @brief Check if a move wins 64-0.
- *
- * Check if a move flipped all the opponent discs.
- *
- * @param move Move.
- * @param board Board.
- * @return true if a move wins 64-0, false otherwise.
- */
-bool move_wipeout(const Move *move, const Board *board)
-{
-	return move->flipped == board->opponent;
-}
-
-#ifdef TUNE_EDAX
-static int w_hash = 1 << 15;
-static int w_eval = 1 << 15;
-static int w_mobility = 1 << 15;
-static int w_corner_stability = 1 << 11;
-static int w_edge_stability = 1 << 11;
-static int w_potential_mobility = 1 << 5;
-static int w_low_parity = 1 << 3;
-static int w_mid_parity = 1 << 2;
-static int w_high_parity = 1 << 1;
-#endif
-
-
-/**
- * @brief Evaluate a list of move.
- *
- * Evaluate the moves to sort them. Evaluation is based on, in order of importance:
- *   - wipeout move    : 1 << 30
- *   - first hash move : 1 << 29
- *   - second hash move: 1 << 28
- *   - shallow search  : 1 << 22 to 1 << 14
- *   - opponent mobility:                 1 << 15            32768...1048576
- *   - player stability near the corner:  1 << 11             2048...24576
- *   - opponent potential mobility:       1 << 5                32...1024
- *   - square value                       1 << 1:               2 ...18
- *   - parity:                            1 << 0:               0 ... 1
- *
- * @param move   Move to evaluate.
- * @param search Position to evaluate.
- * @param hash_data   Position (maybe) stored in the hashtable.
- * @param sort_alpha   Alpha bound to evaluate moves.
- * @param sort_depth   depth for the shallow search
- */
-static void move_evaluate(Move *move, Search *search, const HashData *hash_data, const int sort_alpha, const int sort_depth)
-{
-#ifndef TUNE_EDAX
-	const int w_hash = 1 << 15;
-	const int w_eval = 1 << 15;
-	const int w_mobility = 1 << 15;
-	const int w_corner_stability = 1 << 11;
-	const int w_edge_stability = 1 << 11;
-	const int w_potential_mobility = 1 << 5;
-	const int w_low_parity = 1 << 3;
-	const int w_mid_parity = 1 << 2;
-	const int w_high_parity = 1 << 1;
-#endif	
-
-	Board *board = search->board;
-	HashData dummy[1];
-
-	if (move_wipeout(move, board)) move->score = (1 << 30);
-	else if (move->x == hash_data->move[0]) move->score = (1 << 29);
-	else if (move->x == hash_data->move[1]) move->score = (1 << 28);
-	else {
-
-		move->score = SQUARE_VALUE[move->x]; // square type
-		if (search->n_empties < 12 && search->parity & QUADRANT_ID[move->x]) move->score += w_low_parity; // parity
-		else if (search->n_empties < 21 && search->parity & QUADRANT_ID[move->x]) move->score += w_mid_parity; // parity
-		else if (search->n_empties < 30 && search->parity & QUADRANT_ID[move->x]) move->score += w_high_parity; // parity
-
-		if (sort_depth < 0) {
-			board_update(board, move);
-				SEARCH_UPDATE_ALL_NODES();
-				move->score += (36 - get_potential_mobility(board->player, board->opponent)) * w_potential_mobility; // potential mobility
-				move->score += get_corner_stability(board->opponent) * w_corner_stability; // corner stability
-				move->score += (36 - get_weighted_mobility(board->player, board->opponent)) * w_mobility; // real mobility
-			board_restore(board, move);
-		} else {
-			int selectivity = search->selectivity;
-			search->selectivity = NO_SELECTIVITY;
-			search_update_midgame(search, move);
-				SEARCH_UPDATE_INTERNAL_NODES();
-				move->score += (36 - get_potential_mobility(board->player, board->opponent)) * w_potential_mobility; // potential mobility
-				move->score += get_edge_stability(board->opponent, board->player) * w_edge_stability; // edge stability
-				move->score += (36 - get_weighted_mobility(board->player, board->opponent)) *  w_mobility; // real mobility
-				switch(sort_depth) {
-				case 0:
-					move->score += ((SCORE_MAX - search_eval_0(search)) >> 2) * w_eval; // 1 level score bonus
-					break;
-				case 1:
-					move->score += ((SCORE_MAX - search_eval_1(search, SCORE_MIN, -sort_alpha)) >> 1) * w_eval;  // 2 level score bonus
-					break;
-				case 2:
-					move->score += ((SCORE_MAX - search_eval_2(search, SCORE_MIN, -sort_alpha)) >> 1) * w_eval;  // 3 level score bonus
-					break;
-				default:
-					if (hash_get(search->hash_table, search->board, board_get_hash_code(search->board), dummy)) move->score += w_hash; // bonus if the position leads to a position stored in the hash-table
-					move->score += ((SCORE_MAX - PVS_shallow(search, SCORE_MIN, -sort_alpha, sort_depth))) * w_eval; // > 3 level bonus
-					break;
-				}
-			search_restore_midgame(search, move);
-			search->selectivity = selectivity;
-		}
-	}
-}
-
 #ifdef TUNE_EDAX
 #include "solver.h"
 
@@ -298,26 +172,24 @@ void tune_move_evaluate(Search *search, const char *filename, const char *w_name
 int movelist_get_moves(MoveList *movelist, const Board *board)
 {
 	Move *previous = movelist->move;
-	Move *move = movelist->move + 1;
-	unsigned long long moves = get_moves(board->player, board->opponent);
-	int x;
-
-	foreach_bit(x, moves) {
-		board_get_move(board, x, move);
-		move->score = -SCORE_INF;
-		previous = previous->next = move;
-		++move;
+	Move *move;
+	unsigned long long moves = board_get_moves(board);
+	int x, n;
+
+	n = 0;
+	foreach_bit (x, moves) {
+		move = previous + 1;
+		previous->next = move;
+		board_get_move_flip(board, x, move);
+		// move->score = -SCORE_INF;	// -INT_MAX?
+		previous = move;
+		++n;
 	}
 	previous->next = NULL;
-	movelist->n_moves = move - movelist->move - 1;
-
-	assert(movelist->n_moves == get_mobility(board->player, board->opponent));
-
-	return movelist->n_moves;
+	movelist->n_moves = n;
+	return n;
 }
 
-
-
 /**
  * @brief Print out a movelist
  *
@@ -331,7 +203,7 @@ void movelist_print(const MoveList *movelist, const int player, FILE *f)
 {
 	Move *iter;
 
-	for (iter = movelist->move->next; iter != NULL; iter = iter->next) {
+	for (iter = movelist->move[0].next; iter != NULL; iter = iter->next) {
 		move_print(iter->x, player, f);
 		fprintf(f, "[%d] ", iter->score);
 	}
@@ -343,24 +215,26 @@ void movelist_print(const MoveList *movelist, const int player, FILE *f)
  * @param previous_best Last best move.
  * @return the following best move in the list.
  */
+#if defined(__INTEL_COMPILER) && defined(__linux__)	// ICC linux emits bogus code in NWS_endgame if inlined
+__attribute__((noinline))
+#endif
 Move* move_next_best(Move *previous_best)
 {
-	if (previous_best->next) {
-		Move *move, *best;
-		best = previous_best;
-		for (move = best->next; move->next != NULL; move = move->next) {
-			if (move->next->score > best->next->score) {
+	Move *move = previous_best->next;
+	if (move && move->next) {	// at least 2 elements
+		Move *best = previous_best;
+		do {
+			if (move->next->score > best->next->score)
 				best = move;
-			}
-		}
-		if (previous_best != best) {
-			move = best->next;
-			best->next = move->next;
-			move->next = previous_best->next;
-			previous_best->next = move;
-		}
+			move = move->next;
+		} while (move->next);
+		// if (previous_best != best) {
+		move = best->next;
+		best->next = move->next;
+		move->next = previous_best->next;
+		previous_best->next = move;
+		// }
 	}
-
 	return previous_best->next;
 }
 
@@ -372,61 +246,119 @@ Move* move_next_best(Move *previous_best)
  */
 Move* move_next_most_expensive(Move *previous_best)
 {
-	if (previous_best->next) {
-		Move *move, *best;
-		best = previous_best;
-		for (move = best->next; move->next != NULL; move = move->next) {
-			if (move->next->cost > best->next->cost) {
+	Move *move = previous_best->next;
+	if (move && move->next) {	// at least 2 elements
+		Move *best = previous_best;
+		do {
+			if (move->next->cost > best->next->cost)
 				best = move;
-			}
-		}
-		if (previous_best != best) {
-			move = best->next;
-			best->next = move->next;
-			move->next = previous_best->next;
-			previous_best->next = move;
-		}
+			move = move->next;
+		} while (move->next);
+		// if (previous_best != best) {
+		move = best->next;
+		best->next = move->next;
+		move->next = previous_best->next;
+		previous_best->next = move;
+		// }
 	}
-
 	return previous_best->next;
 }
 
-/**
- * @brief Return the next move from the list.
- *
- * @param move previous move.
- * @return the next move in the list.
- */
-Move* move_next(Move *move)
-{
-	return move->next;
-}
-
-/**
- * @brief Return the best move of the list.
- *
- * @param movelist The list of move.
- * @return the best move.
- */
-Move* movelist_best(MoveList *movelist)
-{
-	return move_next_best(movelist->move);
-}
+#ifdef TUNE_EDAX
+static int w_hash = 1 << 15;
+static int w_eval = 1 << 15;
+static int w_mobility = 1 << 15;
+static int w_corner_stability = 1 << 11;
+static int w_edge_stability = 1 << 11;
+static int w_potential_mobility = 1 << 5;
+static int w_low_parity = 1 << 3;
+static int w_mid_parity = 1 << 2;
+static int w_high_parity = 1 << 1;
+#else
+enum {
+	w_hash = 1 << 15,
+	w_eval = 1 << 15,
+	w_mobility = 1 << 15,
+	w_corner_stability = 1 << 11,
+	w_edge_stability = 1 << 11,
+	w_potential_mobility = 1 << 5,
+	w_low_parity = 1 << 3,
+	w_mid_parity = 1 << 2,
+	w_high_parity = 1 << 1
+};
+#endif
 
 /**
- * @brief Return the first move of the list.
+ * @brief Evaluate a list of move in order to sort it with depth 0.
+ * (called from NWS_endgame and movelist_evaluate)
  *
- * @param movelist The list of move.
- * @return the first move.
+ * @param movelist List of moves to sort.
+ * @param search Position to evaluate.
+ * @param hash_data   Position (maybe) stored in the hashtable.
  */
-Move* movelist_first(MoveList *movelist)
+void movelist_evaluate_fast(MoveList *movelist, Search *search, const HashData *hash_data)
 {
-	return move_next(movelist->move);
+	Move	*move;
+	int	score, parity_weight;
+
+	// if (search->eval.n_empties < 21)	// mostly true
+		parity_weight = (search->eval.n_empties < 12) ? w_low_parity : w_mid_parity;
+	// else	parity_weight = (search->eval.n_empties < 30) ? w_high_parity : 0;
+
+	move = movelist->move[0].next;
+	do {
+		// move_evaluate(move, search, hash_data, sort_alpha, -1);
+		if (move_wipeout(move, &search->board)) score = (1 << 30);
+		else if (move->x == hash_data->move[0]) score = (1 << 29);
+		else if (move->x == hash_data->move[1]) score = (1 << 28);
+		else {
+#ifdef __AVX2__
+			__m128i PO = _mm_xor_si128(*(__m128i *) &search->board,
+				_mm_or_si128(_mm_set1_epi64x(move->flipped), _mm_loadl_epi64((__m128i *) &X_TO_BIT[move->x])));
+			score  = get_corner_stability(_mm_cvtsi128_si64(PO)) * w_corner_stability; // corner stability
+			__m128i MM = get_moves_and_potential(_mm256_broadcastq_epi64(_mm_unpackhi_epi64(PO, PO)), _mm256_broadcastq_epi64(PO));
+			score += (36 - bit_weighted_count(_mm_extract_epi64(MM, 1))) * w_potential_mobility; // potential mobility
+			score += (36 - bit_weighted_count(_mm_cvtsi128_si64(MM))) * w_mobility; // real mobility
+
+#else
+			unsigned long long O = search->board.player ^ (move->flipped | x_to_bit(move->x));
+			unsigned long long P = search->board.opponent ^ move->flipped;
+			score  = get_corner_stability(O) * w_corner_stability; // corner stability
+  #if defined(hasSSE2) && !defined(POPCOUNT)
+			__m128i MM = bit_weighted_count_sse(get_moves(P, O), get_potential_moves(P, O));
+			score += (36 - _mm_extract_epi16(MM, 4)) * w_potential_mobility; // potential mobility
+			score += (36 - _mm_cvtsi128_si32(MM)) * w_mobility; // real mobility
+  #elif defined(__ARM_NEON)
+			uint64x2_t MM = bit_weighted_count_neon(get_moves(P, O), get_potential_moves(P, O));
+			score += (36 - vgetq_lane_u32(vreinterpretq_u32_u64(MM), 2)) * w_potential_mobility; // potential mobility
+			score += (36 - vgetq_lane_u32(vreinterpretq_u32_u64(MM), 0)) * w_mobility; // real mobility
+  #else
+			score += (36 - bit_weighted_count(get_potential_moves(P, O))) * w_potential_mobility; // potential mobility
+			score += (36 - bit_weighted_count(get_moves(P, O))) * w_mobility; // real mobility
+  #endif
+#endif
+			score += SQUARE_VALUE[move->x]; // square type
+			score += (search->eval.parity & QUADRANT_ID[move->x]) ? parity_weight : 0; // parity
+			SEARCH_UPDATE_ALL_NODES(search->n_nodes);
+		}
+		move->score = score;
+	} while ((move = move->next));
 }
 
 /**
  * @brief Evaluate a list of move in order to sort it.
  *
+ * Evaluate the moves to sort them. Evaluation is based on, in order of importance:
+ *   - wipeout move    : 1 << 30
+ *   - first hash move : 1 << 29
+ *   - second hash move: 1 << 28
+ *   - shallow search  : 1 << 22 to 1 << 14
+ *   - opponent mobility:                 1 << 15            32768...1048576
+ *   - player stability near the corner:  1 << 11             2048...24576
+ *   - opponent potential mobility:       1 << 5                32...1024
+ *   - square value                       1 << 1:               2 ...18
+ *   - parity:                            1 << 0:               0 ... 1
+ *
  * @param movelist List of moves to sort.
  * @param search Position to evaluate.
  * @param hash_data   Position (maybe) stored in the hashtable.
@@ -435,25 +367,103 @@ Move* movelist_first(MoveList *movelist)
  */
 void movelist_evaluate(MoveList *movelist, Search *search, const HashData *hash_data, const int alpha, const int depth)
 {
-	int sort_depth, min_depth;
-	int sort_alpha;
+	static const char min_depth_table[64] = {
+		19, 18, 18, 18, 17, 17, 17, 16,	// (Never for empties < 14)
+		16, 16, 15, 15, 15, 14, 14, 14,
+		13, 13, 13, 12, 12, 12, 11, 11,
+		11, 10, 10, 10,  9,  9,  9,  9,
+		 9,  9,  9,  9,  9,  9,  9,  9,
+		 9,  9,  9,  9,  9,  9,  9,  9,
+		 9,  9,  9,  9,  9,  9,  9,  9,
+		 9,  9,  9,  9,  9,  9,  9,  9
+	};
 	Move *move;
+	int	sort_depth, min_depth, sort_alpha, score, empties, parity_weight;
+	unsigned long long moves;
+	HashData dummy;
+	Eval eval0;
+	Board board0;
+
+	empties = search->eval.n_empties;
+	// min_depth = 9;
+	// if (empties <= 27) min_depth += (30 - empties) / 3;
+	min_depth = min_depth_table[empties];
 
-	min_depth = 9;
-	if (search->n_empties <= 27) min_depth += (30 - search->n_empties) / 3;
 	if (depth >= min_depth) {
+		if (empties < 21)
+			parity_weight = (empties < 12) ? w_low_parity : w_mid_parity;
+		else	parity_weight = (empties < 30) ? w_high_parity : 0;
+
 		sort_depth = (depth - 15) / 3;
-		if (hash_data && hash_data->upper < alpha) sort_depth -= 2; 
-		if (search->n_empties >= 27) ++sort_depth;
-		if (sort_depth < 0) sort_depth = 0; else if (sort_depth > 6) sort_depth = 6;
-	} else {
-		sort_depth = -1;
-	}
+		if (hash_data->upper < alpha) sort_depth -= 2;
+		if (empties >= 27) ++sort_depth;
+		if (sort_depth < 0) sort_depth = 0;
+		else if (sort_depth > 6) sort_depth = 6;
+
+		board0 = search->board;
+		eval0 = search->eval;
+		sort_alpha = MAX(SCORE_MIN, alpha - SORT_ALPHA_DELTA);
+
+		move = movelist->move[0].next;
+		do {
+			// move_evaluate(move, search, hash_data, sort_alpha, sort_depth);
+			if (move_wipeout(move, &search->board)) score = (1 << 30);
+			else if (move->x == hash_data->move[0] && hash_data->wl.c.depth > sort_depth - 3) score = (1 << 29);	// https://github.com/eukaryo/edax-reversi-AVX-v446mod2
+			else if (move->x == hash_data->move[1] && hash_data->wl.c.depth > sort_depth - 3) score = (1 << 28);
+			else {
+				score = SQUARE_VALUE[move->x]; // square type
+				score += (search->eval.parity & QUADRANT_ID[move->x]) ? parity_weight : 0; // parity
+
+				search_update_midgame(search, move);
+
+				SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
+#ifdef __AVX2__
+				__m128i MM =  get_moves_and_potential(_mm256_set1_epi64x(search->board.player), _mm256_set1_epi64x(search->board.opponent));
+				score += (36 - bit_weighted_count(_mm_extract_epi64(MM, 1))) * w_potential_mobility; // potential mobility
+				score += (36 - bit_weighted_count(moves = _mm_cvtsi128_si64(MM))) * w_mobility; // real mobility
+#else
+				moves = board_get_moves(&search->board);
+  #if defined(hasSSE2) && !defined(POPCOUNT)
+				__m128i MM = bit_weighted_count_sse(moves, get_potential_moves(search->board.player, search->board.opponent));
+				score += (36 - _mm_extract_epi16(MM, 4)) * w_potential_mobility; // potential mobility
+				score += (36 - _mm_cvtsi128_si32(MM)) * w_mobility; // real mobility
+  #elif defined(__ARM_NEON)
+				uint64x2_t MM = bit_weighted_count_neon(moves, get_potential_moves(search->board.player, search->board.opponent));
+				score += (36 - vgetq_lane_u32(vreinterpretq_u32_u64(MM), 2)) * w_potential_mobility; // potential mobility
+				score += (36 - vgetq_lane_u32(vreinterpretq_u32_u64(MM), 0)) * w_mobility; // real mobility
+  #else
+				score += (36 - bit_weighted_count(get_potential_moves(search->board.player, search->board.opponent))) * w_potential_mobility; // potential mobility
+				score += (36 - bit_weighted_count(moves)) * w_mobility; // real mobility
+  #endif
+#endif
+				score += get_edge_stability(search->board.opponent, search->board.player) * w_edge_stability; // edge stability
+				switch (sort_depth) {
+				case 0:
+					score += (SCORE_MAX - search_eval_0(search)) * (w_eval >> 2);	// 1 level score bonus
+					break;
+				case 1:
+					score += (SCORE_MAX + search_eval_1(search, sort_alpha, SCORE_MAX, moves)) * (w_eval >> 1);	// 2 level score bonus
+					break;
+				case 2:
+					score += (SCORE_MAX - search_eval_2(search, SCORE_MIN, -sort_alpha, moves)) * (w_eval >> 1);	// 3 level score bonus
+					break;
+				default:	// 3 to 6
+					if (hash_get_from_board(&search->hash_table, &search->board, &dummy)) score += w_hash;	// bonus if the position leads to a position stored in the hash-table
+					// org_selectivity = search->selectivity;
+					// search->selectivity = NO_SELECTIVITY;	// No probcut in PVS_shallow
+					score += ((SCORE_MAX - PVS_shallow(search, SCORE_MIN, -sort_alpha, sort_depth))) * w_eval;	// > 3 level bonus
+					// search->selectivity = org_selectivity;
+					break;
+				}
 
-	sort_alpha = MAX(SCORE_MIN, alpha - SORT_ALPHA_DELTA);
-	foreach_move (move, movelist) {
-		move_evaluate(move, search, hash_data, sort_alpha, sort_depth);
-	}
+				search_restore_midgame(search, move->x, &eval0);
+				search->board = board0;
+			}
+			move->score = score;
+		} while ((move = move->next));
+
+	} else	// sort_depth = -1
+		movelist_evaluate_fast(movelist, search, hash_data);
 }
 
 /**
@@ -467,35 +477,52 @@ void movelist_evaluate(MoveList *movelist, Search *search, const HashData *hash_
  */
 Move* movelist_sort_bestmove(MoveList *movelist, const int move)
 {
-	Move *iter, *previous;
+	Move *iter, *m;
 
-	for (iter = (previous = movelist->move)->next; iter != NULL; iter = (previous = iter)->next) {
-		if (iter->x == move) {
-			previous->next = iter->next;
-			iter->next = movelist->move->next;
-			movelist->move->next = iter;
+	for (iter = &movelist->move[0]; (m = iter->next); iter = m) {
+		if (m->x == move) {
+			iter->next = m->next;
+			m->next = movelist->move[0].next;
+			movelist->move[0].next = m;
 			break;
 		}
 	}
-	return previous;
+	return iter;
 }
 
 /**
- * @brief Sort all moves except the first, based on move cost & hash_table storage.
+ * @brief Sort all moves based on move cost & hash_table storage.
  *
  * @param movelist List of moves to sort.
  * @param hash_data  Data from the hash table.
  */
 void movelist_sort_cost(MoveList *movelist, const HashData *hash_data)
 {
-	Move *iter;
-
-
-	foreach_move(iter, movelist) {
-		if (iter->x == hash_data->move[0]) iter->cost = INT_MAX;
-		else if (iter->x == hash_data->move[1]) iter->cost = INT_MAX - 1;
+	Move *iter, *prev, *m, *hashmove0, *hashmove1;
+
+	hashmove0 = hashmove1 = NULL;
+	for (prev = iter = &movelist->move[0]; (m = prev->next); prev = m) {
+		if (m->x == hash_data->move[0])
+			hashmove0 = prev;
+		if (m->x == hash_data->move[1])
+			hashmove1 = prev;
+	}
+	if (hashmove0) {
+		m = hashmove0->next;
+		hashmove0->next = m->next;
+		m->next = iter->next;
+		if (hashmove1 == iter)
+			hashmove1 = m;
+		iter = iter->next = m;
+	}
+	if (hashmove1) {
+		m = hashmove1->next;
+		hashmove1->next = m->next;
+		m->next = iter->next;
+		iter = iter->next = m;
 	}
-	for (iter =  move_next_most_expensive(movelist->move); iter; iter = move_next_most_expensive(iter));
+	while ((iter = move_next_most_expensive(iter)))
+		;
 }
 
 /**
@@ -504,8 +531,25 @@ void movelist_sort_cost(MoveList *movelist, const HashData *hash_data)
  */
 void movelist_sort(MoveList *movelist)
 {
-	Move *move;
-	foreach_best_move(move, movelist) ;
+	// foreach_best_move(move, *movelist) ;
+
+	Move *previous_best = &movelist->move[0];
+	while (previous_best->next->next) {	// until last 2
+		Move *best = previous_best;
+		Move *move = previous_best->next;
+		do {
+			if (move->next->score > best->next->score)
+				best = move;
+			move = move->next;
+		} while (move->next);
+		// if (previous_best != best) {
+		move = best->next;
+		best->next = move->next;
+		move->next = previous_best->next;
+		previous_best->next = move;
+		// }
+		previous_best = previous_best->next;
+	}
 }
 
 /**
@@ -515,31 +559,18 @@ void movelist_sort(MoveList *movelist)
  */
 Move* movelist_exclude(MoveList *movelist, const int move)
 {
-	Move *iter, *previous;
+	Move *iter, *m;
 
-	for (iter = (previous = movelist->move)->next; iter != NULL; iter = (previous = iter)->next) {
-		if (iter->x == move) {
-			previous->next = iter->next;
+	for (iter = &movelist->move[0]; (m = iter->next); iter = m) {
+		if (m->x == move) {
+			iter->next = m->next;
+			--movelist->n_moves;
 			break;
 		}
 	}
-	if (iter) --movelist->n_moves;
-
-	return iter;
-}
-
-/**
- * @brief Check if the list is empty.
- *
- * @param movelist The list of move.
- * @return true if the list is empty, false otherwise.
- */
-bool movelist_is_empty(const MoveList *movelist)
-{
-	return movelist->n_moves == 0;
+	return m;
 }
 
-
 /**
  * @brief Initialize a sequence of moves.
  *
@@ -620,7 +651,7 @@ void line_print(const Line *line, int width, const char *separator, FILE *f)
 		move_print(line->move[i], player, f);
 	}
 	for (len = MIN(len, width); len > w; len -= w) {
-		fputc(' ', f);fputc(' ', f); if (separator) fputs(separator, f);
+		fputc(' ', f); fputc(' ', f); if (separator) fputs(separator, f);
 	}
 }
 
diff --git a/src/move.h b/src/move.h
index cb86ca8b..31722b6f 100644
--- a/src/move.h
+++ b/src/move.h
@@ -1,11 +1,11 @@
 /**
- * @file move.c
+ * @file move.h
  *
  * @brief Move & list of moves management - header file.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_MOVE_H
@@ -18,17 +18,17 @@
 
 /** move representation */
 typedef struct Move {
+	struct Move *next;            /**< next move in a MoveList */
 	unsigned long long flipped;   /**< bitboard representation of flipped squares */
 	int x;                        /**< square played */
 	int score;                    /**< score for this move */
 	unsigned int cost;            /**< move cost */
-	struct Move *next;            /**< next move in a MoveList */
 } Move;
 
 /** (simple) list of a legal moves */
 typedef struct MoveList {
-	Move move[MAX_MOVE + 2];   /**< array of legal moves */
 	int n_moves;
+	Move move[MAX_MOVE + 1];   /**< array of legal moves */
 } MoveList;
 
 /** (simple) sequence of a legal moves */
@@ -51,9 +51,7 @@ extern const Move MOVE_PASS;
 int symetry(int, const int);
 
 void move_print(const int, const int, FILE*);
-bool move_wipeout(const Move*, const struct Board*);
 Move* move_next_best(Move*);
-Move* move_next(Move*);
 char* move_to_string(const int, const int, char*);
 
 void tune_move_evaluate(struct Search*, const char*, const char*);
@@ -61,26 +59,35 @@ void tune_move_evaluate(struct Search*, const char*, const char*);
 int movelist_get_moves(MoveList*, const struct Board*);
 void movelist_print(const MoveList*, const int, FILE*);
 Move* movelist_sort_bestmove(MoveList*, const int);
+void movelist_evaluate_fast(MoveList*, struct Search*, const struct HashData*);
 void movelist_evaluate(MoveList*, struct Search*, const struct HashData*, const int, const int);
-void movelist_evaluate_fast(MoveList*, struct Search*);
-Move* movelist_best(MoveList*);
-Move* movelist_first(MoveList*);
+
+// bool move_wipeout(const Move*, const struct Board*);	// Check if a move wins 64-0.
+#define	move_wipeout(move,board)	((move)->flipped == (board)->opponent)
+// Move* move_next(Move*);	// Return the next move from the list.
+#define move_next(move)	((move)->next)
+// Move* movelist_best(MoveList*);	// Return the best move of the list.
+#define	movelist_best(movelist)	move_next_best((movelist)->move)
+// Move* movelist_first(MoveList*);	// Return the first move of the list.
+#define	movelist_first(movelist)	move_next((movelist)->move)
+// bool movelist_is_empty(const MoveList*);	// Check if the list is empty.
+#define	movelist_is_empty(movelist)	((movelist)->n_moves < 1)
 
 Move* movelist_exclude(MoveList*, const int);
 void movelist_restore(MoveList*, Move*);
 
 void movelist_sort(MoveList*);
 void movelist_sort_cost(MoveList*, const struct HashData*);
-bool movelist_is_empty(const MoveList*);
 bool movelist_is_single(const MoveList*);
 
 /** macro to iterate over the movelist */
 #define foreach_move(iter, movelist) \
-	for ((iter) = (movelist)->move->next; (iter); (iter) = (iter)->next)
+	for ((iter) = (movelist).move[0].next; (iter); (iter) = (iter)->next)
 
 /** macro to iterate over the movelist from best to worst move */
 #define foreach_best_move(iter, movelist) \
-	for ((iter) = movelist_best(movelist); (iter); (iter) = move_next_best(iter))
+	(iter) = &(movelist).move[0];\
+	while (((iter) = move_next_best(iter)))
 
 void line_init(Line*, const int);
 void line_push(Line*, const int);
diff --git a/src/nboard.c b/src/nboard.c
index 2883bf16..f3345a02 100644
--- a/src/nboard.c
+++ b/src/nboard.c
@@ -3,7 +3,7 @@
  *
  * Chris Welty's NBoard Protocol
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -82,12 +82,12 @@ void ui_init_nboard(UI *ui)
 	Play *play = ui->play;
 
 	// other update...
-	play_init(play, ui->book);
-	play->search->options.header = play->search->options.separator = NULL;
-	ui->book->search = play->search;
-	book_load(ui->book, options.book_file);
-	play->search->id = 1;
-	search_set_observer(play->search, nboard_observer);
+	play_init(play, &ui->book);
+	play->search.options.header = play->search.options.separator = NULL;
+	ui->book.search = &play->search;
+	book_load(&ui->book, options.book_file);
+	play->search.id = 1;
+	search_set_observer(&play->search, nboard_observer);
 	ui->mode = 3;
 	play->type = ui->type;
 
@@ -100,8 +100,8 @@ void ui_init_nboard(UI *ui)
  */
 void ui_free_nboard(UI *ui)
 {
-	if (ui->book->need_saving) book_save(ui->book, options.book_file);
-	book_free(ui->book);
+	if (ui->book.need_saving) book_save(&ui->book, options.book_file);
+	book_free(&ui->book);
 	play_free(ui->play);
 	log_close(nboard_log);
 }
@@ -136,9 +136,12 @@ void ui_loop_nboard(UI *ui)
 			nboard_send("set myname Edax%d", options.level);
 
 		} else if (strcmp(cmd, "game") == 0) {
-			Game game[1];
-			if (parse_ggf(game, param) != param) {
-				game_get_board(game, 60, play->initial_board);
+			Game game;
+			int lastmove = parse_ggf(&game, param);
+			if (lastmove >= 0) {
+				game_get_board(&game, 60, &play->initial_board);
+				if (lastmove == PASS)	// https://github.com/okuhara/edax-reversi-AVX/issues/1
+					board_pass(&play->initial_board);
 				play_new(play);
 			} else {
 				nboard_fail("Cannot parse game \"%s\"", param);
@@ -157,7 +160,7 @@ void ui_loop_nboard(UI *ui)
 		} else if (strcmp(cmd, "go") == 0) {
 			nboard_send("status Edax is thinking");
 			play_go(play, false);
-			nboard_send_move(play->result);
+			nboard_send_move(&play->result);
 			nboard_send("status Edax is waiting");
 
 		} else if (strcmp(cmd, "quit") == 0 || strcmp(cmd, "eof") == 0) {
diff --git a/src/obftest.c b/src/obftest.c
index b913f328..7915a6f2 100644
--- a/src/obftest.c
+++ b/src/obftest.c
@@ -26,7 +26,7 @@
 
 /** OBF structure: Othello Board File */
 typedef struct OBF {
-	Board board[1];   /**<! Othello board */
+	Board board;      /**<! Othello board */
 	int player;       /**<! Player on turn */
 	struct {
 		int x;        /**<! Move coordinate */
@@ -64,8 +64,8 @@ static void obf_write(OBF *obf, FILE *f)
 	char s[80];
 	int i;
 
-	if ((obf->board->player | obf->board->opponent) != 0) {
-		board_to_string(obf->board, obf->player, s);
+	if ((obf->board.player | obf->board.opponent) != 0) {
+		board_to_string(&obf->board, obf->player, s);
 		fprintf(f, "%s;", s);
 		for (i = 0; i < obf->n_moves; ++i) {
 			putc(' ', f);
@@ -89,12 +89,12 @@ static void obf_write(OBF *obf, FILE *f)
 static int obf_read(OBF *obf, FILE *f)
 {
 	char *string, *line, *next;
-	Move move[1];
+	Move move;
 	int parse_ok;
 
 	obf->n_moves = 0;
 	obf->best_score = -SCORE_INF;
-	obf->board->player = obf->board->opponent = 0;
+	obf->board.player = obf->board.opponent = 0;
 	obf->comments = NULL;
 
 	line = string_read_line(f);
@@ -107,36 +107,36 @@ static int obf_read(OBF *obf, FILE *f)
 		} else if (*string == '\n' || *string == '\r' || *string == '\0') {
 			parse_ok = OBF_PARSE_SKIP;
 		} else {
-			next = parse_board(string, obf->board, &obf->player);
+			next = parse_board(string, &obf->board, &obf->player);
 			parse_ok = (next > string) ? OBF_PARSE_OK : OBF_PARSE_SKIP;
 		}
 
 		while (parse_ok == OBF_PARSE_OK && *(string = parse_find(next, ';')) == ';') {
-			next = parse_move(++string, obf->board, move);
+			next = parse_move(++string, &obf->board, &move);
 			if (next != string) {
 				string = parse_find(next, ':');
 				if (*string == ':') ++string;
 				else {
-					warn("missing score in %s (%d) %s %s\n", line, move->x, next, string);
+					warn("missing score in %s (%d) %s %s\n", line, move.x, next, string);
 					printf("read>"); obf_write(obf, stdout);
 					parse_ok = OBF_PARSE_SKIP;
 					break;
 				}
 			}
-			move->score = -SCORE_INF;
-			next = parse_int(string, &move->score);
+			move.score = -SCORE_INF;
+			next = parse_int(string, &move.score);
 			if (next == string && obf->best_score == -SCORE_INF) {
 				warn("missing best score in %s\n", line);
 				break;
 			}
 
-			if (move->x == NOMOVE && move->score == -SCORE_INF) {
+			if (move.x == NOMOVE && move.score == -SCORE_INF) {
 				break;
 			}
 
-			if (move->score > obf->best_score) obf->best_score = move->score;
-			obf->move[obf->n_moves].x = move->x;
-			obf->move[obf->n_moves].score = move->score;
+			if (move.score > obf->best_score) obf->best_score = move.score;
+			obf->move[obf->n_moves].x = move.x;
+			obf->move[obf->n_moves].score = move.score;
 			++obf->n_moves;
 		}
 
@@ -158,9 +158,9 @@ static void obf_search(Search *search, OBF *obf, int n)
 	int i, j;
 
 	search_cleanup(search);
-	search_set_board(search, obf->board, obf->player);
-	search_set_level(search, options.level, search->n_empties);
-	if (options.depth >= 0) search->options.depth = MIN(options.depth, search->n_empties);
+	search_set_board(search, &obf->board, obf->player);
+	search_set_level(search, options.level, search->eval.n_empties);
+	if (options.depth >= 0) search->options.depth = MIN(options.depth, search->eval.n_empties);
 	if (options.selectivity >= 0) search->options.selectivity = options.selectivity;
 
 	if (options.play_type == EDAX_TIME_PER_MOVE) search_set_move_time(search, options.time);
@@ -168,7 +168,7 @@ static void obf_search(Search *search, OBF *obf, int n)
 
 	if (options.verbosity >= 2) {
 		printf("\n*** problem # %d ***\n\n", n);
-		board_print(search->board, search->player, stdout);
+		board_print(&search->board, search->player, stdout);
 		putchar('\n');
 		puts(search->options.header);
 		puts(search->options.separator);
@@ -218,12 +218,13 @@ static void obf_search(Search *search, OBF *obf, int n)
 static void obf_build(Search *search, OBF *obf, int n)
 {
 	int n_moves;
-	
+	unsigned long long hash_code;
+
 	search_cleanup(search);
-	search_set_board(search, obf->board, obf->player);
-	search_set_level(search, options.level, search->n_empties);
+	search_set_board(search, &obf->board, obf->player);
+	search_set_level(search, options.level, search->eval.n_empties);
 	if (options.depth >= 0) {
-		search->options.depth = MAX(options.depth, search->n_empties);
+		search->options.depth = MAX(options.depth, search->eval.n_empties);
 		search->options.selectivity = 0;
 	}
 	if (options.selectivity >= 0) search->options.selectivity = options.selectivity;
@@ -235,7 +236,7 @@ static void obf_build(Search *search, OBF *obf, int n)
 	if (options.verbosity >= 2) {
 		printf("\n*** problem # %d ***\n\n", n);
 		if (obf->comments) printf("* %s *\n\n", obf->comments);
-		board_print(search->board, search->player, stdout);
+		board_print(&search->board, search->player, stdout);
 		putchar('\n');
 		puts(search->options.header);
 		puts(search->options.separator);
@@ -245,7 +246,7 @@ static void obf_build(Search *search, OBF *obf, int n)
 	obf->n_moves = 0;
 	obf->best_score = -SCORE_INF;
 	search->result->score = -SCORE_INF;
-	n_moves = search->movelist->n_moves;
+	n_moves = search->movelist.n_moves;
 
 	if (n_moves == 0) {
 		if (options.verbosity == 1) printf("%3d|", n);
@@ -270,9 +271,10 @@ static void obf_build(Search *search, OBF *obf, int n)
 		if (obf->best_score < search->result->score) obf->best_score = search->result->score;
 		++obf->n_moves;
 
-		hash_exclude_move(search->pv_table, search->board, board_get_hash_code(search->board), search->result->move);
-		hash_exclude_move(search->hash_table,  search->board, board_get_hash_code(search->board), search->result->move);
-		movelist_exclude(search->movelist, search->result->move);
+		hash_code = board_get_hash_code(&search->board);
+		hash_exclude_move(&search->pv_table, &search->board, hash_code, search->result->move);
+		hash_exclude_move(&search->hash_table, &search->board, hash_code, search->result->move);
+		movelist_exclude(&search->movelist, search->result->move);
 	}
 
 	if (options.verbosity) {
@@ -291,7 +293,7 @@ static void obf_build(Search *search, OBF *obf, int n)
 void obf_test(Search *search, const char *obf_file, const char *wrong_file)
 {
 	FILE *f, *w = NULL;
-	OBF obf[1];
+	OBF obf;
 	unsigned long long T = 0, n_nodes = 0;
 	int n = 0, n_bad_score = 0, n_bad_move = 0;
 	double score_error = 0.0, move_error = 0.0;
@@ -323,28 +325,28 @@ void obf_test(Search *search, const char *obf_file, const char *wrong_file)
 		if (search->options.separator) printf("---+%s\n", search->options.separator);
 	}
 
-	while ((ok = obf_read(obf, f)) != OBF_PARSE_END) {
+	while ((ok = obf_read(&obf, f)) != OBF_PARSE_END) {
 		if (ok == OBF_PARSE_OK) {
-			obf_search(search, obf, ++n);
+			obf_search(search, &obf, ++n);
 		
 			T += search_time(search);
 			n_nodes += search_count_nodes(search);
-			for (i = 0; i < obf->n_moves; ++i) {
-				if (obf->move[i].x == search->result->move) break;
+			for (i = 0; i < obf.n_moves; ++i) {
+				if (obf.move[i].x == search->result->move) break;
 			}
-			if (i < obf->n_moves) {
-				if (obf->move[i].score < obf->best_score) ++n_bad_move;
-				if (obf->move[i].score != search->result->score) ++n_bad_score;
-				move_error += abs(obf->best_score - obf->move[i].score);
-				if (w && obf->move[i].score < obf->best_score) obf_write(obf, w);
+			if (i < obf.n_moves) {
+				if (obf.move[i].score < obf.best_score) ++n_bad_move;
+				if (obf.move[i].score != search->result->score) ++n_bad_score;
+				move_error += abs(obf.best_score - obf.move[i].score);
+				if (w && obf.move[i].score < obf.best_score) obf_write(&obf, w);
 			} 
-			if (obf->best_score > -SCORE_INF) score_error += abs(obf->best_score - search->result->score);
+			if (obf.best_score > -SCORE_INF) score_error += abs(obf.best_score - search->result->score);
 			else print_summary = true;
 		}
-		obf_free(obf);			
+		obf_free(&obf);			
 	}
 
-	if (options.verbosity == 1 && search->options.separator) puts(search->options.separator);
+	if (options.verbosity == 1 && search->options.separator) printf("---+%s\n", search->options.separator);
 	printf("%.30s: ", obf_file);
 	if (n_nodes) printf("%llu nodes in ", n_nodes);
 	time_print(T, false, stdout);
@@ -376,7 +378,7 @@ void script_to_obf(Search *search, const char *script_file, const char *obf_file
 {
 	
 	FILE *i, *o;
-	OBF obf[1];
+	OBF obf;
 	int n = 0, ok;
 
 	// add observers
@@ -410,15 +412,15 @@ void script_to_obf(Search *search, const char *script_file, const char *obf_file
 		if (search->options.separator) printf("---+%s\n", search->options.separator);
 	}
 
-	while ((ok = obf_read(obf, i)) != OBF_PARSE_END) {
+	while ((ok = obf_read(&obf, i)) != OBF_PARSE_END) {
 		if (ok == OBF_PARSE_OK) {
-			obf_build(search, obf, ++n);
+			obf_build(search, &obf, ++n);
 		}
-		obf_write(obf, o);
-		obf_free(obf);			
+		obf_write(&obf, o);
+		obf_free(&obf);			
 	}
 
-	if (options.verbosity == 1 && search->options.separator) puts(search->options.separator);
+	if (options.verbosity == 1 && search->options.separator) printf("---+%s\n", search->options.separator);
 	putchar('\n');
 
 	fclose(o);
@@ -436,7 +438,7 @@ void obf_filter(const char *input_file, const char *output_file)
 	FILE *in, *out;
 	int i, n, f, ok;
 	int n_best, second_best;
-	OBF obf[1];
+	OBF obf;
 
 	// open script file with problems
 	in = fopen(input_file, "r");
@@ -451,21 +453,21 @@ void obf_filter(const char *input_file, const char *output_file)
 	}
 	
 	n = f = 0;
-	while ((ok = obf_read(obf, in)) != OBF_PARSE_END) {
+	while ((ok = obf_read(&obf, in)) != OBF_PARSE_END) {
 		if (ok == OBF_PARSE_OK) {
 			++n;
 			n_best = 0;
-			second_best = obf->best_score - 4;
-			for (i = 0; i < obf->n_moves; ++i) {
-				if (obf->move[i].score == obf->best_score) ++n_best;
-				else if (obf->move[i].score > second_best) second_best = obf->move[i].score;
+			second_best = obf.best_score - 4;
+			for (i = 0; i < obf.n_moves; ++i) {
+				if (obf.move[i].score == obf.best_score) ++n_best;
+				else if (obf.move[i].score > second_best) second_best = obf.move[i].score;
 			}
-			if (n_best == 1 && second_best == obf->best_score - 2) {
+			if (n_best == 1 && second_best == obf.best_score - 2) {
 				++f;
-				obf_write(obf, out);
+				obf_write(&obf, out);
 			}
 		}
-		obf_free(obf);			
+		obf_free(&obf);
 	}
 
 	printf("OBF filter: %d selected out of %d positions\n", f, n);
@@ -484,13 +486,13 @@ void obf_speed(Search *search, const int n)
 	unsigned long long t = real_clock();
 	unsigned long long T = 0, n_nodes = 0;
 	const int level = options.level;
-	Random r[1];
+	Random r;
 	OBF obf;
 	
 	obf.n_moves = 0;
 	obf.best_score = -SCORE_INF;
 	
-	random_seed(r, 42);
+	random_seed(&r, 42);
 	options.level = 60;
 	search_set_observer(search, search_observer);
 	search->options.verbosity = (options.verbosity == 1 ? 0 : options.verbosity);
@@ -504,11 +506,13 @@ void obf_speed(Search *search, const int n)
 	for (i = 0; n == - 1 ? real_clock() - t < 60000 : i < n; ++i) {
 		const int ply = MAX(30, 40 - i / 5);
 		obf.player = ply & 1;
-		board_rand(obf.board, ply, r);
+		board_rand(&obf.board, ply, &r);
 		obf_search(search, &obf, i + 1);
 		T += search_time(search);
 		n_nodes += search_count_nodes(search);
 	}
+
+	if (options.verbosity == 1 && search->options.separator) printf("---+%s\n", search->options.separator);
 	printf("%d positions solved: ", i);
 	if (n_nodes) printf("%llu nodes in ", n_nodes);
 	time_print(T, false, stdout);
diff --git a/src/opening.c b/src/opening.c
index 55201079..3d8297e3 100644
--- a/src/opening.c
+++ b/src/opening.c
@@ -3,7 +3,7 @@
  *
  * Opening Name aliasing.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -12,6 +12,9 @@
 #include "board.h"
 
 #include <ctype.h>
+#ifdef UNICODE
+#include <wctype.h>
+#endif
 
 /** opening name structure */
 typedef struct OpeningName {
@@ -31,10 +34,10 @@ static const OpeningName OPENING_NAME[] = {
 	{"f5d6", "perpendiculaire"},
 	{"f5d6c3", "inhumaine"},
 	{"f5d6c3d3c4", "tigre"},
-	{"f5d6c3d3c4b3", "bill - de grey"},
-	{"f5d6c3d3c4b3c5", "de grey classique"},
-	{"f5d6c3d3c4b3c6", "de grey de bétonnage"},
-	{"f5d6c3d3c4b3d7", "de grey edmead"},
+	{"f5d6c3d3c4b3", "Bill - de Grey"},
+	{"f5d6c3d3c4b3c5", "de Grey classique"},
+	{"f5d6c3d3c4b3c6", "de Grey de bétonnage"},
+	{"f5d6c3d3c4b3d7", "de Grey edmead"},
 	{"f5d6c3d3c4f4c5", "tigre centrale"},
 	{"f5d6c3d3c4f4c5b3", "petite tigre centrale"},
 	{"f5d6c3d3c4f4c5b3c2", "triangle"},
@@ -42,205 +45,205 @@ static const OpeningName OPENING_NAME[] = {
 	{"f5d6c3d3c4f4c5b3c2b4c6", "triangle centrale classique"},
 	{"f5d6c3d3c4f4c5b3c2b4c6d2", "triangle grosse masse"},
 	{"f5d6c3d3c4f4c5b3c2b4c6d2a3", "triangle grosse masse"},
-	{"f5d6c3d3c4f4c5b3c2b4c6d2e3", "triangle de varsovie"},
-	{"f5d6c3d3c4f4c5b3c2b4c6d2e6", "caspard"},
-	{"f5d6c3d3c4f4c5b3c2b4c6d2e6b5a5", "caspard"},
-	{"f5d6c3d3c4f4c5b3c2b4c6d2e6b5e3", "caspard retardée"},
-	{"f5d6c3d3c4f4c5b3c2b4c6d2e6b5e3f3g4", "caspard de 91"},
-	{"f5d6c3d3c4f4c5b3c2b4c6e6", "tamenori retardée"},
-	{"f5d6c3d3c4f4c5b3c2b4c6e6b5", "tamenori retardée penloup-caspard"},
-	{"f5d6c3d3c4f4c5b3c2b4c6e6e3", "tamenori retardée di meglio"},
+	{"f5d6c3d3c4f4c5b3c2b4c6d2e3", "triangle de Varsovie"},
+	{"f5d6c3d3c4f4c5b3c2b4c6d2e6", "Caspard"},
+	{"f5d6c3d3c4f4c5b3c2b4c6d2e6b5a5", "Caspard"},
+	{"f5d6c3d3c4f4c5b3c2b4c6d2e6b5e3", "Caspard retardée"},
+	{"f5d6c3d3c4f4c5b3c2b4c6d2e6b5e3f3g4", "Caspard de 91"},
+	{"f5d6c3d3c4f4c5b3c2b4c6e6", "Tamenori retardée"},
+	{"f5d6c3d3c4f4c5b3c2b4c6e6b5", "tamenori retardée Penloup-Caspard"},
+	{"f5d6c3d3c4f4c5b3c2b4c6e6e3", "Tamenori retardée Di Meglio"},
 	{"f5d6c3d3c4f4c5b3c2b4e3", "coccinelle"},
 	{"f5d6c3d3c4f4c5b3c2b4e3e6c6", "coccinelle thor"},
 	{"f5d6c3d3c4f4c5b3c2b4e3e6c6f6", "coccinelle moderne"},
 	{"f5d6c3d3c4f4c5b3c2b4e3e6c6g4", "coccinelle classique"},
-	{"f5d6c3d3c4f4c5b3c2e3", "triangle nicolet"},
-	{"f5d6c3d3c4f4c5b3c2e3d2b4", "triangle nicolet centrale"},
-	{"f5d6c3d3c4f4c5b3c2e3d2c6", "triangle nicolet à plat"},
-	{"f5d6c3d3c4f4c5b3c2e6", "tamenori"},
-	{"f5d6c3d3c4f4c5b3c2e6b4", "variante de stockholm"},
-	{"f5d6c3d3c4f4c5b3c2e6b4f6c6b6", "moorlin retardée"},
-	{"f5d6c3d3c4f4c5b3c2e6c6", "tamenori classique"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2a3", "tamenori japonaise"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c1", "tamenori française"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c1b6", "tamenori française penloup"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c1d7", "tamenori française shaman"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c7", "tamenori de sophia"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6f3", "casse-tête"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6f6", "tamenori de londres"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2f7", "tamenori anglaise"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b6b4f6", "moorlin"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b6b4f6c7b5", "moorlin du centre"},
-	{"f5d6c3d3c4f4c5b3c2e6c6b6b4f6g3b5", "moorlin de béton"},
+	{"f5d6c3d3c4f4c5b3c2e3", "triangle Nicolet"},
+	{"f5d6c3d3c4f4c5b3c2e3d2b4", "triangle Nicolet centrale"},
+	{"f5d6c3d3c4f4c5b3c2e3d2c6", "triangle Nicolet à plat"},
+	{"f5d6c3d3c4f4c5b3c2e6", "Tamenori"},
+	{"f5d6c3d3c4f4c5b3c2e6b4", "variante de Stockholm"},
+	{"f5d6c3d3c4f4c5b3c2e6b4f6c6b6", "moorlin retardée"},
+	{"f5d6c3d3c4f4c5b3c2e6c6", "Tamenori classique"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2a3", "Tamenori japonaise"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c1", "Tamenori française"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c1b6", "Tamenori française penloup"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c1d7", "Tamenori française shaman"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6c7", "Tamenori de sophia"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6f3", "casse-tête"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2e3a6f6", "Tamenori de Londres"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b4b5d2f7", "Tamenori anglaise"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b6b4f6", "Moorlin"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b6b4f6c7b5", "Moorlin du centre"},
+	{"f5d6c3d3c4f4c5b3c2e6c6b6b4f6g3b5", "Moorlin de béton"},
 	{"f5d6c3d3c4f4c5b3d2", "in my country"},
 	{"f5d6c3d3c4f4c5b3d2b4", "in my country tire-bouchon"},
 	{"f5d6c3d3c4f4c5b3d2c6", "in my country a plat"},
-	{"f5d6c3d3c4f4c5b3d2c6b4", "in my country de lyon"},
+	{"f5d6c3d3c4f4c5b3d2c6b4", "in my country de Lyon"},
 	{"f5d6c3d3c4f4c5b3d2c6b5", "in my country alien"},
-	{"f5d6c3d3c4f4c5b3d2c6b6", "in my country jensen"},
+	{"f5d6c3d3c4f4c5b3d2c6b6", "in my country Jensen"},
 	{"f5d6c3d3c4f4c5b3d2e3", "geisha"},
-	{"f5d6c3d3c4f4c5b3d2e3b4", "geisha ghirardato"},
-	{"f5d6c3d3c4f4c5b3d2e3c2", "geisha pseudo-nicolet"},
-	{"f5d6c3d3c4f4c5b3e2", "tigre centrale décalée"},
-	{"f5d6c3d3c4f4c5b3e2c6", "décalée à plat"},
-	{"f5d6c3d3c4f4c5b3e2e3", "geisha décalée"},
+	{"f5d6c3d3c4f4c5b3d2e3b4", "geisha Ghirardato"},
+	{"f5d6c3d3c4f4c5b3d2e3c2", "geisha pseudo-Nicolet"},
+	{"f5d6c3d3c4f4c5b3e2", "tigre centrale décalée"},
+	{"f5d6c3d3c4f4c5b3e2c6", "décalée à plat"},
+	{"f5d6c3d3c4f4c5b3e2e3", "geisha décalée"},
 	{"f5d6c3d3c4f4c5b4", "grande tigre centrale"},
-	{"f5d6c3d3c4f4c5b4b3", "penloup-juhem"},
-	{"f5d6c3d3c4f4c5b4b3b5", "penloup-juhem requiem"},
-	{"f5d6c3d3c4f4c5b4b3c2", "penloup-juhem, défense tastet"},
+	{"f5d6c3d3c4f4c5b4b3", "Penloup-Juhem"},
+	{"f5d6c3d3c4f4c5b4b3b5", "Penloup-Juhem requiem"},
+	{"f5d6c3d3c4f4c5b4b3c2", "Penloup-Juhem, défense Tastet"},
 	{"f5d6c3d3c4f4c5b4b3c2d7c6", "equerre centrale"},
 	{"f5d6c3d3c4f4c5b4b3c2d7c7", "equerre damier"},
-	{"f5d6c3d3c4f4c5b4b3c6", "penloup-juhem croix du sud"},
-	{"f5d6c3d3c4f4c5b4b3e6", "penloup-juhem kaneda"},
-	{"f5d6c3d3c4f4c5b4b3e6c6", "penloup-juhem andriani"},
-	{"f5d6c3d3c4f4c5b4b3e6c6b5e3c2", "penloup-juhem de 92"},
-	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2", "penloup-juhem ohyanagi"},
-	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2a6", "penloup-juhem néo-tastet"},
-	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2a6a5", "penloup-juhem classique"},
-	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2f7", "penloup-juhem ancienne"},
+	{"f5d6c3d3c4f4c5b4b3c6", "Penloup-Juhem croix du sud"},
+	{"f5d6c3d3c4f4c5b4b3e6", "Penloup-Juhem Kaneda"},
+	{"f5d6c3d3c4f4c5b4b3e6c6", "Penloup-Juhem Andriani"},
+	{"f5d6c3d3c4f4c5b4b3e6c6b5e3c2", "Penloup-Juhem de 92"},
+	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2", "Penloup-Juhem Ohyanagi"},
+	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2a6", "Penloup-Juhem néo-Tastet"},
+	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2a6a5", "Penloup-Juhem classique"},
+	{"f5d6c3d3c4f4c5b4b3e6c6b5e3f2f7", "Penloup-Juhem ancienne"},
 	{"f5d6c3d3c4f4c5b4b5", "tigre centrale classique"},
-	{"f5d6c3d3c4f4c5b4b5c6", "tigre centrale de paris"},
-	{"f5d6c3d3c4f4c5b4b5c6f3", "tigre centrale d'athènes"},
+	{"f5d6c3d3c4f4c5b4b5c6", "tigre centrale de Paris"},
+	{"f5d6c3d3c4f4c5b4b5c6f3", "tigre centrale d'Athènes"},
 	{"f5d6c3d3c4f4c5b4b5c6f3a5", "tigre centrale grosse masse"},
-	{"f5d6c3d3c4f4c5b4b5c6f3e6", "tigre centrale murakami"},
+	{"f5d6c3d3c4f4c5b4b5c6f3e6", "tigre centrale Murakami"},
 	{"f5d6c3d3c4f4c5b4b5c6f3e6e3d2", "tigre centrale japonaise"},
-	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6b6", "murakami taïshii"},
-	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6", "murakami doyo-kaï"},
-	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6g5d7g3b6", "doyo-kaï polonaise"},
-	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6g5d7g3e7", "doyo-kaï centrale"},
-	{"f5d6c3d3c4f4c5b4b5c6f3f6", "tigre centrale plowman"},
+	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6b6", "Murakami Taïshii"},
+	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6", "Murakami doyo-kaï"},
+	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6g5d7g3b6", "doyo-kaï polonaise"},
+	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6g5d7g3e7", "doyo-kaï centrale"},
+	{"f5d6c3d3c4f4c5b4b5c6f3f6", "tigre centrale Plowman"},
 	{"f5d6c3d3c4f4c5b4b5e6", "tigre centrale d'interversion"},
-	{"f5d6c3d3c4f4c5b4c6", "tigre centrale andersson"},
-	{"f5d6c3d3c4f4c5b4c6e6a3", "andersson, var.cali"},
+	{"f5d6c3d3c4f4c5b4c6", "tigre centrale Andersson"},
+	{"f5d6c3d3c4f4c5b4c6e6a3", "Andersson, var. Cali"},
 	{"f5d6c3d3c4f4c5b4e3", "tigre centrale baltique"},
-	{"f5d6c3d3c4f4e3", "brightwell"},
-	{"f5d6c3d3c4f4e3f3", "brightwell intérieure"},
-	{"f5d6c3d3c4f4e3f3e6", "brightwell anglaise"},
-	{"f5d6c3d3c4f4e3f3e6b4", "brightwell leader"},
-	{"f5d6c3d3c4f4e3f3e6b4c5", "brightwell anglaise robin"},
-	{"f5d6c3d3c4f4e3f3e6b4c6", "brightwell anglaise nicolet"},
-	{"f5d6c3d3c4f4e3f3e6c6", "brightwell papillon"},
-	{"f5d6c3d3c4f4e3f3e6c6c5", "lepidopterix albus"},
-	{"f5d6c3d3c4f4e3f3e6c6g4", "lepidopterix niger"},
-	{"f5d6c3d3c4f4e3f3e6f6", "brightwell aile"},
+	{"f5d6c3d3c4f4e3", "Brightwell"},
+	{"f5d6c3d3c4f4e3f3", "Brightwell intérieure"},
+	{"f5d6c3d3c4f4e3f3e6", "Brightwell anglaise"},
+	{"f5d6c3d3c4f4e3f3e6b4", "Brightwell Leader"},
+	{"f5d6c3d3c4f4e3f3e6b4c5", "Brightwell anglaise Robin"},
+	{"f5d6c3d3c4f4e3f3e6b4c6", "Brightwell anglaise Nicolet"},
+	{"f5d6c3d3c4f4e3f3e6c6", "Brightwell papillon"},
+	{"f5d6c3d3c4f4e3f3e6c6c5", "Lepidopterix albus"},
+	{"f5d6c3d3c4f4e3f3e6c6g4", "Lepidopterix niger"},
+	{"f5d6c3d3c4f4e3f3e6f6", "Brightwell aile"},
 	{"f5d6c3d3c4f4e3f3e6f6g4c5", "aile op'masse"},
-	{"f5d6c3d3c4f4e3f3e6f6g4e2", "aile feldborg"},
-	{"f5d6c3d3c4f4e3f3e6f6g4g3", "aile de béton"},
-	{"f5d6c3d3c4f4e3f3g4", "brightwell orque"},
-	{"f5d6c3d3c4f4e3f3g4e2", "orque de cambridge"},
-	{"f5d6c3d3c4f4e3f3g4f6", "orque extérieure retardée"},
+	{"f5d6c3d3c4f4e3f3e6f6g4e2", "aile Feldborg"},
+	{"f5d6c3d3c4f4e3f3e6f6g4g3", "aile de béton"},
+	{"f5d6c3d3c4f4e3f3g4", "Brightwell orque"},
+	{"f5d6c3d3c4f4e3f3g4e2", "orque de Cambridge"},
+	{"f5d6c3d3c4f4e3f3g4f6", "orque extérieure retardée"},
 	{"f5d6c3d3c4f4e3f3g4g3", "orque diagonale"},
 	{"f5d6c3d3c4f4e3f3g4g3f6", "orque diagonale de lille"},
-	{"f5d6c3d3c4f4e3f3g4g3g5", "orque diagonale rossi"},
-	{"f5d6c3d3c4f4e3f3g4g5", "orque à plat"},
-	{"f5d6c3d3c4f4e3f6", "brightwell extérieure"},
-	{"f5d6c3d3c4f4e3f6c6c5d7c7", "brightwell sablier"},
-	{"f5d6c3d3c4f4e3f6c6c5d7e7", "brightwell d'attente"},
-	{"f5d6c3d3c4f4e3f6c6c5d7e7b6", "brightwell d'attente transverse"},
-	{"f5d6c3d3c4f4e3f6c6c5d7e7e6c8", "brightwell d'attente au bord"},
-	{"f5d6c3d3c4f4e3f6c6c5e6", "brightwell parisienne"},
+	{"f5d6c3d3c4f4e3f3g4g3g5", "orque diagonale Rossi"},
+	{"f5d6c3d3c4f4e3f3g4g5", "orque à plat"},
+	{"f5d6c3d3c4f4e3f6", "Brightwell extérieure"},
+	{"f5d6c3d3c4f4e3f6c6c5d7c7", "Brightwell sablier"},
+	{"f5d6c3d3c4f4e3f6c6c5d7e7", "Brightwell d'attente"},
+	{"f5d6c3d3c4f4e3f6c6c5d7e7b6", "Brightwell d'attente transverse"},
+	{"f5d6c3d3c4f4e3f6c6c5d7e7e6c8", "Brightwell d'attente au bord"},
+	{"f5d6c3d3c4f4e3f6c6c5e6", "Brightwell parisienne"},
 	{"f5d6c3d3c4f4e6", "tigre compacte"},
-	{"f5d6c3d3c4f4e6b3", "compacte extérieure"},
+	{"f5d6c3d3c4f4e6b3", "compacte extérieure"},
 	{"f5d6c3d3c4f4e6b3c2", "compacte triangle"},
 	{"f5d6c3d3c4f4e6b3c2e3d2b4", "compacte triangle qvist"},
-	{"f5d6c3d3c4f4e6b3c2e3d2c5", "compacte triangle de varsovie"},
-	{"f5d6c3d3c4f4e6b3d2", "compacte extérieure droite"},
-	{"f5d6c3d3c4f4e6b3d2c5", "variante aldaron"},
+	{"f5d6c3d3c4f4e6b3c2e3d2c5", "compacte triangle de Varsovie"},
+	{"f5d6c3d3c4f4e6b3d2", "compacte extérieure droite"},
+	{"f5d6c3d3c4f4e6b3d2c5", "variante Aldaron"},
 	{"f5d6c3d3c4f4e6b3d2e3", "variante des deux diagonales"},
-	{"f5d6c3d3c4f4e6b3e2", "compacte extérieure diagonale"},
+	{"f5d6c3d3c4f4e6b3e2", "compacte extérieure diagonale"},
 	{"f5d6c3d3c4f4e6b3e2c5", "variante du triplet"},
 	{"f5d6c3d3c4f4e6b3e2e3", "variante du quadruplet"},
 	{"f5d6c3d3c4f4e6f6", "compacte en coin"},
 	{"f5d6c3d3c4f4e6f6e3", "compacte principale"},
 	{"f5d6c3d3c4f4e6f6e3c5c6", "compacte d'opposition"},
-	{"f5d6c3d3c4f4e6f6e3c5c6b5", "compacte d'opposition française"},
-	{"f5d6c3d3c4f4e6f6e3c5c6b6", "compacte d'opposition sakaguchi"},
-	{"f5d6c3d3c4f4e6f6e3c5g4", "compacte à plat"},
-	{"f5d6c3d3c4f4e6f6e7", "compacte de grey"},
+	{"f5d6c3d3c4f4e6f6e3c5c6b5", "compacte d'opposition française"},
+	{"f5d6c3d3c4f4e6f6e3c5c6b6", "compacte d'opposition Sakaguchi"},
+	{"f5d6c3d3c4f4e6f6e3c5g4", "compacte à plat"},
+	{"f5d6c3d3c4f4e6f6e7", "compacte de Grey"},
 	{"f5d6c3d3c4f4f6", "tigre diagonale"},
-	{"f5d6c3d3c4f4f6b4", "kung"},
-	{"f5d6c3d3c4f4f6b4c2", "kung diagonale"},
-	{"f5d6c3d3c4f4f6b4c2e2", "kung diagonale, variante 42"},
-	{"f5d6c3d3c4f4f6b4c2f3", "kung diagonale, variante 33"},
-	{"f5d6c3d3c4f4f6b4f3", "kung plate"},
-	{"f5d6c3d3c4f4f6b4f3e6e3g5b5", "kung du pion isolé"},
-	{"f5d6c3d3c4f4f6b4f3e6e3g5g6", "kung béton"},
+	{"f5d6c3d3c4f4f6b4", "Kung"},
+	{"f5d6c3d3c4f4f6b4c2", "Kung diagonale"},
+	{"f5d6c3d3c4f4f6b4c2e2", "Kung diagonale, variante 42"},
+	{"f5d6c3d3c4f4f6b4c2f3", "Kung diagonale, variante 33"},
+	{"f5d6c3d3c4f4f6b4f3", "Kung plate"},
+	{"f5d6c3d3c4f4f6b4f3e6e3g5b5", "Kung du pion isolé"},
+	{"f5d6c3d3c4f4f6b4f3e6e3g5g6", "Kung béton"},
 	{"f5d6c3d3c4f4f6f3", "tigre diagonale moderne"},
-	{"f5d6c3d3c4f4f6f3e3", "tigre diagonale française"},
-	{"f5d6c3d3c4f4f6f3e3b4", "suite française"},
-	{"f5d6c3d3c4f4f6f3e3g5g4", "popov (interversion)"},
-	{"f5d6c3d3c4f4f6f3e3g5g6", "japon 93 (interversion)"},
+	{"f5d6c3d3c4f4f6f3e3", "tigre diagonale française"},
+	{"f5d6c3d3c4f4f6f3e3b4", "suite française"},
+	{"f5d6c3d3c4f4f6f3e3g5g4", "Popov (interversion)"},
+	{"f5d6c3d3c4f4f6f3e3g5g6", "Japon 93 (interversion)"},
 	{"f5d6c3d3c4f4f6f3e6", "tigre scorpion"},
-	{"f5d6c3d3c4f4f6f3e6e7c6", "scorpion piau-puget"},
-	{"f5d6c3d3c4f4f6f3e6e7c6g6f8", "scorpion piau de béton"},
-	{"f5d6c3d3c4f4f6f3e6e7c6g6f8c5", "scorpion piau-puget, var. de béton"},
-	{"f5d6c3d3c4f4f6f3e6e7c6g6g5", "scorpion piau centrale"},
+	{"f5d6c3d3c4f4f6f3e6e7c6", "scorpion Piau-puget"},
+	{"f5d6c3d3c4f4f6f3e6e7c6g6f8", "scorpion Piau de béton"},
+	{"f5d6c3d3c4f4f6f3e6e7c6g6f8c5", "scorpion Piau-Puget, var. de béton"},
+	{"f5d6c3d3c4f4f6f3e6e7c6g6g5", "scorpion Piau centrale"},
 	{"f5d6c3d3c4f4f6f3e6e7d7", "nouveau scorpion"},
-	{"f5d6c3d3c4f4f6f3e6e7d7c5b6", "scorpion excentré"},
-	{"f5d6c3d3c4f4f6f3e6e7d7c5c6", "scorpion groupé"},
-	{"f5d6c3d3c4f4f6f3e6e7d7c5c6g6d8", "scorpion jacpoth retardé"},
+	{"f5d6c3d3c4f4f6f3e6e7d7c5b6", "scorpion excentré"},
+	{"f5d6c3d3c4f4f6f3e6e7d7c5c6", "scorpion groupé"},
+	{"f5d6c3d3c4f4f6f3e6e7d7c5c6g6d8", "scorpion Jacpoth retardé"},
 	{"f5d6c3d3c4f4f6f3e6e7d7c5c6g6g5", "scorpion wada (interversion)"},
-	{"f5d6c3d3c4f4f6f3e6e7d7g6d8", "scorpion jacpoth"},
-	{"f5d6c3d3c4f4f6f3e6e7d7g6f8", "scorpion fausse piau"},
-	{"f5d6c3d3c4f4f6f3e6e7d7g6g5", "scorpion wada"},
+	{"f5d6c3d3c4f4f6f3e6e7d7g6d8", "scorpion Jacpoth"},
+	{"f5d6c3d3c4f4f6f3e6e7d7g6f8", "scorpion fausse Piau"},
+	{"f5d6c3d3c4f4f6f3e6e7d7g6g5", "scorpion Wada"},
 	{"f5d6c3d3c4f4f6f3e6e7f7", "scorpion classique"},
-	{"f5d6c3d3c4f4f6f3e6e7f7c5b6b4", "scorpion des 2 pions isolés"},
-	{"f5d6c3d3c4f4f6f3e6e7f7c5b6b5", "scorpion de varsovie"},
-	{"f5d6c3d3c4f4f6f3e6e7f7c5b6g5", "scorpion du luxembourg"},
-	{"f5d6c3d3c4f4f6f3e6e7f7c5b6g6", "scorpion du pion isolé"},
+	{"f5d6c3d3c4f4f6f3e6e7f7c5b6b4", "scorpion des 2 pions isolés"},
+	{"f5d6c3d3c4f4f6f3e6e7f7c5b6b5", "scorpion de Varsovie"},
+	{"f5d6c3d3c4f4f6f3e6e7f7c5b6g5", "scorpion du Luxembourg"},
+	{"f5d6c3d3c4f4f6f3e6e7f7c5b6g6", "scorpion du pion isolé"},
 	{"f5d6c3d3c4f4f6f3g4", "tigre diagonale damier"},
-	{"f5d6c3d3c4f4f6f3g4g3c5", "tigre diagonale ralle"},
+	{"f5d6c3d3c4f4f6f3g4g3c5", "tigre diagonale Ralle"},
 	{"f5d6c3d3c4f4f6f3g4g3e6b3", "bicorne"},
-	{"f5d6c3d3c4f4f6f3g4g5", "popov (interversion)"},
+	{"f5d6c3d3c4f4f6f3g4g5", "Popov (interversion)"},
 	{"f5d6c3d3c4f4f6g5", "tigre diagonale classique"},
-	{"f5d6c3d3c4f4f6g5c6", "tigre diagonale holgersson"},
-	{"f5d6c3d3c4f4f6g5e3", "brightwell retardée"},
-	{"f5d6c3d3c4f4f6g5e3f3g4", "popov"},
-	{"f5d6c3d3c4f4f6g5e3f3g4e2", "popov brisson"},
-	{"f5d6c3d3c4f4f6g5e3f3g4h3", "popov au bord"},
-	{"f5d6c3d3c4f4f6g5e3f3g4h3c6", "popov sharalle"},
-	{"f5d6c3d3c4f4f6g5e3f3g4h3c7", "popov le saout"},
-	{"f5d6c3d3c4f4f6g5e3f3g4h3e6", "popov murakami"},
-	{"f5d6c3d3c4f4f6g5e3f3g4h3g3", "popov murakami retardée"},
-	{"f5d6c3d3c4f4f6g5e3f3g6", "tigre japon 93"},
-	{"f5d6c3d3c4f4f6g5e3f3g6e2", "suite de béton"},
-	{"f5d6c3d3c4f4f6g5e3f3g6f7", "tau"},
-	{"f5d6c3d3c4f4f6g5e6", "tigre diagonale groupée"},
-	{"f5d6c3d3c4f4f6g5e6c5", "groupée anglaise "},
+	{"f5d6c3d3c4f4f6g5c6", "tigre diagonale Holgersson"},
+	{"f5d6c3d3c4f4f6g5e3", "Brightwell retardée"},
+	{"f5d6c3d3c4f4f6g5e3f3g4", "Popov"},
+	{"f5d6c3d3c4f4f6g5e3f3g4e2", "Popov brisson"},
+	{"f5d6c3d3c4f4f6g5e3f3g4h3", "Popov au bord"},
+	{"f5d6c3d3c4f4f6g5e3f3g4h3c6", "Popov sharalle"},
+	{"f5d6c3d3c4f4f6g5e3f3g4h3c7", "Popov le saout"},
+	{"f5d6c3d3c4f4f6g5e3f3g4h3e6", "Popov murakami"},
+	{"f5d6c3d3c4f4f6g5e3f3g4h3g3", "Popov murakami retardée"},
+	{"f5d6c3d3c4f4f6g5e3f3g6", "tigre Japon 93"},
+	{"f5d6c3d3c4f4f6g5e3f3g6e2", "suite de béton"},
+	{"f5d6c3d3c4f4f6g5e3f3g6f7", "Tau"},
+	{"f5d6c3d3c4f4f6g5e6", "tigre diagonale groupée"},
+	{"f5d6c3d3c4f4f6g5e6c5", "groupée anglaise "},
 	{"f5d6c3d3c4f4f6g5e6d7", "tigre diagonale milanaise"},
-	{"f5d6c3d3c4f4f6g5e6f7", "groupée japonaise"},
+	{"f5d6c3d3c4f4f6g5e6f7", "groupée japonaise"},
 	{"f5d6c3d3c4f4f6g5e6f7c7", "japonaise corbeau"},
-	{"f5d6c3d3c4f4f6g5e6f7d7", "japonaise juhem-caspard"},
-	{"f5d6c3d3c4f4f6g5e6f7d7c5", "japonaise juhem-caspard"},
-	{"f5d6c3d3c4f4f6g5e6f7d7c5g3e3", "japonaise suekuni"},
-	{"f5d6c3d3c4f4f6g5e6f7e3", "japonaise suekuni"},
+	{"f5d6c3d3c4f4f6g5e6f7d7", "japonaise Juhem-Caspard"},
+	{"f5d6c3d3c4f4f6g5e6f7d7c5", "japonaise Juhem-Caspard"},
+	{"f5d6c3d3c4f4f6g5e6f7d7c5g3e3", "japonaise Suekuni"},
+	{"f5d6c3d3c4f4f6g5e6f7e3", "japonaise Suekuni"},
 	{"f5d6c3d3c4f4f6g5e6f7g6", "japonaise de la roussette"},
 	{"f5d6c3d3c4f4f6g5e6f7h5", "japonaise douteuse"},
-	{"f5d6c3d3c4f4f6g5f3", "tigre diagonale hashimoto"},
-	{"f5d6c3d3c4f4f6g5g6", "tigre diagonale tom-pouce"},
-	{"f5d6c3d3c5", "parker"},
-	{"f5d6c3d3c5f4e3", "parker groupée"},
-	{"f5d6c3d3c5f4f3", "parker rectangulaire"},
+	{"f5d6c3d3c4f4f6g5f3", "tigre diagonale Hashimoto"},
+	{"f5d6c3d3c4f4f6g5g6", "tigre diagonale Tom-Pouce"},
+	{"f5d6c3d3c5", "Parker"},
+	{"f5d6c3d3c5f4e3", "Parker groupée"},
+	{"f5d6c3d3c5f4f3", "Parker rectangulaire"},
 	{"f5d6c3f4", "inconnue"},
 	{"f5d6c3g5", "ganglion"},
 	{"f5d6c4", "italienne"},
 	{"f5d6c4d3c5", "chat"},
-	{"f5d6c4d3c5b4", "nicolet"},
-	{"f5d6c4d3c5b4c3d2b6c6b5e6a3a5", "nicolet historique"},
-	{"f5d6c4d3c5b4d7f4e3f3", "nicolet moderne"},
-	{"f5d6c4d3c5f4d7", "tanida inversée"},
+	{"f5d6c4d3c5b4", "Nicolet"},
+	{"f5d6c4d3c5b4c3d2b6c6b5e6a3a5", "Nicolet historique"},
+	{"f5d6c4d3c5b4d7f4e3f3", "Nicolet moderne"},
+	{"f5d6c4d3c5f4d7", "Tanida inversée"},
 	{"f5d6c4d3c5f4e3f3c2", "romaine"},
 	{"f5d6c4d3c5f4e3f3c2b4", "chat en damier"},
-	{"f5d6c4d3c5f4e3f3c2b4b5d2d7c7e7f6", "chat marconi"},
+	{"f5d6c4d3c5f4e3f3c2b4b5d2d7c7e7f6", "chat Marconi"},
 	{"f5d6c4d3c5f4e3f3c2c6", "romaine connexe"},
-	{"f5d6c4d3c5f4e3f3c2c6d7", "romaine handel"},
-	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5c3b4c1f2a3e2a5", "chat penloup"},
-	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5c3b4c1f2a4", "chat glissée au bord"},
-	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5e7", "chat andriani"},
+	{"f5d6c4d3c5f4e3f3c2c6d7", "romaine Handel"},
+	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5c3b4c1f2a3e2a5", "chat Penloup"},
+	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5c3b4c1f2a4", "chat glissée au bord"},
+	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5e7", "chat Andriani"},
 	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5g3c7a5", "chat russe"},
 	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5g3c7a5f2", "romaine des minis diagos"},
-	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5g3d1c3", "chat svirskiy"},
-	{"f5d6c4d3c5f4e3f3g4", "chat américaine"},
+	{"f5d6c4d3c5f4e3f3c2c6e6d2g4b6b5g3d1c3", "chat Svirskiy"},
+	{"f5d6c4d3c5f4e3f3g4", "chat américaine"},
 	{"f5d6c4d3e6", "italienne"},
 	{"f5d6c4g5", "ganglion"},
 	{"f5d6c5", "perpendiculaire classique"},
@@ -248,298 +251,298 @@ static const OpeningName OPENING_NAME[] = {
 	{"f5d6c5f4d3c4", "cheval centrale"},
 	{"f5d6c5f4d3c4c3", "cheval crochet"},
 	{"f5d6c5f4d3c4c3c6e3", "crochet en coin"},
-	{"f5d6c5f4d3c4c3c6e3b5", "crochet tastet"},
+	{"f5d6c5f4d3c4c3c6e3b5", "crochet Tastet"},
 	{"f5d6c5f4d3c4c3c6e3f6", "crochet pseudo-rose"},
-	{"f5d6c5f4d3c4c3c6e6b5", "crochet intérieur"},
-	{"f5d6c5f4d3c4e3", "cheval muller"},
-	{"f5d6c5f4d3c4e3c3", "muller d'été symétrique"},
-	{"f5d6c5f4d3c4e3e6", "muller en coins"},
-	{"f5d6c5f4d3c4e3e6f6g5c3e7", "muller fusée"},
-	{"f5d6c5f4d3c4e3e6f6g5c3g6", "muller en coins décalée"},
+	{"f5d6c5f4d3c4c3c6e6b5", "crochet intérieur"},
+	{"f5d6c5f4d3c4e3", "cheval Muller"},
+	{"f5d6c5f4d3c4e3c3", "Muller d'été symétrique"},
+	{"f5d6c5f4d3c4e3e6", "Muller en coins"},
+	{"f5d6c5f4d3c4e3e6f6g5c3e7", "Muller fusée"},
+	{"f5d6c5f4d3c4e3e6f6g5c3g6", "Muller en coins décalée"},
 	{"f5d6c5f4d3e3", "cheval transversale"},
-	{"f5d6c5f4d3e3g4g3", "cheval daunas"},
+	{"f5d6c5f4d3e3g4g3", "cheval Daunas"},
 	{"f5d6c5f4d3e3g4g3e2c4e6", "daunas aberration optique (interversion)"},
-	{"f5d6c5f4d3e3g4g3e2f6e6", "daunas kyu syu"},
-	{"f5d6c5f4d3e3g4g3e6c4", "daunas aberration optique"},
+	{"f5d6c5f4d3e3g4g3e2f6e6", "Daunas Kyu Syu"},
+	{"f5d6c5f4d3e3g4g3e6c4", "Daunas aberration optique"},
 	{"f5d6c5f4d3e3g4g3e6c4e2", "aberration optique droite"},
 	{"f5d6c5f4d3e3g4g3e6c4f2", "aberration optique diagonale"},
 	{"f5d6c5f4d3e3g4g5", "cheval roques"},
 	{"f5d6c5f4d3e3g4g5e2c4f3", "roques argentine"},
-	{"f5d6c5f4d3e3g4g5e6c4", "roques penloup antisymétrique"},
-	{"f5d6c5f4d3e3g4g5e6f6", "roques caspard"},
+	{"f5d6c5f4d3e3g4g5e6c4", "roques Penloup antisymétrique"},
+	{"f5d6c5f4d3e3g4g5e6f6", "roques Caspard"},
 	{"f5d6c5f4d7", "beta"},
 	{"f5d6c5f4e3c4", "ball"},
-	{"f5d6c5f4e3c6d3f3", "ralle"},
-	{"f5d6c5f4e3c6d3f6", "rose"},
-	{"f5d6c5f4e3c6d3f6e6d7e7", "rose greenberg"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7b6", "greenberg alard (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3", "greenberg classique"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3b6", "greenberg alard"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8", "greenberg polyakov"},
+	{"f5d6c5f4e3c6d3f3", "Ralle"},
+	{"f5d6c5f4e3c6d3f6", "Rose"},
+	{"f5d6c5f4e3c6d3f6e6d7e7", "Rose Greenberg"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7b6", "Greenberg Alard (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3", "Greenberg classique"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3b6", "Greenberg Alard"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8", "Greenberg polyakov"},
 	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e2b6", "suite polyakov"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e2b6e8", "greenberg polyakov penloup"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e8", "greenberg polyakov de barcelone"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e8f8f7g8e2b5c2", "greenberg polyakov grosse masse"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e8f8f7g8e2b5c3", "greenberg polyakov shastein"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8f7", "greenberg originelle"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8", "défense tamenori"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8b6", "défense tamenori du double accès"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8d8", "réfutation tamenori"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8g5", "défense tamenori finlandaise"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7d8", "greenberg classique (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7d8c8", "greenberg semi-originelle"},
-	{"f5d6c5f4e3c6d3f6e6d7e7c7d8c8f7f3", "greenberg originelle (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7e7f3", "greenberg classique (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7e7f3c4c7b6", "greenberg alard (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7e7f3d8", "greenberg wahlberg"},
-	{"f5d6c5f4e3c6d3f6e6d7g3", "rose diagonale"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4", "rose transverse"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e2b6e8", "Greenberg Polyakov Penloup"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e8", "Greenberg Polyakov de Barcelone"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e8f8f7g8e2b5c2", "Greenberg Polyakov grosse masse"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8b8e8f8f7g8e2b5c3", "Greenberg Polyakov Shastein"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f3d8c8f7", "Greenberg originelle"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8", "défense Tamenori"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8b6", "défense Tamenori du double accès"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8d8", "réfutation Tamenori"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7c4f8g5", "défense Tamenori finlandaise"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7d8", "Greenberg classique (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7d8c8", "Greenberg semi-originelle"},
+	{"f5d6c5f4e3c6d3f6e6d7e7c7d8c8f7f3", "Greenberg originelle (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7e7f3", "Greenberg classique (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7e7f3c4c7b6", "Greenberg Alard (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7e7f3d8", "Greenberg wahlberg"},
+	{"f5d6c5f4e3c6d3f6e6d7g3", "Rose diagonale"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4", "Rose transverse"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3", "transverse principale"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b5", "transverse du pion isolé"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b5", "transverse du pion isolé"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b5a4", "transverse go"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b5a5", "transverse droite au bord"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6", "transverse trois croix"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6a3", "transverse trois croix de l'arche"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6b5", "transverse trois croix mercedes"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6c3b5", "transverse trois croix classique"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6c3b5a6", "transverse trois croix de béton"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6c3b5a6g5a5a4a3f7", "rose béton (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3g5", "transverse épineuse"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3g5c3b5a5a4a3b6a6f7", "rose béton (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3g5c3b5e2", "brightstein retardée (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6c3b5a6", "transverse trois croix de béton"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3b6c3b5a6g5a5a4a3f7", "rose béton (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3g5", "transverse épineuse"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3g5c3b5a5a4a3b6a6f7", "rose béton (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4b3g5c3b5e2", "Brightstein retardée (interversion)"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4c3", "transverse compacte"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4e2", "brightstein accélérée"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4e7", "rose piau"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4e7c3g4", "rose piau classique"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4e7c3g5", "rose piau-marconi"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4", "rose transverse retardée"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6c2", "rose brisson"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6d8", "rose tardy"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6f7", "rose béton"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6f7e2", "rose béton collée"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6f7f2", "rose béton d'extraction"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6c7", "rose fautive"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5e2", "brightstein retardée"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5e2d2", "défense bhagat"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5e2f3", "défense danoise"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4d2e2", "rose collay"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2", "rose brightstein"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3", "brightstein andersson"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3d2", "brightstein andersson morillon"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3g6f3d2", "brightstein andersson centrale"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3g6f3h5", "brightstein andersson au bord"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5", "brightstein classique"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7b3", "brightstein lazard"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7b6c2", "brightstein torben"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7b6e8", "brightstein piau"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7g6", "brightstein piau (interversion)"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2f7", "brightstein clef anglaise"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5g6", "brightstein tastet"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5g6c7", "brightstein tastet 2 contre 1"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5g6f2", "brightstein tastet ko"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2d2", "brightstein bhagat"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2f3", "brightstein cric"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2f3d2", "brightstein cric centrale"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2f3g6", "brightstein cric diagonale"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7", "rose tournante"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4e2", "Brightstein accélérée"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4e7", "Rose Piau"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4e7c3g4", "Rose Piau classique"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4e7c3g5", "Rose Piau-Marconi"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4", "Rose transverse retardée"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6c2", "Rose brisson"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6d8", "Rose tardy"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6f7", "Rose béton"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6f7e2", "Rose béton collée"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6a6f7f2", "Rose béton d'extraction"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5a5a4a3b6c7", "Rose fautive"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5e2", "Brightstein retardée"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5e2d2", "défense Bhagat"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4b3b5e2f3", "défense danoise"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4d2e2", "rose Collay"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2", "rose Brightstein"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3", "Brightstein Andersson"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3d2", "Brightstein Andersson Morillon"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3g6f3d2", "Brightstein Andersson centrale"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b3g6f3h5", "Brightstein Andersson au bord"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5", "Brightstein classique"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7b3", "Brightstein Lazard"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7b6c2", "Brightstein Torben"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7b6e8", "Brightstein Piau"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2c7g6", "Brightstein Piau (interversion)"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5d2f7", "Brightstein clef anglaise"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5g6", "Brightstein Tastet"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5g6c7", "Brightstein Tastet 2 contre 1"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2b5g6f2", "Brightstein Tastet ko"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2d2", "Brightstein Bhagat"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2f3", "Brightstein cric"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2f3d2", "Brightstein cric centrale"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2f3g6", "Brightstein cric diagonale"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7", "Rose tournante"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2c8", "tournante tourniquet"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2e1", "tournante paradoxale"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2e1f3c8g4", "paradoxale réussie"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2e1f3c8g4", "paradoxale réussie"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2e1f3c8h3", "paradoxale de sacrifice"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2e2", "tournante manège"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7g6", "tournante tamenori"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g6", "rose daunas"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g6c3", "rose daunas tournante"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g6g5", "rose daunas microb"},
-	{"f5d6c5f4e3c6d3f6e6d7g4", "rose plate"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4b4", "rose plate transverse"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7d2e7f2e2", "tournante manège"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3f7g6", "tournante Tamenori"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g6", "Rose Daunas"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g6c3", "Rose Daunas tournante"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g6g5", "Rose Daunas Microb"},
+	{"f5d6c5f4e3c6d3f6e6d7g4", "Rose plate"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4b4", "Rose plate transverse"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4b4b3", "plate transverse principale"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4b4b3b6a3", "plate transverse de l'arche"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4b4b3b6b5", "plate transverse mercedes"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4b4b3b6c3", "plate transverse classique"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4b4e2", "rose stenvenson"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4b4g3", "rose amadeus"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4b4g3g5", "amadeus du hâbleur"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4b4g3g6", "amadeus mercedes"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4b4e2", "Rose Stenvenson"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4b4g3", "Rose Amadeus"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4b4g3g5", "Amadeus du hâbleur"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4b4g3g6", "Amadeus Mercedes"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5", "rose plate tournante (rotating flat)"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1", "plate tournante ouverte (?)"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2b5", "plate tournante de tchéliabinsk"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2b5g3f3h4", "tchéliabinsk droite au bord"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2b5g3f3h6", "tchéliabinsk diagonale au bord"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2b5", "plate tournante de Tchéliabinsk"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2b5g3f3h4", "Tchéliabinsk droite au bord"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2b5g3f3h6", "Tchéliabinsk diagonale au bord"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2f2", "plate tournante japonaise"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2f2f1", "plate tournante plébéenne"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2f2f1", "plate tournante plébéenne"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2f2g6", "plate tournante kaneda"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2f2h3", "plate tournante, réfutation tamenori"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7", "plate tournante fermée (?)"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2c1e2f2h3", "plate tournante, réfutation tamenori"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7", "plate tournante fermée (?)"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2c8f3c7d8e2", "johnson"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2c8f3c7d8e8g3e2f1", "feinder"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2c8f3c7d8e8g3e2h4", "jotel"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f1c8f3c1", "plate tournante fermée, var. ouverte"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f1c8f3c7", "plate tournante fermée, var. fermée"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f3c1f1", "plate tournante fermée, var. ouverte"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f1c8f3c1", "plate tournante fermée, var. ouverte"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f1c8f3c7", "plate tournante fermée, var. fermée"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f3c1f1", "plate tournante fermée, var. ouverte"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f3c1g3", "cygne"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f3c1h3", "semi-tamenori"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g6", "rose murakami"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g6c3", "murakami tournante"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g6g5e7c3", "murakami occidentale"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g6g5e7f8", "murakami japonaise"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g6h6", "murakami bhagat"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3", "rose bruyninckx"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3e7", "greenberg retardée"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g5h4", "bruyninckx d'encerclement"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6f3", "bruyninckx classique"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6g5", "bruyninckx mercedes"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6g5e7", "bruyninckx mercedes nordique"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6g5h5", "bruyninckx mercedes koala"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6h3", "bruyninckx arche"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6h3e7", "bruyninckx arche ralle"},
-	{"f5d6c5f4e3c6d3f6e6d7g4g3g6h3g5", "bruyninckx arche tortue"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2e2f3c1h3", "semi-Tamenori"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g6", "Rose Murakami"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g6c3", "Murakami tournante"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g6g5e7c3", "Murakami occidentale"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g6g5e7f8", "Murakami japonaise"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g6h6", "Murakami Bhagat"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3", "Rose Bruyninckx"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3e7", "Greenberg retardée"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g5h4", "Bruyninckx d'encerclement"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6f3", "Bruyninckx classique"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6g5", "Bruyninckx Mercedes"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6g5e7", "Bruyninckx Mercedes nordique"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6g5h5", "Bruyninckx Mercedes koala"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6h3", "Bruyninckx arche"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6h3e7", "Bruyninckx arche Ralle"},
+	{"f5d6c5f4e3c6d3f6e6d7g4g3g6h3g5", "Bruyninckx arche tortue"},
 	{"f5d6c5f4e3c6d3g5", "coup 8"},
-	{"f5d6c5f4e3c6d7", "bhagat"},
-	{"f5d6c5f4e3c6d7e6", "bhagat, var.principale"},
-	{"f5d6c5f4e3c6e6", "inoue"},
-	{"f5d6c5f4e3c6f3", "shaman"},
-	{"f5d6c5f4e3c6f3c3d3c4", "shaman triangle"},
-	{"f5d6c5f4e3c6f3c3d3c4b3", "shaman triangle mur"},
-	{"f5d6c5f4e3c6f3c3d3c4b4", "shaman triangle transverse"},
-	{"f5d6c5f4e3c6f3d3", "shaman tau"},
-	{"f5d6c5f4e3c6f3d3c4b4", "tau don quichotte"},
-	{"f5d6c5f4e3c6f3d3c4e2", "tau cerf"},
-	{"f5d6c5f4e3c6f3g5", "shaman plate"},
-	{"f5d6c5f4e3c6f3g5e6f6d7b5", "shaman plate ancienne"},
-	{"f5d6c5f4e3c6f3g5e6f6d7d3", "shaman plate moderne"},
-	{"f5d6c5f4e3c6f3g6", "shaman diagonale"},
-	{"f5d6c5f4e3c6f3g6e6", "shaman diagonale jensen"},
-	{"f5d6c5f4e3c6f3g6f6", "shaman diagonale vallund"},
-	{"f5d6c5f4e3d3", "mimura"},
-	{"f5d6c6", "collay"},
-	{"f5f4", "parallèle"},
+	{"f5d6c5f4e3c6d7", "Bhagat"},
+	{"f5d6c5f4e3c6d7e6", "Bhagat, var. principale"},
+	{"f5d6c5f4e3c6e6", "Inoue"},
+	{"f5d6c5f4e3c6f3", "Shaman"},
+	{"f5d6c5f4e3c6f3c3d3c4", "Shaman triangle"},
+	{"f5d6c5f4e3c6f3c3d3c4b3", "Shaman triangle mur"},
+	{"f5d6c5f4e3c6f3c3d3c4b4", "Shaman triangle transverse"},
+	{"f5d6c5f4e3c6f3d3", "Shaman tau"},
+	{"f5d6c5f4e3c6f3d3c4b4", "Tau don Quichotte"},
+	{"f5d6c5f4e3c6f3d3c4e2", "Tau cerf"},
+	{"f5d6c5f4e3c6f3g5", "Shaman plate"},
+	{"f5d6c5f4e3c6f3g5e6f6d7b5", "Shaman plate ancienne"},
+	{"f5d6c5f4e3c6f3g5e6f6d7d3", "Shaman plate moderne"},
+	{"f5d6c5f4e3c6f3g6", "Shaman diagonale"},
+	{"f5d6c5f4e3c6f3g6e6", "Shaman diagonale Jensen"},
+	{"f5d6c5f4e3c6f3g6f6", "Shaman diagonale Vallund"},
+	{"f5d6c5f4e3d3", "Mimura"},
+	{"f5d6c6", "Collay"},
+	{"f5f4", "parallèle"},
 	{"f5f6", "diagonale"},
 	{"f5f6e6f4", "diagonale"},
-	{"f5f6e6f4c3", "ishii"},
-	{"f5f6e6f4c3c4", "ishii transverse"},
-	{"f5f6e6f4c3c4d3", "ishii tigre"},
-	{"f5f6e6f4c3c4g5", "ishii heath"},
-	{"f5f6e6f4c3d6", "ishii collée"},
-	{"f5f6e6f4c3d6f3c4", "ishii cannibale"},
+	{"f5f6e6f4c3", "Ishii"},
+	{"f5f6e6f4c3c4", "Ishii transverse"},
+	{"f5f6e6f4c3c4d3", "Ishii tigre"},
+	{"f5f6e6f4c3c4g5", "Ishii Heath"},
+	{"f5f6e6f4c3d6", "Ishii collée"},
+	{"f5f6e6f4c3d6f3c4", "Ishii cannibale"},
 	{"f5f6e6f4c3d6f3c4c5b4", "cannibale cannibalesque"},
 	{"f5f6e6f4c3d6f3c4c5b4a5", "cannibale 11 au bord"},
 	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b3", "cannibale diagonale"},
-	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b3e3", "cannibale diagonale maruoka"},
+	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b3e3", "cannibale diagonale Maruoka"},
 	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b3g5", "cannibale diagonale transverse"},
 	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b5", "cannibale classique"},
-	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b5a6b6g4", "cannibale tezuka"},
-	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b5a6e3", "cannibale murakami"},
+	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b5a6b6g4", "cannibale Tezuka"},
+	{"f5f6e6f4c3d6f3c4c5b4a5a3c6b5a6e3", "cannibale Murakami"},
 	{"f5f6e6f4c3d6f3c4c5b4c6", "cannibale centrale"},
-	{"f5f6e6f4c3d6f3c4c5b6c6b5e7", "zèbre"},
+	{"f5f6e6f4c3d6f3c4c5b6c6b5e7", "zèbre"},
 	{"f5f6e6f4c3d6f3c4c5b6g4", "charriot"},
-	{"f5f6e6f4c3d6f3c4c5b6g4g3", "troïka"},
+	{"f5f6e6f4c3d6f3c4c5b6g4g3", "troïka"},
 	{"f5f6e6f4c3d6f3c4c5b6g4h3", "charriot au bord"},
 	{"f5f6e6f4c3d6f3c4c5f2", "cannibale p"},
-	{"f5f6e6f4c3d6f3e3", "ishii piau"},
-	{"f5f6e6f4c3d6f3e3d3c5", "ishii piau droite"},
-	{"f5f6e6f4c3d6f3e3d3c6", "ishii piau diagonale"},
-	{"f5f6e6f4c3d7", "ishii décollée"},
-	{"f5f6e6f4c3d7e3", "ishii lazard"},
-	{"f5f6e6f4c3d7e3d6e7c4", "ishii t noir"},
-	{"f5f6e6f4c3d7e3d6e7c5c4", "ishii matignon"},
-	{"f5f6e6f4c3d7e3d6e7c5c6", "ishii elyséenne"},
-	{"f5f6e6f4c3d7f3", "ishii décollée en coin"},
-	{"f5f6e6f4c3d7f3d6g5e3", "ishii des danseurs"},
-	{"f5f6e6f4c3d7f3d6g5g4e3e2", "panthéon"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g3", "ishii ancienne"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g3g6", "ishii ancienne de la mini-diagonale"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g3h4", "ishii ancienne droite au bord"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g6", "ishii décollée classique"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g6e7", "ishii de sacrifice"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g6e7g3f7c4", "ishii, var. d'évitement accélérée"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g6e7g3f7f8", "ishii, var. d'évitement"},
-	{"f5f6e6f4c3d7f3d6g5g4e3g6h6", "ishii béton"},
-	{"f5f6e6f4c3d7f3d6g5g4e3h5", "ishii nordique"},
-	{"f5f6e6f4c3d7f3d6g5g4e3h5e7", "ishii nordique vallund du pion blanc"},
-	{"f5f6e6f4c3d7f3d6g5g4e3h5g6", "ishii nordique vallund"},
-	{"f5f6e6f4c3d7f3d6g5g4g6", "ishii penloup"},
+	{"f5f6e6f4c3d6f3e3", "Ishii Piau"},
+	{"f5f6e6f4c3d6f3e3d3c5", "Ishii Piau droite"},
+	{"f5f6e6f4c3d6f3e3d3c6", "Ishii Piau diagonale"},
+	{"f5f6e6f4c3d7", "Ishii décollée"},
+	{"f5f6e6f4c3d7e3", "Ishii lazard"},
+	{"f5f6e6f4c3d7e3d6e7c4", "Ishii T noir"},
+	{"f5f6e6f4c3d7e3d6e7c5c4", "Ishii matignon"},
+	{"f5f6e6f4c3d7e3d6e7c5c6", "Ishii elyséenne"},
+	{"f5f6e6f4c3d7f3", "Ishii décollée en coin"},
+	{"f5f6e6f4c3d7f3d6g5e3", "Ishii des danseurs"},
+	{"f5f6e6f4c3d7f3d6g5g4e3e2", "Panthéon"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g3", "Ishii ancienne"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g3g6", "Ishii ancienne de la mini-diagonale"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g3h4", "Ishii ancienne droite au bord"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g6", "Ishii décollée classique"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g6e7", "Ishii de sacrifice"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g6e7g3f7c4", "Ishii, var. d'évitement accélérée"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g6e7g3f7f8", "Ishii, var. d'évitement"},
+	{"f5f6e6f4c3d7f3d6g5g4e3g6h6", "Ishii béton"},
+	{"f5f6e6f4c3d7f3d6g5g4e3h5", "Ishii nordique"},
+	{"f5f6e6f4c3d7f3d6g5g4e3h5e7", "Ishii nordique Vallund du pion blanc"},
+	{"f5f6e6f4c3d7f3d6g5g4e3h5g6", "Ishii nordique Vallund"},
+	{"f5f6e6f4c3d7f3d6g5g4g6", "Ishii Penloup"},
 	{"f5f6e6f4c3e7", "ishii droite"},
-	{"f5f6e6f4c3e7f3e3d3e2g5c5", "ishii t blanc"},
+	{"f5f6e6f4c3e7f3e3d3e2g5c5", "ishii T blanc"},
 	{"f5f6e6f4d3", "citadine"},
 	{"f5f6e6f4e3", "diagonale classique"},
-	{"f5f6e6f4e3c5c4d3", "maruoka"},
-	{"f5f6e6f4e3c5c4e7", "tanida"},
-	{"f5f6e6f4e3c5c4e7b5e2f2", "tanida diagonale"},
-	{"f5f6e6f4e3c5c4e7b5e2f3", "tanida droite"},
+	{"f5f6e6f4e3c5c4d3", "Maruoka"},
+	{"f5f6e6f4e3c5c4e7", "Tanida"},
+	{"f5f6e6f4e3c5c4e7b5e2f2", "Tanida diagonale"},
+	{"f5f6e6f4e3c5c4e7b5e2f3", "Tanida droite"},
 	{"f5f6e6f4e3c5c4e7g4", "avion"},
 	{"f5f6e6f4e3c5c4e7g4f3", "avion droit"},
 	{"f5f6e6f4e3c5c4e7g4g3", "avion diagonal"},
-	{"f5f6e6f4e3c5g5", "cambridge"},
-	{"f5f6e6f4e3d6", "cheminée"},
+	{"f5f6e6f4e3c5g5", "Cambridge"},
+	{"f5f6e6f4e3d6", "cheminée"},
 	{"f5f6e6f4f3", "raton laveur"},
-	{"f5f6e6f4f3c5f7", "raton shaman"},
+	{"f5f6e6f4f3c5f7", "raton Shaman"},
 	{"f5f6e6f4g3", "coquelicot"},
-	{"f5f6e6f4g3f3", "hamilton"},
-	{"f5f6e6f4g3g4", "sprague"},
-	{"f5f6e6f4g4", "peccerillo"},
-	{"f5f6e6f4g5", "heath"},
-	{"f5f6e6f4g5d6", "heath cheminée"},
-	{"f5f6e6f4g5d6e7", "heath cheminée diagonale"},
-	{"f5f6e6f4g5d6e7g4f3h5e3", "heath cheminée diagonale centrale"},
-	{"f5f6e6f4g5d6e7g4f3h5h6h7", "heath cheminée diagonale béton"},
-	{"f5f6e6f4g5d6e7g6c5c4", "heath cheminée russe"},
-	{"f5f6e6f4g5d6f7", "heath cheminée droite"},
-	{"f5f6e6f4g5e7d7", "heath drumel"},
-	{"f5f6e6f4g5e7e3", "heath comp'oth (bat)"},
-	{"f5f6e6f4g5e7e3d6", "heath comp'oth groupée"},
-	{"f5f6e6f4g5e7e3d6d3g4g6f3", "heath comp'oth groupée moderne"},
-	{"f5f6e6f4g5e7e3d6d3g4g6h5", "heath comp'oth groupée, var. de béton"},
-	{"f5f6e6f4g5e7e3f3", "heath comp'oth droite"},
-	{"f5f6e6f4g5e7e3f3d3c3", "heath comp'oth cannibale"},
-	{"f5f6e6f4g5e7e3f3d3c5", "heath comp'oth sauvage"},
-	{"f5f6e6f4g5e7e3f3d3e2", "heath comp'oth canoé"},
-	{"f5f6e6f4g5e7e3g4", "heath comp'oth centrale"},
-	{"f5f6e6f4g5e7e3g4d3", "heath comp'oth générale"},
-	{"f5f6e6f4g5e7e3g4d3c5", "heath comp'oth plate"},
-	{"f5f6e6f4g5e7e3g4d3c5g6f3", "heath comp'oth plate, var. d'insertion"},
-	{"f5f6e6f4g5e7e3g4d3c5g6h5h6h7h4h3", "heath comp'oth plate, var. de béton"},
-	{"f5f6e6f4g5e7e3g4d3c6", "heath comp'oth prétendante"},
-	{"f5f6e6f4g5e7e3g4d3c6d6", "heath comp'oth ralle"},
-	{"f5f6e6f4g5e7e3g4d3c6g6f3", "heath comp'oth prétendante, var. d'insertion"},
-	{"f5f6e6f4g5e7e3g4d3c6g6h5",  "heath comp'oth prétendante, var. de béton"},
-	{"f5f6e6f4g5e7e3g4f3", "heath comp'oth buridan"},
-	{"f5f6e6f4g5e7e3g6",  "heath comp'oth diagonale"},
-	{"f5f6e6f4g5e7e3g6d3", "heath comp'oth murakami"},
-	{"f5f6e6f4g5e7e3g6d3c5d6c4", "heath comp'oth murakami au centre"},
-	{"f5f6e6f4g5e7e3g6d3c5d6f3g4h4", "heath comp'oth murakami au bord"},
-	{"f5f6e6f4g5e7e3g6d3f3g4h4", "heath comp'oth murakami au bord"},
-	{"f5f6e6f4g5e7e3g6d6c4", "heath comp'oth orthodoxe"},
-	{"f5f6e6f4g5e7e3g6d6c4c5b5", "heath comp'oth damier"},
-	{"f5f6e6f4g5e7e3g6d6c4d3", "heath comp'oth brightwell"},
-	{"f5f6e6f4g5e7e3g6d6c4f7",  "heath comp'oth informatique"},
-	{"f5f6e6f4g5e7e3g6d6f3f7", "heath comp'oth takizawa"},
-	{"f5f6e6f4g5e7e3g6f3", "heath comp'oth chinoise"},
-	{"f5f6e6f4g5e7f7", "heath classique"},
-	{"f5f6e6f4g5e7f7c5f3g3h3h5", "heath mirage"},
-	{"f5f6e6f4g5e7f7c5f3g4", "heath mystere"},
-	{"f5f6e6f4g5e7f7g6", "heath marconi"},
-	{"f5f6e6f4g5e7f7h5", "heath au bord"},
-	{"f5f6e6f4g5e7f7h5d3", "heath au bord extérieure"},
-	{"f5f6e6f4g5e7f7h5d3c6", "heath ancienne"},
-	{"f5f6e6f4g5e7f7h5d3c6d7", "heath bracchi"},
-	{"f5f6e6f4g5e7f7h5d3c6d7c4g4h4c3", "heath en coin"},
-	{"f5f6e6f4g5e7f7h5d3c6d7c4g4h4d6", "heath japonaise"},
-	{"f5f6e6f4g5e7f7h5d3c6d7c4g4h4e3", "heath standard"},
-	{"f5f6e6f4g5e7f7h5e3", "heath au bord médiane"},
-	{"f5f6e6f4g5e7f7h5e3d3f3", "heath shaman"},
-	{"f5f6e6f4g5e7f7h5e3d3g4g6f3", "heath shaman retardée"},
-	{"f5f6e6f4g5e7f7h5e3d3g4h4f3", "heath carré blanc"},
-	{"f5f6e6f4g5e7f7h5e3d3g4h4g3", "heath scorpion"},
-	{"f5f6e6f4g5e7f7h5g4", "heath au bord diagonale"},
-	{"f5f6e6f4g5e7f7h5g4g6", "heath diagonale sur le prébord"},
-	{"f5f6e6f4g5e7f7h5g4g6e3d3f3", "heath shaman retardée"},
-	{"f5f6e6f4g5e7f7h5g4g6e3f3", "heath ka"},
-	{"f5f6e6f4g5e7f7h5g4g6e3f8", "heath variante 56"},
-	{"f5f6e6f4g5e7f7h5g4g6e3h4", "heath kawazoe"},
-	{"f5f6e6f4g5e7f7h5g4h4", "heath diagonale au bord"},
-	{"f5f6e6f4g5g6", "heath d'évitement"},
-	{"f5f6e6f4g5g6g4e7f3", "heath d'évitement malgache"},
+	{"f5f6e6f4g3f3", "Hamilton"},
+	{"f5f6e6f4g3g4", "Sprague"},
+	{"f5f6e6f4g4", "Peccerillo"},
+	{"f5f6e6f4g5", "Heath"},
+	{"f5f6e6f4g5d6", "Heath cheminée"},
+	{"f5f6e6f4g5d6e7", "Heath cheminée diagonale"},
+	{"f5f6e6f4g5d6e7g4f3h5e3", "Heath cheminée diagonale centrale"},
+	{"f5f6e6f4g5d6e7g4f3h5h6h7", "Heath cheminée diagonale béton"},
+	{"f5f6e6f4g5d6e7g6c5c4", "Heath cheminée russe"},
+	{"f5f6e6f4g5d6f7", "Heath cheminée droite"},
+	{"f5f6e6f4g5e7d7", "Heath Drumel"},
+	{"f5f6e6f4g5e7e3", "Heath Comp'oth (bat)"},
+	{"f5f6e6f4g5e7e3d6", "Heath Comp'oth groupée"},
+	{"f5f6e6f4g5e7e3d6d3g4g6f3", "Heath Comp'oth groupée moderne"},
+	{"f5f6e6f4g5e7e3d6d3g4g6h5", "Heath Comp'oth groupée, var. de béton"},
+	{"f5f6e6f4g5e7e3f3", "Heath Comp'oth droite"},
+	{"f5f6e6f4g5e7e3f3d3c3", "Heath Comp'oth cannibale"},
+	{"f5f6e6f4g5e7e3f3d3c5", "Heath Comp'oth sauvage"},
+	{"f5f6e6f4g5e7e3f3d3e2", "Heath Comp'oth canoé"},
+	{"f5f6e6f4g5e7e3g4", "Heath Comp'oth centrale"},
+	{"f5f6e6f4g5e7e3g4d3", "Heath Comp'oth générale"},
+	{"f5f6e6f4g5e7e3g4d3c5", "Heath Comp'oth plate"},
+	{"f5f6e6f4g5e7e3g4d3c5g6f3", "Heath Comp'oth plate, var. d'insertion"},
+	{"f5f6e6f4g5e7e3g4d3c5g6h5h6h7h4h3", "Heath Comp'oth plate, var. de béton"},
+	{"f5f6e6f4g5e7e3g4d3c6", "Heath Comp'oth prétendante"},
+	{"f5f6e6f4g5e7e3g4d3c6d6", "Heath Comp'oth Ralle"},
+	{"f5f6e6f4g5e7e3g4d3c6g6f3", "Heath Comp'oth prétendante, var. d'insertion"},
+	{"f5f6e6f4g5e7e3g4d3c6g6h5", "Heath Comp'oth prétendante, var. de béton"},
+	{"f5f6e6f4g5e7e3g4f3", "Heath Comp'oth Buridan"},
+	{"f5f6e6f4g5e7e3g6", "Heath Comp'oth diagonale"},
+	{"f5f6e6f4g5e7e3g6d3", "Heath Comp'oth Murakami"},
+	{"f5f6e6f4g5e7e3g6d3c5d6c4", "Heath Comp'oth Murakami au centre"},
+	{"f5f6e6f4g5e7e3g6d3c5d6f3g4h4", "Heath Comp'oth Murakami au bord"},
+	{"f5f6e6f4g5e7e3g6d3f3g4h4", "Heath Comp'oth Murakami au bord"},
+	{"f5f6e6f4g5e7e3g6d6c4", "Heath Comp'oth orthodoxe"},
+	{"f5f6e6f4g5e7e3g6d6c4c5b5", "Heath Comp'oth damier"},
+	{"f5f6e6f4g5e7e3g6d6c4d3", "Heath Comp'oth Brightwell"},
+	{"f5f6e6f4g5e7e3g6d6c4f7", "Heath Comp'oth informatique"},
+	{"f5f6e6f4g5e7e3g6d6f3f7", "Heath Comp'oth Takizawa"},
+	{"f5f6e6f4g5e7e3g6f3", "Heath Comp'oth chinoise"},
+	{"f5f6e6f4g5e7f7", "Heath classique"},
+	{"f5f6e6f4g5e7f7c5f3g3h3h5", "Heath mirage"},
+	{"f5f6e6f4g5e7f7c5f3g4", "Heath mystere"},
+	{"f5f6e6f4g5e7f7g6", "Heath Marconi"},
+	{"f5f6e6f4g5e7f7h5", "Heath au bord"},
+	{"f5f6e6f4g5e7f7h5d3", "Heath au bord extérieure"},
+	{"f5f6e6f4g5e7f7h5d3c6", "Heath ancienne"},
+	{"f5f6e6f4g5e7f7h5d3c6d7", "Heath Bracchi"},
+	{"f5f6e6f4g5e7f7h5d3c6d7c4g4h4c3", "Heath en coin"},
+	{"f5f6e6f4g5e7f7h5d3c6d7c4g4h4d6", "Heath japonaise"},
+	{"f5f6e6f4g5e7f7h5d3c6d7c4g4h4e3", "Heath standard"},
+	{"f5f6e6f4g5e7f7h5e3", "Heath au bord médiane"},
+	{"f5f6e6f4g5e7f7h5e3d3f3", "Heath Shaman"},
+	{"f5f6e6f4g5e7f7h5e3d3g4g6f3", "Heath Shaman retardée"},
+	{"f5f6e6f4g5e7f7h5e3d3g4h4f3", "Heath carré blanc"},
+	{"f5f6e6f4g5e7f7h5e3d3g4h4g3", "Heath scorpion"},
+	{"f5f6e6f4g5e7f7h5g4", "Heath au bord diagonale"},
+	{"f5f6e6f4g5e7f7h5g4g6", "Heath diagonale sur le prébord"},
+	{"f5f6e6f4g5e7f7h5g4g6e3d3f3", "Heath Shaman retardée"},
+	{"f5f6e6f4g5e7f7h5g4g6e3f3", "Heath Ka"},
+	{"f5f6e6f4g5e7f7h5g4g6e3f8", "Heath variante 56"},
+	{"f5f6e6f4g5e7f7h5g4g6e3h4", "Heath Kawazoe"},
+	{"f5f6e6f4g5e7f7h5g4h4", "Heath diagonale au bord"},
+	{"f5f6e6f4g5g6", "Heath d'évitement"},
+	{"f5f6e6f4g5g6g4e7f3", "Heath d'évitement malgache"},
 	{"f5f6e6f4g6", "campagnarde"},
 	{"f5f6e6f4g6c5", "campagnarde droite"},
 	{"f5f6e6f4g6c5g4g5e3", "campagnarde berner"},
@@ -547,106 +550,106 @@ static const OpeningName OPENING_NAME[] = {
 	{"f5f6e6f4g6c5g4g5f3e3h5", "campagnarde classique ou 11 au bord"},
 	{"f5f6e6f4g6c5g4g5h4", "campagnarde 9 au bord"},
 	{"f5f6e6f4g6c5g4g5h4h3f3g3e3", "campagnarde milanaise"},
-	{"f5f6e6f4g6c5g4g5h4h3f3g3h5h6e3", "campagnarde ???"},
+	{"f5f6e6f4g6c5g4g5h4h3f3g3h5h6e3", "campagnarde"},
 	{"f5f6e6f4g6c5g4g5h4h3f3h5", "campagnarde clou"},
 	{"f5f6e6f4g6c5g4g5h4h6e3", "campagnarde danoise"},
-	{"f5f6e6f4g6c5g4g5h4h6f3", "campagnarde ???"},
-	{"f5f6e6f4g6c6","campagnarde décollée"},
+	{"f5f6e6f4g6c5g4g5h4h6f3", "campagnarde"},
+	{"f5f6e6f4g6c6", "campagnarde décollée"},
 	{"f5f6e6f4g6c6c5", "campagnarde nordique"},
 	{"f5f6e6f4g6c6g5", "campagnarde traineau"},
-	{"f5f6e6f4g6d6", "campagnarde collée"},
-	{"f5f6e6f4g6d6e3d3g4f3g3", "campagnarde tanigushi"},
-	{"f5f6e6f4g6d6d3g5", "campagnarde kitajima"},
+	{"f5f6e6f4g6d6", "campagnarde collée"},
+	{"f5f6e6f4g6d6e3d3g4f3g3", "campagnarde Tanigushi"},
+	{"f5f6e6f4g6d6d3g5", "campagnarde Kitajima"},
 	{"f5f6e6f4g6d6e3", "campagnarde transverse"},
-	{"f5f6e6f4g6d6e3d3g4f3g3", "campagnarde taniguchi"},
-	{"f5f6e6f4g6d6e3d3g5", "campagnarde kitajima"},
-	{"f5f6e6f4g6d6e3f3g4g5d3e2c5", "campagnarde ralle"},
-	{"f5f6e6f4g6d6e3f3g4g5f2", "campagnarde shibata"},
+	{"f5f6e6f4g6d6e3d3g4f3g3", "campagnarde Taniguchi"},
+	{"f5f6e6f4g6d6e3d3g5", "campagnarde Kitajima"},
+	{"f5f6e6f4g6d6e3f3g4g5d3e2c5", "campagnarde Ralle"},
+	{"f5f6e6f4g6d6e3f3g4g5f2", "campagnarde Shibata"},
 	{"f5f6e6f4g6d6g4f7", "campagnarde cannibale"},
-	{"f5f6e6f4g7", "ouverture x"},
+	{"f5f6e6f4g7", "ouverture X"},
 
 	// English names
 	{"f5d6", "perpendicular opening"},
 	{"f5d6c3d3c4", "tiger"},
-	{"f5d6c3d3c4b3", "aubrey, tanaka"},
-	{"f5d6c3d3c4f4c5b3c2", "rose-bill"},
-	{"f5d6c3d3c4f4c5b3c2e6", "tamenori"},
-	{"f5d6c3d3c4f4c5b4b5c6f3e6e3", "ishii"},
+	{"f5d6c3d3c4b3", "Aubrey, Tanaka"},
+	{"f5d6c3d3c4f4c5b3c2", "Rose-Bill"},
+	{"f5d6c3d3c4f4c5b3c2e6", "Tamenori"},
+	{"f5d6c3d3c4f4c5b4b5c6f3e6e3", "Ishii"},
 	{"f5d6c3d3c4f4c5b4b5c6f3e6e3g6f6g5d7g3", "mainline tiger"},
-	{"f5d6c3d3c4f4e3", "brightwell"},
-	{"f5d6c3d3c4f4e6", "leader's tiger"},
-	{"f5d6c3d3c4f4f6", "stephenson"},
-	{"f5d6c3d3c4f4f6b4", "kung"},
-	{"f5d6c3d3c4f4f6f3", "comp'oth"},
-	{"f5d6c3d3c4f4f6f3e6e7d7g6f8f7g5h6", "f.a.t. draw"},
-	{"f5d6c3d3c4f4f6g5", "no-kung"},
-	{"f5d6c3d3c4f4f6g5e3f3g4h3g3f2", "no-kung (continuation)"},
+	{"f5d6c3d3c4f4e3", "Brightwell"},
+	{"f5d6c3d3c4f4e6", "Leader's tiger"},
+	{"f5d6c3d3c4f4f6", "Stephenson"},
+	{"f5d6c3d3c4f4f6b4", "Kung"},
+	{"f5d6c3d3c4f4f6f3", "Comp'oth"},
+	{"f5d6c3d3c4f4f6f3e6e7d7g6f8f7g5h6", "F.A.T. draw"},
+	{"f5d6c3d3c4f4f6g5", "no-Kung"},
+	{"f5d6c3d3c4f4f6g5e3f3g4h3g3f2", "no-Kung (continuation)"},
 	{"f5d6c3g5", "ganglion"},
 	{"f5d6c4d3c5", "cat"},
-	{"f5d6c4d3c5f4e3f3c2b4b3", "berner"},
-	{"f5d6c4d3c5f4e3f3c2c6", "sakaguchi"},
+	{"f5d6c4d3c5f4e3f3c2b4b3", "Berner"},
+	{"f5d6c4d3c5f4e3f3c2c6", "Sakaguchi"},
 	{"f5d6c4d3e6", "italian"},
 	{"f5d6c4g5", "no-cat"},
 	{"f5d6c4g5c6", "swallow"},
 	{"f5d6c4g5c6c5d7d3b4c3e3f3", "no-cat (continuation)"},
 	{"f5d6c5f4d3", "horse"},
-	{"f5d6c5f4e3c6d3f3", "ralle"},
-	{"f5d6c5f4e3c6d3f6e6d7", "rose"},
-	{"f5d6c5f4e3c6d3f6e6d7e7", "greenberg"},
-	{"f5d6c5f4e3c6d3f6e6d7e7", "dawg"}, 
+	{"f5d6c5f4e3c6d3f3", "Ralle"},
+	{"f5d6c5f4e3c6d3f6e6d7", "Rose"},
+	{"f5d6c5f4e3c6d3f6e6d7e7", "Greenberg"},
+	{"f5d6c5f4e3c6d3f6e6d7e7", "Dawg"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4", "rose-birth"},
 	{"f5d6c5f4e3c6d3f6e6d7g3c4b4", "rose-birdie"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4",  "rose-tamenori"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4b4c3", "rose-tamenori-kling"},
-	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2", "brightstein"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4", "rose-tamenori"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4b4c3", "Rose-Tamenori-Kling"},
+	{"f5d6c5f4e3c6d3f6e6d7g3c4g5c3b4e2", "Brightstein"},
 	{"f5d6c5f4e3c6d3f6e6d7g4", "flat"},
 	{"f5d6c5f4e3c6d3f6e6d7g4c4", "rotating flat"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2", "rotating flat (kling continuation)"},
-	{"f5d6c5f4e3c6d3f6e6d7g4c4g6", "murakami variation"},
-	{"f5d6c5f4e3c6d7", "bhagat"},
-	{"f5d6c5f4e3c6e6", "inoue"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g5c3f7d2e7f2", "rotating flat (Kling continuation)"},
+	{"f5d6c5f4e3c6d3f6e6d7g4c4g6", "Murakami variation"},
+	{"f5d6c5f4e3c6d7", "Bhagat"},
+	{"f5d6c5f4e3c6e6", "Inoue"},
 	{"f5d6c5f4e3c6e6f6", "iago"},
-	{"f5d6c5f4e3c6f3", "shaman"},
+	{"f5d6c5f4e3c6f3", "Shaman"},
 	{"f5d6c5f4e3c6f3", "danish"},
-	{"f5d6c5f4e3d3", "mimura"},
- 	{"f5f4", "parallel opening"},
+	{"f5d6c5f4e3d3", "Mimura"},
+	{"f5f4", "parallel opening"},
 	{"f5f6", "diagonal opening"},
 	{"f5f6c4f4", "semi-wing variation"},
 	{"f5f6d3f4", "wing variation"},
 	{"f5f6e6d6c3", "buffalo"},
-	{"f5f6e6d6c3",  "kenichi variation"},
-	{"f5f6e6d6c3d3", "hokuriku buffalo"},
-	{"f5f6e6d6c3f4c6d3e3d2", "tanida buffalo"},
-	{"f5f6e6d6c3g4c6", "maruoka buffalo"},
+	{"f5f6e6d6c3", "kenichi variation"},
+	{"f5f6e6d6c3d3", "Hokuriku buffalo"},
+	{"f5f6e6d6c3f4c6d3e3d2", "Tanida buffalo"},
+	{"f5f6e6d6c3g4c6", "Maruoka buffalo"},
 	{"f5f6e6d6c5", "cow"},
-	{"f5f6e6d6c5e3d3", "rose-v-toth"},
-	{"f5f6e6d6c5e3d3c4c3", "landau"},
-	{"f5f6e6d6c5e3d3c4c6b5", "maruoka"},
-	{"f5f6e6d6c5e3d3g5", "tanida"},
+	{"f5f6e6d6c5e3d3", "Rose-v-Toth"},
+	{"f5f6e6d6c5e3d3c4c3", "Landau"},
+	{"f5f6e6d6c5e3d3c4c6b5", "Maruoka"},
+	{"f5f6e6d6c5e3d3g5", "Tanida"},
 	{"f5f6e6d6c5e3d3g5d7", "aircraft"},
 	{"f5f6e6d6c5e3d3g5d7", "feldborg"},
 	{"f5f6e6d6c5e3d3g5e2b5", "sailboat"},
 	{"f5f6e6d6c5e3e7", "cow bat"},
 	{"f5f6e6d6c5e3e7", "bat"},
-	{"f5f6e6d6c5e3e7", "cambridge"},
-	{"f5f6e6d6c5e3e7c6d7f7c7f4g6e8d8c8g5", "bat (kling continuation)"},
+	{"f5f6e6d6c5e3e7", "Cambridge"},
+	{"f5f6e6d6c5e3e7c6d7f7c7f4g6e8d8c8g5", "bat (Kling continuation)"},
 	{"f5f6e6d6c5e3e7c7d7c6d3", "melnikov"},
- 	{"f5f6e6d6c5e3e7c7d7c6d3", "bat (piau continuation 1)"},
-	{"f5f6e6d6c5e3e7c7d7c6f7", "bat (piau continuation 2)"},
-	{"f5f6e6d6c5e3e7f4f7", "bat (kling alternative)"},
+	{"f5f6e6d6c5e3e7c7d7c6d3", "bat (piau continuation 1)"},
+	{"f5f6e6d6c5e3e7c7d7c6f7", "bat (Piau continuation 2)"},
+	{"f5f6e6d6c5e3e7f4f7", "bat (Kling alternative)"},
 	{"f5f6e6d6c5f4", "chimney"},
-	{"f5f6e6d6c7c6d7", "hamilton"},
+	{"f5f6e6d6c7c6d7", "Hamilton"},
 	{"f5f6e6d6c7f4", "lollipop"},
 	{"f5f6e6d6d7", "raccoon dog"},
-	{"f5f6e6d6e7", "heath"},
+	{"f5f6e6d6e7", "Heath"},
 	{"f5f6e6d6e7", "tobidashi \"jumping out\""},
 	{"f5f6e6d6e7f4", "heath-chimney"},
 	{"f5f6e6d6e7f4", "\"mass-turning\""},
-	{"f5f6e6d6e7g5c5", "heath-bat"},
-	{"f5f6e6d6e7g5g4", "iwasaki variation"},
-	{"f5f6e6d6e7g5g6e3c5c6d3c4b3", "mimura variation ii"},
+	{"f5f6e6d6e7g5c5", "Heath-bat"},
+	{"f5f6e6d6e7g5g4", "Iwasaki variation"},
+	{"f5f6e6d6e7g5g6e3c5c6d3c4b3", "Mimura variation ii"},
 	{"f5f6e6d6f7", "snake"},
-	{"f5f6e6d6f7",  "peasant"},
+	{"f5f6e6d6f7", "peasant"},
 	{"f5f6e6d6f7e3d7e7c6c5d3", "pyramid"},
 	{"f5f6e6d6f7e3d7e7c6c5d3", "checkerboarding peasant"},
 	{"f5f6e6d6g7", "x-square opening"},
@@ -656,24 +659,24 @@ static const OpeningName OPENING_NAME[] = {
 /** The list of french opening names */
 static const PositionName NOM_POSITION[] = {
 	{{0x0000000000001400, 0x0000001c1c1e0000}, "campagnarde cannibale"},
-	{{0x0000000000080800, 0x0000001c1c140000}, "Heath cheminée"},
-	{{0x00000000000e0000, 0x0000001c1c100000}, "campagnarde collée"},
+	{{0x0000000000080800, 0x0000001c1c140000}, "Heath cheminée"},
+	{{0x00000000000e0000, 0x0000001c1c100000}, "campagnarde collée"},
 	{{0x00000000000e0000, 0x0000001c3c000000}, "campagnarde droite"},
 	{{0x00000000001c0000, 0x00003e3838000000}, "cannibale p"},
 	{{0x0000000000240000, 0x00001c1c3c000000}, "Ishii cannibale"},
 	{{0x0000000000240000, 0x00001c3c7c000000}, "cannibale cannibalesque"},
-	{{0x00000000002c1c20, 0x0000183c7c100000}, "défense Tamenori finlandaise"},
-	{{0x0000000002340800, 0x0000001c1c08100e}, "Heath cheminée diagonale béton"},
+	{{0x00000000002c1c20, 0x0000183c7c100000}, "défense Tamenori finlandaise"},
+	{{0x0000000002340800, 0x0000001c1c08100e}, "Heath cheminée diagonale béton"},
 	{{0x00000000040c0400, 0x0000101878000000}, "de Grey edmead"},
-	{{0x0000000004181000, 0x0000003878200000}, "Heath Comp'oth groupée"},
+	{{0x0000000004181000, 0x0000003878200000}, "Heath Comp'oth groupée"},
 	{{0x0000000004262020, 0x000008181a180808}, "Heath mirage"},
 	{{0x00000000042e0800, 0x000008181a101000}, "Heath mystere"},
 	{{0x0000000004340400, 0x0000081818081838}, "campagnarde clou"},
-	{{0x000000000624343c, 0x00281e3c38180800}, "Rose béton"},
+	{{0x000000000624343c, 0x00281e3c38180800}, "Rose béton"},
 	{{0x0000000008080000, 0x0000001c30000000}, "italienne"},
 	{{0x0000000008080000, 0x0000041830000000}, "inhumaine"},
-	{{0x0000000008080000, 0x00001c1c14000000}, "cheminée"},
-	{{0x00000000080e0000, 0x0000001c14200000}, "campagnarde décollée"},
+	{{0x0000000008080000, 0x00001c1c14000000}, "cheminée"},
+	{{0x00000000080e0000, 0x0000001c14200000}, "campagnarde décollée"},
 	{{0x0000000008302000, 0x00000038f0001000}, "Heath au bord"},
 	{{0x0000000008380000, 0x0000001c30000000}, "citadine"},
 	{{0x0000000008380000, 0x0000041830000000}, "Ishii"},
@@ -687,21 +690,21 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000000014320000, 0x00000c1c28080000}, "Shaman diagonale Jensen"},
 	{{0x00000000143c1000, 0x0000181e28000000}, "Rose plate"},
 	{{0x00000000143c1000, 0x00001a1c28000000}, "Rose diagonale"},
-	{{0x00000000162c343c, 0x00281e3c28100800}, "rose béton (interversion)"},
+	{{0x00000000162c343c, 0x00281e3c28100800}, "rose béton (interversion)"},
 	{{0x0000000018040000, 0x0000087800000000}, "ganglion"},
-	{{0x0000000018040000, 0x0000383820000000}, "Ishii collée"},
+	{{0x0000000018040000, 0x0000383820000000}, "Ishii collée"},
 	{{0x0000000018040000, 0x0000387800000000}, "ishii droite"},
 	{{0x0000000018080000, 0x0000001c00000000}, "perpendiculaire"},
 	{{0x0000000018080000, 0x0000001c04040000}, "diagonale"},
-	{{0x000000001a080000, 0x0000001c04060000}, "Heath d'évitement"},
-	{{0x000000001a180808, 0x0000003804060000}, "Heath au bord extérieure"},
-	{{0x000000001c000000, 0x0000001c00000000}, "parallèle"},
+	{{0x000000001a080000, 0x0000001c04060000}, "Heath d'évitement"},
+	{{0x000000001a180808, 0x0000003804060000}, "Heath au bord extérieure"},
+	{{0x000000001c000000, 0x0000001c00000000}, "parallèle"},
 	{{0x000000001c000000, 0x0000087800000000}, "ganglion"},
-	{{0x000000001c1c0000, 0x0000283820000000}, "Brightwell extérieure"},
+	{{0x000000001c1c0000, 0x0000283820000000}, "Brightwell extérieure"},
 	{{0x000000001e0c0400, 0x0000003820100800}, "Heath Comp'oth Murakami"},
-	{{0x000000001e1c1000, 0x0000003820000800}, "Heath Comp'oth générale"},
+	{{0x000000001e1c1000, 0x0000003820000800}, "Heath Comp'oth générale"},
 	{{0x00000000240c0400, 0x0000101818100000}, "de Grey classique"},
-	{{0x00000000240c0400, 0x0000101818200000}, "de Grey de bétonnage"},
+	{{0x00000000240c0400, 0x0000101818200000}, "de Grey de bétonnage"},
 	{{0x000000002c000000, 0x0000081810300000}, "tigre"},
 	{{0x000000002c000000, 0x0000101810140000}, "Parker"},
 	{{0x000000002c000000, 0x0000101810180000}, "chat"},
@@ -709,41 +712,41 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000000002c0c0800, 0x0000083e10000000}, "avion"},
 	{{0x000000002c3c0800, 0x0000187e10000000}, "Rose plate transverse"},
 	{{0x000000002c3c0800, 0x0000583e10000000}, "Rose transverse"},
-	{{0x000000002e100800, 0x0000003c100e0000}, "Heath cheminée russe"},
-	{{0x000000002e480000, 0x00083c3c10101000}, "Brightstein accélérée"},
+	{{0x000000002e100800, 0x0000003c100e0000}, "Heath cheminée russe"},
+	{{0x000000002e480000, 0x00083c3c10101000}, "Brightstein accélérée"},
 	{{0x000000002e7e0000, 0x00087cfc10001000}, "Brightstein Andersson au bord"},
 	{{0x0000000032580000, 0x00083c3c0c040000}, "transverse compacte"},
 	{{0x000000003a0e0800, 0x00001c3c04000400}, "Caspard"},
-	{{0x000000003a240000, 0x00005c3c04020000}, "troïka"},
-	{{0x000000003a380000, 0x0000141c04040000}, "orque extérieure retardée"},
-	{{0x000000003c1c0000, 0x0000383e00000000}, "compacte à plat"},
+	{{0x000000003a240000, 0x00005c3c04020000}, "troïka"},
+	{{0x000000003a380000, 0x0000141c04040000}, "orque extérieure retardée"},
+	{{0x000000003c1c0000, 0x0000383e00000000}, "compacte à plat"},
 	{{0x000000003c240000, 0x00003a3c40800000}, "charriot au bord"},
-	{{0x000000003c322000, 0x00007c7c40400000}, "Moorlin de béton"},
+	{{0x000000003c322000, 0x00007c7c40400000}, "Moorlin de béton"},
 	{{0x000000003c3a0000, 0x0000247c00000000}, "charriot"},
 	{{0x000000003d1f0500, 0x00003c7f02000000}, "Greenberg Polyakov Penloup"},
 	{{0x000000003e200000, 0x00001c38001c0000}, "Brightwell anglaise Nicolet"},
-	{{0x000000003e380000, 0x0000101e00040000}, "orque à plat"},
+	{{0x000000003e380000, 0x0000101e00040000}, "orque à plat"},
 	{{0x000000003e380000, 0x00001c3c00040000}, "aile op'masse"},
 	{{0x000000003e580000, 0x00083c3f00020000}, "transverse droite au bord"},
 	{{0x000000005e180000, 0x00083c3c20400000}, "Rose Amadeus"},
 	{{0x000000005e1c0000, 0x0008181820400000}, "Tanida diagonale"},
 	{{0x000000006e080000, 0x00083c3c10101000}, "Rose Stenvenson"},
 	{{0x000000006e1c0000, 0x0008181810200000}, "Tanida droite"},
-	{{0x000000007e3c0000, 0x00181e3e00000000}, "plate tournante fermée (?)"},
+	{{0x000000007e3c0000, 0x00181e3e00000000}, "plate tournante fermée (?)"},
 	{{0x00000002031c1000, 0x00002c1c1c020000}, "Ishii nordique Vallund"},
-	{{0x00000002041c0000, 0x0000201818200000}, "Ishii décollée en coin"},
+	{{0x00000002041c0000, 0x0000201818200000}, "Ishii décollée en coin"},
 	{{0x00000002041c0000, 0x0000201838000000}, "Ishii lazard"},
-	{{0x00000002041e1000, 0x00002c1c1a010000}, "Ishii béton"},
+	{{0x00000002041e1000, 0x00002c1c1a010000}, "Ishii béton"},
 	{{0x0000000206161000, 0x00002c1c18080800}, "Ishii de sacrifice"},
 	{{0x00000002063e0800, 0x00001c3c78000400}, "Caspard de 91"},
 	{{0x0000000207141000, 0x00002c1c18080800}, "Ishii nordique Vallund du pion blanc"},
 	{{0x000000020e580800, 0x00003c3870021000}, "chat Marconi"},
-	{{0x00000002100c0400, 0x0000001c0f020800}, "Heath diagonale sur le prébord"},
+	{{0x00000002100c0400, 0x0000001c0f020800}, "Heath diagonale sur le prébord"},
 	{{0x0000000210180000, 0x00080c3c0c040000}, "Heath Comp'oth sauvage"},
 	{{0x0000000210180000, 0x00080c3c0e000000}, "Heath Comp'oth plate"},
-	{{0x0000000210180000, 0x00082c1c0e000000}, "Heath Comp'oth prétendante"},
-	{{0x000000021c180000, 0x00090f3d03010000}, "Heath Comp'oth plate, var. de béton"},
-	{{0x00000002260e0800, 0x00001c3c18100400}, "Caspard retardée"},
+	{{0x0000000210180000, 0x00082c1c0e000000}, "Heath Comp'oth prétendante"},
+	{{0x000000021c180000, 0x00090f3d03010000}, "Heath Comp'oth plate, var. de béton"},
+	{{0x00000002260e0800, 0x00001c3c18100400}, "Caspard retardée"},
 	{{0x00000002646e0000, 0x00103e3c18101800}, "Brightstein Andersson centrale"},
 	{{0x00000002741e0000, 0x00103e3c08200800}, "Brightstein cric diagonale"},
 	{{0x000000027c3c0000, 0x00051f3d02000000}, "suite polyakov"},
@@ -753,22 +756,22 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000000400300000, 0x000030383c080000}, "Brightwell anglaise"},
 	{{0x0000000400781000, 0x00000c7838000000}, "japonaise Juhem-Caspard"},
 	{{0x0000000400781000, 0x00004c3838000000}, "japonaise corbeau"},
-	{{0x0000000404103000, 0x00000038782c0800}, "Heath Comp'oth groupée moderne"},
+	{{0x0000000404103000, 0x00000038782c0800}, "Heath Comp'oth groupée moderne"},
 	{{0x00000004041c0000, 0x0000303838000000}, "compacte principale"},
 	{{0x0000000408100000, 0x0000083810080000}, "cheval"},
 	{{0x0000000408281820, 0x0000343830140000}, "Popov sharalle"},
 	{{0x000000040a1c0000, 0x00043c3a30000000}, "Brightwell d'attente transverse"},
-	{{0x000000040c002000, 0x0000003870381810}, "Heath Comp'oth groupée, var. de béton"},
-	{{0x000000040c043804, 0x0000183830780000}, "défense Tamenori du double accès"},
+	{{0x000000040c002000, 0x0000003870381810}, "Heath Comp'oth groupée, var. de béton"},
+	{{0x000000040c043804, 0x0000183830780000}, "défense Tamenori du double accès"},
 	{{0x000000040c182400, 0x00003c7830200000}, "Rose Daunas tournante"},
 	{{0x000000040c182800, 0x00003c7830200000}, "Murakami tournante"},
 	{{0x000000040c1c0000, 0x00002c3830000000}, "crochet pseudo-rose"},
 	{{0x000000040c1c0000, 0x0000303830200000}, "Shaman triangle"},
 	{{0x000000040c1c0000, 0x0000383830200000}, "compacte d'opposition"},
-	{{0x000000040c1c0000, 0x0000787830000000}, "Muller en coins décalée"},
-	{{0x000000040c1c0000, 0x0010387830000000}, "Muller fusée"},
+	{{0x000000040c1c0000, 0x0000787830000000}, "Muller en coins décalée"},
+	{{0x000000040c1c0000, 0x0010387830000000}, "Muller fusée"},
 	{{0x000000040c242000, 0x0000181830181810}, "Greenberg classique (interversion)"},
-	{{0x000000040c242804, 0x0000183830181010}, "réfutation Tamenori"},
+	{{0x000000040c242804, 0x0000183830181010}, "réfutation Tamenori"},
 	{{0x000000040c3c0800, 0x0000187830400000}, "Rose Murakami"},
 	{{0x000000040c3c0800, 0x0000187870000000}, "rose plate tournante (rotating flat)"},
 	{{0x000000040c3c0800, 0x0000583830400000}, "Rose Daunas"},
@@ -776,28 +779,28 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000000040e1c2c7e, 0x00103c3830201000}, "Greenberg Polyakov Shastein"},
 	{{0x0000000410300000, 0x000008182c080000}, "Inoue"},
 	{{0x0000000414241000, 0x0000181828180800}, "Rose Greenberg"},
-	{{0x0000000418100000, 0x0000283820080000}, "Parker groupée"},
+	{{0x0000000418100000, 0x0000283820080000}, "Parker groupée"},
 	{{0x0000000418100000, 0x0000383804000000}, "Brightwell"},
 	{{0x0000000418180000, 0x00000c7820000000}, "coup 8"},
 	{{0x0000000418180000, 0x00002c3820000000}, "Rose"},
 	{{0x00000004181c2000, 0x00000c7860a00000}, "scorpion fausse Piau"},
 	{{0x00000004181c2000, 0x00000cf860200000}, "scorpion Jacpoth"},
-	{{0x00000004181c2000, 0x00002c3860a00000}, "scorpion Piau de béton"},
+	{{0x00000004181c2000, 0x00002c3860a00000}, "scorpion Piau de béton"},
 	{{0x0000000418200000, 0x0000101804000000}, "inconnue"},
 	{{0x000000041c000000, 0x00000e1800000000}, "campagnarde"},
 	{{0x000000041c000000, 0x00020c1800000000}, "ouverture X"},
 	{{0x000000041c043000, 0x0000181820780800}, "Greenberg Alard (interversion)"},
-	{{0x000000041e100000, 0x0000383800040000}, "Brightwell retardée"},
+	{{0x000000041e100000, 0x0000383800040000}, "Brightwell retardée"},
 	{{0x0000000424040000, 0x0000383818380000}, "Brightwell parisienne"},
 	{{0x0000000428100800, 0x00001018160c0400}, "Heath Comp'oth orthodoxe"},
 	{{0x0000000428202000, 0x0000003810181000}, "campagnarde Kitajima"},
 	{{0x0000000428300000, 0x00000c7810000000}, "Shaman plate"},
 	{{0x0000000428300000, 0x00004c3810000000}, "Shaman diagonale"},
 	{{0x0000000428300000, 0x0000583810080000}, "romaine"},
-	{{0x000000042c041000, 0x0000281810380800}, "Ishii elyséenne"},
+	{{0x000000042c041000, 0x0000281810380800}, "Ishii elyséenne"},
 	{{0x000000042c141000, 0x0000283810080800}, "Ishii matignon"},
 	{{0x000000042c2c0800, 0x0000583810101000}, "Rose Piau"},
-	{{0x0000000430380000, 0x000010180c040000}, "Brightwell intérieure"},
+	{{0x0000000430380000, 0x000010180c040000}, "Brightwell intérieure"},
 	{{0x0000000430380000, 0x000030780c000000}, "crochet Tastet"},
 	{{0x0000000436300000, 0x00001018080c0800}, "orque de Cambridge"},
 	{{0x000000043a380000, 0x0000101804060000}, "orque diagonale"},
@@ -808,13 +811,13 @@ static const PositionName NOM_POSITION[] = {
 	{{0x00000004580c0000, 0x00002c3820300000}, "scorpion Piau-puget"},
 	{{0x0000000458180000, 0x00083c3820400000}, "Rose Bruyninckx"},
 	{{0x000000046c082800, 0x00003c7810301000}, "Murakami occidentale"},
-	{{0x000000046c303804, 0x00003838104c0000}, "casse-tête"},
+	{{0x000000046c303804, 0x00003838104c0000}, "casse-tête"},
 	{{0x000000047e3c0000, 0x00147a7900000000}, "tournante paradoxale"},
 	{{0x00000004bcd88000, 0x00003cf840200000}, "Greenberg Polyakov de Barcelone"},
 	{{0x00000006001c1000, 0x000024181e020000}, "Ishii Penloup"},
 	{{0x000000060c0c2000, 0x0000201830301810}, "Ishii ancienne droite au bord"},
 	{{0x000000060c143000, 0x0000201830280c00}, "Ishii ancienne de la mini-diagonale"},
-	{{0x0000000636580000, 0x00083f3808060000}, "transverse trois croix de béton"},
+	{{0x0000000636580000, 0x00083f3808060000}, "transverse trois croix de béton"},
 	{{0x00000006640e0000, 0x00103c3818301800}, "Brightstein cric centrale"},
 	{{0x0000000664620000, 0x00103c3818181800}, "Brightstein Andersson Morillon"},
 	{{0x0000000674120000, 0x00103c3808280800}, "rose Brightstein"},
@@ -830,14 +833,14 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000000080c2c0000, 0x0000383030101000}, "Shaman triangle transverse"},
 	{{0x0000000810080000, 0x0000001008040000}, "diagonale"},
 	{{0x0000000810320000, 0x00000c142c040000}, "Shaman diagonale Vallund"},
-	{{0x0000000810701000, 0x0000207068000000}, "Heath d'évitement malgache"},
+	{{0x0000000810701000, 0x0000207068000000}, "Heath d'évitement malgache"},
 	{{0x0000000818080000, 0x0000107000100000}, "beta"},
 	{{0x0000000818080000, 0x00003e1400000000}, "raton Shaman"},
 	{{0x0000000818080000, 0x0010183400000000}, "Nicolet"},
 	{{0x0000000818100000, 0x00040c3400000000}, "Bill - de Grey"},
-	{{0x0000000818200000, 0x00001c1402000000}, "Ishii décollée"},
+	{{0x0000000818200000, 0x00001c1402000000}, "Ishii décollée"},
 	{{0x0000000818300000, 0x00000c1424000000}, "Shaman"},
-	{{0x000000081c100000, 0x0010103420000000}, "Tanida inversée"},
+	{{0x000000081c100000, 0x0010103420000000}, "Tanida inversée"},
 	{{0x000000081c100000, 0x0010303420000000}, "Tanida"},
 	{{0x000000081c101000, 0x00001c7420000000}, "Nicolet moderne"},
 	{{0x000000081c1c0000, 0x0000383020202000}, "Shaman triangle mur"},
@@ -853,8 +856,8 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000000083c060000, 0x0000001002381c08}, "Heath Ka"},
 	{{0x000000083c080800, 0x00003c1000040000}, "Kung plate"},
 	{{0x000000083c200000, 0x0000103040100000}, "Cambridge"},
-	{{0x000000083c380800, 0x00001c1000041000}, "tigre centrale d'Athènes"},
-	{{0x0000000840181010, 0x000000103c600000}, "Heath au bord médiane"},
+	{{0x000000083c380800, 0x00001c1000041000}, "tigre centrale d'Athènes"},
+	{{0x0000000840181010, 0x000000103c600000}, "Heath au bord médiane"},
 	{{0x00000008483c2000, 0x0000003034401000}, "Heath Comp'oth Takizawa"},
 	{{0x0000000858080000, 0x0000001020701000}, "Heath classique"},
 	{{0x0000000858081010, 0x0000001020700800}, "Heath au bord diagonale"},
@@ -862,18 +865,18 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000000085c100000, 0x0010303420200000}, "avion droit"},
 	{{0x000000085c100000, 0x0010303420400000}, "avion diagonal"},
 	{{0x000000085c1a0000, 0x00103c3420400000}, "transverse principale"},
-	{{0x000000085c1c0000, 0x0000383020600000}, "aile de béton"},
+	{{0x000000085c1c0000, 0x0000383020600000}, "aile de béton"},
 	{{0x000000085e180000, 0x00103c3420400000}, "plate transverse principale"},
 	{{0x000000086c0c0000, 0x0000383010301000}, "aile Feldborg"},
 	{{0x0000000870380800, 0x000000100c041000}, "Heath Comp'oth Buridan"},
 	{{0x0000000878180000, 0x0010707080200000}, "Heath Comp'oth Murakami au bord"},
 	{{0x0000000878200000, 0x0000001004181000}, "Heath Comp'oth (bat)"},
-	{{0x0000000c00300000, 0x00003030380c0000}, "tigre diagonale française"},
+	{{0x0000000c00300000, 0x00003030380c0000}, "tigre diagonale française"},
 	{{0x0000000c00302000, 0x00003030380c1000}, "orque diagonale de lille"},
 	{{0x0000000c04103000, 0x00001010782c0800}, "Heath Comp'oth plate, var. d'insertion"},
-	{{0x0000000c04103000, 0x00002010782c0800}, "Heath Comp'oth prétendante, var. d'insertion"},
+	{{0x0000000c04103000, 0x00002010782c0800}, "Heath Comp'oth prétendante, var. d'insertion"},
 	{{0x0000000c04240000, 0x000030f078100000}, "tigre centrale grosse masse"},
-	{{0x0000000c08081820, 0x0000303030342000}, "Popov murakami retardée"},
+	{{0x0000000c08081820, 0x0000303030342000}, "Popov murakami retardée"},
 	{{0x0000000c08200000, 0x0000081034101000}, "Bhagat"},
 	{{0x0000000c08200000, 0x00001c1010100000}, "Ishii transverse"},
 	{{0x0000000c08200000, 0x0000303030181000}, "Brightwell orque"},
@@ -882,9 +885,9 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000000c08280800, 0x0000303030141000}, "Popov (interversion)"},
 	{{0x0000000c08300800, 0x00003030300c0400}, "Japon 93 (interversion)"},
 	{{0x0000000c08300800, 0x00003030300c0400}, "tigre Japon 93"},
-	{{0x0000000c0c002000, 0x0000201070381810}, "Heath Comp'oth prétendante, var. de béton"},
+	{{0x0000000c0c002000, 0x0000201070381810}, "Heath Comp'oth prétendante, var. de béton"},
 	{{0x0000000c0c082400, 0x0000387030301000}, "Rose Daunas Microb"},
-	{{0x0000000c0c2c0000, 0x0000383030101000}, "compacte d'opposition française"},
+	{{0x0000000c0c2c0000, 0x0000383030101000}, "compacte d'opposition française"},
 	{{0x0000000c0e1c2c7e, 0x0014383030201000}, "Greenberg Polyakov grosse masse"},
 	{{0x0000000c143e0000, 0x0000383028000c00}, "coccinelle moderne"},
 	{{0x0000000c18300000, 0x0000383024000000}, "crochet en coin"},
@@ -897,63 +900,63 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000000c3c082800, 0x0000387040b01000}, "Murakami japonaise"},
 	{{0x0000000c3e3c0000, 0x00181e3040800000}, "plate tournante ouverte (?)"},
 	{{0x0000000c40001010, 0x000000103c7c0000}, "Heath Shaman"},
-	{{0x0000000c40001818, 0x000000103c7c0000}, "Heath carré blanc"},
-	{{0x0000000c40003010, 0x000000103c7c0800}, "Heath Shaman retardée"},
+	{{0x0000000c40001818, 0x000000103c7c0000}, "Heath carré blanc"},
+	{{0x0000000c40003010, 0x000000103c7c0800}, "Heath Shaman retardée"},
 	{{0x0000000c48001818, 0x0000001034780400}, "Heath scorpion"},
 	{{0x0000000c48c00000, 0x00007070b0300000}, "campagnarde milanaise"},
 	{{0x0000000c58080000, 0x0000087020100000}, "cheval roques"},
 	{{0x0000000c5c0c0000, 0x0000381020700000}, "Brightwell sablier"},
 	{{0x0000000c5c2c0000, 0x0000385020100000}, "Brightwell d'attente"},
 	{{0x0000000e0c2c0800, 0x0000181012100000}, "Heath Comp'oth Ralle"},
-	{{0x0000000e58180000, 0x00003c3020600000}, "Kung béton"},
+	{{0x0000000e58180000, 0x00003c3020600000}, "Kung béton"},
 	{{0x0000000e6e240000, 0x0014783010181800}, "Brightstein clef anglaise"},
-	{{0x0000001210100000, 0x00080c0c0c0c0800}, "Heath Comp'oth canoé"},
-	{{0x0000001214200000, 0x00101c0c0a0c0800}, "Panthéon"},
-	{{0x0000001217100000, 0x00000c0c080c0800}, "Heath cheminée diagonale centrale"},
+	{{0x0000001210100000, 0x00080c0c0c0c0800}, "Heath Comp'oth canoé"},
+	{{0x0000001214200000, 0x00101c0c0a0c0800}, "Panthéon"},
+	{{0x0000001217100000, 0x00000c0c080c0800}, "Heath cheminée diagonale centrale"},
 	{{0x00000012182c0000, 0x00101c0c06020000}, "Ishii ancienne"},
 	{{0x0000001400102000, 0x000010287c0c0000}, "chat en damier"},
 	{{0x0000001414100000, 0x00000808080e0000}, "campagnarde transverse"},
 	{{0x0000001416300000, 0x00081e0828080000}, "japonaise Juhem-Caspard"},
 	{{0x0000001418100000, 0x0000382800080000}, "cheval crochet"},
-	{{0x00000014181c2000, 0x00003ce860200000}, "scorpion Jacpoth retardé"},
+	{{0x00000014181c2000, 0x00003ce860200000}, "scorpion Jacpoth retardé"},
 	{{0x0000001420100800, 0x000818081e0c0400}, "Heath Comp'oth damier"},
 	{{0x0000001420600000, 0x000018285c100000}, "Penloup-Juhem Kaneda"},
 	{{0x0000001420701000, 0x0000182858080000}, "Heath Comp'oth Brightwell"},
 	{{0x0000001436000000, 0x0000080a080e0000}, "campagnarde berner"},
 	{{0x0000001436010000, 0x0000080b080e0000}, "campagnarde danoise"},
-	{{0x00000014580c0000, 0x00003c6820300000}, "scorpion groupé"},
+	{{0x00000014580c0000, 0x00003c6820300000}, "scorpion groupé"},
 	{{0x0000001470300800, 0x000008280c0c1400}, "campagnarde Ralle"},
-	{{0x0000001474540000, 0x0000242808280800}, "zèbre"},
-	{{0x000000160c5c0000, 0x00003c2832200000}, "Murakami doyo-kaï"},
+	{{0x0000001474540000, 0x0000242808280800}, "zèbre"},
+	{{0x000000160c5c0000, 0x00003c2832200000}, "Murakami doyo-kaï"},
 	{{0x0000001610100000, 0x000c1c2808080000}, "in my country tire-bouchon"},
 	{{0x0000001610240000, 0x00101c080c080000}, "Ishii des danseurs"},
 	{{0x0000001630300000, 0x00080c080c0c0800}, "Shaman plate ancienne"},
-	{{0x00000016385c0000, 0x00003c2806020000}, "Murakami Taïshii"},
+	{{0x00000016385c0000, 0x00003c2806020000}, "Murakami Taïshii"},
 	{{0x00000018180c0000, 0x0000382024000000}, "compacte en coin"},
 	{{0x000000181a100000, 0x00040c06040e0000}, "campagnarde Shibata"},
 	{{0x000000181c1c0000, 0x0000382020200000}, "Brightwell aile"},
 	{{0x000000181c1e0800, 0x0000382020202400}, "Moorlin"},
-	{{0x000000181c1e0800, 0x0000382020202400}, "moorlin retardée"},
+	{{0x000000181c1e0800, 0x0000382020202400}, "moorlin retardée"},
 	{{0x000000181c2c0000, 0x00101c0702000000}, "Ishii nordique"},
-	{{0x000000181c2c0000, 0x00101e0602000000}, "Ishii décollée classique"},
+	{{0x000000181c2c0000, 0x00101e0602000000}, "Ishii décollée classique"},
 	{{0x000000183a010000, 0x00000407040e0000}, "campagnarde ???"},
-	{{0x0000001a78180000, 0x00003c2402200000}, "Kung du pion isolé"},
+	{{0x0000001a78180000, 0x00003c2402200000}, "Kung du pion isolé"},
 	{{0x0000001c00103000, 0x000010207c680000}, "triangle Nicolet centrale"},
 	{{0x0000001c00200000, 0x000010207c100000}, "grande tigre centrale"},
 	{{0x0000001c00302000, 0x000010207c400000}, "triangle centrale"},
-	{{0x0000001c00400000, 0x000010207c302000}, "Penloup-Juhem, défense Tastet"},
+	{{0x0000001c00400000, 0x000010207c302000}, "Penloup-Juhem, défense Tastet"},
 	{{0x0000001c00600000, 0x000010607c100000}, "Penloup-Juhem requiem"},
 	{{0x0000001c04200000, 0x00000000380e0000}, "campagnarde nordique"},
 	{{0x0000001c08501000, 0x0000102070282000}, "Heath Comp'oth informatique"},
 	{{0x0000001c10200000, 0x000000000e0e0000}, "campagnarde traineau"},
 	{{0x0000001c143e0000, 0x0008182028000c00}, "coccinelle classique"},
-	{{0x0000001c18100800, 0x0000302024600000}, "décalée à plat"},
+	{{0x0000001c18100800, 0x0000302024600000}, "décalée à plat"},
 	{{0x0000001c18101000, 0x0000302024600000}, "in my country a plat"},
-	{{0x0000001c18103000, 0x0000302024680000}, "triangle Nicolet à plat"},
-	{{0x0000001c18180000, 0x0000000006040400}, "Heath cheminée droite"},
-	{{0x0000001c18180000, 0x0000000006040800}, "Heath cheminée diagonale"},
-	{{0x0000001c18300000, 0x00081e0024000000}, "groupée japonaise"},
-	{{0x0000001c38100000, 0x00000e2000080000}, "compacte extérieure"},
+	{{0x0000001c18103000, 0x0000302024680000}, "triangle Nicolet à plat"},
+	{{0x0000001c18180000, 0x0000000006040400}, "Heath cheminée droite"},
+	{{0x0000001c18180000, 0x0000000006040800}, "Heath cheminée diagonale"},
+	{{0x0000001c18300000, 0x00081e0024000000}, "groupée japonaise"},
+	{{0x0000001c38100000, 0x00000e2000080000}, "compacte extérieure"},
 	{{0x0000001c38100000, 0x000070e040200000}, "campagnarde classique ou 11 au bord"},
 	{{0x0000001c3a100000, 0x00041c2000080000}, "variante du triplet"},
 	{{0x0000001c3c000000, 0x00000003020e0000}, "campagnarde 9 au bord"},
@@ -972,7 +975,7 @@ static const PositionName NOM_POSITION[] = {
 	{{0x00000024000c0400, 0x00001c1818300800}, "tigre diagonale Ralle"},
 	{{0x0000002400120800, 0x000030181c0c0400}, "japonaise de la roussette"},
 	{{0x0000002400160000, 0x000030181c080808}, "japonaise douteuse"},
-	{{0x0000002400180800, 0x000030181c040000}, "tigre diagonale groupée"},
+	{{0x0000002400180800, 0x000030181c040000}, "tigre diagonale groupée"},
 	{{0x00000024001c0000, 0x000030181e000000}, "compacte de Grey"},
 	{{0x00000024040c0000, 0x0000301818100000}, "Shaman tau"},
 	{{0x00000024080c0000, 0x00000c1830300000}, "tigre scorpion"},
@@ -980,7 +983,7 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000002408180000, 0x0000181834000000}, "Muller en coins"},
 	{{0x0000002408180800, 0x0000341810040000}, "tigre diagonale Holgersson"},
 	{{0x000000240c080400, 0x00000c1830300000}, "romaine connexe"},
-	{{0x0000002414040000, 0x0000181808180800}, "chat américaine"},
+	{{0x0000002414040000, 0x0000181808180800}, "chat américaine"},
 	{{0x0000002414081000, 0x0000181868302000}, "Heath Comp'oth Murakami au centre"},
 	{{0x0000002418080000, 0x0000381804100000}, "Maruoka"},
 	{{0x000000241a300000, 0x00003018040e0000}, "scorpion classique"},
@@ -992,18 +995,18 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000002c00080000, 0x000008103c000000}, "cheval centrale"},
 	{{0x0000002c00100000, 0x000008103c000000}, "ball"},
 	{{0x0000002c00100000, 0x00003010180c0000}, "tigre diagonale"},
-	{{0x0000002c00180000, 0x000008103c040000}, "Muller d'été symétrique"},
+	{{0x0000002c00180000, 0x000008103c040000}, "Muller d'été symétrique"},
 	{{0x0000002c00200000, 0x00003010181c1000}, "tigre diagonale damier"},
 	{{0x0000002c04040000, 0x0000301018080000}, "Ishii tigre"},
 	{{0x0000002c08000800, 0x00003010103c0000}, "tigre diagonale Hashimoto"},
 	{{0x0000002c08080000, 0x0000081030100000}, "cheval transversale"},
 	{{0x0000002c08100000, 0x0000181034000000}, "cheval Muller"},
 	{{0x0000002c08100800, 0x00003010100c0400}, "tigre diagonale Tom-Pouce"},
-	{{0x0000002c18083020, 0x0000f85064700000}, "Tamenori française penloup"},
-	{{0x0000002c18083020, 0x0010b85064700000}, "Tamenori française shaman"},
+	{{0x0000002c18083020, 0x0000f85064700000}, "Tamenori française penloup"},
+	{{0x0000002c18083020, 0x0010b85064700000}, "Tamenori française shaman"},
 	{{0x0000002c18302000, 0x0000181024400000}, "Tamenori"},
-	{{0x0000002c1a300000, 0x00043812040c0000}, "scorpion excentré"},
-	{{0x0000002c1c180000, 0x0000b85060600000}, "défense Tamenori"},
+	{{0x0000002c1a300000, 0x00043812040c0000}, "scorpion excentré"},
+	{{0x0000002c1c180000, 0x0000b85060600000}, "défense Tamenori"},
 	{{0x0000002c38080000, 0x04083c1000100000}, "Andersson, var. Cali"},
 	{{0x0000002c58080000, 0x0000081020500000}, "cheval Daunas"},
 	{{0x0000002c70080000, 0x001038500c000000}, "roques argentine"},
@@ -1012,7 +1015,7 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000002e08200000, 0x00001c1016100000}, "Ishii T noir"},
 	{{0x0000002e34080000, 0x00003c100a040000}, "Greenberg classique (interversion)"},
 	{{0x0000002e64000400, 0x00101e1018380800}, "chat Andriani"},
-	{{0x0000002e6c2c0000, 0x0018781012111000}, "plate tournante de Tchéliabinsk"},
+	{{0x0000002e6c2c0000, 0x0018781012111000}, "plate tournante de Tchéliabinsk"},
 	{{0x0000002f0b200000, 0x00001010141c1c00}, "Heath japonaise"},
 	{{0x0000002f13200000, 0x000030100c0c1c00}, "Heath en coin"},
 	{{0x0000003200040000, 0x00000c0c3e080000}, "tigre centrale de Paris"},
@@ -1024,39 +1027,39 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000003c0c040000, 0x0000000030382c00}, "campagnarde Tanigushi"},
 	{{0x0000003c1c000400, 0x00000800201e0000}, "triangle Nicolet"},
 	{{0x0000003c1c000800, 0x00000800201e0000}, "geisha"},
-	{{0x0000003c1c001000, 0x00000800201e0000}, "geisha décalée"},
+	{{0x0000003c1c001000, 0x00000800201e0000}, "geisha décalée"},
 	{{0x0000003c1c080800, 0x0000100060343008}, "Heath Comp'oth Murakami au bord"},
 	{{0x0000003c1e180000, 0x00103c0201020000}, "Bruyninckx d'encerclement"},
 	{{0x0000003c3c1c0000, 0x0000244080000000}, "cannibale 11 au bord"},
 	{{0x0000003c3e3c0000, 0x00185e4040800000}, "plate tournante japonaise"},
 	{{0x0000005e2e480000, 0x00087c2010141000}, "Brightstein Tastet"},
-	{{0x0000006e26480000, 0x00083c1018161000}, "Brightstein retardée (interversion)"},
-	{{0x0000006e2e480000, 0x00083c1010161000}, "Brightstein retardée"},
+	{{0x0000006e26480000, 0x00083c1018161000}, "Brightstein retardée (interversion)"},
+	{{0x0000006e2e480000, 0x00083c1010161000}, "Brightstein retardée"},
 	{{0x0000007e3c1a0000, 0x00307c80c0e00000}, "Rose fautive"},
-	{{0x00000102007a1800, 0x00003c7c3e010000}, "plate tournante plébéenne"},
+	{{0x00000102007a1800, 0x00003c7c3e010000}, "plate tournante plébéenne"},
 	{{0x00000102024a1800, 0x00003c7c3c302000}, "plate tournante kaneda"},
-	{{0x00000102026a1000, 0x00003c7c3c100804}, "plate tournante, réfutation tamenori"},
+	{{0x00000102026a1000, 0x00003c7c3c100804}, "plate tournante, réfutation tamenori"},
 	{{0x0000010256681000, 0x00003c7c28160804}, "semi-Tamenori"},
 	{{0x0000010266701800, 0x00003c7c180e0400}, "cygne"},
-	{{0x0000010274781800, 0x00003c7c0a070000}, "plate tournante fermée, var. ouverte"},
-	{{0x000001028e4e2800, 0x00003c7c30301000}, "paradoxale réussie"},
+	{{0x0000010274781800, 0x00003c7c0a070000}, "plate tournante fermée, var. ouverte"},
+	{{0x000001028e4e2800, 0x00003c7c30301000}, "paradoxale réussie"},
 	{{0x000001028e5e0800, 0x00003c7c30202020}, "paradoxale de sacrifice"},
 	{{0x0000010a260e0800, 0x00003c3418100400}, "Tamenori de Londres"},
 	{{0x0000010a3e3e0000, 0x0000247401010000}, "cannibale Tezuka"},
 	{{0x0000011830020000, 0x00080c060f1c0000}, "Nicolet historique"},
 	{{0x0000013315030000, 0x00000e0c0a0c0000}, "campagnarde ???"},
-	{{0x0000020010380400, 0x00043c1e2c000000}, "scorpion du pion isolé"},
-	{{0x00000200203c0800, 0x0000583e1e000000}, "transverse du pion isolé"},
+	{{0x0000020010380400, 0x00043c1e2c000000}, "scorpion du pion isolé"},
+	{{0x00000200203c0800, 0x0000583e1e000000}, "transverse du pion isolé"},
 	{{0x0000020028000800, 0x00040c3e14080400}, "equerre damier"},
 	{{0x0000020030080800, 0x00040c3e0c040000}, "equerre centrale"},
 	{{0x0000020038380000, 0x0004141e04040000}, "Tau"},
-	{{0x000002003c3c1000, 0x0000187e02000000}, "Amadeus du hâbleur"},
-	{{0x000002007e3c0000, 0x0014787e00000000}, "tournante manège"},
+	{{0x000002003c3c1000, 0x0000187e02000000}, "Amadeus du hâbleur"},
+	{{0x000002007e3c0000, 0x0014787e00000000}, "tournante manège"},
 	{{0x00000200fe3c0000, 0x00187c7e00c00000}, "johnson"},
 	{{0x00000202183c0000, 0x00041c3c26000000}, "Greenberg alard (interversion)"},
-	{{0x000002040c3c0800, 0x0000583a70000000}, "transverse épineuse"},
+	{{0x000002040c3c0800, 0x0000583a70000000}, "transverse épineuse"},
 	{{0x0000020410380400, 0x00083c1a2c000000}, "scorpion du Luxembourg"},
-	{{0x0000020414241000, 0x0000181a28180800}, "Greenberg retardée"},
+	{{0x0000020414241000, 0x0000181a28180800}, "Greenberg retardée"},
 	{{0x00000204283c0800, 0x0000583a14020000}, "transverse trois croix"},
 	{{0x00000204383c1000, 0x0000187a04020000}, "Amadeus Mercedes"},
 	{{0x000002043e3c0000, 0x0014787840800000}, "tournante tourniquet"},
@@ -1079,17 +1082,17 @@ static const PositionName NOM_POSITION[] = {
 	{{0x0000022400180000, 0x00040c183c040000}, "Tamenori classique"},
 	{{0x0000022412180000, 0x00103c180c060000}, "Bruyninckx classique"},
 	{{0x0000022635080000, 0x00003c180a070000}, "Greenberg originelle (interversion)"},
-	{{0x0000022664020000, 0x00183c58183c0000}, "doyo-kaï centrale"},
+	{{0x0000022664020000, 0x00183c58183c0000}, "doyo-kaï centrale"},
 	{{0x0000022a00180000, 0x00041c143c040000}, "coccinelle thor"},
 	{{0x0000022c00100000, 0x000418123c080000}, "aberration optique diagonale"},
 	{{0x0000022e04080000, 0x00041c1038000000}, "coccinelle"},
 	{{0x0000023400100000, 0x0008180a3c080000}, "aberration optique droite"},
-	{{0x0000023618180000, 0x00041c0824040000}, "Tamenori retardée Di Meglio"},
+	{{0x0000023618180000, 0x00041c0824040000}, "Tamenori retardée Di Meglio"},
 	{{0x0000023a00080000, 0x00040c043c040000}, "triangle centrale classique"},
-	{{0x0000023a18180000, 0x00040c0426040000}, "tamenori retardée Penloup-Caspard"},
+	{{0x0000023a18180000, 0x00040c0426040000}, "tamenori retardée Penloup-Caspard"},
 	{{0x000002446e302000, 0x00187838100c1000}, "Brightstein Lazard"},
 	{{0x000002646a302000, 0x00183818140e1000}, "Brightstein Piau (interversion)"},
-	{{0x0000026c0e0a0000, 0x00003c1070741000}, "doyo-kaï polonaise"},
+	{{0x0000026c0e0a0000, 0x00003c1070741000}, "doyo-kaï polonaise"},
 	{{0x000003013f2e1800, 0x00003c7e40d02000}, "feinder"},
 	{{0x000003017f2e0800, 0x00003c7e00503010}, "jotel"},
 	{{0x00000302003c1000, 0x0000181c3e020000}, "Bruyninckx arche tortue"},
@@ -1100,8 +1103,8 @@ static const PositionName NOM_POSITION[] = {
 	{{0x00000400002c1030, 0x0000383c38100804}, "cannibale Murakami"},
 	{{0x0000040010300000, 0x0000383e0c080000}, "Lepidopterix niger"},
 	{{0x0000040010300000, 0x0008083c08080000}, "Kung"},
-	{{0x000004001c3c0800, 0x0000583e60000000}, "Rose transverse retardée"},
-	{{0x0000040020322000, 0x0000283e1c081000}, "scorpion des 2 pions isolés"},
+	{{0x000004001c3c0800, 0x0000583e60000000}, "Rose transverse retardée"},
+	{{0x0000040020322000, 0x0000283e1c081000}, "scorpion des 2 pions isolés"},
 	{{0x0000040036300000, 0x0000101e080c0800}, "Popov brisson"},
 	{{0x0000040038200000, 0x0000101e04100000}, "tigre diagonale classique"},
 	{{0x0000040038300000, 0x0000583e00080000}, "romaine Handel"},
@@ -1110,32 +1113,32 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000004021c3c0000, 0x00011b3d22000000}, "Greenberg polyakov"},
 	{{0x000004040024343c, 0x002818383f180800}, "Rose tardy"},
 	{{0x0000040410300000, 0x000038382c080000}, "Lepidopterix albus"},
-	{{0x0000040414300000, 0x00080838080c0000}, "suite française"},
+	{{0x0000040414300000, 0x00080838080c0000}, "suite française"},
 	{{0x0000040510240000, 0x000038382e030000}, "cannibale diagonale"},
 	{{0x00000408103c0000, 0x000008372e000000}, "Greenberg wahlberg"},
 	{{0x000004081e3c0000, 0x0030183620000000}, "Rose Piau classique"},
 	{{0x0000040820322000, 0x000028341e081000}, "scorpion de Varsovie"},
 	{{0x0000040c00302000, 0x000010107c040000}, "Kung diagonale, variante 33"},
-	{{0x0000040c003c1020, 0x000028303c400000}, "scorpion Piau-Puget, var. de béton"},
+	{{0x0000040c003c1020, 0x000028303c400000}, "scorpion Piau-Puget, var. de béton"},
 	{{0x0000040c08202000, 0x0000101074100800}, "Kung diagonale, variante 42"},
 	{{0x0000040c0c243020, 0x0000183030180c10}, "Greenberg originelle"},
-	{{0x0000040c1c3c3820, 0x043c387060000000}, "plate tournante fermée, var. fermée"},
+	{{0x0000040c1c3c3820, 0x043c387060000000}, "plate tournante fermée, var. fermée"},
 	{{0x0000040c30200000, 0x000010100c140000}, "tigre diagonale moderne"},
 	{{0x0000040c3c0c0800, 0x0000583040301000}, "Rose Piau-Marconi"},
 	{{0x0000040c5e2c0000, 0x0028187020101000}, "rose Collay"},
-	{{0x0000041064740000, 0x0000086818083c00}, "Ishii, var. d'évitement accélérée"},
-	{{0x0000041410300000, 0x000818082c080000}, "groupée anglaise "},
+	{{0x0000041064740000, 0x0000086818083c00}, "Ishii, var. d'évitement accélérée"},
+	{{0x0000041410300000, 0x000818082c080000}, "groupée anglaise "},
 	{{0x0000041434100000, 0x00080828080c0000}, "Brightwell Leader"},
 	{{0x0000041818300000, 0x0008180426000000}, "tigre diagonale milanaise"},
-	{{0x000004182c7c0000, 0x0000006050803c00}, "Ishii, var. d'évitement"},
+	{{0x000004182c7c0000, 0x0000006050803c00}, "Ishii, var. d'évitement"},
 	{{0x00000420000e0000, 0x0000181e3e102000}, "Penloup-Juhem Ohyanagi"},
 	{{0x0000042000120000, 0x0000181e3e0c0400}, "Penloup-Juhem de 92"},
-	{{0x00000424000c0400, 0x000018183e020000}, "Tamenori retardée"},
+	{{0x00000424000c0400, 0x000018183e020000}, "Tamenori retardée"},
 	{{0x0000043c04000400, 0x000008003a0e0800}, "triangle grosse masse"},
 	{{0x000004402e302000, 0x0018783c10081400}, "Brightstein Tastet 2 contre 1"},
 	{{0x0000044c00100000, 0x000038303c080000}, "Brightwell anglaise Robin"},
-	{{0x0000044c06242000, 0x0028383038181800}, "défense danoise"},
-	{{0x0000045c06042000, 0x0028182078381800}, "défense Bhagat"},
+	{{0x0000044c06242000, 0x0028383038181800}, "défense danoise"},
+	{{0x0000045c06042000, 0x0028182078381800}, "défense Bhagat"},
 	{{0x0000045c0e0c0000, 0x0028182070301000}, "Brightstein Bhagat"},
 	{{0x0000045c0e2c0000, 0x0028382030101000}, "Brightstein cric"},
 	{{0x000004645e0c0400, 0x0028181820721800}, "Brightstein Torben"},
@@ -1143,15 +1146,15 @@ static const PositionName NOM_POSITION[] = {
 	{{0x000004747c280400, 0x0028180902161800}, "Brightstein Piau"},
 	{{0x0000047c0e0c0000, 0x0028180030303000}, "Brightstein Andersson"},
 	{{0x00000520040e0000, 0x0000181f3a102000}, "Penloup-Juhem classique"},
-	{{0x0000060430300000, 0x0000101a0c0c0800}, "suite de béton"},
+	{{0x0000060430300000, 0x0000101a0c0c0800}, "suite de béton"},
 	{{0x00000608383c0800, 0x0000583606020000}, "transverse trois croix classique"},
-	{{0x0000062000080000, 0x0008081c38100000}, "compacte extérieure droite"},
+	{{0x0000062000080000, 0x0008081c38100000}, "compacte extérieure droite"},
 	{{0x0000062000080000, 0x0008081c3c000000}, "in my country"},
-	{{0x0000062000080000, 0x0010081c38100000}, "compacte extérieure diagonale"},
-	{{0x0000062000080000, 0x0010081c3c000000}, "tigre centrale décalée"},
+	{{0x0000062000080000, 0x0010081c38100000}, "compacte extérieure diagonale"},
+	{{0x0000062000080000, 0x0010081c3c000000}, "tigre centrale décalée"},
 	{{0x00000620000c0000, 0x0008081c3e000000}, "in my country alien"},
 	{{0x00000624000c0000, 0x000808183c020000}, "in my country Jensen"},
-	{{0x0000070a3c3c0000, 0x0018787442810000}, "plate tournante fermée, var. ouverte"},
+	{{0x0000070a3c3c0000, 0x0018787442810000}, "plate tournante fermée, var. ouverte"},
 	{{0x0000080020120000, 0x0000003c1c0c0c00}, "geisha pseudo-Nicolet"},
 	{{0x00000800201a0000, 0x0000003c1e040800}, "geisha Ghirardato"},
 	{{0x00000800220e0800, 0x0000043c1c100400}, "triangle de Varsovie"},
@@ -1159,32 +1162,32 @@ static const PositionName NOM_POSITION[] = {
 	{{0x00000800380e0800, 0x0000043c06010400}, "triangle grosse masse"},
 	{{0x000008003a080000, 0x0000043c04040000}, "tigre centrale Andersson"},
 	{{0x000008003e080000, 0x0000003e00040000}, "tigre centrale classique"},
-	{{0x0000080420300000, 0x000010181c0c0800}, "crochet intérieur"},
+	{{0x0000080420300000, 0x000010181c0c0800}, "crochet intérieur"},
 	{{0x000008043a080000, 0x0000003804060000}, "Penloup-Juhem"},
 	{{0x0000080c30380000, 0x000030100c040000}, "Brightwell papillon"},
-	{{0x0000081034001000, 0x0000000c08380000}, "Bhagat, var.principale"},
+	{{0x0000081034001000, 0x0000000c08380000}, "Bhagat, var. principale"},
 	{{0x000008163a102000, 0x00201428040e0000}, "Penloup-Juhem ancienne"},
 	{{0x000008183a100000, 0x0004042404080000}, "variante du quadruplet"},
-	{{0x000008183c1e2800, 0x3c3c342640000000}, "Rose béton collée"},
+	{{0x000008183c1e2800, 0x3c3c342640000000}, "Rose béton collée"},
 	{{0x0000081a38100000, 0x0004042404080000}, "variante des deux diagonales"},
 	{{0x0000081c3e1c0c00, 0x000070e040a03020}, "chat Penloup"},
-	{{0x0000081c7e0c0400, 0x0000706080303020}, "chat glissée au bord"},
+	{{0x0000081c7e0c0400, 0x0000706080303020}, "chat glissée au bord"},
 	{{0x0000081e28300000, 0x00000420140c0800}, "Shaman plate moderne"},
 	{{0x00000820160c1c20, 0x0000101c28720000}, "Tamenori de sophia"},
-	{{0x00000820340c1c20, 0x0000101c0a330000}, "Tamenori française"},
+	{{0x00000820340c1c20, 0x0000101c0a330000}, "Tamenori française"},
 	{{0x000008203e040400, 0x00001018003a1804}, "Tamenori japonaise"},
-	{{0x000008280c081000, 0x0000101430100800}, "roques Penloup antisymétrique"},
+	{{0x000008280c081000, 0x0000101430100800}, "roques Penloup antisymétrique"},
 	{{0x000008280c081000, 0x0000101430102000}, "Daunas aberration optique"},
 	{{0x000008382c000800, 0x00001000103c0400}, "Penloup-Juhem Andriani"},
 	{{0x000008540a003010, 0x00007028343e0000}, "chat Svirskiy"},
 	{{0x00000a1f08580800, 0x0004142074202400}, "romaine des minis diagos"},
-	{{0x00000a3c38100800, 0x00001000042c1420}, "Penloup-Juhem néo-Tastet"},
+	{{0x00000a3c38100800, 0x00001000042c1420}, "Penloup-Juhem néo-Tastet"},
 	{{0x00000c6038000400, 0x0000101c04781000}, "japonaise Suekuni"},
-	{{0x0000122c5e0c0400, 0x0004e8d0a0f01000}, "Rose béton d'extraction"},
+	{{0x0000122c5e0c0400, 0x0004e8d0a0f01000}, "Rose béton d'extraction"},
 	{{0x00002406540c0400, 0x0018183828502800}, "Brightstein Tastet ko"},
 	{{0x0000560014081000, 0x080c087c28302000}, "chat russe"},
-	{{0x000404740a041020, 0x0010390a343a0800}, "Tchéliabinsk diagonale au bord"},
-	{{0x0004047600041020, 0x001038083f3a0800}, "Tchéliabinsk droite au bord"},
+	{{0x000404740a041020, 0x0010390a343a0800}, "Tchéliabinsk diagonale au bord"},
+	{{0x0004047600041020, 0x001038083f3a0800}, "Tchéliabinsk droite au bord"},
 	{{0, 0}, NULL}
 };
 
@@ -1265,6 +1268,28 @@ static const PositionName POSITION_NAME[] = {
 	{{0,0}, NULL},
 };
 
+/**
+ * Normalize a char, ignoring accents and font case.
+ *
+ * @param c char input.
+ * @return converted char.
+ */
+static int to_lower_no_accent(int c)
+{
+#ifdef UNICODE
+	c = towlower(c);
+	if (c == L'é' || c == L'è' || c == L'ê')	return 'e';
+	if (c == L'à')	return 'a';
+	if (c == L'ï')	return 'i';
+#else
+	c = tolower(c);
+	if (c == 'é' || c == 'è' || c == 'ê')	return 'e';
+	if (c == 'à')	return 'a';
+	if (c == 'ï')	return 'i';
+#endif
+	return c;
+}
+
 /**
  * Compare two string, ignoring accents, font case, etc.
  *
@@ -1278,21 +1303,29 @@ static bool match(const char *s1, const char *s2)
 	for (;;) {
 		while (isspace(*s1) || ispunct(*s1)) ++s1;
 		while (isspace(*s2) || ispunct(*s2)) ++s2;
-	
+
 		if (*s1 == '\0' || *s2 == '\0') return (*s2 == '\0');
 
-		c1 = tolower(*s1);
-		c2 = tolower(*s2);
-		if (c1 == 'é' || c1 == 'è' || c1 == 'ê') c1 = 'e';
-		if (c1 == 'à') c1 = 'a';
-		if (c1 == 'ï') c1 = 'i';
-		if (c2 == 'é' || c2 == 'è' || c2 == 'ê') c2 = 'e';
-		if (c2 == 'à') c2 = 'a';
-		if (c2 == 'ï') c2 = 'i';
+		c1 = *s1++;
+		c2 = *s2++;
+#ifdef UNICODE
+		if ("ê"[0] == '\xc3') {	// test source encoding
+			if (c1 & 0x80) {	// utf8 to UCS2
+				c1 &= 0x1f;
+				while ((*s1 & 0xc0) == 0x80)
+					c1 = (c1 << 6) | (*s1++ & 0x3f);
+			}
+			if (c2 & 0x80) {
+				c2 &= 0x1f;
+				while ((*s2 & 0xc0) == 0x80)
+					c2 = (c2 << 6) | (*s2++ & 0x3f);
+			}
+		}
+#endif
+		c1 = to_lower_no_accent(c1);
+		c2 = to_lower_no_accent(c2);
 
 		if (c1 != c2) return false;
-
-		++s1; ++s2;
 	}
 }
 
@@ -1321,11 +1354,11 @@ const char *opening_get_line(const char *opening_name)
 const char *opening_get_english_name(const Board *board)
 {
 	const PositionName *p;
-	Board unique[1];
+	Board unique;
 
-	board_unique(board, unique);
+	board_unique(board, &unique);
 	for (p = POSITION_NAME; p->name != NULL; ++p) {
-		if (board_equal(unique, &p->board)) break;
+		if (board_equal(&unique, &p->board)) break;
 	}
 
 	return p->name;
@@ -1340,13 +1373,12 @@ const char *opening_get_english_name(const Board *board)
 const char *opening_get_french_name(const Board *board)
 {
 	const PositionName *p;
-	Board unique[1];
+	Board unique;
 
-	board_unique(board, unique);
+	board_unique(board, &unique);
 	for (p = NOM_POSITION; p->name != NULL; ++p) {
-		if (board_equal(unique, &p->board)) break;
+		if (board_equal(&unique, &p->board)) break;
 	}
 
 	return p->name;
 }
-
diff --git a/src/options.c b/src/options.c
index ea5622a9..a382d2a2 100644
--- a/src/options.c
+++ b/src/options.c
@@ -1,11 +1,11 @@
 /**
- * @file options.h
+ * @file options.c
  *
  * Options reader.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "options.h"
@@ -20,7 +20,7 @@
 
 /** global options with default value */
 Options options = {
-	21, // hash table size
+	22, // hash table size (2^22 * 24 * 1.125 = 113MB)
 
 	{0,-2,-3}, // inc_sort_depth
 
@@ -89,39 +89,39 @@ Options options = {
  */
 void options_usage(void)
 {
-	fprintf(stderr, "\nCommon options:\n");
-	fprintf(stderr, "  -?|help                       show this message.\n");
-	fprintf(stderr, "  -o|option-file                read options from this file.\n");
-	fprintf(stderr, "  -v|version                    display the version number.\n");
-	fprintf(stderr, "  -name <string>                set Edax name to <string>.\n");
-	fprintf(stderr, "  -verbose <n>                  verbosity level.\n");
-	fprintf(stderr, "  -q                            silent mode (eq. -verbose 0).\n");
-	fprintf(stderr, "  -vv                           very verbose mode (eq. -verbose 2).\n");
-	fprintf(stderr, "  -noise <n>                    noise level (print search output from ply <n>).\n");
-	fprintf(stderr, "  -width <n>                    line width.\n");
-	fprintf(stderr, "  -h|hash-table-size <nbits>    hash table size.\n");
-	fprintf(stderr, "  -n|n-tasks <n>                search in parallel using n tasks.\n");
-	fprintf(stderr, "  -cpu                          search using 1 cpu/thread.\n");
+	fprintf(stderr, "\nCommon options:\n"
+		"  -?|help                       show this message.\n"
+		"  -o|option-file                read options from this file.\n"
+		"  -v|version                    display the version number.\n"
+		"  -name <string>                set Edax name to <string>.\n"
+		"  -verbose <n>                  verbosity level.\n"
+		"  -q                            silent mode (eq. -verbose 0).\n"
+		"  -vv                           very verbose mode (eq. -verbose 2).\n"
+		"  -noise <n>                    noise level (print search output from ply <n>).\n"
+		"  -width <n>                    line width.\n"
+		"  -h|hash-table-size <nbits>    hash table size.\n"
+		"  -n|n-tasks <n>                search in parallel using n tasks.\n"
+		"  -cpu                          search using 1 cpu/thread.\n"
 #ifdef __APPLE__
-	fprintf(stderr, "\nCassio protocol options:\n");
-	fprintf(stderr, "  -debug-cassio                 print extra-information in cassio.\n");
-	fprintf(stderr, "  -follow-cassio                follow more closely cassio requests.\n");
-	fprintf(stderr, "\nOptions unavailable to Cassio protocol\n:");
+		"\nCassio protocol options:\n"
+		"  -debug-cassio                 print extra-information in cassio.\n"
+		"  -follow-cassio                follow more closely cassio requests.\n"
+		"\nOptions unavailable to Cassio protocol\n:"
 #endif
-	fprintf(stderr, "  -l|level <n>                  search using limited depth.\n");
-	fprintf(stderr, "  -t|game-time <n>              search using limited time per game.\n");
-	fprintf(stderr, "  -move-time <n>                search using limited time per move.\n");
-	fprintf(stderr, "  -ponder <on/off>              search during opponent time.\n");
-	fprintf(stderr, "  -eval-file                    read eval weight from this file.\n");
-	fprintf(stderr, "  -book-file                    load opening book from this file.\n");
-	fprintf(stderr, "  -book-usage <on/off>          play from the opening book.\n");
-	fprintf(stderr, "  -book-randomness <n>          play various but worse moves from the opening book.\n");
-	fprintf(stderr, "  -auto-start <on/off>          automatically restart a new game.\n");
-	fprintf(stderr, "  -auto-swap <on/off>           automatically Edax's color between games\n");
-	fprintf(stderr, "  -auto-store <on/off>          automatically save played games\n");
-	fprintf(stderr, "  -game-file <file>             file to store all played game/s.\n");
-	fprintf(stderr, "  -search-log-file <file>       file to store search detailed output/s.\n");
-	fprintf(stderr, "  -ui-log-file <file>           file to store input/output to the (U)ser (I)nterface.\n");
+		"  -l|level <n>                  search using limited depth.\n"
+		"  -t|game-time <n>              search using limited time per game.\n"
+		"  -move-time <n>                search using limited time per move.\n"
+		"  -ponder <on/off>              search during opponent time.\n"
+		"  -eval-file                    read eval weight from this file.\n"
+		"  -book-file                    load opening book from this file.\n"
+		"  -book-usage <on/off>          play from the opening book.\n"
+		"  -book-randomness <n>          play various but worse moves from the opening book.\n"
+		"  -auto-start <on/off>          automatically restart a new game.\n"
+		"  -auto-swap <on/off>           automatically Edax's color between games\n"
+		"  -auto-store <on/off>          automatically save played games\n"
+		"  -game-file <file>             file to store all played game/s.\n"
+		"  -search-log-file <file>       file to store search detailed output/s.\n"
+		"  -ui-log-file <file>           file to store input/output to the (U)ser (I)nterface.\n");
 
 	exit(EXIT_SUCCESS);
 }
@@ -202,8 +202,8 @@ int options_read(const char *option, const char *value)
 
 		else if (strcmp(option, "game-file") == 0) options.game_file = string_duplicate(value);
 
-		else if (strcmp(option, "eval-file") == 0) options.eval_file = string_duplicate(value);
-		
+		else if (strcmp(option, "eval-file") == 0) options.eval_file = string_duplicate(value);	// 11/13/2015
+
 		else if (strcmp(option, "book-file") == 0) options.book_file = string_duplicate(value);
 		else if (strcmp(option, "book-usage") == 0) parse_boolean(value, &options.book_allowed);
 		else if (strcmp(option, "book-randomness") == 0) parse_int(value, &options.book_randomness);
@@ -213,7 +213,7 @@ int options_read(const char *option, const char *value)
 		else if (strcmp(option, "ggs-log-file") == 0) options.ggs_log_file = string_duplicate(value);
 
 		else if (strcmp(option, "name") == 0) options.name = string_duplicate(value);
-		else if (strcmp(option, "echo") == 0)parse_boolean(value, &options.echo);
+		else if (strcmp(option, "echo") == 0) parse_boolean(value, &options.echo);
 
 		else if (strcmp(option, "auto-start") == 0) parse_boolean(value, &options.auto_start);
 		else if (strcmp(option, "auto-store") == 0) parse_boolean(value, &options.auto_store);
@@ -271,7 +271,7 @@ void options_parse(const char *file)
 	if (f != NULL) {
 
 		while ((line = string_read_line(f)) != NULL) {
-			int n = strlen(line);
+			size_t n = strlen(line);
 			option = (char*) malloc(n + 1);
 			value = (char*) malloc(n + 1);
 			option_parse(line, option, value, n);
@@ -291,9 +291,9 @@ void options_bound(void)
 	int max_threads;
 
 	if (sizeof (void*) == 4) {
-		BOUND(options.hash_table_size, 10, 25, "hash-table-size");
+		BOUND(options.hash_table_size, 10, 25, "hash-table-size");	// 51KB to 1.7GB
 	} else {
-		BOUND(options.hash_table_size, 10, 30, "hash-table-size");
+		BOUND(options.hash_table_size, 10, 30, "hash-table-size");	// 51KB to 53GB
 	}
 
 	max_threads = MIN(get_cpu_number(), MAX_THREADS);
diff --git a/src/perft.c b/src/perft.c
index ad5590ed..d7f7c36c 100644
--- a/src/perft.c
+++ b/src/perft.c
@@ -3,9 +3,9 @@
  *
  * @brief Move generator test.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "bit.h"
@@ -65,10 +65,10 @@ static void count_game(const Board *board, const int depth, GameStatistics *glob
 	GameStatistics stats = GAME_STATISTICS_INIT;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (depth == 1) {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 		stats.n_moves = stats.max_mobility = stats.min_mobility = bit_count(moves);
 		if (moves == 0) {
 			if (can_move(board->opponent, board->player)) {
@@ -82,16 +82,16 @@ static void count_game(const Board *board, const int depth, GameStatistics *glob
 			}
 		}
 	} else {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				count_game(next, depth - 1, &stats);
+				board_next(board, x, &next);
+				count_game(&next, depth - 1, &stats);
 			}
 		} else {
-			board_next(board, PASS, next);
-			if (can_move(next->player, next->opponent)) {
-				count_game(next, depth - 1, &stats);
+			board_next(board, PASS, &next);
+			if (can_move(next.player, next.opponent)) {
+				count_game(&next, depth - 1, &stats);
 			}
 		}
 	}
@@ -143,23 +143,23 @@ static void estimate_game(const Board *board, const int depth, Random *r, double
 {
 	unsigned long long moves;
 	int x, i, j, k;
-	Board next[1];
+	Board next;
 
-	moves = get_moves(board->player, board->opponent);
+	moves = board_get_moves(board);
 	i = bit_count(moves);
 	if (i == 0 && !can_move(board->opponent, board->player)) {
 		n[depth] = 0;
 	} else {
 		n[depth] = 1;
 		if (i == 0) {
-			board_next(board, PASS, next);
-			estimate_game(next, depth + 1, r, n);
+			board_next(board, PASS, &next);
+			estimate_game(&next, depth + 1, r, n);
 		} else {
 			j = random_get(r) % i;
 			foreach_bit (x, moves) {
 				if (j == 0) {
-					board_next(board, x, next);
-					estimate_game(next, depth + 1, r, n);
+					board_next(board, x, &next);
+					estimate_game(&next, depth + 1, r, n);
 					for (k = depth; n[k]; ++k) n[k] *= i;
 					break;
 				} else --j;
@@ -240,12 +240,12 @@ static void test_mobility(const Board *board, const int ply, Random *r, int *mov
 {
 	unsigned long long moves;
 	int x, i, k, e;
-	Board next[1];
+	Board next;
 
 	e = board_count_empties(board);
 
 	if (e > *max_mobility) {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 		if (moves) {
 			i = bit_count(moves);
 			if (i > *max_mobility || (i == *max_mobility && e > *max_empties)) {
@@ -265,8 +265,8 @@ static void test_mobility(const Board *board, const int ply, Random *r, int *mov
 				foreach_bit (x, moves) {
 					if (i-- == 0) {
 						move[ply] = x;
-						board_next(board, x, next);
-						test_mobility(next, ply + 1, r, move, max_mobility, max_empties, n);
+						board_next(board, x, &next);
+						test_mobility(&next, ply + 1, r, move, max_mobility, max_empties, n);
 						break;
 					}
 				}
@@ -274,8 +274,8 @@ static void test_mobility(const Board *board, const int ply, Random *r, int *mov
 		} else {
 			if (can_move(board->opponent, board->player)) {
 				move[ply] = PASS;
-				board_next(board, PASS, next);
-				test_mobility(next, ply + 1, r, move, max_mobility, max_empties, n);
+				board_next(board, PASS, &next);
+				test_mobility(&next, ply + 1, r, move, max_mobility, max_empties, n);
 			}
 		}
 	}
@@ -324,10 +324,10 @@ const GameHash GAME_HASH_INIT = {{0ULL, 0ULL}, {0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 64
 typedef struct {
 	GameHash *array; /**< array of hash entries */
 	int size;          /**< size */
-    int mask;          /**< mask */
+	int mask;          /**< mask */
 	unsigned long long n_tries; /**< n_tries */
 	unsigned long long n_hits;  /**< n_tries */
-} GameHashTable;	
+} GameHashTable;
 
 /**
  * @brief Hash table initialisation
@@ -398,7 +398,6 @@ static bool gamehash_fail(GameHashTable *hash, const Board *b, const int depth,
 	GameHash *i, *j;
 
 	if (depth > 2) {
-
 		board_unique(b, &u);
 		j = hash->array + (board_get_hash_code(&u) & hash->mask);
 		++hash->n_tries;
@@ -430,7 +429,7 @@ static void quick_count_game_6x6(GameHashTable *hash, const Board *board, const
 	GameStatistics stats = GAME_STATISTICS_INIT;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (depth == 1) {
 		moves = get_moves_6x6(board->player, board->opponent);
@@ -450,13 +449,13 @@ static void quick_count_game_6x6(GameHashTable *hash, const Board *board, const
 		moves = get_moves_6x6(board->player, board->opponent);
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				quick_count_game_6x6(hash, next, depth - 1, &stats);
+				board_next(board, x, &next);
+				quick_count_game_6x6(hash, &next, depth - 1, &stats);
 			}
 		} else {
-			board_next(board, PASS, next);
-			if (can_move_6x6(next->player, next->opponent)) {
-				quick_count_game_6x6(hash, next, depth - 1, &stats);
+			board_next(board, PASS, &next);
+			if (can_move_6x6(next.player, next.opponent)) {
+				quick_count_game_6x6(hash, &next, depth - 1, &stats);
 			}
 		}
 		gamehash_store(hash, board, depth, &stats);
@@ -477,10 +476,10 @@ static void quick_count_game(GameHashTable *hash, const Board *board, const int
 	GameStatistics stats = GAME_STATISTICS_INIT;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (depth == 1) {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 		stats.n_moves = stats.max_mobility = stats.min_mobility = bit_count(moves);
 		if (moves == 0) {
 			if (can_move(board->opponent, board->player)) {
@@ -494,16 +493,16 @@ static void quick_count_game(GameHashTable *hash, const Board *board, const int
 			}
 		}
 	} else if (gamehash_fail(hash, board, depth, &stats)) {
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				quick_count_game(hash, next, depth - 1, &stats);
+				board_next(board, x, &next);
+				quick_count_game(hash, &next, depth - 1, &stats);
 			}
 		} else {
-			board_next(board, PASS, next);
-			if (can_move(next->player, next->opponent)) {
-				quick_count_game(hash, next, depth - 1, &stats);
+			board_next(board, PASS, &next);
+			if (can_move(next.player, next.opponent)) {
+				quick_count_game(hash, &next, depth - 1, &stats);
 			}
 		}
 		gamehash_store(hash, board, depth, &stats);
@@ -531,8 +530,8 @@ void quick_count_games(const Board *board, const int depth, const int size)
 	puts("------------------------------------------------------------------------------------------------------------------");
 	n = 1;
 	for (i = 1; i <= depth; ++i) {
-		t = -cpu_clock();
 		gamehash_init(&hash, options.hash_table_size);
+		t = -cpu_clock();
 		stats = GAME_STATISTICS_INIT;
 		if (size == 6) quick_count_game_6x6(&hash, board, i, &stats);
 		else quick_count_game(&hash, board, i, &stats);
@@ -561,13 +560,15 @@ typedef struct CBoard {
 #pragma pack()
 
 static void compact_board(const Board *b, CBoard *c) {
-	int i, n = 0, x;
+	int i, n, m, x;
 
-	i = 0;
+	i = n = m = 0;
 	for (x = A1; x <= H8; ++x) {
-		if (x % 5 == 0) n = 0;
 		n = 3 * n + board_get_square_color(b, x);
-		if (x % 5 == 4) c->x[i++] = n;
+		if (++m == 5) {
+			c->x[i++] = n;
+			n = m = 0;
+		}
 	}
 	c->x[i] = n;
 }
@@ -670,10 +671,10 @@ static bool boardcache_undone(BoardCache *hash, const Board *b)
 	board_unique(b, &u);
 	h = board_get_hash_code(&u);
 	i = (h & hash->mask);
-	if (board_compare(&u, hash->array + i) == 0
-	 || board_compare(&u, hash->array + i + 1) == 0
-	 || board_compare(&u, hash->array + i + 2) == 0
-	 || board_compare(&u, hash->array + i + 3) == 0) return false;
+	if (board_equal(&u, hash->array + i)
+	 || board_equal(&u, hash->array + i + 1)
+	 || board_equal(&u, hash->array + i + 2)
+	 || board_equal(&u, hash->array + i + 3)) return false;
 
 	return true;
 }
@@ -688,10 +689,10 @@ static void boardcache_append(BoardCache *hash, const Board *b)
 	board_unique(b, &u);
 	h = board_get_hash_code(&u);
 	i = (h & hash->mask);
-	if (board_compare(&u, hash->array + i) == 0
-	 || board_compare(&u, hash->array + i + 1) == 0
-	 || board_compare(&u, hash->array + i + 2) == 0
-	 || board_compare(&u, hash->array + i + 3) == 0) return;
+	if (board_equal(&u, hash->array + i)
+	 || board_equal(&u, hash->array + i + 1)
+	 || board_equal(&u, hash->array + i + 2)
+	 || board_equal(&u, hash->array + i + 3)) return;
 
 	l = board_count_empties(hash->array + i); j = i;
 	k = board_count_empties(hash->array + ++i); if (k > l) {l = k; j = i;}
@@ -759,20 +760,20 @@ static unsigned long long count_position(PositionHash *hash, BoardCache *cache,
 	unsigned long long nodes = 0;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (boardcache_undone(cache, board)) {
 		if (depth == 0) return positionhash_append(hash, board);
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				nodes += count_position(hash, cache, next, depth - 1);
+				board_next(board, x, &next);
+				nodes += count_position(hash, cache, &next, depth - 1);
 			}
 		} else if (can_move(board->opponent, board->player)) {
-			board_next(board, PASS, next);
-			nodes += count_position(hash, cache, next, depth);
+			board_next(board, PASS, &next);
+			nodes += count_position(hash, cache, &next, depth);
 		}
 		boardcache_append(cache, board);
 	}
@@ -792,7 +793,7 @@ static unsigned long long count_position_6x6(PositionHash *hash, BoardCache *cac
 	unsigned long long nodes = 0;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (boardcache_undone(cache, board)) {
 		if (depth == 0) return positionhash_append(hash, board);
@@ -800,12 +801,12 @@ static unsigned long long count_position_6x6(PositionHash *hash, BoardCache *cac
 
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				nodes += count_position_6x6(hash, cache, next, depth - 1);
+				board_next(board, x, &next);
+				nodes += count_position_6x6(hash, cache, &next, depth - 1);
 			}
 		} else if (can_move_6x6(board->opponent, board->player)) {
-			board_next(board, PASS, next);
-			nodes += count_position_6x6(hash, cache, next, depth);
+			board_next(board, PASS, &next);
+			nodes += count_position_6x6(hash, cache, &next, depth);
 		}
 		boardcache_append(cache, board);
 	}
@@ -872,30 +873,6 @@ unsigned long long shape_unique(unsigned long long shape)
 	return unique;
 }
 
-/**
- * @brief Compute a hash code.
- *
- * @param shape Board shape.
- * @return The hash code of the bitboard.
- */
-unsigned long long shape_get_hash_code(const unsigned long long shape)
-{
-	unsigned long long h;
-	const unsigned char *p = (const unsigned char*)&shape;
-
-	h  = hash_rank[0][p[0]];
-	h ^= hash_rank[1][p[1]];
-	h ^= hash_rank[2][p[2]];
-	h ^= hash_rank[3][p[3]];
-	h ^= hash_rank[4][p[4]];
-	h ^= hash_rank[5][p[5]];
-	h ^= hash_rank[6][p[6]];
-	h ^= hash_rank[7][p[7]];
-	h ^= hash_rank[8][p[8]];
-
-	return h;
-}
-
 /**
  * Array of shape.
  */
@@ -994,7 +971,7 @@ static bool shapehash_append(ShapeHash *hash, const Board *b)
 	unsigned long long u;
 
 	u = shape_unique(b->player | b->opponent);
-	return shapearray_append(hash->array + (shape_get_hash_code(u) & hash->mask), u);
+	return shapearray_append(hash->array + (crc32c_u64(0, u) & hash->mask), u);
 }
 
 /**
@@ -1009,21 +986,21 @@ static unsigned long long count_shape(ShapeHash *hash, BoardCache *cache, const
 	unsigned long long nodes = 0;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (boardcache_undone(cache, board)) {
 		if (depth == 0) return shapehash_append(hash, board);
-		moves = get_moves(board->player, board->opponent);
+		moves = board_get_moves(board);
 
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				nodes += count_shape(hash, cache, next, depth - 1);
+				board_next(board, x, &next);
+				nodes += count_shape(hash, cache, &next, depth - 1);
 			}
 		} else {
-			board_next(board, PASS, next);
+			board_next(board, PASS, &next);
 			if (can_move(board->player, board->opponent)) {
-				nodes += count_shape(hash, cache, next, depth);
+				nodes += count_shape(hash, cache, &next, depth);
 			}
 		}
 		boardcache_append(cache, board);
@@ -1044,7 +1021,7 @@ static unsigned long long count_shape_6x6(ShapeHash *hash, BoardCache *cache, co
 	unsigned long long nodes = 0;
 	unsigned long long moves;
 	int x;
-	Board next[1];
+	Board next;
 
 	if (boardcache_undone(cache, board)) {
 		if (depth == 0) return shapehash_append(hash, board);
@@ -1052,13 +1029,13 @@ static unsigned long long count_shape_6x6(ShapeHash *hash, BoardCache *cache, co
 
 		if (moves) {
 			foreach_bit (x, moves) {
-				board_next(board, x, next);
-				nodes += count_shape_6x6(hash, cache, next, depth - 1);
+				board_next(board, x, &next);
+				nodes += count_shape_6x6(hash, cache, &next, depth - 1);
 			}
 		} else {
-			board_next(board, PASS, next);
+			board_next(board, PASS, &next);
 			if (can_move_6x6(board->player, board->opponent)) {
-				nodes += count_shape_6x6(hash, cache, next, depth);
+				nodes += count_shape_6x6(hash, cache, &next, depth);
 			}
 		}
 		boardcache_append(cache, board);
@@ -1113,29 +1090,29 @@ void count_shapes(const Board *board, const int depth, const int size)
  * @param line line to reach the target position
  */
 bool seek_position(const Board *target, const Board *board, Line *line) {
- 	const unsigned long long mask = target->opponent | target->player;
- 	unsigned long long moves;
- 	int x;
- 	Board next[1];
- 	
- 	if (board_equal(board, target)) return true;
- 		
- 	moves = get_moves(board->player, board->opponent);
+	const unsigned long long mask = target->opponent | target->player;
+	unsigned long long moves;
+	int x;
+	Board next;
+
+	if (board_equal(board, target)) return true;
+
+	moves = board_get_moves(board);
 	if (moves) {
 		moves &= mask;
 		foreach_bit (x, moves) {
 			line_push(line, x);
-			board_next(board, x, next);
-			if (seek_position(target, next, line)) return true;
+			board_next(board, x, &next);
+			if (seek_position(target, &next, line)) return true;
 			line_pop(line);
 		}
 	} else {
-		board_next(board, PASS, next);
-		if (can_move(next->player, next->opponent)) {
-			if (seek_position(target, next, line)) return true;
+		board_next(board, PASS, &next);
+		if (can_move(next.player, next.opponent)) {
+			if (seek_position(target, &next, line)) return true;
 		}
 	}
-	
+
 	return false;
 }
 
diff --git a/src/play.c b/src/play.c
index 74d7a5b9..e08e2e08 100644
--- a/src/play.c
+++ b/src/play.c
@@ -3,7 +3,7 @@
  *
  * Edax play control.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -26,21 +26,21 @@
  */
 void play_init(Play *play, Book *book)
 {
-	search_init(play->search);
+	search_init(&play->search);
 	play->book = book;
-	board_init(play->initial_board);
-	play->search->options.header = " depth|score|       time   |  nodes (N)  |   N/s    | principal variation";
-	play->search->options.separator = "------+-----+--------------+-------------+----------+----------------------";
+	board_init(&play->initial_board);
+	play->search.options.header = " depth|score|       time   |  nodes (N)  |   N/s    | principal variation";
+	play->search.options.separator = "------+-----+--------------+-------------+----------+----------------------";
 	play->player = play->initial_player = BLACK;
 	play->time[0].left = options.time;
 	play->time[0].extra = 0;
 	play->time[1].left = options.time;
 	play->time[1].extra = 0;
 	play_new(play);
-	lock_init(play->ponder);
-	play->ponder->launched = false;
-	spin_init(play->result);
-	play->ponder->verbose = false;
+	lock_init(&play->ponder);
+	play->ponder.launched = false;
+	spin_init(&play->result);
+	play->ponder.verbose = false;
 	memset(play->error_message, 0, PLAY_MESSAGE_MAX_LENGTH);
 	play_force_init(play, "F5");
 }
@@ -52,7 +52,7 @@ void play_init(Play *play, Book *book)
 void play_free(Play *play)
 {
 	play_stop_pondering(play);
-	search_free(play->search);
+	search_free(&play->search);
 }
 
 /**
@@ -63,13 +63,13 @@ void play_new(Play *play)
 {
 	play->clock = real_clock();
 	play->time[0].spent = play->time[1].spent = 0;
-	*play->board = *play->initial_board;
+	play->board = play->initial_board;
 	play->player = play->initial_player;
-	play->ponder->board->player = play->ponder->board->opponent = 0;
-	search_cleanup(play->search);
+	play->ponder.board.player = play->ponder.board.opponent = 0;
+	search_cleanup(&play->search);
 	play->i_game = play->n_game = 0;
 	play->state = IS_WAITING;
-	play->result->move = NOMOVE; // missing more initialisation ?
+	play->result.move = NOMOVE; // missing more initialisation ?
 	play->time[0].left = options.time;
 	play->time[1].left = options.time;
 	play->force.i_move = 0;
@@ -83,7 +83,7 @@ void play_new(Play *play)
  */
 bool play_load(Play *play, const char *file)
 {
-	Game game[1];
+	Game game;
 	FILE *f;
 	int i, l;
 	char ext[8], move[8];
@@ -96,24 +96,24 @@ bool play_load(Play *play, const char *file)
 
 	l = strlen(file); strcpy(ext, file + l - 4); string_to_lowercase(ext);
 
-	if (strcmp(ext, ".txt") == 0) game_import_text(game, f);
-	else if (strcmp(ext, ".ggf") == 0) game_import_ggf(game, f);
-	else if (strcmp(ext, ".sgf") == 0) game_import_sgf(game, f);
-	else if (strcmp(ext, ".pgn") == 0) game_import_pgn(game, f);
-	else if (strcmp(ext, ".edx") == 0) game_read(game, f);
+	if (strcmp(ext, ".txt") == 0) game_import_text(&game, f);
+	else if (strcmp(ext, ".ggf") == 0) game_import_ggf(&game, f);
+	else if (strcmp(ext, ".sgf") == 0) game_import_sgf(&game, f);
+	else if (strcmp(ext, ".pgn") == 0) game_import_pgn(&game, f);
+	else if (strcmp(ext, ".edx") == 0) game_read(&game, f);
 	else {
 		sprintf(play->error_message, "Unknown game format extension: %s\n", ext);
 		fclose(f);
 		return false;
 	}
 
-	*play->initial_board = *game->initial_board;
-	play->initial_player = game->player;
+	play->initial_board = game.initial_board;
+	play->initial_player = game.player;
 	play_new(play);
-	for (i = 0; i < 60 && game->move[i] != NOMOVE; ++i) {
+	for (i = 0; i < 60 && game.move[i] != NOMOVE; ++i) {
 		if (play_must_pass(play)) play_move(play, PASS);
-		if (!play_move(play, game->move[i])) {
-			sprintf(play->error_message, "Illegal move #%d: %s\n", i, move_to_string(game->move[i], play->player, move));
+		if (!play_move(play, game.move[i])) {
+			sprintf(play->error_message, "Illegal move #%d: %s\n", i, move_to_string(game.move[i], play->player, move));
 			fclose(f);
 			return false;
 		}
@@ -130,18 +130,18 @@ bool play_load(Play *play, const char *file)
  */
 void play_save(Play *play, const char *file)
 {
-	Game game[1];
+	Game game;
 	FILE *f;
 	int i, j, l;
 	char ext[8];
 
 
-	game_init(game);
-	*game->initial_board = *play->initial_board;
-	game->player = play->initial_player;
+	game_init(&game);
+	game.initial_board = play->initial_board;
+	game.player = play->initial_player;
 	for (i = j = 0; i < play->n_game; ++i) {
 		if (play->game[i].x != PASS) {
-			game->move[j++] = play->game[i].x;
+			game.move[j++] = play->game[i].x;
 		}
 	}
 
@@ -153,13 +153,13 @@ void play_save(Play *play, const char *file)
 
 	l = strlen(file); strcpy(ext, file + l - 4); string_to_lowercase(ext);
 
-	if (strcmp(ext, ".txt") == 0) game_export_text(game, f);
-	else if (strcmp(ext, ".ggf") == 0) game_export_ggf(game, f);
-	else if (strcmp(ext, ".sgf") == 0) game_save_sgf(game, f, true);
-	else if (strcmp(ext, ".pgn") == 0) game_export_pgn(game, f);
-	else if (strcmp(ext, ".eps") == 0) game_export_eps(game, f);
-	else if (strcmp(ext, ".svg") == 0) game_export_svg(game, f);
-	else if (strcmp(ext, ".edx") == 0) game_write(game, f);
+	if (strcmp(ext, ".txt") == 0) game_export_text(&game, f);
+	else if (strcmp(ext, ".ggf") == 0) game_export_ggf(&game, f);
+	else if (strcmp(ext, ".sgf") == 0) game_save_sgf(&game, f, true);
+	else if (strcmp(ext, ".pgn") == 0) game_export_pgn(&game, f);
+	else if (strcmp(ext, ".eps") == 0) game_export_eps(&game, f);
+	else if (strcmp(ext, ".svg") == 0) game_export_svg(&game, f);
+	else if (strcmp(ext, ".edx") == 0) game_write(&game, f);
 	else warn("Unknown game format extension: %s\n", ext);
 
 	fclose(f);
@@ -174,7 +174,7 @@ void play_save(Play *play, const char *file)
 void play_update(Play *play, Move *move)
 {
 	play_force_update(play);
-	board_update(play->board, move);
+	board_update(&play->board, move);
 	play->game[play->i_game] = *move;
 	play->n_game = ++play->i_game;
 	play->time[play->player].spent += real_clock() - play->clock;
@@ -182,6 +182,7 @@ void play_update(Play *play, Move *move)
 	play->player ^= 1;
 }
 
+#if 0
 /**
  * @brief Check if game is over.
  * @param play Play.
@@ -189,9 +190,8 @@ void play_update(Play *play, Move *move)
  */
 bool play_is_game_over(Play *play)
 {
-	Board *board = play->board;
-	return can_move(board->player, board->opponent) == false &&
-		can_move(board->opponent, board->player) == false;
+	return !can_move(play->board.player, play->board.opponent) &&
+		!can_move(play->board.opponent, play->board.player);
 }
 
 /**
@@ -201,10 +201,10 @@ bool play_is_game_over(Play *play)
  */
 bool play_must_pass(Play *play)
 {
-	Board *board = play->board;
-	return can_move(board->player, board->opponent) == false &&
-		can_move(board->opponent, board->player) == true;
+	return !can_move(play->board.player, play->board.opponent) &&
+		can_move(play->board.opponent, play->board.player);
 }
+#endif
 
 /**
  * @brief Start thinking.
@@ -217,64 +217,64 @@ void play_go(Play *play, const bool update)
 
 	long long t_real = -real_clock();
 	long long t_cpu = -cpu_clock();
-	Move move[1];
-	Search *search = play->search;
+	Move move;
+	Search *const search = &play->search;
 	char s_move[4];
 
 	if (play_is_game_over(play)) return;
 
-	if (play_force_go(play, move)) {
+	if (play_force_go(play, &move)) {
 		play_stop_pondering(play);
 
-		play->result->depth = 0;
-		play->result->selectivity = 0;
-		play->result->move = move->x;
-		play->result->score = 0;
-		play->result->book_move = false;
-		play->result->time = real_clock() + t_real;
-		play->result->n_nodes = 0;
-		line_init(play->result->pv, play->player);
-		line_push(play->result->pv, move->x);
+		play->result.depth = 0;
+		play->result.selectivity = 0;
+		play->result.move = move.x;
+		play->result.score = 0;
+		play->result.book_move = false;
+		play->result.time = real_clock() + t_real;
+		play->result.n_nodes = 0;
+		line_init(&play->result.pv, play->player);
+		line_push(&play->result.pv, move.x);
 
 		if (options.verbosity) {
-			info("\n[Forced move %s]\n\n",  move_to_string(move->x, play->player, s_move));
+			info("\n[Forced move %s]\n\n",  move_to_string(move.x, play->player, s_move));
 		}
 
-	} else if (options.book_allowed && book_get_random_move(play->book, play->board, move, options.book_randomness)) {
+	} else if (options.book_allowed && book_get_random_move(play->book, &play->board, &move, options.book_randomness)) {
 		play_stop_pondering(play);
 
-		play->result->depth = 0;
-		play->result->selectivity = 0;
-		play->result->move = move->x;
-		play->result->score = move->score;
-		play->result->book_move = true;
-		play->result->time = real_clock() + t_real;
-		play->result->n_nodes = 0;
-		line_init(play->result->pv, play->player);
-		book_get_line(play->book, play->board, move, play->result->pv);
+		play->result.depth = 0;
+		play->result.selectivity = 0;
+		play->result.move = move.x;
+		play->result.score = move.score;
+		play->result.book_move = true;
+		play->result.time = real_clock() + t_real;
+		play->result.n_nodes = 0;
+		line_init(&play->result.pv, play->player);
+		book_get_line(play->book, &play->board, &move, &play->result.pv);
 		
 		if (options.verbosity) {
 			info("\n[book move]\n");
-			if (options.info) book_show(play->book, play->board);
+			if (options.info) book_show(play->book, &play->board);
 			info("\n\n");
 
 			if (play->type == UI_XBOARD) {
-				search->observer(play->result);
+				search->observer(&play->result);
 			} else {
 				if (search->options.header) puts(search->options.header);
 				if (search->options.separator) puts(search->options.separator);
-				printf("book    %+02d                                          ", move->score);
-				line_print(play->result->pv, options.width - 54, " ", stdout);
+				printf("book    %+02d                                          ", move.score);
+				line_print(&play->result.pv, options.width - 54, " ", stdout);
 				putchar('\n');
 				if (search->options.separator) puts(search->options.separator);
 			} 
 		}
-	} else if (play->state == IS_PONDERING && board_equal(play->board, play->ponder->board)) {
+	} else if (play->state == IS_PONDERING && board_equal(&play->board, &play->ponder.board)) {
 		play->state = IS_THINKING;
 
 		search->options.verbosity = options.verbosity;
 		if (options.verbosity) {
-			info("\n[switch from pondering to thinking (id.%d)]\n", play->search->id);
+			info("\n[switch from pondering to thinking (id.%d)]\n", play->search.id);
 			if (search->options.header) puts(search->options.header);
 			if (search->options.separator) puts(search->options.separator);
 		}
@@ -282,7 +282,7 @@ void play_go(Play *play, const bool update)
 		if (options.play_type == EDAX_TIME_PER_MOVE) search_set_move_time(search, options.time);
 		else search_set_game_time(search, play->time[play->player].left);
 
-		search_time_reset(search, play->board);
+		search_time_reset(search, &play->board);
 		if (log_is_open(xboard_log)) {
 			 fprintf(xboard_log->f, "edax search> cpu: %d\n", options.n_task);
 			 fprintf(xboard_log->f, "edax search> time: spent while pondering = %.2f mini = %.2f; maxi = %.2f; extra = %.2f\n",
@@ -292,18 +292,18 @@ void play_go(Play *play, const bool update)
 		}
 
 		search->observer(search->result);
-		thread_join(play->ponder->thread);
-		play->ponder->launched = false;
+		thread_join(play->ponder.thread);
+		play->ponder.launched = false;
 		search->observer(search->result);
 				
-		*play->result = *search->result;
+		play->result = *search->result;
 		play->state = IS_WAITING;
-		if (!board_get_move(play->board, search->result->move, move) && move->x != PASS) {
-			fatal_error("bad move found: %s\n", move_to_string(move->x, play->player, s_move));
+		if (!board_get_move_flip(&play->board, search->result->move, &move) && move.x != PASS) {
+			fatal_error("bad move found: %s\n", move_to_string(move.x, play->player, s_move));
 		}
 		if (options.verbosity) {
 			if (search->options.separator) puts(search->options.separator);
-			info("[stop thinking (id.%d)]\n", play->search->id);
+			info("[stop thinking (id.%d)]\n", play->search.id);
 		}
 
 	} else {
@@ -314,12 +314,12 @@ void play_go(Play *play, const bool update)
 
 		search->options.verbosity = options.verbosity;
 		if (options.verbosity) {
-			info("\n[start thinking (id.%d)]\n", play->search->id);
+			info("\n[start thinking (id.%d)]\n", play->search.id);
 			if (search->options.header) puts(search->options.header);
 			if (search->options.separator) puts(search->options.separator);
 		}
-		search_set_board(search, play->board, play->player);
-		search_set_level(search, options.level, search->n_empties);
+		search_set_board(search, &play->board, play->player);
+		search_set_level(search, options.level, search->eval.n_empties);
 		if (options.play_type == EDAX_TIME_PER_MOVE) search_set_move_time(search, options.time);
 		else search_set_game_time(search, play->time[play->player].left);
 
@@ -333,14 +333,14 @@ void play_go(Play *play, const bool update)
 		}
 		
 		search_run(search);
-		*play->result = *search->result;
+		play->result = *search->result;
 		play->state = IS_WAITING;
-		if (!board_get_move(play->board, search->result->move, move) && move->x != PASS) {
-			fatal_error("bad move found: %s\n", move_to_string(move->x, play->player, s_move));
+		if (!board_get_move_flip(&play->board, search->result->move, &move) && move.x != PASS) {
+			fatal_error("bad move found: %s\n", move_to_string(move.x, play->player, s_move));
 		}
 		if (options.verbosity) {
 			if (search->options.separator) puts(search->options.separator);
-			info("[stop thinking] (id.%d)]\n", play->search->id);
+			info("[stop thinking] (id.%d)]\n", play->search.id);
 		}
 	}
 
@@ -350,7 +350,7 @@ void play_go(Play *play, const bool update)
 
 	if (options.play_type != EDAX_TIME_PER_MOVE) play->time[play->player].left -= t_real;
 
-	if (update) play_update(play, move);
+	if (update) play_update(play, &move);
 
 }
 
@@ -364,12 +364,12 @@ void play_go(Play *play, const bool update)
  */
 void play_hint(Play *play, int n)
 {
-	Line pv[1];
+	Line pv;
 	Move *m;
-	Search *search = play->search;
-	MoveList book_moves[1];
+	Search *const search = &play->search;
+	MoveList book_moves;
 	GameStats stat;
-	Board b[1];
+	Board b;
 
 	if (play_is_game_over(play)) return;
 
@@ -383,25 +383,25 @@ void play_hint(Play *play, int n)
 		if (search->options.header) puts(search->options.header);
 		if (search->options.separator) puts(search->options.separator);
 	}
-	search_set_board(search, play->board, play->player);
-	search_set_level(search, options.level, search->n_empties);
-	if (n > search->movelist->n_moves) n = search->movelist->n_moves;
+	search_set_board(search, &play->board, play->player);
+	search_set_level(search, options.level, search->eval.n_empties);
+	if (n > search->movelist.n_moves) n = search->movelist.n_moves;
 	info("<hint %d moves>\n", n);
 
-	if (options.book_allowed && book_get_moves(play->book, play->board, book_moves)) {
+	if (options.book_allowed && book_get_moves(play->book, &play->board, &book_moves)) {
 		foreach_move (m, book_moves) if (n) {
 			--n;
-			line_init(pv, play->player);
-			book_get_line(play->book, play->board, m, pv);
-			movelist_exclude(search->movelist, m->x);
+			line_init(&pv, play->player);
+			book_get_line(play->book, &play->board, m, &pv);
+			movelist_exclude(&search->movelist, m->x);
 			if (play->type == UI_NBOARD) {
-				board_next(play->board, m->x, b);
-				book_get_game_stats(play->book, b, &stat);
-				printf("book "); line_print(pv, 10, NULL, stdout);
+				board_next(&play->board, m->x, &b);
+				book_get_game_stats(play->book, &b, &stat);
+				printf("book "); line_print(&pv, 10, NULL, stdout);
 				printf(" %d %llu %d\n", m->score, stat.n_lines, play->book->options.level);
 			} else {
 				printf("book    %+02d                                          ", m->score);
-				line_print(pv, options.width - 54, " ", stdout); putchar('\n');
+				line_print(&pv, options.width - 54, " ", stdout); putchar('\n');
 			}
 		}
 	}
@@ -413,13 +413,13 @@ void play_hint(Play *play, int n)
 		search_run(search);
 		search->options.multipv_depth = MULTIPV_DEPTH;
 		if (play->type == UI_NBOARD) {
-			printf("search "); line_print(search->result->pv, 10, NULL, stdout);
+			printf("search "); line_print(&search->result->pv, 10, NULL, stdout);
 			printf(" %d 0 %d\n", search->result->score, search->result->depth);
 		} else {
 			if (options.verbosity == 0) search->observer(search->result);
 		}
 		if (search->stop != STOP_END) break;
-		movelist_exclude(search->movelist, search->result->move);
+		movelist_exclude(&search->movelist, search->result->move);
 	}
 	if (options.verbosity) {
 		info("\n[stop thinking]\n");
@@ -442,43 +442,43 @@ void play_hint(Play *play, int n)
 void* play_ponder_run(void *v)
 {
 	extern Log xboard_log[1];
-	Play *play = (Play*) v;
+	Play *const play = (Play*) v;
 	int player;
-	Search *search = play->search;
-	Board board[1];
-	Move move[1];
+	Search *search = &play->search;
+	Board board;
+	Move move;
 	char m[4];
 
-	lock(play->ponder);
+	lock(&play->ponder);
 	if (play->state == IS_PONDERING || play->state == IS_ANALYZING) {
-		*board = *play->board;
+		board = play->board;
 		player = play->player;
 		search_set_game_time(search, TIME_MAX);
-		search->options.keep_date = (play->state == IS_PONDERING && search->pv_table->date > 0);
-		if (play->ponder->verbose) search->options.verbosity = options.verbosity;
+		search->options.keep_date = (play->state == IS_PONDERING && search->pv_table.date > 0);
+		if (play->ponder.verbose) search->options.verbosity = options.verbosity;
 		else search->options.verbosity = 0;
 
-		move->x = search_guess(search, board);
+		move.x = search_guess(search, &board);
 
 		// guess opponent move and start the search
-		if (play->state == IS_PONDERING && move->x != NOMOVE) {
-			board_get_move(board, move->x, move);
+		if (play->state == IS_PONDERING && move.x != NOMOVE) {
+			board_get_move_flip(&board, move.x, &move);
 
-			board_update(board, move);
-				*play->ponder->board = *board;
-				search_set_board(search, board, player ^ 1);
-				search_set_level(search, options.level, search->n_empties);
+			board_update(&board, &move);
+				play->ponder.board = board;
+				search_set_board(search, &board, player ^ 1);
+				search_set_level(search, options.level, search->eval.n_empties);
 				search_run(search);
 				if (options.info && play->state == IS_PONDERING) {
-					printf("[ponder after %s id.%d: ", move_to_string(move->x, player, m), search->id);
+					printf("[ponder after %s id.%d: ", move_to_string(move.x, player, m), search->id);
 					result_print(search->result, stdout);
 					printf("]\n");
 				}
-			board_restore(board, move);
+			board_restore(&board, &move);
 		} else {
-			*play->ponder->board = *board;
-			search_set_board(search, board, player);
-			search_set_ponder_level(search, options.level, search->n_empties);
+			play->ponder.board = board;
+			search_set_board(search, &board, player);
+			search_set_ponder_level(search, options.level, search->eval.n_empties);
 			log_print(xboard_log, "edax (ponder)> start search\n");
 			search_run(search);
 			log_print(xboard_log, "edax (ponder)> search ended\n");
@@ -493,7 +493,7 @@ void* play_ponder_run(void *v)
 		play->state = IS_WAITING;
 		search->options.keep_date = false;
 	}
-	unlock(play->ponder);
+	unlock(&play->ponder);
 
 	return NULL;
 }
@@ -510,11 +510,11 @@ void play_ponder(Play *play)
 {
 	if (play_is_game_over(play)) return;
 	if (options.can_ponder && play->state == IS_WAITING) {
-		play->ponder->board->player = play->ponder->board->opponent = 0;
-		play->state = IS_PONDERING;		
+		play->ponder.board.player = play->ponder.board.opponent = 0;
+		play->state = IS_PONDERING;
 		info("\n[start ponderation]\n");
-		thread_create(&play->ponder->thread, play_ponder_run, play);
-		play->ponder->launched = true;
+		thread_create(&play->ponder.thread, play_ponder_run, play);
+		play->ponder.launched = true;
 	}
 }
 
@@ -530,14 +530,14 @@ void play_stop_pondering(Play *play)
 {
 	while (play->state == IS_PONDERING) {
 		info("[stop pondering]\n");
-		search_stop_all(play->search, STOP_PONDERING);
+		search_stop_all(&play->search, STOP_PONDERING);
 		relax(10);
 	}
 
-	if (play->ponder->launched) {
+	if (play->ponder.launched) {
 		info("[joining thread]\n");
-		thread_join(play->ponder->thread);
-		play->ponder->launched = false;
+		thread_join(play->ponder.thread);
+		play->ponder.launched = false;
 		info("[thread joined]\n");
 	}
 }
@@ -548,7 +548,7 @@ void play_stop_pondering(Play *play)
  */
 void play_stop(Play *play)
 {
-	search_stop_all(play->search, STOP_ON_DEMAND);
+	search_stop_all(&play->search, STOP_ON_DEMAND);
 	info("[stop on user demand]\n");
 }
 
@@ -560,11 +560,11 @@ void play_undo(Play *play)
 {
 	if (play->i_game > 0) {
 		play_stop_pondering(play);
-		lock(play->ponder);
+		lock(&play->ponder);
 		play_force_restore(play);
-		board_restore(play->board, &play->game[--play->i_game]);
+		board_restore(&play->board, &play->game[--play->i_game]);
 		play->player ^= 1;
-		unlock(play->ponder);
+		unlock(&play->ponder);
 	}
 }
 
@@ -577,7 +577,7 @@ void play_redo(Play *play)
 	if (play->i_game < play->n_game) {
 		play_stop_pondering(play);
 		play_force_update(play);
-		board_update(play->board, &play->game[play->i_game++]);
+		board_update(&play->board, &play->game[play->i_game++]);
 		play->player ^= 1;
 	}
 }
@@ -590,11 +590,11 @@ void play_redo(Play *play)
 void play_set_board(Play *play, const char *board)
 {
 	play_stop_pondering(play);
-	play->initial_player = board_set(play->initial_board, board);
+	play->initial_player = board_set(&play->initial_board, board);
 	if (play->initial_player == EMPTY) { /* bad board ? */
-		play->initial_board->opponent &= (~play->initial_board->player);
-		play->initial_player = (board_count_empties(play->initial_board) & 1);
-		if (play->initial_player == WHITE) board_swap_players(play->initial_board);
+		play->initial_board.opponent &= (~play->initial_board.player);
+		play->initial_player = (board_count_empties(&play->initial_board) & 1);
+		if (play->initial_player == WHITE) board_swap_players(&play->initial_board);
 	}
 	play_force_init(play, "");
 	play_new(play);
@@ -608,7 +608,7 @@ void play_set_board(Play *play, const char *board)
 void play_set_board_from_FEN(Play *play, const char *board)
 {
 	play_stop_pondering(play);
-	play->initial_player = board_from_FEN(play->initial_board, board);
+	play->initial_player = board_from_FEN(&play->initial_board, board);
 	if (play->initial_player != EMPTY) {
 		play_force_init(play, "");
 		play_new(play);
@@ -622,7 +622,7 @@ void play_set_board_from_FEN(Play *play, const char *board)
  */
 void play_game(Play *play, const char *string)
 {
-	Move move[1];
+	Move move;
 	const char *next;
 
 	play_stop_pondering(play);
@@ -631,9 +631,9 @@ void play_game(Play *play, const char *string)
 	next = opening_get_line(string);
 	if (next) string = next;	
 
-	while ((next = parse_move(string, play->board, move)) != string || move->x == PASS) {
+	while ((next = parse_move(string, &play->board, &move)) != string || move.x == PASS) {
 		string = next;
-		play_update(play, move);
+		play_update(play, &move);
 	}
 }
 
@@ -645,12 +645,12 @@ void play_game(Play *play, const char *string)
  */
 bool play_move(Play *play, int x)
 {
-	Move move[1];
+	Move move;
 
-	*move = MOVE_INIT;
-	board_get_move(play->board, x, move);
-	if (board_check_move(play->board, move)) {
-		play_update(play, move);
+	move = MOVE_INIT;
+	board_get_move_flip(&play->board, x, &move);
+	if (board_check_move(&play->board, &move)) {
+		play_update(play, &move);
 		return true;
 	} else {
 		return false;
@@ -665,10 +665,10 @@ bool play_move(Play *play, int x)
  */
 bool play_user_move(Play *play, const char *string)
 {
-	Move move[1];
+	Move move;
 
-	if (parse_move(string, play->board, move) != string) {
-		play_update(play, move);
+	if (parse_move(string, &play->board, &move) != string) {
+		play_update(play, &move);
 		return true;
 	} else {
 		return false;
@@ -699,31 +699,34 @@ Move* play_get_last_move(Play *play)
  */
 static int play_alternative(Play *play, Move *played, Move *alternative, int *depth, int *percent)
 {
-	Search *search = play->search;
-	Result *result = search->result;
-	Board excluded[1], board[1], unique[1];
+	Search *const search = &play->search;
+	Result *const result = search->result;
+	Board excluded, board, unique;
 	Move *move;
+	unsigned long long hash_code;
 
-	search_set_board(search, play->board, play->player);
+	search_set_board(search, &play->board, play->player);
 	if (A1 <= played->x && played->x <= H8) {
-		movelist_exclude(search->movelist, played->x);
-		hash_exclude_move(search->pv_table, search->board, board_get_hash_code(search->board), played->x);
-		hash_exclude_move(search->hash_table, search->board, board_get_hash_code(search->board), played->x);
+		movelist_exclude(&search->movelist, played->x);
+		hash_code = board_get_hash_code(&search->board);
+		hash_exclude_move(&search->pv_table, &search->board, hash_code, played->x);
+		hash_exclude_move(&search->hash_table, &search->board, hash_code, played->x);
 		// also remove moves leading to symetrical positions
-		board_next(play->board, played->x, board);
-		board_unique(board,  excluded);
+		board_next(&play->board, played->x, &board);
+		board_unique(&board, &excluded);
 		foreach_move (move, search->movelist) {
-			board_next(play->board, move->x, board);
-			board_unique(board, unique);
-			if (board_equal(excluded, unique)) {
-				hash_exclude_move(search->pv_table, search->board, board_get_hash_code(search->board), move->x);
-				hash_exclude_move(search->hash_table, search->board, board_get_hash_code(search->board), move->x);
-				move = movelist_exclude(search->movelist, move->x);
+			board_next(&play->board, move->x, &board);
+			board_unique(&board, &unique);
+			if (board_equal(&excluded, &unique)) {
+				hash_code = board_get_hash_code(&search->board);
+				hash_exclude_move(&search->pv_table, &search->board, hash_code, move->x);
+				hash_exclude_move(&search->hash_table, &search->board, hash_code, move->x);
+				move = movelist_exclude(&search->movelist, move->x);
 			}
 		}
 	}
-	if (search->movelist->n_moves >= 1 || played->x == NOMOVE) {
-		search_set_level(search, options.level, search->n_empties);
+	if (search->movelist.n_moves >= 1 || played->x == NOMOVE) {
+		search_set_level(search, options.level, search->eval.n_empties);
 		search->options.verbosity = 0;
 		search_run(search);
 		search->options.verbosity = options.verbosity;
@@ -732,7 +735,7 @@ static int play_alternative(Play *play, Move *played, Move *alternative, int *de
 		*depth = result->depth;
 		*percent = selectivity_table[result->selectivity].percent;
 	}
-	return search->movelist->n_moves;
+	return search->movelist.n_moves;
 }
 
 /**
@@ -753,7 +756,7 @@ static void play_write_analysis(Play *play, const Move *m, const Move *a, const
 	char s[4];
 
 	if (n_moves >= 0) {
-		int n_empties = board_count_empties(play->board);
+		int n_empties = board_count_empties(&play->board);
 		fprintf(f, "%3d ", 61 - n_empties);
 		if (depth == -1) fputs("  book  ", f);
 		else {
@@ -791,7 +794,7 @@ void play_analyze(Play *play, int n)
 {
 	int i, score, n_alternatives;
 	int depth = 0, percent = 0, n_empties;
-	Move *move, alternative[1];
+	Move *move, alternative;
 	int n_exact[2] = {0, 0}, n_eval[2] = {0, 0};
 	int n_error[2] = {0, 0}, n_rejection[2] = {0, 0};
 	int disc_error[2] = {0, 0}, disc_rejection[2] = {0, 0};
@@ -804,39 +807,39 @@ void play_analyze(Play *play, int n)
 	puts("ply  level   alt. move  score     score   move");
 	puts("---+-------+-----+-----------+--+---------------");
 
-	search_cleanup(play->search);
-	search_set_board(play->search, play->board, play->player);
-	alternative->x = NOMOVE;
-	play_alternative(play, alternative, alternative, &depth, &percent);
-	score = alternative->score;
+	search_cleanup(&play->search);
+	search_set_board(&play->search, &play->board, play->player);
+	alternative.x = NOMOVE;
+	play_alternative(play, &alternative, &alternative, &depth, &percent);
+	score = alternative.score;
 
 	for (i = play->i_game - 1; i >= 0 && i >= play->i_game - n; --i) {
 		move = play->game + i;
 		move->score = -score;
 		play->player ^= 1;
-		board_restore(play->board, move);
+		board_restore(&play->board, move);
 		if (move->x == PASS) ++n;
 
-		n_empties = board_count_empties(play->board);
-		n_alternatives = play_alternative(play, move, alternative, &depth, &percent);
+		n_empties = board_count_empties(&play->board);
+		n_alternatives = play_alternative(play, move, &alternative, &depth, &percent);
 		if (options.verbosity == 1) fputs(clr, stdout);
-		play_write_analysis(play, move, alternative, n_alternatives, depth, percent, stdout);
+		play_write_analysis(play, move, &alternative, n_alternatives, depth, percent, stdout);
 
 		score = move->score; 
 		if (n_alternatives > 0) {
 			if (depth == n_empties && percent == 100) ++n_exact[play->player]; else ++n_eval[play->player];
-			if (alternative->score > score) {
+			if (alternative.score > score) {
 				if (depth == n_empties && percent == 100) {
 					++n_error[play->player];
-					disc_error[play->player] += alternative->score - score;
+					disc_error[play->player] += alternative.score - score;
 				} else {
 					++n_rejection[play->player];
-					disc_rejection[play->player] += alternative->score - score;
+					disc_rejection[play->player] += alternative.score - score;
 				}
-				score = alternative->score;
+				score = alternative.score;
 			}
 		}
-		if (play->search->stop == STOP_ON_DEMAND) break;
+		if (play->search.stop == STOP_ON_DEMAND) break;
 	}
 	puts("\n      | rejections : discs | errors    : discs | error rate |");
 	printf("Black | %3d / %3d  :  %+4d | %3d / %3d :  %+4d |      %5.3f |\n",
@@ -846,7 +849,7 @@ void play_analyze(Play *play, int n)
 
 	if (i < 0 || i < play->i_game - n) ++i;
 	for (; i < play->i_game; ++i) {
-		board_update(play->board, play->game + i);
+		board_update(&play->board, play->game + i);
 		play->player ^= 1;
 	}
 }
@@ -861,29 +864,29 @@ void play_analyze(Play *play, int n)
  */
 static int play_book_alternative(Play *play, Move *played, Move* alternative)
 {
-	MoveList movelist[1];
+	MoveList movelist;
 	Move *exclude, *best;
-	Board excluded[1], board[1], unique[1];
+	Board excluded, board, unique;
 	Move *move;
 
-	if (book_get_moves(play->book, play->board, movelist)) {
-		exclude = movelist_exclude(movelist, played->x);
+	if (book_get_moves(play->book, &play->board, &movelist)) {
+		exclude = movelist_exclude(&movelist, played->x);
 
 		if (exclude && exclude->x == played->x) {
 			played->score = exclude->score;
 			// also remove moves leading to symetrical positions
-			board_next(play->board, played->x, board);
-			board_unique(board,  excluded);
+			board_next(&play->board, played->x, &board);
+			board_unique(&board, &excluded);
 			foreach_move (move, movelist) {
-				board_next(play->board, move->x, board);
-				board_unique(board, unique);
-				if (board_equal(excluded, unique)) move = movelist_exclude(movelist, move->x);
+				board_next(&play->board, move->x, &board);
+				board_unique(&board, &unique);
+				if (board_equal(&excluded, &unique)) move = movelist_exclude(&movelist, move->x);
 			}
-			if (movelist->n_moves) {
-				best = movelist_best(movelist);
+			if (movelist.n_moves) {
+				best = movelist_best(&movelist);
 				*alternative = *best;
 			}
-			return movelist->n_moves;
+			return movelist.n_moves;
 		}
 	}
 	return -1;
@@ -897,7 +900,7 @@ static int play_book_alternative(Play *play, Move *played, Move* alternative)
 void play_book_analyze(Play *play, int n)
 {
 	int i, n_alternatives;
-	Move *move, alternative[1];
+	Move *move, alternative;
 
 	play_stop_pondering(play);
 
@@ -908,18 +911,18 @@ void play_book_analyze(Play *play, int n)
 	for (i = play->i_game - 1; i >= 0 && i >= play->i_game - n; --i) {
 		move = play->game + i;
 		play->player ^= 1;
-		board_restore(play->board, move);
+		board_restore(&play->board, move);
 		if (move->x == PASS) ++n;
 
-		n_alternatives = play_book_alternative(play, move, alternative);
-		play_write_analysis(play, move, alternative, n_alternatives, -1, 100, stdout);
+		n_alternatives = play_book_alternative(play, move, &alternative);
+		play_write_analysis(play, move, &alternative, n_alternatives, -1, 100, stdout);
 
-		if (play->search->stop == STOP_ON_DEMAND) break;
+		if (play->search.stop == STOP_ON_DEMAND) break;
 	}
 
 	if (i < 0 || i < play->i_game - n) ++i;
 	for (; i < play->i_game; ++i) {
-		board_update(play->board, play->game + i);
+		board_update(&play->board, play->game + i);
 		play->player ^= 1;
 	}
 }
@@ -931,7 +934,7 @@ void play_book_analyze(Play *play, int n)
  */
 void play_store(Play *play)
 {
-	Board board[1];
+	Board board;
 	int i;
 	char file[FILENAME_MAX + 1];
 
@@ -939,16 +942,16 @@ void play_store(Play *play)
 
 	play->book->stats.n_nodes = play->book->stats.n_links = 0;
 
-	*board = *play->initial_board;
-	for (i = 0; i < play->n_game && board_check_move(board, play->game + i); ++i) {
-		board_update(board, play->game + i);
+	board = play->initial_board;
+	for (i = 0; i < play->n_game && board_check_move(&board, play->game + i); ++i) {
+		board_update(&board, play->game + i);
 	}
 
 	for (--i; i >= 0; --i) {
-		book_add_board(play->book, board);
-		board_restore(board, play->game + i);
+		book_add_board(play->book, &board);
+		board_restore(&board, play->game + i);
 	}
-	book_add_board(play->book, board);
+	book_add_board(play->book, &board);
 	if (play->book->stats.n_nodes + play->book->stats.n_links) {
 		book_link(play->book);
 		book_negamax(play->book);
@@ -983,20 +986,35 @@ void play_print(Play *play, FILE *f)
 {
 	int i, j, x, discs[2], mobility[2], square;
 	char history[64];
-	const char *color = "?*O-." + 1;
+	const char color[5] = "?*O-.";
 	const char big_color[3][4] = {"|##", "|()", "|  "};
 	const char player[2][6] = {"Black", "White"};
-	Board *board = play->board;
 	const int p = play->player;
-	const int o = !p;
-	const int ip = play->player ^ (play->i_game & 1);
-	unsigned long long moves;
-
-	moves = get_moves(board->player, board->opponent);
-	discs[p] = bit_count(board->player);
-	discs[o] = bit_count(board->opponent);
-	mobility[p] = get_mobility(board->player, board->opponent);
-	mobility[o] = get_mobility(board->opponent, board->player);
+	unsigned long long bk, wh, bk0, wh0, moves;
+	bool gameover;
+
+	if (p == BLACK) {
+		bk = play->board.player;
+		wh = play->board.opponent;
+	} else {
+		bk = play->board.opponent;
+		wh = play->board.player;
+	}
+	if ((p ^ (play->i_game & 1)) == BLACK) {
+		bk0 = play->initial_board.player;
+		wh0 = play->initial_board.opponent;
+	} else {
+		bk0 = play->initial_board.opponent;
+		wh0 = play->initial_board.player;
+	}
+
+	moves = board_get_moves(&play->board);
+	discs[BLACK] = bit_count(bk);
+	discs[WHITE] = bit_count(wh);
+	mobility[BLACK] = get_mobility(bk, wh);
+	mobility[WHITE] = get_mobility(wh, bk);
+	gameover = (mobility[BLACK] + mobility[WHITE] == 0);
+
 	memset(history, 0, 64);
 	for (i = j = 0; i < play->i_game; i++) {
 		x = play->game[i].x;
@@ -1008,12 +1026,14 @@ void play_print(Play *play, FILE *f)
 		fputc(i + '1', f);
 		fputc(' ', f);
 		for (j = 0; j < 8; j++) {
-			x = i * 8 + j;
-			if (p == BLACK) square = 2 - ((board->opponent >> x) & 1) - 2 * ((board->player >> x) & 1);
-			else square = 2 - ((board->player >> x) & 1) - 2 * ((board->opponent >> x) & 1);
-			if (square == EMPTY && (moves & x_to_bit(x))) ++square;
-			fputc(color[square], f);
+			square = 2 - (wh & 1) - 2 * (bk & 1);
+			if ((square == EMPTY) && (moves & 1))
+				square = EMPTY + 1;
+			fputc(color[square + 1], f);
 			fputc(' ', f);
+			bk >>= 1;
+			wh >>= 1;
+			moves >>= 1;
 		}
 		fputc(i + '1', f);
 
@@ -1022,21 +1042,21 @@ void play_print(Play *play, FILE *f)
 			fputs("  ", f); time_print(play->time[BLACK].spent, true, f); fputs("       ", f);
 			break;
 		case 1:
-			fprintf(f,"   %2d discs  %2d moves   ", discs[BLACK], mobility[BLACK]);
+			fprintf(f, "   %2d discs  %2d moves   ", discs[BLACK], mobility[BLACK]);
 			break;
 		case 3:
-			if (mobility[BLACK] + mobility[WHITE] == 0) fprintf(f,"       Game over        ");
-			else fprintf(f,"  ply %2d (%2d empties)   ", play->i_game + 1, board_count_empties(board));
+			if (gameover) fprintf(f, "       Game over        ");
+			else fprintf(f, "  ply %2d (%2d empties)   ", play->i_game + 1, board_count_empties(&play->board));
 			break;
 		case 4:
-			if (mobility[BLACK] + mobility[WHITE] == 0) {
-				if (discs[BLACK] > discs[WHITE]) fprintf(f,"       %s won        ", player[BLACK]);
-				else if (discs[BLACK] < discs[WHITE]) fprintf(f,"       %s won        ", player[WHITE]);
-				else fprintf(f,"          draw          ");
-			} else fprintf(f,"    %s's turn (%c)    ",player[p], color[p]);
+			if (gameover) {
+				if (discs[BLACK] > discs[WHITE]) fprintf(f, "       %s won        ", player[BLACK]);
+				else if (discs[BLACK] < discs[WHITE]) fprintf(f, "       %s won        ", player[WHITE]);
+				else fprintf(f, "          draw          ");
+			} else fprintf(f, "    %s's turn (%c)    ", player[p], color[p + 1]);
 			break;
 		case 6:
-			fprintf(f,"   %2d discs  %2d moves   ",discs[WHITE], mobility[WHITE]);
+			fprintf(f, "   %2d discs  %2d moves   ", discs[WHITE], mobility[WHITE]);
 			break;
 		case 7:
 			fputs("  ", f); time_print(play->time[WHITE].spent, true, f); fputs("       ", f);
@@ -1048,12 +1068,12 @@ void play_print(Play *play, FILE *f)
 		fputc(i + '1', f); fputc(' ', f);
 		for (j = 0; j < 8; j++){
 			x = i * 8 + j;
-			if (history[x]) fprintf(f,"|%2d",history[x]);
-			else {
-				if (ip == BLACK) square = 2 - ((play->initial_board->opponent >> x) & 1) - 2 * ((play->initial_board->player >> x) & 1);
-				else square = 2 - ((play->initial_board->player >> x) & 1) - 2 * ((play->initial_board->opponent >> x) & 1);
-				fputs(big_color[square], f);
-			}
+			if (history[x])
+				fprintf(f, "|%2d", history[x]);
+			else
+				fputs(big_color[2 - (wh0 & 1) - 2 * (bk0 & 1)], f);
+			wh0 >>= 1;
+			bk0 >>= 1;
 		}
 		fprintf(f, "| %1d\n", i + 1);
 	}
@@ -1069,25 +1089,25 @@ void play_print(Play *play, FILE *f)
  */
 void play_force_init(Play *play, const char *string)
 {
-	Move move[1];
+	Move move;
 	const char *next;
-	Board board[1];
+	Board board;
 
 	play->force.n_move = play->force.i_move = 0;
-	*board = *play->initial_board;
-	play->force.real[play->force.n_move] = *board;
-	board_unique(board, play->force.unique + play->force.n_move);
+	board = play->initial_board;
+	play->force.real[play->force.n_move] = board;
+	board_unique(&board, play->force.unique + play->force.n_move);
 
 	next = opening_get_line(string);
 	if (next) string = next;
 
-	while ((next = parse_move(string, board, move)) != string || move->x == PASS) {
+	while ((next = parse_move(string, &board, &move)) != string || move.x == PASS) {
 		string = next;
-		play->force.move[play->force.n_move] = *move;
-		board_update(board, move);
+		play->force.move[play->force.n_move] = move;
+		board_update(&board, &move);
 		++play->force.n_move;
-		play->force.real[play->force.n_move] = *board;
-		board_unique(board, play->force.unique + play->force.n_move);
+		play->force.real[play->force.n_move] = board;
+		board_unique(&board, play->force.unique + play->force.n_move);
 	}
 }
 
@@ -1101,10 +1121,10 @@ void play_force_init(Play *play, const char *string)
  */
 void play_force_update(Play *play)
 {
-	Board unique[1];
+	Board unique;
 	if (play->force.i_move < play->force.n_move) {
-		board_unique(play->board, unique);
-		if ((board_equal(unique, play->force.unique + play->force.i_move))) {
+		board_unique(&play->board, &unique);
+		if ((board_equal(&unique, play->force.unique + play->force.i_move))) {
 			++play->force.i_move;
 		}
 	}
@@ -1120,10 +1140,10 @@ void play_force_update(Play *play)
  */
 void play_force_restore(Play *play)
 {
-	Board unique[1];
+	Board unique;
 	if (play->force.i_move > 0) {
-		board_unique(play->board, unique);
-		if (board_equal(unique, play->force.unique + play->force.i_move)) {
+		board_unique(&play->board, &unique);
+		if (board_equal(&unique, play->force.unique + play->force.i_move)) {
 			--play->force.i_move;
 		}
 	}
@@ -1140,23 +1160,23 @@ void play_force_restore(Play *play)
  */
 bool play_force_go(Play *play, Move *move)
 {
-	Board unique[1];
-	Board sym[1];
+	Board unique;
+	Board sym;
 	int s, x;
 
 	if (play->force.i_move < play->force.n_move) {
-		if (board_equal(play->board, play->force.real + play->force.i_move)) {
+		if (board_equal(&play->board, play->force.real + play->force.i_move)) {
 			*move = play->force.move[play->force.i_move];
 			return true;
 		}
 
-		board_unique(play->board, unique);
-		if (board_equal(unique, play->force.unique + play->force.i_move)) {
+		board_unique(&play->board, &unique);
+		if (board_equal(&unique, play->force.unique + play->force.i_move)) {
 			for (s = 1; s < 8; ++s) {
-				board_symetry(play->force.real + play->force.i_move, s, sym);
-				if (board_equal(play->board, sym)) {
+				board_symetry(play->force.real + play->force.i_move, s, &sym);
+				if (board_equal(&play->board, &sym)) {
 					x = symetry(play->force.move[play->force.i_move].x, s);
-					board_get_move(play->board, x, move);
+					board_get_move_flip(&play->board, x, move);
 					return true;
 				}
 			}
@@ -1176,15 +1196,15 @@ void play_symetry(Play *play, const int sym)
 {
 	int i, x;
 	Move move = MOVE_INIT;
-	Board board[1];
+	Board board;
 
-	board_symetry(play->initial_board, sym, play->initial_board);
-	board_symetry(play->board, sym, play->board);
-	*board = *play->initial_board;
+	board_symetry(&play->initial_board, sym, &play->initial_board);
+	board_symetry(&play->board, sym, &play->board);
+	board = play->initial_board;
 	for (i = 0; i  < play->n_game; ++i) {
 		x = symetry(play->game[i].x, sym);
-		board_get_move(board, x, &move);
-		board_update(board, &move);
+		board_get_move_flip(&board, x, &move);
+		board_update(&board, &move);
 		play->game[i] = move;
 	}
 }
@@ -1195,14 +1215,14 @@ void play_symetry(Play *play, const int sym)
 const char* play_show_opening_name(Play *play, const char *(*opening_get_name)(const Board*))
 {
 	int i;
-	Board board[1];
+	Board board;
 	const char *name;
 	const char *last = NULL;
 
-	*board = *play->initial_board;
+	board = play->initial_board;
 	for (i = 0; i  < play->i_game; ++i) {
-		board_update(board, play->game + i);
-		name = opening_get_name(board);
+		board_update(&board, play->game + i);
+		name = opening_get_name(&board);
 		if (name != NULL) last = name;
 	}
 
diff --git a/src/play.h b/src/play.h
index 7082ee62..fb9e31e5 100644
--- a/src/play.h
+++ b/src/play.h
@@ -23,10 +23,10 @@
 
 /** play structure */
 typedef struct Play {
-	Board board[1];            /**< current board. */
-	Board initial_board[1];    /**< initial board. */
-	Search search[1];          /**< search. */
-	Result result[1];          /**< search result. */
+	Board board;               /**< current board. */
+	Board initial_board;       /**< initial board. */
+	Search search;             /**< search. */
+	Result result;             /**< search result. */
 	Book *book;                /**< opening book */
 	int type;                  /**< ui type */
 	int player;                /**< current player's color. */
@@ -52,16 +52,14 @@ typedef struct Play {
 	struct {
 		Thread thread;         /**< thread. */
 		Lock lock;             /**< lock. */
-		Board board[1];        /**< pondered position */
+		Board board;           /**< pondered position */
 		bool launched;         /**< launched thread */
 		bool verbose;          /**< verbose pondering */
-	} ponder[1];               /**< pondering thread */
+	} ponder;                  /**< pondering thread */
 	char error_message[PLAY_MESSAGE_MAX_LENGTH]; /**< error message */
 } Play;
 
 /* functions */
-bool play_is_game_over(Play*);
-bool play_must_pass(Play *play);
 void play_init(Play*, Book*);
 void play_free(Play*);
 void play_new(Play*);
@@ -98,6 +96,10 @@ void play_force_restore(Play*);
 bool play_force_go(Play*, Move*);
 void play_symetry(Play*, const int);
 const char* play_show_opening_name(Play*, const char *(*opening_get_name)(const Board*));
+// bool play_is_game_over(Play*);
+// bool play_must_pass(Play *play);
+#define	play_is_game_over(play)	board_is_game_over(&(play)->board)
+#define	play_must_pass(play)	board_is_pass(&(play)->board)
 
 #endif
 
diff --git a/src/qemu.sh b/src/qemu.sh
new file mode 100644
index 00000000..3c7b7e4f
--- /dev/null
+++ b/src/qemu.sh
@@ -0,0 +1,17 @@
+if [ "$1" = arm32 ]
+then
+make build OS=linux ARCH=arm-neon COMP=gcc CC=arm-linux-gnueabi-gcc
+cd ../bin
+qemu-arm -L /usr/arm-linux-gnueabi ./lEdax-arm-neon -n 1 -l 60 -solve ../problem/fforum-20-39.obf
+elif [ "$1" = sve ]
+then
+make build OS=linux ARCH=arm-sve COMP=gcc CC=aarch64-linux-gnu-gcc
+cd ../bin
+qemu-aarch64 -L /usr/aarch64-linux-gnu -cpu max,sve128=on ./lEdax-arm-sve -n 1 -l 60 -solve ../problem/fforum-20-39.obf
+else
+make build OS=linux ARCH=arm COMP=gcc CC=aarch64-linux-gnu-gcc
+cd ../bin
+qemu-aarch64 -L /usr/aarch64-linux-gnu ./lEdax-arm -n 1 -l 60 -solve ../problem/fforum-20-39.obf
+fi
+cd ../src
+# C:\Android\android-ndk-r21\toolchains\llvm\prebuilt\windows-x86_64\bin\clang.exe --target=aarch64-linux-gnu -O2 -S flip_neon_bitscan.c
diff --git a/src/root.c b/src/root.c
index ab499e28..65a8685f 100644
--- a/src/root.c
+++ b/src/root.c
@@ -3,9 +3,9 @@
  *
  * Search near the end of the game.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "search.h"
@@ -32,39 +32,38 @@ extern Log engine_log[1];
  */
 void pv_debug(Search *search, const Move *bestmove, FILE *f)
 {
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 	int x;
 	unsigned long long hash_code;
-	HashData hash_data[1];
+	HashData hash_data;
 	char s[4];
 	int player = BLACK;
 
 	spin_lock(search->result);
 
-	*board = *search->board;
+	board = search->board;
 	if (search->height == 1) { // hack to call this function from height 1 or 0
-		board_restore(board, bestmove);
+		board_restore(&board, bestmove);
 	}
 
 	x = bestmove->x;
 	fprintf(f, "pv = %s ", move_to_string(x, player, s));
-	hash_code = board_get_hash_code(board);
-	if (hash_get(search->pv_table, board, hash_code, hash_data)) {
-		fprintf(f, ":%02d@%d%%[%+03d,%+03d]; ", hash_data->depth, selectivity_table[hash_data->selectivity].percent, hash_data->lower, hash_data->upper);
+	if (hash_get_from_board(&search->pv_table, &board, &hash_data)) {
+		fprintf(f, ":%02d@%d%%[%+03d,%+03d]; ", hash_data.wl.c.depth, selectivity_table[hash_data.wl.c.selectivity].percent, hash_data.lower, hash_data.upper);
 	}
 	while (x != NOMOVE) {
-		board_get_move(board, x, move);
-		board_update(board, move);
+		board_get_move_flip(&board, x, &move);
+		board_update(&board, &move);
 		player ^= 1;
 
-		hash_code = board_get_hash_code(board);
-		if (hash_get(search->pv_table, board, hash_code, hash_data)) {
-			x = hash_data->move[0];
-			fprintf(f, "%s:%02d@%d%%[%+03d,%+03d]; ", move_to_string(x, player, s), hash_data->depth, selectivity_table[hash_data->selectivity].percent, hash_data->lower, hash_data->upper);
-		} else if (hash_get(search->hash_table, board, hash_code, hash_data)) {
-			x = hash_data->move[0];
-			fprintf(f, "{%s}:%2d@%d%%[%+03d,%+03d]; ", move_to_string(x, player, s), hash_data->depth, selectivity_table[hash_data->selectivity].percent, hash_data->lower, hash_data->upper);
+		hash_code = board_get_hash_code(&board);
+		if (hash_get(&search->pv_table, &board, hash_code, &hash_data)) {
+			x = hash_data.move[0];
+			fprintf(f, "%s:%02d@%d%%[%+03d,%+03d]; ", move_to_string(x, player, s), hash_data.wl.c.depth, selectivity_table[hash_data.wl.c.selectivity].percent, hash_data.lower, hash_data.upper);
+		} else if (hash_get(&search->hash_table, &board, hash_code, &hash_data)) {
+			x = hash_data.move[0];
+			fprintf(f, "{%s}:%2d@%d%%[%+03d,%+03d]; ", move_to_string(x, player, s), hash_data.wl.c.depth, selectivity_table[hash_data.wl.c.selectivity].percent, hash_data.lower, hash_data.upper);
 		} else x = NOMOVE;
 	}
 	fputc('\n', f);
@@ -82,28 +81,27 @@ void pv_debug(Search *search, const Move *bestmove, FILE *f)
  */
 bool is_pv_ok(Search *search, int bestmove, int search_depth)
 {
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 	int x;
 	unsigned long long hash_code;
-	HashData hash_data[1];
+	HashData hash_data;
 
-	*board = *search->board;
+	board = search->board;
 
 	x = bestmove;
 	while (search_depth > 0 && x != NOMOVE) {
 		if (x != PASS) --search_depth;
-		board_get_move(board, x, move);
-		board_update(board, move);
-
-		hash_code = board_get_hash_code(board);
-		if (hash_get(search->pv_table, board, hash_code, hash_data)) {
-			x = hash_data->move[0];
-		} else if (hash_get(search->hash_table, board, hash_code, hash_data)) {
-			x = hash_data->move[0];
+		board_get_move_flip(&board, x, &move);
+		board_update(&board, &move);
+
+		hash_code = board_get_hash_code(&board);
+		if (hash_get(&search->pv_table, &board, hash_code, &hash_data)
+		 || hash_get(&search->hash_table, &board, hash_code, &hash_data)) {
+			x = hash_data.move[0];
 		} else break;
-		if (hash_data->depth < search_depth || hash_data->selectivity < search->selectivity || hash_data->lower != hash_data->upper) return false;
-		if (x == NOMOVE && !board_is_game_over(board)) return false;
+		if (hash_data.wl.c.depth < search_depth || hash_data.wl.c.selectivity < search->selectivity || hash_data.lower != hash_data.upper) return false;
+		if (x == NOMOVE && !board_is_game_over(&board)) return false;
 	}
 	return true;
 }
@@ -118,43 +116,42 @@ bool is_pv_ok(Search *search, int bestmove, int search_depth)
  * 
  * @param search Search.
  * @param board Board to guess move from.
- * @return a best move guessed from a shallow search (depth = 4).
+ * @return a best move guessed from a shallow search (depth = 6).
  */
 static int guess_move(Search *search, Board *board)
 {
-	HashData hash_data[1];
-	Board saved = *search->board;
+	HashData hash_data;
+	Board saved = search->board;
 
-	*search->board = *board; search_setup(search);
+	search->board = *board; search_setup(search);
 
-	PVS_shallow(search, SCORE_MIN, SCORE_MAX, MIN(search->n_empties, 6));
-	hash_get(search->shallow_table, board, board_get_hash_code(board), hash_data);
+	PVS_shallow(search, SCORE_MIN, SCORE_MAX, MIN(search->eval.n_empties, 6));
+	hash_get_from_board(&search->shallow_table, board, &hash_data);
 
-	*search->board = saved; search_setup(search);
+	search->board = saved; search_setup(search);
 
-	assert(hash_data->move[0] != NOMOVE || board_is_game_over(board));
+	assert(hash_data.move[0] != NOMOVE || board_is_game_over(board));
 
-	return hash_data->move[0];
+	return hash_data.move[0];
 }
 
 /**
  * @brief Record best move.
  *
  * @param search Search.
- * @param init_board Initial board.
  * @param bestmove Best move.
  * @param alpha Alpha Bound.
  * @param beta Beta Bound.
  * @param depth Depth.
  */
-void record_best_move(Search *search, const Board *init_board, const Move *bestmove, const int alpha, const int beta, const int depth)
+void record_best_move(Search *search, const Move *bestmove, const int alpha, const int beta, const int depth)
 {
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 	Result *result = search->result;
 	int x;
 	unsigned long long hash_code;
-	HashData hash_data[1];
+	HashData hash_data;
 	bool has_changed;
 	Bound *bound = result->bound + bestmove->x;
 	bool fail_low;
@@ -162,7 +159,7 @@ void record_best_move(Search *search, const Board *init_board, const Move *bestm
 	int expected_depth, expected_selectivity, tmp;
 	Bound expected_bound;
 
-	*board = *init_board;
+	board = search->board;
 
 	spin_lock(result);
 
@@ -184,28 +181,28 @@ void record_best_move(Search *search, const Board *init_board, const Move *bestm
 	expected_selectivity = result->selectivity = search->selectivity;
 	expected_bound = *bound;
 
-	line_init(result->pv, search->player);
+	line_init(&result->pv, search->player);
 	x = bestmove->x;
 
-	guess_pv = (search->options.guess_pv && depth == search->n_empties && (bestmove->score <= alpha || bestmove->score >= beta));
+	guess_pv = (search->options.guess_pv && depth == search->eval.n_empties && (bestmove->score <= alpha || bestmove->score >= beta));
 	fail_low = (bestmove->score <= alpha);
 
 	while (x != NOMOVE) {
-		board_get_move(board, x, move);
-		if (board_check_move(board, move)) {
-			board_update(board, move);
+		board_get_move_flip(&board, x, &move);
+		if (board_check_move(&board, &move)) {
+			board_update(&board, &move);
 			--expected_depth; 
 			tmp = expected_bound.upper; expected_bound.upper = -expected_bound.lower; expected_bound.lower = -tmp;
 			fail_low = !fail_low;
-			line_push(result->pv, move->x);
+			line_push(&result->pv, move.x);
 
-			hash_code = board_get_hash_code(board);
-			if ((hash_get(search->pv_table, board, hash_code, hash_data) || hash_get(search->hash_table, board, hash_code, hash_data)) 
-			 && (hash_data->depth >= expected_depth && hash_data->selectivity >= expected_selectivity)
-			 && (hash_data->upper <= expected_bound.upper && hash_data->lower >= expected_bound.lower)) {
-				x = hash_data->move[0];
+			hash_code = board_get_hash_code(&board);
+			if ((hash_get(&search->pv_table, &board, hash_code, &hash_data) || hash_get(&search->hash_table, &board, hash_code, &hash_data)) 
+			 && (hash_data.wl.c.depth >= expected_depth && hash_data.wl.c.selectivity >= expected_selectivity)
+			 && (hash_data.upper <= expected_bound.upper && hash_data.lower >= expected_bound.lower)) {
+				x = hash_data.move[0];
 			} else x = NOMOVE;
-			if (guess_pv && x == NOMOVE && fail_low) x = guess_move(search, board);
+			if (guess_pv && x == NOMOVE && fail_low) x = guess_move(search, &board);
 		} else x = NOMOVE;
 	}
 
@@ -225,7 +222,7 @@ void record_best_move(Search *search, const Board *init_board, const Move *bestm
 			log_print(search_log, "; nodes = %lld N; ", result->n_nodes);
 			if (result->time > 0) {log_print(search_log, "speed = %9.0f Nps", 1000.0 * result->n_nodes / result->time);}
 			log_print(search_log, "\npv = ");
-			line_print(result->pv, 200, " ", search_log->f);
+			line_print(&result->pv, 200, " ", search_log->f);
 			log_print(search_log, "\npv-debug = ");
 			pv_debug(search, bestmove, search_log->f);
 			log_print(search_log, "\n\n");
@@ -272,17 +269,17 @@ static int search_route_PVS(Search *search, int alpha, int beta, const int depth
 	int score;
 
 	assert(alpha < beta);
-	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
-	assert(SCORE_MIN <= beta && beta <= SCORE_MAX);
-	assert(depth >= 0 && depth <= search->n_empties);
+	assert(SCORE_MIN <= alpha);
+	assert(beta <= SCORE_MAX);
+	assert(depth >= 0 && depth <= search->eval.n_empties);
 
-	if (depth == search->n_empties) {
+	if (depth == search->eval.n_empties) {
 		if (depth == 0) score = search_solve_0(search);
 		else score = PVS_midgame(search, alpha, beta, depth, node);
 	} else {
 		if (depth == 0) score = search_eval_0(search);
-		else if (depth == 1) score = search_eval_1(search, alpha, beta);
-		else if (depth == 2) score = search_eval_2(search, alpha, beta);
+		else if (depth == 1) score = -search_eval_1(search, -beta, -alpha, board_get_moves(&search->board));
+		else if (depth == 2) score = search_eval_2(search, alpha, beta, board_get_moves(&search->board));
 		else score = PVS_midgame(search, alpha, beta, depth, node);
 	}
 
@@ -302,14 +299,14 @@ static int search_route_PVS(Search *search, int alpha, int beta, const int depth
  */
 int search_get_pv_cost(Search *search)
 {
-	HashTable *hash_table = search->hash_table;
-	HashTable *pv_table = search->pv_table;
-	HashTable *shallow_table = search->shallow_table;
-	HashData hash_data[1];
-	const unsigned long long hash_code = board_get_hash_code(search->board);
+	HashTable *hash_table = &search->hash_table;
+	HashTable *pv_table = &search->pv_table;
+	HashTable *shallow_table = &search->shallow_table;
+	HashData hash_data;
+	const unsigned long long hash_code = board_get_hash_code(&search->board);
 
-	if ((hash_get(pv_table, search->board, hash_code, hash_data) || hash_get(hash_table, search->board, hash_code, hash_data) || hash_get(shallow_table, search->board, hash_code, hash_data))) {
-		return writeable_level(hash_data);
+	if ((hash_get(pv_table, &search->board, hash_code, &hash_data) || hash_get(hash_table, &search->board, hash_code, &hash_data) || hash_get(shallow_table, &search->board, hash_code, &hash_data))) {
+		return writeable_level(&hash_data);
 	}
 	return 0;
 }
@@ -329,17 +326,18 @@ int search_get_pv_cost(Search *search)
  */
 int PVS_root(Search *search, const int alpha, const int beta, const int depth)
 {
-	HashData hash_data[1];
-	MoveList *movelist = search->movelist;
-	Board *board = search->board;
-	Move *move;
-	Node node[1];
-	long long cost = -search_count_nodes(search);
 	unsigned long long hash_code;
+	HashStoreData hash_data;
+	MoveList *const movelist = &search->movelist;
+	Move *move;
+	Node node;
+	Eval eval0;
+	Board board0;
+	long long nodes_org = search_count_nodes(search);
 	assert(alpha < beta);
 	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
 	assert(SCORE_MIN <= beta && beta <= SCORE_MAX);
-	assert(depth > 0 && depth <= search->n_empties);
+	assert(depth > 0 && depth <= search->eval.n_empties);
 
 	search->probcut_level = 0;
 	search->result->n_moves_left = search->result->n_moves;
@@ -347,95 +345,105 @@ int PVS_root(Search *search, const int alpha, const int beta, const int depth)
 	cassio_debug("PVS_root [%d, %d], %d@%d%%\n", alpha, beta, depth, selectivity_table[search->selectivity].percent);
 	if (search->options.verbosity == 4) printf("PVS_root [%d, %d], %d@%d%%\n", alpha, beta, depth, selectivity_table[search->selectivity].percent);
 	SEARCH_STATS(++statistics.n_PVS_root);
-	SEARCH_UPDATE_INTERNAL_NODES();
-
-	// transposition cutoff
-	hash_code = board_get_hash_code(board);
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
 
-	node_init(node, search, alpha, beta, depth, movelist->n_moves, NULL);
-	node->pv_node = true;
+	node_init(&node, search, alpha, beta, depth, movelist->n_moves, NULL);
+	node.pv_node = true;
 	search->node_type[0] = PV_NODE;
 	search->time.can_update = false;
-	
+
 	// special cases: pass or game over
 	if (movelist_is_empty(movelist)) {
 		move = movelist->move->next = movelist->move + 1;
 		move->flipped = 0;
-		if (can_move(board->opponent, board->player)) {
-			search_update_pass_midgame(search);
-				node->bestscore = move->score = -search_route_PVS(search, -node->beta, -node->alpha, depth, node);
-			search_restore_pass_midgame(search);
-			node->bestmove =  move->x = PASS;
+		if (can_move(search->board.opponent, search->board.player)) {
+			search_update_pass_midgame(search, &eval0);
+			node.bestscore = move->score = -search_route_PVS(search, -node.beta, -node.alpha, depth, &node);
+			search_restore_pass_midgame(search, &eval0);
+			node.bestmove =  move->x = PASS;
 		} else  { // game over
-			node->bestscore =  move->score = search_solve(search);
+			node.bestscore =  move->score = search_solve(search);
 			move->x = NOMOVE;
 		}
-	} else {
 
+	} else {
 		// first move
-		if ((move = node_first_move(node, movelist))) {
-			assert(board_check_move(board, move));
+		board0 = search->board;
+		eval0 = search->eval;
+		if ((move = node_first_move(&node, movelist))) {
+			assert(board_check_move(&search->board, move));
 			search_update_midgame(search, move); search->node_type[search->height] = PV_NODE;
-				move->score = -search_route_PVS(search, -beta, -alpha, depth - 1, node);
+				move->score = -search_route_PVS(search, -beta, -alpha, depth - 1, &node);
 				move->cost = search_get_pv_cost(search);
 				assert(SCORE_MIN <= move->score && move->score <= SCORE_MAX);
 				assert(search->stability_bound.lower <= move->score && move->score <= search->stability_bound.upper);
-			search_restore_midgame(search, move);
+			search_restore_midgame(search, move->x, &eval0);
+			search->board = board0;
 			if (log_is_open(search_log)) show_current_move(search_log->f, search, move, alpha, beta, false);
-			node_update(node, move);
+			node_update(&node, move);
 			if (search->options.verbosity == 4) pv_debug(search, move, stdout);
 
 			search->time.can_update = true;
 
 			// other moves : try to refute the first/best one
-			while ((move = node_next_move(node))) {
-				const int alpha = depth > search->options.multipv_depth ? node->alpha : SCORE_MIN;
+			while ((move = node_next_move(&node))) {
+				const int alpha = depth > search->options.multipv_depth ? node.alpha : SCORE_MIN;
 
-				assert(board_check_move(board, move));
-				if (depth > search->options.multipv_depth && node_split(node, move)) {
+				assert(board_check_move(&search->board, move));
+				if (depth > search->options.multipv_depth && node_split(&node, move)) {
 				} else {
 					search_update_midgame(search, move);
-						move->score = -search_route_PVS(search, -alpha - 1, -alpha, depth - 1, node);
+						move->score = -search_route_PVS(search, -alpha - 1, -alpha, depth - 1, &node);
 						if (alpha < move->score && move->score < beta) {
 							search->node_type[search->height] = PV_NODE;
-							move->score = -search_route_PVS(search, -beta, -alpha, depth - 1, node);
+							move->score = -search_route_PVS(search, -beta, -alpha, depth - 1, &node);
 						}
 						move->cost = search_get_pv_cost(search);
 					assert(SCORE_MIN <= move->score && move->score <= SCORE_MAX);
-					search_restore_midgame(search, move);
+					search_restore_midgame(search, move->x, &eval0);
+					search->board = board0;
 					if (log_is_open(search_log)) show_current_move(search_log->f, search, move, alpha, beta, false);
-					node_update(node, move);
-					assert(SCORE_MIN <= node->bestscore && node->bestscore <= SCORE_MAX);
+					node_update(&node, move);
+					assert(SCORE_MIN <= node.bestscore && node.bestscore <= SCORE_MAX);
 				}
 				if (search->options.verbosity == 4) pv_debug(search, move, stdout);
-				if (search_time(search) > search->time.maxi && node->bestscore > alpha) search->stop = STOP_TIMEOUT;
+				if (search_time(search) > search->time.maxi && node.bestscore > alpha) search->stop = STOP_TIMEOUT;
 			}
-			node_wait_slaves(node);
+			node_wait_slaves(&node);
 		}
 	}
 
-
 	if (!search->stop) {
-		hash_get(search->pv_table, board, hash_code, hash_data);
-		if (depth < search->options.multipv_depth) movelist_sort(movelist);
-		else movelist_sort_cost(movelist, hash_data);
-		movelist_sort_bestmove(movelist, node->bestmove);
-		record_best_move(search, board, movelist_first(movelist), alpha, beta, depth);
-
-		if (movelist->n_moves == get_mobility(board->player, board->opponent)) {
-			cost += search_count_nodes(search);
-			hash_store(search->hash_table, board, hash_code, depth, search->selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
-			if (search->options.guess_pv) hash_force(search->pv_table, board, hash_code, depth, search->selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
-			else hash_store(search->pv_table, board, hash_code, depth, search->selectivity, last_bit(cost), alpha, beta, node->bestscore, node->bestmove);
+		hash_code = board_get_hash_code(&search->board);
+		hash_get(&search->pv_table, &search->board, hash_code, &hash_data.data);
+		if (movelist->n_moves) {	// 4.5.1
+			if (depth < search->options.multipv_depth) movelist_sort(movelist);
+			else movelist_sort_cost(movelist, &hash_data.data);
+			movelist_sort_bestmove(movelist, node.bestmove);
+		}
+		record_best_move(search, movelist_first(movelist), alpha, beta, depth);
+
+		if (movelist->n_moves == get_mobility(search->board.player, search->board.opponent)) {
+			hash_data.data.wl.c.depth = depth;
+			hash_data.data.wl.c.selectivity = search->selectivity;
+			hash_data.data.wl.c.cost = last_bit(search_count_nodes(search) - nodes_org);
+			hash_data.data.move[0] = node.bestmove;
+			hash_data.alpha = alpha;
+			hash_data.beta = beta;
+			hash_data.score = node.bestscore;
+
+			hash_store(&search->hash_table, &search->board, hash_code, &hash_data);
+			if (search->options.guess_pv) hash_force(&search->pv_table, &search->board, hash_code, &hash_data);
+			else hash_store(&search->pv_table, &search->board, hash_code, &hash_data);
 		}
 
-		assert(SCORE_MIN <= node->bestscore && node->bestscore <= SCORE_MAX);
+		assert(SCORE_MIN <= node.bestscore && node.bestscore <= SCORE_MAX);
 
 	}
 
-	node_free(node);
+	node_free(&node);
 
-	return node->bestscore;
+	return node.bestscore;
 }
 
 /**
@@ -461,13 +469,13 @@ int aspiration_search(Search *search, int alpha, int beta, const int depth, int
 	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
 	assert(SCORE_MIN <= beta && beta <= SCORE_MAX);
 	assert(SCORE_MIN <= score && score <= SCORE_MAX);
-	assert(depth >= 0 && depth <= search->n_empties);
+	assert(depth >= 0 && depth <= search->eval.n_empties);
 
 	log_print(xboard_log, "edax (search)> search [%d, %d] %d (%d)\n", alpha, beta, depth, score);
 
-	if (is_depth_solving(depth, search->n_empties)) {
-		if (alpha & 1) --alpha;
-		if (beta & 1) ++beta;
+	if (is_depth_solving(depth, search->eval.n_empties)) {
+		alpha -= (alpha & 1);
+		beta += (beta & 1);
 	}
 
 	// at shallow depths always use a large window, for better move ordering
@@ -476,7 +484,6 @@ int aspiration_search(Search *search, int alpha, int beta, const int depth, int
 		beta = SCORE_MAX;
 	}
 
-
 	high = MIN(SCORE_MAX, search->stability_bound.upper + 2);
 	low = MAX(SCORE_MIN, search->stability_bound.lower - 2);
 	if (alpha < low) alpha = low;
@@ -491,11 +498,11 @@ int aspiration_search(Search *search, int alpha, int beta, const int depth, int
 	}
 
 	width = 10 - depth; if (width < 1) width = 1;
-	if ((width & 1) && depth == search->n_empties) ++width;
-	
+	if ((width & 1) && depth == search->eval.n_empties) ++width;
+
 	for (i = 0; i < 10; ++i) {
 		old_score = score;
-	
+
 		// if in multipv mode or the alphabeta window is already small, search directly
 		if (depth <= search->options.multipv_depth || beta - alpha <= 2 * width) {
 			log_print(search_log, "direct root_PVS [%d, %d]:\n", low, high);
@@ -527,24 +534,24 @@ int aspiration_search(Search *search, int alpha, int beta, const int depth, int
 		if (search->stop) break;
 
 		// check PV if alpha < score < beta
-		if (is_depth_solving(depth, search->n_empties)
+		if (is_depth_solving(depth, search->eval.n_empties)
 		&& ((alpha < score && score < beta) || (score == alpha && score == options.alpha) || (score == beta && score == options.beta))
 		&& !is_pv_ok(search, search->result->move, depth)) {
 			log_print(search_log, "*** WRONG PV => re-research id %d ***\n", search->id);
 			if (log_is_open(search_log)) {
-				pv_debug(search, movelist_first(search->movelist), search_log->f);
+				pv_debug(search, movelist_first(&search->movelist), search_log->f);
 				putc('\n', search_log->f); fflush(search_log->f);
 			}
 			if (options.debug_cassio) {
-				printf("DEBUG: Wrong PV: "); pv_debug(search, movelist_first(search->movelist), stdout); putchar('\n'); fflush(stdout); 
+				printf("DEBUG: Wrong PV: "); pv_debug(search, movelist_first(&search->movelist), stdout); putchar('\n'); fflush(stdout); 
 				if (log_is_open(engine_log)) {
-					fprintf(engine_log->f, "DEBUG: Wrong PV: "); pv_debug(search, movelist_first(search->movelist), engine_log->f);
+					fprintf(engine_log->f, "DEBUG: Wrong PV: "); pv_debug(search, movelist_first(&search->movelist), engine_log->f);
 					putc('\n', engine_log->f); fflush(engine_log->f);
 				}
 			}
 			continue;
 		}
-		if (is_depth_solving(depth, search->n_empties) && (score & 1)) {
+		if (is_depth_solving(depth, search->eval.n_empties) && (score & 1)) {
 			log_print(search_log, "*** UNEXPECTED ODD SCORE (score=%+d) => re-research id %d ***\n", score, search->id);			
 			cassio_debug("wrong odd score => re-research.\n");
 			continue;
@@ -552,7 +559,7 @@ int aspiration_search(Search *search, int alpha, int beta, const int depth, int
 		if (score == old_score) break;
 	}
 
-	if (!search->stop) record_best_move(search, search->board, movelist_first(search->movelist), alpha, beta, depth);
+	if (!search->stop) record_best_move(search, movelist_first(&search->movelist), alpha, beta, depth);
 	search->result->time = search_time(search);
 	search->result->n_nodes = search_count_nodes(search);
 	if (options.noise <= depth && search->options.verbosity >= 2) {
@@ -572,33 +579,31 @@ int aspiration_search(Search *search, int alpha, int beta, const int depth, int
 static bool get_last_level(Search *search, int *depth, int *selectivity)
 {
 	int i, d, s, x;
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 	unsigned long long hash_code;
-	HashData hash_data[1];
-	
+	HashData hash_data;
 
-	*board = *search->board;
+	board = search->board;
 
 	*depth = *selectivity = -1;
 
 	for (i = 0; i < 4; ++i) {
-		hash_code = board_get_hash_code(board);
-		if (hash_get(search->pv_table, board, hash_code, hash_data)) {
-			x = hash_data->move[0];
-		} else if (hash_get(search->hash_table, board, hash_code, hash_data)) {
-			x = hash_data->move[0];
+		hash_code = board_get_hash_code(&board);
+		if (hash_get(&search->pv_table, &board, hash_code, &hash_data)
+		 || hash_get(&search->hash_table, &board, hash_code, &hash_data)) {
+			x = hash_data.move[0];
 		} else break;
 
-		d = hash_data->depth + i;
-		s = hash_data->selectivity;
+		d = hash_data.wl.c.depth + i;
+		s = hash_data.wl.c.selectivity;
 
 		if (d > *depth) *depth = d;
 		if (s > *selectivity) *selectivity = s;
 
-		board_get_move(board, x, move);
-		board_update(board, move);
-		
+		board_get_move_flip(&board, x, &move);
+		board_update(&board, &move);
+
 		if (x == PASS) --i;
 	}
 
@@ -621,10 +626,9 @@ static bool get_last_level(Search *search, int *depth, int *selectivity)
 void iterative_deepening(Search *search, int alpha, int beta)
 {
 	Result *result = search->result;
-	MoveList *movelist = search->movelist;
-	Board *board = search->board;
+	MoveList *movelist = &search->movelist;
 	Move *bestmove, *move;
-	HashData hash_data[1];
+	HashData hash_data;
 	int score, end, start;
 	long long t;
 	bool has_time;
@@ -641,26 +645,26 @@ void iterative_deepening(Search *search, int alpha, int beta)
 	result->selectivity = 0;
 	result->time = 0;
 	result->n_nodes = 0;
-	line_init(result->pv, search->player);
+	line_init(&result->pv, search->player);
 
 	// special case: game over...
-	if (movelist_is_empty(movelist) && !can_move(board->opponent, board->player)) {
+	if (movelist_is_empty(movelist) && !can_move(search->board.opponent, search->board.player)) {
 		result->move = NOMOVE;
 		result->score = search_solve(search);
-		result->depth = search->n_empties;
+		result->depth = search->eval.n_empties;
 		result->selectivity = NO_SELECTIVITY;
 		result->time = search_time(search);
 		result->n_nodes = search_count_nodes(search);
 		result->bound[NOMOVE].lower = result->bound[NOMOVE].upper = result->score;
-		line_init(result->pv, search->player);
+		line_init(&result->pv, search->player);
 		return;
 	}
 
 	score = search_bound(search, search_eval_0(search));
 	end = search->options.depth;
-	if (end >= search->n_empties) {
-		end = search->n_empties - ITERATIVE_MIN_EMPTIES + 2;
-		if (end <= 0) end = 2 - (search->n_empties & 1);
+	if (end >= search->eval.n_empties) {
+		end = search->eval.n_empties - ITERATIVE_MIN_EMPTIES + 2;
+		if (end <= 0) end = 2 - (search->eval.n_empties & 1);
 	}
 	start = 6 - (end & 1);
 	if (start > end - 2) start = end - 2;
@@ -677,30 +681,30 @@ void iterative_deepening(Search *search, int alpha, int beta)
 	}
 
 	// reuse last search ?
-	if (hash_get(search->pv_table, board, board_get_hash_code(board), hash_data)) {
+	if (hash_get_from_board(&search->pv_table, &search->board, &hash_data)) {
 		char s[2][3];
 		if (search->options.verbosity >= 2) {
 			info("<hash: value = [%+02d, %+02d] ; bestmove = %s, %s ; level = %d@%d%% ; date = %d ; cost = %d>\n",
-				hash_data->lower, hash_data->upper,
-				move_to_string(hash_data->move[0], search->player, s[0]),
-				move_to_string(hash_data->move[1], search->player, s[1]),
-				hash_data->depth, selectivity_table[hash_data->selectivity].percent,
-				hash_data->date, hash_data->cost);
+				hash_data.lower, hash_data.upper,
+				move_to_string(hash_data.move[0], search->player, s[0]),
+				move_to_string(hash_data.move[1], search->player, s[1]),
+				hash_data.wl.c.depth, selectivity_table[hash_data.wl.c.selectivity].percent,
+				hash_data.wl.c.date, hash_data.wl.c.cost);
 		}
 		if (log_is_open(search_log)) {
 			log_print(search_log, "--- Next Search ---: ");
-			hash_print(hash_data, search_log->f);
+			hash_print(&hash_data, search_log->f);
 		}
-		old_depth = hash_data->depth;
-		old_selectivity = hash_data->selectivity;
+		old_depth = hash_data.wl.c.depth;
+		old_selectivity = hash_data.wl.c.selectivity;
 
 		if (USE_PREVIOUS_SEARCH) {
-			if (hash_data->lower == hash_data->upper) {
+			if (hash_data.lower == hash_data.upper) {
 				if (get_last_level(search, &old_depth, &old_selectivity)) {
 					start = old_depth;
 					search->selectivity = old_selectivity;
 				}
-				score = hash_data->lower;
+				score = hash_data.lower;
 			} else {
 				search_adjust_time(search, true);
 				log_print(search_log, "--- New Search (inexact score) ---:\n");
@@ -715,15 +719,15 @@ void iterative_deepening(Search *search, int alpha, int beta)
 	if (search->selectivity > search->options.selectivity) search->selectivity = search->options.selectivity;
 
 	if (start > search->options.depth) start = search->options.depth;
-	if (start > search->n_empties) start = search->n_empties;
-	if (start < search->n_empties) {
-		if ((start & 1) != (end & 1)) ++start;
+	if (start > search->eval.n_empties) start = search->eval.n_empties;
+	if (start < search->eval.n_empties) {
+		start += ((start ^ end) & 1);
 		if (start <= 0) start = 2 - (end & 1);
 		if (start > end) start = end;
 	}
 
 	if (log_is_open(search_log)) {
-		log_print(search_log,"date: pv = %d, main = %d %s\n", search->pv_table->date, search->hash_table->date, search->options.keep_date ? "(keep)":"");
+		log_print(search_log,"date: pv = %d, main = %d %s\n", search->pv_table.date, search->hash_table.date, search->options.keep_date ? "(keep)":"");
 		log_print(search_log,"iterating from level %d@%d\n", start, selectivity_table[search->selectivity].percent);
 		log_print(search_log, "alloted time: mini=%.1fs maxi=%.1fs extra=%.1fs\n", 0.001 * search->time.mini, 0.001 * search->time.maxi, 0.001 * search->time.extra);
 		unlock(search_log);
@@ -733,19 +737,19 @@ void iterative_deepening(Search *search, int alpha, int beta)
 	tmp_selectivity = search->selectivity; search->selectivity = old_selectivity;
 	if (!movelist_is_empty(movelist)) {
 		if (end == 0) { // shuffle the movelist
-			foreach_move(move, movelist) move->score = (random_get(search->random) & 0x7fffffff);
+			foreach_move(move, *movelist) move->score = (random_get(&search->random) & 0x7fffffff);
 			// randomness is not perfect as several moves may share the same value, but this should be rare enough not to care about it.
 		} else { // sort the moves
-			movelist_evaluate(movelist, search, hash_data, alpha, start);
+			movelist_evaluate(movelist, search, &hash_data, alpha, start);
 		}
 		movelist_sort(movelist);
 		bestmove = movelist_first(movelist); bestmove->score = score;
-		record_best_move(search, board, bestmove, alpha, beta, old_depth);
+		record_best_move(search, bestmove, alpha, beta, old_depth);
 		assert(SCORE_MIN <= result->score  && result->score <= SCORE_MAX);
 	} else {
 		Move pass = MOVE_PASS;
 		bestmove = &pass; bestmove->score = score;
-		record_best_move(search, board, bestmove, alpha, beta, old_depth);
+		record_best_move(search, bestmove, alpha, beta, old_depth);
 		assert(SCORE_MIN <= result->score  && result->score <= SCORE_MAX);
 	}
 	search->selectivity = tmp_selectivity;
@@ -759,31 +763,30 @@ void iterative_deepening(Search *search, int alpha, int beta)
 
 	// special case : level 0
 	if (end == 0) {
-		return;		
+		return;
 	}
 
 	// midgame : iterative depth
 	for (search->depth = start; search->depth < end; search->depth += 2) {
-		search->depth_pv_extension = get_pv_extension(search->depth, search->n_empties);
-		score = aspiration_search(search, alpha, beta, search->depth, score);
+		search->depth_pv_extension = get_pv_extension(search->depth, search->eval.n_empties);
+		score = aspiration_search(search, SCORE_MIN, SCORE_MAX/*alpha, beta*/, search->depth, score);	// https://github.com/eukaryo/edax-reversi-AVX-v446mod2
 		if (!search_continue(search)) return;
-		if (abs(score) >= SCORE_MAX - 1 && search->depth > end - ITERATIVE_MIN_EMPTIES && search->options.depth >= search->n_empties) break;
+		if (abs(score) >= SCORE_MAX - 1 && search->depth > end - ITERATIVE_MIN_EMPTIES && search->options.depth >= search->eval.n_empties) break;
 	}
 	search->depth = end;
 
 	// switch to endgame
-	if (search->options.depth >= search->n_empties) search->depth = search->n_empties;
+	if (search->options.depth >= search->eval.n_empties) search->depth = search->eval.n_empties;
 
 	// iterative selectivity
 	t = (search->options.time - search_time(search));
 	has_time = (solvable_depth(t / 10, search_count_tasks(search)) > search->depth);
 	for (; search->selectivity <= search->options.selectivity; ++search->selectivity) {
-		if (search->depth == search->n_empties && 
+		if (search->depth == search->eval.n_empties && 
 		(  (search->depth < 21 && search->selectivity >= 1)
 		|| (search->depth < 24 && search->selectivity >= 2)
 		|| (search->depth < 27 && search->selectivity >= 3)
-		|| (search->depth < 30 && search->selectivity >= 4)
-		|| (has_time && search->depth < 30 && search->selectivity >= 2)
+		|| (search->depth < 30 && search->selectivity >= (has_time ? 2 : 4))
 		|| (abs(score) >= SCORE_MAX))) { // jump to exact endgame (to solve faster) ?
 			search->selectivity = search->options.selectivity;
 		}
@@ -820,20 +823,20 @@ void* search_run(void *v)
 	search->time.spent = -search_clock(search);
 	search_time_init(search);
 	if (!search->options.keep_date) {
-		hash_clear(search->hash_table);
-		hash_clear(search->pv_table);
-		hash_clear(search->shallow_table);
+		hash_clear(&search->hash_table);
+		hash_clear(&search->pv_table);
+		hash_clear(&search->shallow_table);
 	}
 	search->height = 0;
 	search->node_type[search->height] = PV_NODE;
-	search->depth_pv_extension = get_pv_extension(0, search->n_empties);
-	search->stability_bound.upper = SCORE_MAX - 2 * get_stability(search->board->opponent, search->board->player);
-	search->stability_bound.lower = 2 * get_stability(search->board->player, search->board->opponent) - SCORE_MAX;
+	search->depth_pv_extension = get_pv_extension(0, search->eval.n_empties);
+	search->stability_bound.upper = SCORE_MAX - 2 * get_stability(search->board.opponent, search->board.player);
+	search->stability_bound.lower = 2 * get_stability(search->board.player, search->board.opponent) - SCORE_MAX;
 	search->result->score = search_bound(search, search_eval_0(search));
-	search->result->n_moves_left = search->result->n_moves = search->movelist->n_moves;
+	search->result->n_moves_left = search->result->n_moves = search->movelist.n_moves;
 	search->result->book_move = false;
 
-	if (!movelist_is_empty(search->movelist)) {
+	if (!movelist_is_empty(&search->movelist)) {
 		foreach_move(move, search->movelist) {
 			search->result->bound[move->x].lower = SCORE_MIN;
 			search->result->bound[move->x].upper = SCORE_MAX;
diff --git a/src/search.c b/src/search.c
index 70caa157..975854a9 100644
--- a/src/search.c
+++ b/src/search.c
@@ -52,9 +52,9 @@
  * -# Reinsfeld A. (1983) An Improvement Of the Scout Tree-Search Algorithm. ICCA
  *     journal, 6(4), pp. 4-14.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "search.h"
@@ -78,17 +78,25 @@ Log search_log[1];
 #endif
 
 /** a quadrant id for each square */
-const int QUADRANT_ID[] = {
-		1, 1, 1, 1, 2, 2, 2, 2,
-		1, 1, 1, 1, 2, 2, 2, 2,
-		1, 1, 1, 1, 2, 2, 2, 2,
-		1, 1, 1, 1, 2, 2, 2, 2,
-		4, 4, 4, 4, 8, 8, 8, 8,
-		4, 4, 4, 4, 8, 8, 8, 8,
-		4, 4, 4, 4, 8, 8, 8, 8,
-		4, 4, 4, 4, 8, 8, 8, 8,
-		0, 0
-	};
+const unsigned char QUADRANT_ID[] = {
+	1, 1, 1, 1, 2, 2, 2, 2,
+	1, 1, 1, 1, 2, 2, 2, 2,
+	1, 1, 1, 1, 2, 2, 2, 2,
+	1, 1, 1, 1, 2, 2, 2, 2,
+	4, 4, 4, 4, 8, 8, 8, 8,
+	4, 4, 4, 4, 8, 8, 8, 8,
+	4, 4, 4, 4, 8, 8, 8, 8,
+	4, 4, 4, 4, 8, 8, 8, 8,
+	0, 0
+};
+
+/** quadrant id to move mask */
+const unsigned long long quadrant_mask[] = {
+	0x0000000000000000, 0x000000000F0F0F0F, 0x00000000F0F0F0F0, 0x00000000FFFFFFFF,
+	0x0F0F0F0F00000000, 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0FF0F0F0F0, 0x0F0F0F0FFFFFFFFF,
+	0xF0F0F0F000000000, 0xF0F0F0F00F0F0F0F, 0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0FFFFFFFF,
+	0xFFFFFFFF00000000, 0xFFFFFFFF0F0F0F0F, 0xFFFFFFFFF0F0F0F0, 0xFFFFFFFFFFFFFFFF
+};
 
 /** level with no selectivity */
 const int NO_SELECTIVITY = 5;
@@ -105,19 +113,20 @@ const Selectivity selectivity_table [] = {
 
 /** threshold values to try stability cutoff during NWS search */
 // TODO: better values may exist.
-const int NWS_STABILITY_THRESHOLD[] = { // 99 = unused value...
+static const signed char NWS_STABILITY_THRESHOLD[] = { // 99 = unused value...
 	 99, 99, 99, 99,  6,  8, 10, 12,
-	 14, 16, 20, 22, 24, 26, 28, 30,
+	  8, 10, 20, 22, 24, 26, 28, 30, // 8 & 9 lowered to work best with solid stone
 	 32, 34, 36, 38, 40, 42, 44, 46,
 	 48, 48, 50, 50, 52, 52, 54, 54,
 	 56, 56, 58, 58, 60, 60, 62, 62,
 	 64, 64, 64, 64, 64, 64, 64, 64,
 	 99, 99, 99, 99, 99, 99, 99, 99, // no stable square at those depths
+	 99, 99, 99, 99, 99, 99, 99, 99
 };
 
 /** threshold values to try stability cutoff during PVS search */
 // TODO: better values may exist.
-const int PVS_STABILITY_THRESHOLD[] = { // 99 = unused value...
+const signed char PVS_STABILITY_THRESHOLD[] = { // 99 = unused value...
 	 99, 99, 99, 99, -2,  0,  2,  4,
 	  6,  8, 12, 14, 16, 18, 20, 22,
 	 24, 26, 28, 30, 32, 34, 36, 38,
@@ -125,11 +134,12 @@ const int PVS_STABILITY_THRESHOLD[] = { // 99 = unused value...
 	 48, 48, 50, 50, 52, 52, 54, 54,
 	 56, 56, 58, 58, 60, 60, 62, 62,
 	 99, 99, 99, 99, 99, 99, 99, 99, // no stable square at those depths
+	 99, 99, 99, 99, 99, 99, 99, 99
 };
 
 
 /** square type */
-const int SQUARE_TYPE[] = {
+const unsigned char SQUARE_TYPE[] = {
 	0, 1, 2, 3, 3, 2, 1, 0,
 	1, 4, 5, 6, 6, 5, 4, 1,
 	2, 5, 7, 8, 8, 7, 5, 2,
@@ -151,181 +161,186 @@ struct Level LEVEL[61][61];
 void search_global_init(void)
 {
 	int level, n_empties;
+	unsigned char dep, sel;
 
 	for (level = 0; level <= 60; ++level)
 	for (n_empties = 0; n_empties <= 60; ++n_empties) {
+		dep = n_empties;
+		sel = 5;
 		if (level <= 0) {
-			LEVEL[level][n_empties].depth = 0;
-			LEVEL[level][n_empties].selectivity = 5;
+			dep = 0;
+			// sel = 5;
 		} else if (level <= 10) {
-			LEVEL[level][n_empties].selectivity = 5;
+			// sel = 5;
 			if (n_empties <= 2 * level) {
-				LEVEL[level][n_empties].depth = n_empties;
+				// dep = n_empties;
 			} else {
-				LEVEL[level][n_empties].depth = level;
+				dep = level;
 			}
 		} else if (level <= 12) {
 			if (n_empties <= 21) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 24) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 18) {
 			if (n_empties <= 21) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 24) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else if (n_empties <= 27) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 1;
+				// dep = n_empties;
+				sel = 1;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 21) {
 			if (n_empties <= 24) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 27) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 1;
+				// dep = n_empties;
+				sel = 1;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 24) {
 			if (n_empties <= 24) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 27) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 4;
+				// dep = n_empties;
+				sel = 4;
 			} else if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 2;
+				// dep = n_empties;
+				sel = 2;
 			} else if (n_empties <= 33) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 0;
+				// dep = n_empties;
+				sel = 0;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 27) {
 			if (n_empties <= 27) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else if (n_empties <= 33) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 1;
+				// dep = n_empties;
+				sel = 1;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level < 30) {
 			if (n_empties <= 27) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 4;
+				// dep = n_empties;
+				sel = 4;
 			} else if (n_empties <= 33) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 2;
+				// dep = n_empties;
+				sel = 2;
 			} else if (n_empties <= 36) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 0;
+				// dep = n_empties;
+				sel = 0;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 31) {
 			if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 33) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else if (n_empties <= 36) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 1;
+				// dep = n_empties;
+				sel = 1;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 33) {
 			if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 33) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 4;
+				// dep = n_empties;
+				sel = 4;
 			} else if (n_empties <= 36) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 2;
+				// dep = n_empties;
+				sel = 2;
 			} else if (n_empties <= 39) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 0;
+				// dep = n_empties;
+				sel = 0;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level <= 35) {
 			if (n_empties <= 30) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= 33) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 4;
+				// dep = n_empties;
+				sel = 4;
 			} else if (n_empties <= 36) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else if (n_empties <= 39) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 1;
+				// dep = n_empties;
+				sel = 1;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else if (level < 60) {
 			if (n_empties <= level - 6) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 5;
+				// dep = n_empties;
+				// sel = 5;
 			} else if (n_empties <= level - 3) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 4;
+				// dep = n_empties;
+				sel = 4;
 			} else if (n_empties <= level) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 3;
+				// dep = n_empties;
+				sel = 3;
 			} else if (n_empties <= level + 3) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 2;
+				// dep = n_empties;
+				sel = 2;
 			} else if (n_empties <= level + 6) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 1;
+				// dep = n_empties;
+				sel = 1;
 			} else if (n_empties <= level + 9) {
-				LEVEL[level][n_empties].depth = n_empties;
-				LEVEL[level][n_empties].selectivity = 0;
+				// dep = n_empties;
+				sel = 0;
 			} else {
-				LEVEL[level][n_empties].depth = level;
-				LEVEL[level][n_empties].selectivity = 0;
+				dep = level;
+				sel = 0;
 			}
 		} else {
-			LEVEL[level][n_empties].depth = n_empties;
-			LEVEL[level][n_empties].selectivity = 5;
+			// dep = n_empties;
+			// sel = 5;
 		}
+		LEVEL[level][n_empties].depth = dep;
+		LEVEL[level][n_empties].selectivity = sel;
 	}
 	search_log->f = NULL;
 }
@@ -333,11 +348,11 @@ void search_global_init(void)
 void search_resize_hashtable(Search *search) {
 	if (search->options.hash_size != options.hash_table_size) {
 		const int hash_size = 1u << options.hash_table_size;
-		const int pv_size = hash_size > 16 ? hash_size >> 4 : 16;
+		const int pv_shallow_size = hash_size > 16 ? hash_size >> 4 : 1;
 
-		hash_init(search->hash_table, hash_size);
-		hash_init(search->pv_table, pv_size);
-		hash_init(search->shallow_table, hash_size);
+		hash_init(&search->hash_table, hash_size);
+		hash_init(&search->pv_table, pv_shallow_size);
+		hash_init(&search->shallow_table, pv_shallow_size);
 		search->options.hash_size = options.hash_table_size;
 	}
 }
@@ -358,23 +373,23 @@ void search_init(Search *search)
 
 	/* hash_table */
 	search->options.hash_size = 0;
-	search->hash_table->hash = NULL;
-	search->hash_table->hash_mask = 0;
-	search->pv_table->hash = NULL;
-	search->pv_table->hash_mask = 0;
-	search->shallow_table->hash = NULL;
-	search->shallow_table->hash_mask = 0;
+	search->hash_table.hash = NULL;
+	search->hash_table.hash_mask = 0;
+	search->pv_table.hash = NULL;
+	search->pv_table.hash_mask = 0;
+	search->shallow_table.hash = NULL;
+	search->shallow_table.hash_mask = 0;
 	search_resize_hashtable(search);
 
 	/* board */
-	search->board->player = search->board->opponent = 0;
+	search->board.player = search->board.opponent = 0;
 	search->player = EMPTY;
 
 	/* evaluation function */
-	eval_init(search->eval);
+	// eval_init(search->eval);
 
 	// radom generator
-	random_seed(search->random, real_clock());
+	random_seed(&search->random, real_clock());
 
 	/* task stack */
 	search->tasks = (TaskStack*) malloc(sizeof (TaskStack));
@@ -441,10 +456,10 @@ void search_init(Search *search)
 void search_free(Search *search)
 {
 
-	hash_free(search->hash_table);
-	hash_free(search->pv_table);
-	hash_free(search->shallow_table);
-	eval_free(search->eval);
+	hash_free(&search->hash_table);
+	hash_free(&search->pv_table);
+	hash_free(&search->shallow_table);
+	// eval_free(search->eval);
 	
 	task_stack_free(search->tasks);
 	free(search->tasks);
@@ -465,9 +480,8 @@ void search_free(Search *search)
  */
 void search_setup(Search *search)
 {
-	int i;
-	SquareList *empty;
-	const int presorted_x[] = {
+	int i, x, prev;
+	static const unsigned char presorted_x[] = {
 		A1, A8, H1, H8,                    /* Corner */
 		C4, C5, D3, D6, E3, E6, F4, F5,    /* E */
 		C3, C6, F3, F6,                    /* D */
@@ -480,55 +494,33 @@ void search_setup(Search *search)
 		D4, E4, D5, E5,                    /* center */
 	};
 
-	Board *board = search->board;
+	const Board * const board = &search->board;
 	unsigned long long E;
 
-	// init empties
-	search->n_empties = 0;
+	// init empties, parity
+	search->eval.n_empties = 0;
+	search->eval.parity = 0;
 
-	empty = search->empties;
-	empty->x = NOMOVE; /* sentinel */
-	empty->previous = NULL;
-	empty->next = empty + 1;
-	empty = empty->next;
+	prev = NOMOVE;
 	E = ~(board->player | board->opponent);
 	for (i = 0; i < BOARD_SIZE; ++i) {    /* add empty squares */
-		if ((E & x_to_bit(presorted_x[i]))) {
-			empty->x = presorted_x[i];
-			empty->b = x_to_bit(presorted_x[i]);
-			empty->quadrant = QUADRANT_ID[empty->x];
-			empty->previous = empty - 1;
-			empty->next = empty + 1;
-			search->x_to_empties[presorted_x[i]] = empty;
-			empty = empty->next;
-			++search->n_empties;
+		x = presorted_x[i];
+		if (E & x_to_bit(x)) {
+			search->eval.parity ^= QUADRANT_ID[x];
+			search->empties[prev].next = x;
+			search->empties[x].previous = prev;
+			prev = x;
+			++search->eval.n_empties;
 		}
 	}
-	empty->x = NOMOVE; /* sentinel */
-	empty->b = 0;
-	empty->previous = empty - 1;
-	empty->next = NULL;
-
-	empty = search->empties + PASS;
-	empty->x = PASS;
-	empty->b = 0;
-	empty->previous = empty->next = empty;
-	search->x_to_empties[PASS] = empty;
-
-	empty = search->empties + NOMOVE;
-	empty->x = NOMOVE;
-	empty->b = 0;
-	empty->previous = empty->next = empty;
-	search->x_to_empties[NOMOVE] = empty;
-
-	// init parity
-	search->parity = 0;
-	foreach_empty (empty, search->empties) {
-		search->parity ^= empty->quadrant;
-	}
+	search->empties[prev].next = NOMOVE;	/* sentinel */
+	search->empties[NOMOVE].previous = prev;
+
+	search->empties[PASS].next = NOMOVE;
+	search->empties[PASS].previous = NOMOVE;
 
 	// init the evaluation function
-	eval_set(search->eval, board);
+	eval_set(&search->eval, &search->board);
 }
 
 /**
@@ -541,11 +533,11 @@ void search_clone(Search *search, Search *master)
 {
 	search->stop = STOP_END;
 	search->player = master->player;
-	*search->board = *master->board;
+	search->board = master->board;
 	search_setup(search);
-	*search->hash_table = *master->hash_table; // share the hashtable
-	*search->pv_table = *master->pv_table; // share the pvtable
-	*search->shallow_table = *master->shallow_table; // share the pvtable
+	search->hash_table = master->hash_table; // share the hashtable
+	search->pv_table = master->pv_table; // share the pvtable
+	search->shallow_table = master->shallow_table; // share the shallowtable
 	search->tasks = master->tasks;
 	search->observer = master->observer;
 
@@ -577,9 +569,9 @@ void search_clone(Search *search, Search *master)
  */
 void search_cleanup(Search *search)
 {
-	hash_cleanup(search->hash_table);
-	hash_cleanup(search->pv_table);
-	hash_cleanup(search->shallow_table);
+	hash_cleanup(&search->hash_table);
+	hash_cleanup(&search->pv_table);
+	hash_cleanup(&search->shallow_table);
 }
 
 
@@ -593,9 +585,9 @@ void search_cleanup(Search *search)
 void search_set_board(Search *search, const Board *board, const int player)
 {
 	search->player = player;
-	*search->board = *board;
+	search->board = *board;
 	search_setup(search);
-	search_get_movelist(search, search->movelist);
+	search_get_movelist(search, &search->movelist);
 }
 
 /**
@@ -707,7 +699,7 @@ void search_time_init(Search *search)
 	} else {
 		long long t = search->options.time;
 		const int sd = solvable_depth(t / 10, search_count_tasks(search)); // depth solvable with 10% of the time
-		const int d = MAX((search->n_empties - sd) / 2, 2); // unsolvable ply to play
+		const int d = MAX((search->eval.n_empties - sd) / 2, 2); // unsolvable ply to play
 		t = MAX(t / d - 10, 100); // keep 0.25 s./remaining move, make at least 1s. available
 		search->time.extra = t;
 		search->time.maxi = t * 3 / 4;
@@ -859,7 +851,7 @@ void search_set_task_number(Search *search, const int n)
  */
 void search_swap_parity(Search *search, const int x)
 {
-	search->parity ^= QUADRANT_ID[x];
+	search->eval.parity ^= QUADRANT_ID[x];
 }
 
 /**
@@ -876,21 +868,25 @@ void search_get_movelist(const Search *search, MoveList *movelist)
 {
 	Move *previous = movelist->move;
 	Move *move = movelist->move + 1;
-	const Board *board = search->board;
-	unsigned long long moves = get_moves(board->player, board->opponent);
-	register int x;
+	V2DI vboard;
+	unsigned long long moves;
+	int x;
 
+	vboard.board = search->board;
+	moves = vboard_get_moves(vboard);
+	movelist->n_moves = 0;
 	foreach_bit(x, moves) {
-		board_get_move(board, x, move);
+		move->x = x;
+		move->flipped = vboard_flip(vboard, x);
 		move->cost = 0;
 		previous = previous->next = move;
 		++move;
+		++(movelist->n_moves);
 	}
 	previous->next = NULL;
-	movelist->n_moves = move - movelist->move - 1;
-	assert(movelist->n_moves == get_mobility(board->player, board->opponent));
 }
 
+#if 0	// inlined
 /**
  * @brief Update the search state after a move.
  *
@@ -900,9 +896,9 @@ void search_get_movelist(const Search *search, MoveList *movelist)
 void search_update_endgame(Search *search, const Move *move)
 {
 	search_swap_parity(search, move->x);
-	empty_remove(search->x_to_empties[move->x]);
-	board_update(search->board, move);
-	--search->n_empties;
+	empty_remove(search->empties, move->x);
+	board_update(&search->board, move);
+	--search->eval.n_empties;
 
 }
 
@@ -915,9 +911,9 @@ void search_update_endgame(Search *search, const Move *move)
 void search_restore_endgame(Search *search, const Move *move)
 {
 	search_swap_parity(search, move->x);
-	empty_restore(search->x_to_empties[move->x]);
-	board_restore(search->board, move);
-	++search->n_empties;
+	empty_restore(search->empties, move->x);
+	board_restore(&search->board, move);
+	++search->eval.n_empties;
 }
 
 /**
@@ -927,9 +923,9 @@ void search_restore_endgame(Search *search, const Move *move)
  */
 void search_pass_endgame(Search *search)
 {
-	board_pass(search->board);
+	board_pass(&search->board);
 }
-
+#endif
 
 //static Line debug_line;
 
@@ -941,36 +937,36 @@ void search_pass_endgame(Search *search)
  */
 void search_update_midgame(Search *search, const Move *move)
 {
-	static const NodeType next_node_type[] = {CUT_NODE, ALL_NODE, CUT_NODE};
-
 //	line_push(&debug_line, move->x);
 
 	search_swap_parity(search, move->x);
-	empty_remove(search->x_to_empties[move->x]);
-	board_update(search->board, move);
-	eval_update(search->eval, move);
-	assert(search->n_empties > 0);
-	--search->n_empties;
+	empty_remove(search->empties, move->x);
+	board_update(&search->board, move);
+	eval_update(move->x, move->flipped, &search->eval);
+	assert(search->eval.n_empties > 0);
+	--search->eval.n_empties;
 	++search->height;
-	search->node_type[search->height] = next_node_type[search->node_type[search->height- 1]];
+	search->node_type[search->height] = (search->node_type[search->height - 1] == CUT_NODE) ? ALL_NODE : CUT_NODE;
 }
 
 /**
  * @brief Restore the search state as before a move.
  *
  * @param search  search.
- * @param move    played move.
+ * @param x       played move.
+ * @param backup  board/eval to restore.
  */
-void search_restore_midgame(Search *search, const Move *move)
+void search_restore_midgame(Search *search, int x, const Eval *eval0)
 {
 //	line_print(&debug_line, 100, " ", stdout); putchar('\n');
 //	line_pop(&debug_line);
 
-	search_swap_parity(search, move->x);
-	empty_restore(search->x_to_empties[move->x]);
-	board_restore(search->board, move);
-	eval_restore(search->eval, move);
-	++search->n_empties;
+	// search_swap_parity(search, move->x);
+	// ++search->eval.n_empties;
+	// eval_restore(search->eval, move);
+	search->eval = *eval0;
+	// board_restore(&search->board, move);
+	empty_restore(search->empties, x);
 	assert(search->height > 0);
 	--search->height;
 }
@@ -980,14 +976,13 @@ void search_restore_midgame(Search *search, const Move *move)
  *
  * @param search  search.
  */
-void search_update_pass_midgame(Search *search)
+void search_update_pass_midgame(Search *search, Eval *backup)
 {
-	static const NodeType next_node_type[] = {CUT_NODE, ALL_NODE, CUT_NODE};
-
-	board_pass(search->board);
-	eval_pass(search->eval);
+	search_pass(search);
+	backup->feature = search->eval.feature;
+	eval_pass(&search->eval);
 	++search->height;
-	search->node_type[search->height] = next_node_type[search->node_type[search->height- 1]];
+	search->node_type[search->height] = (search->node_type[search->height - 1] == CUT_NODE) ? ALL_NODE : CUT_NODE;
 }
 
 /**
@@ -995,10 +990,11 @@ void search_update_pass_midgame(Search *search)
  *
  * @param search  search.
  */
-void search_restore_pass_midgame(Search *search)
+void search_restore_pass_midgame(Search *search, const Eval *eval0)
 {
-	board_pass(search->board);
-	eval_pass(search->eval);
+	search_pass(search);
+	// eval_pass(&search->eval);
+	search->eval.feature = eval0->feature;
 	assert(search->height > 0);
 	--search->height;
 }
@@ -1128,12 +1124,13 @@ void result_print(Result *result, FILE *f)
 		if (result->time > 0) fprintf(f, "%10.0f ", 1000.0 * result->n_nodes / result->time);
 		else fprintf(f, "           ");
 	} else fputs("                          ", f);
-	line_print(result->pv, options.width - PRINTED_WIDTH, " ", f);
+	line_print(&result->pv, options.width - PRINTED_WIDTH, " ", f);
 	fflush(f);
 
 	spin_unlock(result);
 }
 
+#if 0	// inlined in PVS_shallow
 /**
  * @brief Stability Cutoff (SC).
  *
@@ -1143,13 +1140,11 @@ void result_print(Result *result, FILE *f)
  * @param score Score to return in case of a cutoff is found.
  * @return 'true' if a cutoff is found, false otherwise.
  */
-bool search_SC_PVS(Search *search, volatile int *alpha, volatile int *beta, int *score)
+bool search_SC_PVS(Search *search, int *alpha, int *beta, int *score)
 {
-	const Board *board = search->board;
-
-	if (USE_SC && *beta >= PVS_STABILITY_THRESHOLD[search->n_empties]) {
+	if (USE_SC && *beta >= PVS_STABILITY_THRESHOLD[search->eval.n_empties]) {
 		CUTOFF_STATS(++statistics.n_stability_try;)
-		*score = SCORE_MAX - 2 * get_stability(board->opponent, board->player);
+		*score = SCORE_MAX - 2 * get_stability(search->board.opponent, search->board.player);
 		if (*score <= *alpha) {
 			CUTOFF_STATS(++statistics.n_stability_low_cutoff;)
 			return true;
@@ -1158,9 +1153,10 @@ bool search_SC_PVS(Search *search, volatile int *alpha, volatile int *beta, int
 	}
 	return false;
 }
+#endif
 
 /**
- * @brief Stability Cutoff (TC).
+ * @brief Stability Cutoff (SC).
  *
  * @param search Current position.
  * @param alpha Alpha bound.
@@ -1169,11 +1165,9 @@ bool search_SC_PVS(Search *search, volatile int *alpha, volatile int *beta, int
  */
 bool search_SC_NWS(Search *search, const int alpha, int *score)
 {
-	const Board *board = search->board;
-
-	if (USE_SC && alpha >= NWS_STABILITY_THRESHOLD[search->n_empties]) {
+	if (USE_SC && alpha >= NWS_STABILITY_THRESHOLD[search->eval.n_empties]) {
 		CUTOFF_STATS(++statistics.n_stability_try;)
-		*score = SCORE_MAX - 2 * get_stability(board->opponent, board->player);
+		*score = SCORE_MAX - 2 * get_stability(search->board.opponent, search->board.player);
 		if (*score <= alpha) {
 			CUTOFF_STATS(++statistics.n_stability_low_cutoff;)
 			return true;
@@ -1182,6 +1176,21 @@ bool search_SC_NWS(Search *search, const int alpha, int *score)
 	return false;
 }
 
+// for 4 empties (min stage)
+bool search_SC_NWS_4(Search *search, const int alpha, int *score)
+{
+	if (USE_SC && alpha < -NWS_STABILITY_THRESHOLD[4]) {
+		CUTOFF_STATS(++statistics.n_stability_try;)
+		*score = 2 * get_stability(search->board.opponent, search->board.player) - SCORE_MAX;
+		if (*score > alpha) {
+			CUTOFF_STATS(++statistics.n_stability_low_cutoff;)
+			return true;
+		}
+	}
+	return false;
+}
+
+#if 0	// unused
 /**
  * @brief Transposition Cutoff (TC).
  *
@@ -1193,9 +1202,9 @@ bool search_SC_NWS(Search *search, const int alpha, int *score)
  * @param score Score to return in case of a cutoff is found.
  * @return 'true' if a cutoff is found, false otherwise.
  */
-bool search_TC_PVS(HashData *data, const int depth, const int selectivity, volatile int *alpha, volatile int *beta, int *score)
+bool search_TC_PVS(HashData *data, const int depth, const int selectivity, int *alpha, int *beta, int *score)
 {
-	if (USE_TC && (data->selectivity >= selectivity && data->depth >= depth)) {
+	if (USE_TC && (data->wl.c.selectivity >= selectivity && data->wl.c.depth >= depth)) {
 		CUTOFF_STATS(++statistics.n_hash_try;)
 		if (*alpha < data->lower) {
 			*alpha = data->lower;
@@ -1216,6 +1225,7 @@ bool search_TC_PVS(HashData *data, const int depth, const int selectivity, volat
 	}
 	return false;
 }
+#endif
 
 /**
  * @brief Transposition Cutoff (TC).
@@ -1229,7 +1239,7 @@ bool search_TC_PVS(HashData *data, const int depth, const int selectivity, volat
  */
 bool search_TC_NWS(HashData *data, const int depth, const int selectivity, const int alpha, int *score)
 {
-	if (USE_TC && (data->selectivity >= selectivity && data->depth >= depth)) {
+	if (USE_TC && (data->wl.c.selectivity >= selectivity && data->wl.c.depth >= depth)) {
 		CUTOFF_STATS(++statistics.n_hash_try;)
 		if (alpha < data->lower) {
 			CUTOFF_STATS(++statistics.n_hash_high_cutoff;)
@@ -1266,33 +1276,44 @@ bool search_ETC_NWS(Search *search, MoveList *movelist, unsigned long long hash_
 	if (USE_ETC && depth > ETC_MIN_DEPTH) {
 
 		Move *move;
-		Board next[1];
-		HashData etc[1];
+		Board next;
+		HashData etc;
+		HashStoreData hash_data;
 		unsigned long long etc_hash_code;
-		HashTable *hash_table = search->hash_table;
+		HashTable *hash_table = &search->hash_table;
 		const int etc_depth = depth - 1;
 		const int beta = alpha + 1;
-	
+
+		hash_data.data.wl.c.depth = depth;
+		hash_data.data.wl.c.selectivity = selectivity;
+		hash_data.data.wl.c.cost = 0;
+		hash_data.alpha = alpha;
+		hash_data.beta = beta;
+
 		CUTOFF_STATS(++statistics.n_etc_try;)
-		foreach_move (move, movelist) {
-			next->opponent = search->board->player ^ (move->flipped | x_to_bit(move->x));
-			next->player = search->board->opponent ^ move->flipped;
-			SEARCH_UPDATE_ALL_NODES();
+		foreach_move (move, *movelist) {
+			next.opponent = search->board.player ^ (move->flipped | x_to_bit(move->x));
+			next.player = search->board.opponent ^ move->flipped;
+			SEARCH_UPDATE_ALL_NODES(search->n_nodes);
 
-			if (USE_SC && alpha <= -NWS_STABILITY_THRESHOLD[search->n_empties]) {
-				*score = 2 * get_stability(next->opponent, next->player) - SCORE_MAX;
+			if (USE_SC && alpha <= -NWS_STABILITY_THRESHOLD[search->eval.n_empties]) {
+				*score = 2 * get_stability(next.opponent, next.player) - SCORE_MAX;
 				if (*score > alpha) {
-					hash_store(hash_table, search->board, hash_code, depth, selectivity, 0, alpha, beta, *score, move->x);
+					hash_data.score = *score;
+					hash_data.data.move[0] = move->x;
+					hash_store(hash_table, &search->board, hash_code, &hash_data);
 					CUTOFF_STATS(++statistics.n_esc_high_cutoff;)
 					return true;
 				}
 			}
 
-			etc_hash_code = board_get_hash_code(next);
-			if (USE_TC && hash_get(hash_table, next, etc_hash_code, etc) && etc->selectivity >= selectivity && etc->depth >= etc_depth) {
-				*score = -etc->upper;
+			etc_hash_code = board_get_hash_code(&next);
+			if (USE_TC && hash_get(hash_table, &next, etc_hash_code, &etc) && etc.wl.c.selectivity >= selectivity && etc.wl.c.depth >= etc_depth) {
+				*score = -etc.upper;
 				if (*score > alpha) {
-					hash_store(hash_table, search->board, hash_code, depth, selectivity, 0, alpha, beta, *score, move->x);
+					hash_data.score = *score;
+					hash_data.data.move[0] = move->x;
+					hash_store(hash_table, &search->board, hash_code, &hash_data);
 					CUTOFF_STATS(++statistics.n_etc_high_cutoff;)
 					return true;
 				}
@@ -1311,8 +1332,8 @@ bool search_ETC_NWS(Search *search, MoveList *movelist, unsigned long long hash_
  */
 void search_share(const Search *src, Search *dest)
 {
-	hash_copy(src->pv_table, dest->pv_table);
-	hash_copy(src->hash_table, dest->hash_table);
+	hash_copy(&src->pv_table, &dest->pv_table);
+	hash_copy(&src->hash_table, &dest->hash_table);
 }
 
 /**
@@ -1368,11 +1389,13 @@ void search_set_state(Search *search, const Stop stop)
  */
 int search_guess(Search *search, const Board *board)
 {
-	HashData hash_data[1];
+	HashData hash_data;
 	int move = NOMOVE;
+	unsigned long long hash_code;
 
-	if (hash_get(search->pv_table, board, board_get_hash_code(board), hash_data)) move = hash_data->move[0];
-	if (move == NOMOVE && hash_get(search->hash_table, board, board_get_hash_code(board), hash_data)) move = hash_data->move[0];
+	hash_code = board_get_hash_code(board);
+	if (hash_get(&search->pv_table, board, hash_code, &hash_data)) move = hash_data.move[0];
+	if (move == NOMOVE && hash_get(&search->hash_table, board, hash_code, &hash_data)) move = hash_data.move[0];
 
 	return move;
 }
diff --git a/src/search.h b/src/search.h
index 01cdb84e..cb264f22 100644
--- a/src/search.h
+++ b/src/search.h
@@ -3,14 +3,15 @@
  *
  * Search's header file.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #ifndef EDAX_SEARCH_H
 #define EDAX_SEARCH_H
 
+#include "bit.h"
 #include "board.h"
 #include "const.h"
 #include "empty.h"
@@ -44,7 +45,7 @@ typedef struct Result {
 	int move;                    /**< best move found */
 	int score;                   /**< best score */
 	Bound bound[BOARD_SIZE + 2]; /**< score bounds / move */
-	Line pv[1];                  /**< principal variation */
+	Line pv;                     /**< principal variation */
 	long long time;              /**< searched time */
 	unsigned long long n_nodes;  /**< searched node count */
 	bool book_move;              /**< book move origin */
@@ -55,25 +56,28 @@ typedef struct Result {
 
 /** levels */
 extern struct Level {
-	int depth;         /** search depth */
-	int selectivity;   /** search selectivity level */
+	unsigned char depth;         /** search depth */
+	unsigned char selectivity;   /** search selectivity level */
 } LEVEL[61][61];
 
 
 /** search stare */
 typedef struct Search {
-	Board board[1];                               /**< othello board */
+	Board board;                                  /**< othello board (16) */
+
+	volatile unsigned long long n_nodes;          /**< node counter (8) */
+	volatile unsigned long long child_nodes;      /**< node counter (8) */
+
+	Eval eval;                                    /**< eval */
+
 	SquareList empties[BOARD_SIZE + 2];           /**< list of empty squares */
-	SquareList *x_to_empties[BOARD_SIZE + 2];     /**< link position to the list */
-	int n_empties;                                /**< number of empty squares */
 	int player;                                   /**< player color */
 	int id;                                       /**< search id */
 
-	HashTable hash_table[1];                      /**< hashtable */
-	HashTable pv_table[1];                        /**< hashtable for the pv */
-	HashTable shallow_table[1];                   /**< hashtable for short search */
-	Eval eval[1];                                 /**< eval */
-	Random random[1];                             /**< random generator */
+	HashTable hash_table;                         /**< hashtable */
+	HashTable pv_table;                           /**< hashtable for the pv */
+	HashTable shallow_table;                      /**< hashtable for short search */
+	Random random;                                /**< random generator */
 
 	struct TaskStack *tasks;                      /**< available task queue */
 	struct Task *task;                            /**< search task */
@@ -86,7 +90,6 @@ typedef struct Search {
 	int depth;                                    /**< depth level */
 	int selectivity;                              /**< selectivity level */
 	int probcut_level;                            /**< probcut recursivity level */
-	unsigned int parity;                          /**< parity */
 	int depth_pv_extension;                       /**< depth for pv_extension */
 	volatile Stop stop;                           /**< thinking status */
 	bool allow_node_splitting;                    /**< allow parallelism */
@@ -98,7 +101,7 @@ typedef struct Search {
 		long long  mini;                          /**< minimal alloted time */
 		long long  maxi;                          /**< maximal alloted time */
 	} time;                                       /**< time */
-	MoveList movelist[1];                         /**< list of moves */
+	MoveList movelist;                            /**< list of moves */
 	int height;                                   /**< search height from root */
 	NodeType node_type[GAME_SIZE];                /**< node type (pv node, cut node, all node) */
 	Bound stability_bound;                        /**< score bounds according to stable squares */
@@ -114,26 +117,23 @@ typedef struct Search {
 		const char *separator;                    /**< separator for search output */
 		bool guess_pv;                            /**< guess PV (in cassio mode only) */
 		int multipv_depth;                        /**< multi PV depth */
-		int hash_size;                            /**< hashtable size */                    
+		int hash_size;                            /**< hashtable size */
 	} options;                                    /**< local (threadable) options. */
 
 	Result *result;                               /**< shared result */
 
 	void (*observer)(Result*);                    /**< call back function to print search result */
-
-	volatile unsigned long long n_nodes;          /**< node counter */
-	volatile unsigned long long child_nodes;      /**< node counter */
-
 } Search;
 
 struct Node;
 
-extern const int QUADRANT_ID[];
+extern const unsigned char QUADRANT_ID[];
+extern const unsigned long long quadrant_mask[];
 extern const Selectivity selectivity_table[];
 extern const int NO_SELECTIVITY;
-extern const int NWS_STABILITY_THRESHOLD[];
-extern const int PVS_STABILITY_THRESHOLD[];
-extern const int SQUARE_TYPE[];
+// extern const signed char NWS_STABILITY_THRESHOLD[];
+extern const signed char PVS_STABILITY_THRESHOLD[];
+extern const unsigned char SQUARE_TYPE[];
 
 /* function definition */
 void search_global_init(void);
@@ -159,13 +159,13 @@ void search_set_task_number(Search*, const int);
 
 void search_swap_parity(Search*, const int);
 void search_get_movelist(const Search*, MoveList*);
-void search_update_endgame(Search*, const Move*);
-void search_restore_endgame(Search*, const Move*);
-void search_pass_endgame(Search*);
+// void search_update_endgame(Search*, const Move*);
+// void search_restore_endgame(Search*, const Move*);
+// void search_pass_endgame(Search*);
 void search_update_midgame(Search*, const Move*);
-void search_restore_midgame(Search*, const Move*);
-void search_update_pass_midgame(Search*);
-void search_restore_pass_midgame(Search*);
+void search_restore_midgame(Search*, int, const Eval*);
+void search_update_pass_midgame(Search*, Eval*);
+void search_restore_pass_midgame(Search*, const Eval*);
 long long search_clock(Search*);
 long long search_time(Search*);
 unsigned long long search_count_nodes(Search*);
@@ -175,30 +175,31 @@ int get_pv_extension(const int, const int);
 
 void result_print(Result*, FILE*);
 
-bool search_SC_PVS(Search*, volatile int*, volatile int*, int*);
+// bool search_SC_PVS(Search*, int*, int*, int*);
 bool search_SC_NWS(Search*, const int, int*);
-bool search_TC_PVS(HashData*, const int, const int, volatile int*, volatile int*, int*);
+bool search_SC_NWS_4(Search*, const int, int*);
+// bool search_TC_PVS(HashData*, const int, const int, int*, int*, int*);
 bool search_TC_NWS(HashData*, const int, const int, const int, int*);
-bool search_ETC_PVS(Search*, MoveList*, unsigned long long, const int, const int, volatile int*, volatile int*, int*);
+// bool search_ETC_PVS(Search*, MoveList*, unsigned long long, const int, const int, int*, int*, int*);
 bool search_ETC_NWS(Search*, MoveList*, unsigned long long, const int, const int, const int, int*);
 
 NodeType next_node_type(const NodeType parent, const bool first_move);
 
 int search_solve(const Search*);
 int search_solve_0(const Search*);
-extern int board_score_1(const Board*, const int, const int);
+extern int board_score_1(const unsigned long long, const int, const int);
 int NWS_endgame(Search*, const int);
 
 int search_eval_0(Search*);
-int search_eval_1(Search*, const int, int);
-int search_eval_2(Search*, int, const int);
+int search_eval_1(Search*, int, int, unsigned long long);
+int search_eval_2(Search*, int, int, unsigned long long);
 int NWS_midgame(Search*, const int, int, struct Node*);
 int PVS_midgame(Search*, const int, const int, int, struct Node*);
-int NWS_shallow(Search*, const int, int, HashTable*);
+// static int NWS_shallow(Search*, const int, int, HashTable*);
 int PVS_shallow(Search*, int, int, int);
 
 bool is_pv_ok(Search*, int, int);
-void record_best_move(Search*, const Board*, const Move*, const int, const int, const int);
+void record_best_move(Search*, const Move*, const int, const int, const int);
 int PVS_root(Search*, const int, const int, const int);
 int aspiration_search(Search*, int, int, const int, int);
 void iterative_deepening(Search*, int, int);
@@ -220,5 +221,36 @@ int search_get_pv_cost(Search*);
 void show_current_move(FILE *f, Search*, const Move*, const int, const int, const bool);
 int search_bound(const Search*, int);
 
+#if defined(hasSSE2) || defined(__ARM_NEON) || defined(USE_GAS_MMX) || defined(USE_MSVC_X86) || defined(ANDROID)
+  #ifdef __AVX2__
+	#define	mm_malloc(s)	_mm_malloc((s), 32)
+	#define	mm_free(p)	_mm_free(p)
+  #elif defined(hasSSE2) && !defined(ANDROID)
+	#define	mm_malloc(s)	_mm_malloc((s), 16)
+	#define	mm_free(p)	_mm_free(p)
+  #elif defined(_MSC_VER)
+	#define	mm_malloc(s)	_aligned_malloc((s), 16)
+	#define	mm_free(p)	_aligned_free(p)
+  #else
+	static inline void *mm_malloc(size_t s) {
+		void *p = malloc(s + 16 + sizeof(void *));
+		if (!p) return p;
+		void **q = (void **)(((size_t) p + 15 + sizeof(void *)) & -16);
+		*(q - 1) = p;
+		return (void *) q;
+	}
+	#define mm_free(p)	free(*((void **)(p) - 1));
+  #endif
+#else
+	#define	mm_malloc(s)	malloc(s)
+	#define	mm_free(p)	free(p)
+#endif
+
+#ifdef hasSSE2	// search->board is aligned
+	#define	search_pass(search)	_mm_store_si128((__m128i *) &(search)->board, _mm_shuffle_epi32(*(__m128i *) &(search)->board, 0x4e))
+#else
+	#define	search_pass(search)	board_pass(&(search)->board)
+#endif
+
 #endif
 
diff --git a/src/settings.h b/src/settings.h
index 35db9f6a..d007b7bd 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -3,9 +3,9 @@
  *
  * Various macro / constants to control algorithm usage.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2024
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 
@@ -14,14 +14,61 @@
 
 #include <stdbool.h>
 
-#define MOVE_GENERATOR_CARRY 1
-#define MOVE_GENERATOR_KINDERGARTEN 2
-#define MOVE_GENERATOR_SSE 3
-#define MOVE_GENERATOR_BITSCAN 4
-#define MOVE_GENERATOR_ROXANE 5
+#define MOVE_GENERATOR_CARRY 1		// 32.6Mnps
+#define MOVE_GENERATOR_KINDERGARTEN 2	// 31.1Mnps
+#define MOVE_GENERATOR_SSE 3		// 34.4Mnps	// best for generic X64
+#define MOVE_GENERATOR_BITSCAN 4	// 32.7Mnps	// best for AMD K10/FX	// 7.21Mnps (neon_bitscan)
+#define MOVE_GENERATOR_ROXANE 5		// 29.0Mnps
+#define MOVE_GENERATOR_32 6		// 31.3Mnps	// best for 32bit X86
+#define MOVE_GENERATOR_SSE_BSWAP 7	// 30.6Mnps
+#define MOVE_GENERATOR_AVX 8		// 34.7Mnps	// best for modern X64
+#define MOVE_GENERATOR_AVX512 9
+#define MOVE_GENERATOR_NEON 10		// 6.71Mnps (neon_rbit), 6.51Mnps (neon_lzcnt), 6.17Mnps (neon_ppfill)
+#define MOVE_GENERATOR_SVE 11
+
+#define COUNT_LAST_FLIP_CARRY 1		// 33.8Mnps
+#define COUNT_LAST_FLIP_KINDERGARTEN 2	// 33.5Mnps
+#define COUNT_LAST_FLIP_SSE 3		// 34.7Mnps
+#define COUNT_LAST_FLIP_BITSCAN 4	// 33.9Mnps
+#define COUNT_LAST_FLIP_PLAIN 5		// 33.3Mnps
+#define COUNT_LAST_FLIP_32 6		// 33.1Mnps
+#define COUNT_LAST_FLIP_BMI2 7		// 34.7Mnps	// slow on AMD
+#define COUNT_LAST_FLIP_AVX_PPFILL 8
+#define COUNT_LAST_FLIP_AVX512 9
+#define COUNT_LAST_FLIP_NEON 10
+#define COUNT_LAST_FLIP_SVE 11
 
 /**move generation. */
-#define MOVE_GENERATOR MOVE_GENERATOR_CARRY
+#ifndef MOVE_GENERATOR
+	#if defined(__AVX512VL__) || defined(__AVX10_1__)
+		#define MOVE_GENERATOR MOVE_GENERATOR_AVX512
+	#elif defined(__AVX2__)
+		#define MOVE_GENERATOR MOVE_GENERATOR_AVX
+	#elif defined(__SSE2__) || defined(_M_X64) || defined(hasSSE2)
+		#define MOVE_GENERATOR MOVE_GENERATOR_SSE
+	#elif defined(__ARM_FEATURE_SVE)
+		#define MOVE_GENERATOR MOVE_GENERATOR_SVE
+	#elif defined(__aarch64__) || defined(_M_ARM64) || defined(__ARM_NEON)
+		#define MOVE_GENERATOR MOVE_GENERATOR_NEON
+	#elif defined(__arm__) || defined(_M_ARM)
+		#define MOVE_GENERATOR MOVE_GENERATOR_BITSCAN
+	#else
+		#define MOVE_GENERATOR MOVE_GENERATOR_32
+	#endif
+#endif
+#ifndef LAST_FLIP_COUNTER
+	#if (defined(__AVX512VL__) || defined(__AVX10_1__)) && (defined(SIMULLASTFLIP512) || defined(SIMULLASTFLIP) || defined(LASTFLIP_HIGHCUT))
+		#define LAST_FLIP_COUNTER COUNT_LAST_FLIP_AVX512
+	#elif defined(__SSE2__) || defined(_M_X64) || defined(hasSSE2)
+		#define LAST_FLIP_COUNTER COUNT_LAST_FLIP_SSE
+	#elif defined(__aarch64__) || defined(_M_ARM64) || defined(__ARM_NEON)
+		#define LAST_FLIP_COUNTER COUNT_LAST_FLIP_NEON
+	#elif defined(__arm__) || defined(_M_ARM)
+		#define LAST_FLIP_COUNTER COUNT_LAST_FLIP_BITSCAN
+	#else
+		#define LAST_FLIP_COUNTER COUNT_LAST_FLIP_32
+	#endif
+#endif
 
 /** transposition cutoff usage. */
 #define USE_TC true
@@ -63,11 +110,9 @@
 
 /** Allow type puning */
 #ifndef USE_TYPE_PUNING
-#ifdef ANDROID
-#define USE_TYPE_PUNING false
-#else
-#define USE_TYPE_PUNING true
-#endif
+// #ifndef ANDROID
+#define USE_TYPE_PUNING 1
+// #endif
 #endif
 
 /** Hash-n-way. */
@@ -94,6 +139,9 @@
 /** Try ETC down to this depth. */
 #define ETC_MIN_DEPTH 5
 
+/** Dogaishi hash reduction Depth (before DEPTH_TO_SHALLOW_SEARCH) */
+#define MASK_SOLID_DEPTH 9
+
 /** bound for usefull move sorting */
 #define SORT_ALPHA_DELTA 8
 
diff --git a/src/stats.h b/src/stats.h
index bc6f6092..792ed145 100644
--- a/src/stats.h
+++ b/src/stats.h
@@ -3,7 +3,7 @@
  *
  * @brief Statistics header.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -37,24 +37,26 @@
 
 #if COUNT_NODES & 1
 	/** node counter for internal nodes */
-	#define SEARCH_UPDATE_INTERNAL_NODES() (++search->n_nodes)
+	#define SEARCH_UPDATE_INTERNAL_NODES(x) (++(x))
+	#define SEARCH_UPDATE_2EMPTIES_NODES(x) x
 #else
 	/** no node counter for internal nodes */
-	#define SEARCH_UPDATE_INTERNAL_NODES()
+	#define SEARCH_UPDATE_INTERNAL_NODES(x)
+	#define SEARCH_UPDATE_2EMPTIES_NODES(x)
 #endif
 #if COUNT_NODES & 2
 	/** node counter for pattern changes */
-	#define SEARCH_UPDATE_EVAL_NODES() (++search->n_nodes)
+	#define SEARCH_UPDATE_EVAL_NODES(x) (++(x))
 #else
 	/** no node counter for pattern changes */
-	#define SEARCH_UPDATE_EVAL_NODES()
+	#define SEARCH_UPDATE_EVAL_NODES(x)
 #endif
 #if COUNT_NODES & 4
 	/** more general node counter */
-	#define SEARCH_UPDATE_ALL_NODES() (++search->n_nodes)
+	#define SEARCH_UPDATE_ALL_NODES(x) (++(x))
 #else
 	/** no general node counter */
-	#define SEARCH_UPDATE_ALL_NODES()
+	#define SEARCH_UPDATE_ALL_NODES(x)
 #endif
 
 /** \struct Statistics */
diff --git a/src/ui.c b/src/ui.c
index 80351afd..b23071e2 100644
--- a/src/ui.c
+++ b/src/ui.c
@@ -3,7 +3,7 @@
  *
  * @brief User interface.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -74,8 +74,8 @@ static void ui_read_input(UI *ui)
 {
 	char *buffer;
 	char cmd[8];
-	Event *event = ui->event;
-	Play *play = ui->play;
+	Event *const event = &ui->event;
+	Play *const play = ui->play;
 
 	buffer = string_read_line(stdin);
 
@@ -125,9 +125,9 @@ static void ui_read_input(UI *ui)
  */
 static void* ui_read_input_loop(void *v)
 {
-	UI *ui = (UI*) v;
+	UI *const ui = (UI*) v;
 
-	while (ui->event->loop && !feof(stdin) && !ferror(stdin)) {
+	while (ui->event.loop && !feof(stdin) && !ferror(stdin)) {
 		ui_read_input(ui);
 	}
 
@@ -146,7 +146,7 @@ static void* ui_read_input_loop(void *v)
  */
 void ui_event_wait(UI *ui, char **cmd, char **param)
 {
-	event_wait(ui->event, cmd, param);
+	event_wait(&ui->event, cmd, param);
 	if (options.echo && *cmd) printf(" %s %s\n", *cmd, *param ? *param : "");
 }
 
@@ -162,7 +162,7 @@ bool ui_event_peek(UI *ui, char **cmd, char **param)
 	int n;
 	char *message;
 
-	if ((message = event_peek_message(ui->event)) != NULL) {
+	if ((message = event_peek_message(&ui->event)) != NULL) {
 
 		free(*cmd); *cmd = NULL;
 		free(*param); *param = NULL;
@@ -190,9 +190,9 @@ bool ui_event_exist(UI *ui)
 {
 	bool ok;
 
-	spin_lock(ui->event);
-	ok = event_exist(ui->event);
-	spin_unlock(ui->event);	
+	spin_lock(&ui->event);
+	ok = event_exist(&ui->event);
+	spin_unlock(&ui->event);	
 
 	return ok;
 }
@@ -205,10 +205,10 @@ bool ui_event_exist(UI *ui)
  */
 void ui_event_init(UI *ui)
 {
-	event_init(ui->event);
+	event_init(&ui->event);
 	
-	thread_create(&ui->event->thread, ui_read_input_loop, ui);
-	thread_detach(ui->event->thread);
+	thread_create(&ui->event.thread, ui_read_input_loop, ui);
+	thread_detach(ui->event.thread);
 }
 
 /**
@@ -219,5 +219,5 @@ void ui_event_init(UI *ui)
  */
 void ui_event_free(UI *ui)
 {
-	event_free(ui->event);
+	event_free(&ui->event);
 }
diff --git a/src/ui.h b/src/ui.h
index 4efa3af5..b4aa5b40 100644
--- a/src/ui.h
+++ b/src/ui.h
@@ -24,12 +24,12 @@
  */
 typedef struct UI {
 	Play play[2];              /**< Play Control */
-	Book book[1];              /**< Opening book */
+	Book book;                 /**< Opening book */
 	struct GGSClient *ggs;     /**< GGS Client */
 	bool is_same_play;         /**< true if play[0] == play[1] */
 	int type;                  /**< type of UI */
 	int mode;                  /**< computer's color mode TODO: remove me*/
-	Event event[1];            /**< event */
+	Event event;               /**< event */
 
 	void (*init)(struct UI*);  /**< init function */
 	void (*loop)(struct UI*);  /**< main loop function */
diff --git a/src/util.c b/src/util.c
index ca5c11f3..cbbc9691 100644
--- a/src/util.c
+++ b/src/util.c
@@ -6,9 +6,9 @@
  * This should be the only file with linux/windows
  * dedicated code.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "bit.h"
@@ -158,7 +158,8 @@ long long time_read(FILE *f)
 	long long t = 0;
 	int n, c;
 
-	while (isspace(c = getc(f)));
+	while (isspace(c = getc(f)))
+		;
 	ungetc(c, f);
 	n = 0; while (isdigit(c = getc(f))) n = n * 10 + (c - '0');
 	if (c == ':') {
@@ -221,8 +222,14 @@ void relax(int t)
  */
 char* format_scientific(double v, const char *unit, char *f)
 {
-	static const char *multiple = "EPTGMk mµnpfa"; //
-	int u;
+#ifdef UNICODE
+	static const wchar_t multiple[] = L"EPTGMK mμnpfa"; // μ:U+03BC
+	static const char fmt[] = " %5.*f %lc%s";
+#else
+	static const char multiple[] = "EPTGMK mμnpfa"; // μ:B5@CP1252
+	static const char fmt[] = " %5.*f %c%s";
+#endif
+	int u, d;
 
 	if (fabs(v) < 1e-24) {
 		u = 0;
@@ -231,11 +238,12 @@ char* format_scientific(double v, const char *unit, char *f)
 		if (u > 6) u = 6; else if (u < -6) u = -6;
 		v /= pow(10, 3 * u);
 	}
-	
-	if (fabs(v) - floor(fabs(v)) < 0.01) sprintf(f, " %5.1f %c%s", v, multiple[6 - u], unit);
-	else if (fabs(v + 0.05) < 10.0) sprintf(f, " %5.3f  %c%s", v, multiple[6 - u], unit);
-	else if (fabs(v + 0.5) < 100.0) sprintf(f, " %5.2f  %c%s", v, multiple[6 - u], unit);
-	else sprintf(f, " %5.1f  %c%s", v, multiple[6 - u], unit);
+
+	if (fabs(v) - floor(fabs(v)) < 0.01) d = 1;
+	else if (fabs(v + 0.05) < 10.0) d = 3;
+	else if (fabs(v + 0.5) < 100.0) d = 2;
+	else d = 1;
+	sprintf(f, fmt, d, v, multiple[6 - u], unit);
 
 	return f;
 }
@@ -250,7 +258,7 @@ char* format_scientific(double v, const char *unit, char *f)
 void print_scientific(double v, const char *unit, FILE *f)
 {
 	char s[32];
-	fprintf(f, "%s", format_scientific(v, unit, s));
+	fputs(format_scientific(v, unit, s), f);
 }
 
 
@@ -564,8 +572,8 @@ char* parse_word(const char *string, char *word, unsigned int n)
 	if (string) {
 		string = parse_skip_spaces(string);
 		while (*string && !isspace(*string) && n--) *word++ = *string++;
-		*word = '\0';
 	}
+	*word = '\0';
 	return (char*) string;
 }
 
@@ -585,8 +593,8 @@ char* parse_field(const char *string, char *word, unsigned int n, char separator
 		string = parse_skip_spaces(string);
 		while (*string && *string != separator && n--) *word++ = *string++;
 		if (*string == separator) ++string;
-		*word = '\0';
 	}
+	*word = '\0';
 	return (char*) string;
 }
 
@@ -626,16 +634,18 @@ char* parse_line(const char *string, char *line, unsigned int n)
  */
 char* parse_move(const char *string, const Board *board, Move *move)
 {
-
 	*move = MOVE_INIT;
 
 	if (string) {
 		char *word = parse_skip_spaces(string);
 		int x = string_to_coordinate(word);
 		move->x = x;
-		move->flipped = flip[x](board->player, board->opponent);
-		if ((x == PASS && board_is_pass(board)) || (move->flipped && !board_is_occupied(board, x))) return word + 2;
-		else if (board_is_pass(board)) {
+		move->flipped = board_flip(board, x);
+		if (move->flipped && !board_is_occupied(board, x)) {
+			return word + 2;
+		} else if (board_is_pass(board)) {
+			if (x == PASS)
+				return word + 2;
 			move->x = PASS;
 			move->flipped = 0;
 		} else {
@@ -657,14 +667,14 @@ char* parse_move(const char *string, const Board *board, Move *move)
 char* parse_game(const char *string, const Board *board_init, Line *line)
 {
 	const char *next;
-	Board board[1];
-	Move move[1];
+	Board board;
+	Move move;
 
-	*board = *board_init;
+	board = *board_init;
 
-	while ((next = parse_move(string, board, move)) != string || move->x == PASS) {
-		line_push(line, move->x);
-		board_update(board, move);
+	while ((next = parse_move(string, &board, &move)) != string || move.x == PASS) {
+		line_push(line, move.x);
+		board_update(&board, &move);
 		string = next;
 	}
 
@@ -683,34 +693,34 @@ char* parse_board(const char *string, Board *board, int *player)
 {
 	if (string) {
 		int i;
-		const char *s = parse_skip_spaces(string);
+		unsigned long long b = 1;
+		const char *s = string;
 
 		board->player = board->opponent = 0;
 		for (i = A1; i <= H8; ++i) {
-			if (*s == '\0') return (char*) string;
+			s = parse_skip_spaces(s);
 			switch (tolower(*s)) {
 			case 'b':
 			case 'x':
 			case '*':
-				board->player |= x_to_bit(i);
+				board->player |= b;
 				break;
 			case 'o':
 			case 'w':
-				board->opponent |= x_to_bit(i);
+				board->opponent |= b;
 				break;
 			case '-':
 			case '.':
 				break;
 			default:
-				if (!isspace(*s)) return (char*) string;
-				i--;
-				break;
+				return (char*) string;
 			}
 			++s;
+			b <<= 1;
 		}
 		board_check(board);
 
-		for (;*s; ++s) {
+		for (; *s; ++s) {
 			switch (tolower(*s)) {
 			case 'b':
 			case 'x':
@@ -765,7 +775,7 @@ char* parse_int(const char *string, int *result)
 		char *end = s;
 		long long n = 0;
 
-		if (s) n = strtol(s, &end, 10);
+		if (*s) n = strtol(s, &end, 10);
 
 		if (end == s) {
 			errno = EINVAL;
@@ -925,7 +935,7 @@ void thread_create(Thread *thread, void* (*function)(void*), void *data)
 	pthread_create(thread, NULL, function, data);
 #elif defined(_WIN32)
 	DWORD id;
-	*thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) function, data, 0, &id);
+	*thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(void (*)(void)) function, data, 0, &id);
 #endif
 }
 
@@ -966,7 +976,7 @@ Thread thread_self(void)
  */
 void thread_set_cpu(Thread thread, int i)
 {
-#if defined(__linux__) && !defined(ANDROID)
+#if defined(__linux__) && defined(CPU_SET)
 	cpu_set_t cpu;
 
 	CPU_ZERO(&cpu);
diff --git a/src/util.h b/src/util.h
index bae8c384..e6bba73d 100644
--- a/src/util.h
+++ b/src/util.h
@@ -3,7 +3,7 @@
  *
  * @brief Miscellaneous utilities header.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  */
@@ -252,11 +252,11 @@ typedef CRITICAL_SECTION Lock;
 typedef CRITICAL_SECTION SpinLock;
 
 /** Some buggy compilers need the following declarations */
-#if defined(_WIN64)
+#if defined __MINGW32__ && (_WIN32_WINNT < 0x0600)
 
-#ifndef _MSC_VER
-
-//typedef DWORD CONDITION_VARIABLE;
+#if (__MINGW64_VERSION_MAJOR < 3)
+typedef DWORD CONDITION_VARIABLE;
+#endif
 void InitializeConditionVariable(CONDITION_VARIABLE*);
 void WakeConditionVariable(CONDITION_VARIABLE*);
 void WakeAllConditionVariable(CONDITION_VARIABLE*);
@@ -264,6 +264,8 @@ BOOL SleepConditionVariableCS(CONDITION_VARIABLE*, CRITICAL_SECTION*, DWORD);
 
 #endif
 
+#if defined(_WIN64) || defined(_WIN32)
+
 /** Typedef to a personalized Condition type for portability */
 typedef CONDITION_VARIABLE Condition;
 
diff --git a/src/xboard.c b/src/xboard.c
index 35602203..63415d63 100644
--- a/src/xboard.c
+++ b/src/xboard.c
@@ -5,7 +5,7 @@
  *
  * Of course, only the "reversi" variant is supported.
  *
- * @date 1998 - 2017
+ * @date 1998 - 2020
  * @author Richard Delorme
  * @version 4.4
  *
@@ -45,7 +45,7 @@ static void xboard_observer(Result *result)
 	printf("%10lld ", result->n_nodes);
 	if (result->selectivity < 5) printf("@%2d%% ", selectivity_table[result->selectivity].percent);	
 	if (result->book_move) putchar('(');
-	line_print(result->pv, -200, " ", stdout);
+	line_print(&result->pv, -200, " ", stdout);
 	if (result->book_move) putchar(')');
 	putchar('\n');
 	fflush(stdout);
@@ -57,7 +57,7 @@ static void xboard_observer(Result *result)
 		fprintf(xboard_log->f, "%10lld ", result->n_nodes);
 		if (result->selectivity < 5) fprintf(xboard_log->f, "@%2d%% ", selectivity_table[result->selectivity].percent);	
 		if (result->book_move) fputc('(', xboard_log->f);
-		line_print(result->pv, -200, " ", xboard_log->f);
+		line_print(&result->pv, -200, " ", xboard_log->f);
 		if (result->book_move) fputc(')', xboard_log->f);
 		putc('\n', xboard_log->f);
 		fflush(xboard_log->f);
@@ -71,21 +71,21 @@ static void xboard_observer(Result *result)
  */
 void ui_init_xboard(UI *ui)
 {
-	Play *play = ui->play;
-	Search *search = play->search;
+	Play *const play = ui->play;
+	Search *const search = &play->search;
 
-	play_init(play, ui->book);
-	play->initial_player = board_from_FEN(play->initial_board, "8/8/8/3Pp3/3pP3/8/8/8 w - - 0 1");
+	play_init(play, &ui->book);
+	play->initial_player = board_from_FEN(&play->initial_board, "8/8/8/3Pp3/3pP3/8/8/8 w - - 0 1");
 	play_new(play);
 	search->options.header = NULL;
 	search->options.separator = NULL;
-	ui->book->search = search;
-	book_load(ui->book, options.book_file);
+	ui->book.search = search;
+	book_load(&ui->book, options.book_file);
 	search->id = 1;
 	search_set_observer(search, xboard_observer);
 	options.level = 60;
 	play->type = ui->type;
-	play->ponder->verbose = true;
+	play->ponder.verbose = true;
 
 	log_open(xboard_log, options.ui_log_file);
 }
@@ -96,8 +96,8 @@ void ui_init_xboard(UI *ui)
  */
 void ui_free_xboard(UI *ui)
 {
-	if (ui->book->need_saving) book_save(ui->book, options.book_file);
-	book_free(ui->book);
+	if (ui->book.need_saving) book_save(&ui->book, options.book_file);
+	book_free(&ui->book);
 	play_free(ui->play);
 	log_close(xboard_log);
 }
@@ -155,7 +155,7 @@ static void xboard_setup(Play *play)
 {
 	char fen[120];
 
-	xboard_send("setup (P.....p.....) %s\n", board_to_FEN(play->board, play->player, fen));
+	xboard_send("setup (P.....p.....) %s\n", board_to_FEN(&play->board, play->player, fen));
 }
 
 /**
@@ -190,7 +190,7 @@ static void xboard_move(const int x)
  */
 static void xboard_hint(Play *play)
 {
-	const int x = search_guess(play->search, play->board);
+	const int x = search_guess(&play->search, &play->board);
 
 	if (x == NOMOVE) return;
 	
@@ -218,12 +218,11 @@ static void xboard_hint(Play *play)
  * @param play Play engine.
  */
 static void xboard_book(Play *play) {
-	Board *board = play->board;
-	Book *book = play->book;
-	MoveList movelist[1];
+	Book *const book = play->book;
+	MoveList movelist;
 	Move *move;
 
-	if (book_get_moves(book, board, movelist)) {
+	if (book_get_moves(book, &play->board, &movelist)) {
 		printf("\tBook:");
 		foreach_move(move, movelist) {
 			printf("  P@"); move_print(move->x, 1, stdout);
@@ -239,7 +238,7 @@ static void xboard_book(Play *play) {
 			}
 			putc('\n', xboard_log->f);
 			fflush(xboard_log->f);
-		}		
+		}
 	}
 }
 
@@ -251,14 +250,13 @@ static void xboard_book(Play *play) {
 static void xboard_check_game_over(Play *play)
 {
 	int n_discs[2];
-	const Board *board = play->board;
 	const char *(color[2]) = {"Black", "White"};
 	const int player = WHITE; // !!!!
 	const int opponent = !player;
 
 	if (play_is_game_over(play)) {
-		n_discs[play->player] = bit_count(board->player);
-		n_discs[!play->player] = bit_count(board->opponent);
+		n_discs[play->player] = bit_count(play->board.player);
+		n_discs[!play->player] = bit_count(play->board.opponent);
 		if (n_discs[player] > n_discs[opponent]) xboard_send("1-0 {%s wins %d-%d}\n", color[player], n_discs[player], n_discs[opponent]);
 		else if (n_discs[player] < n_discs[opponent]) xboard_send("0-1 {%s wins %d-%d}\n", color[opponent], n_discs[opponent], n_discs[player]);
 		else xboard_send("1/2-1/2 {Draw %d-%d}\n", n_discs[player], n_discs[opponent]);
@@ -282,9 +280,9 @@ static inline int hash_size(int n)
  */
 static void xboard_go(UI *ui, XBoardStats *stats)
 {
-	Play *play = ui->play;
-	Search *search = play->search;
-	Result *result = search->result;
+	Play *const play = ui->play;
+	Search *const search = &play->search;
+	Result *const result = search->result;
 
 	play_go(play, true);
 	xboard_move(play_get_last_move(play)->x);
@@ -303,7 +301,7 @@ static void xboard_go(UI *ui, XBoardStats *stats)
 		fprintf(xboard_log->f, "edax search> time spent = %.2f; depth reached = %d@%d%%; nodes = %lld\n",
 			0.001 * result->time,  result->depth, selectivity_table[result->selectivity].percent, result->n_nodes);
 		fprintf(xboard_log->f, "edax search> best score = %d; pv = ", result->score);
-		line_print(result->pv, 100, NULL, xboard_log->f);
+		line_print(&result->pv, 100, NULL, xboard_log->f);
 		putc('\n', xboard_log->f);
 		fflush(xboard_log->f);
 	}
@@ -322,13 +320,13 @@ void xboard_stop_analyzing(Play *play)
 {
 	while (play->state == IS_ANALYZING) {
 		log_print(xboard_log, "edax (analyze)> stop\n");
-		search_stop_all(play->search, STOP_PONDERING);
+		search_stop_all(&play->search, STOP_PONDERING);
 		relax(10);
 	}
 
-	if (play->ponder->launched) {
-		thread_join(play->ponder->thread);
-		play->ponder->launched = false;
+	if (play->ponder.launched) {
+		thread_join(play->ponder.thread);
+		play->ponder.launched = false;
 		log_print(xboard_log, "edax (analyze)> stopped\n");
 	}
 }
@@ -348,12 +346,12 @@ static void xboard_analyze(Play *play)
 
 	if (play_is_game_over(play)) return;
 	if (play->state == IS_WAITING) {
-		play->ponder->board->player = play->ponder->board->opponent = 0;
-		play->state = IS_ANALYZING;		
-		search_cleanup(play->search);
+		play->ponder.board.player = play->ponder.board.opponent = 0;
+		play->state = IS_ANALYZING;
+		search_cleanup(&play->search);
 		log_print(xboard_log, "edax (analyze)> start\n");
-		thread_create(&play->ponder->thread, play_ponder_run, play);
-		play->ponder->launched = true;
+		thread_create(&play->ponder.thread, play_ponder_run, play);
+		play->ponder.launched = true;
 	}
 }
 
@@ -368,7 +366,7 @@ static void xboard_loop_analyze(UI *ui)
 {
 	Play *play = ui->play;
 	char *cmd = NULL, *param = NULL;
-	Search *search = play->search;
+	Search *const search = &play->search;
 
 	play_stop_pondering(play);
 	xboard_analyze(play);
@@ -440,7 +438,7 @@ static void xboard_loop_analyze(UI *ui)
 void ui_loop_xboard(UI *ui)
 {
 	char *cmd = NULL, *param = NULL;
-	Play *play = ui->play;
+	Play *const play = ui->play;
 	bool alien_variant = false;
 	XBoardStats stats = {0, 0, 0};
 	int edax_turn = EMPTY;
@@ -514,7 +512,7 @@ void ui_loop_xboard(UI *ui)
 			// new
 			} else if (strcmp(cmd, "new") == 0 ) {
 				options.level = 60;
-				play->initial_player = board_from_FEN(play->initial_board, "8/8/8/3Pp3/3pP3/8/8/8 w - - 0 1");
+				play->initial_player = board_from_FEN(&play->initial_board, "8/8/8/3Pp3/3pP3/8/8/8 w - - 0 1");
 				play_new(play);
 				edax_turn = !play->player;
 				if (alien_variant) xboard_setup(play);
@@ -705,14 +703,14 @@ void ui_loop_xboard(UI *ui)
 				BOUND(options.hash_table_size, 10, 30, "hash-table-size");
 				log_print(xboard_log, "edax setup> hash table size: 2**%d entries\n", options.hash_table_size);
 				play_stop_pondering(play);
-				search_resize_hashtable(play->search);
+				search_resize_hashtable(&play->search);
 			
 			} else if ((strcmp(cmd, "cores") == 0)) {
 				options.n_task = string_to_int(param, 1);
 				log_print(xboard_log, "edax setup> cores: %d\n", options.n_task);
-				if (search_count_tasks(play->search) != options.n_task) {
+				if (search_count_tasks(&play->search) != options.n_task) {
 					play_stop_pondering(play);
-					search_set_task_number(play->search, options.n_task);
+					search_set_task_number(&play->search, options.n_task);
 				}
 
 			} else if ((strcmp(cmd, "egtpath") == 0)) {
diff --git a/src/ybwc.c b/src/ybwc.c
index fc42ed61..8fd89251 100644
--- a/src/ybwc.c
+++ b/src/ybwc.c
@@ -22,9 +22,9 @@
  * ICCA Journal, Vol. 12, No. 2, pp. 65-73.
  * -# Feldmann R. (1993) Game-Tree Search on Massively Parallel System - PhD Thesis, Paderborn (English version).
  *
- * @date 1998 - 2017
+ * @date 1998 - 2023
  * @author Richard Delorme
- * @version 4.4
+ * @version 4.5
  */
 
 #include "ybwc.h"
@@ -119,7 +119,7 @@ static bool get_helper(Node *master, Node *node, Move *move)
 			lock(master);
 			if (master->n_slave && master->is_waiting && !master->is_helping) {
 				master->is_helping = true;
-				task = master->help;
+				task = &master->help;
 				task_init(task) ;
 				task->is_helping = true;
 				task->node = node;
@@ -230,9 +230,9 @@ void node_wait_slaves(Node* node)
 		condition_wait(node);
 
 		if (node->is_helping) {
-			assert(node->help->run);
-			task_search(node->help);
-			task_free(node->help);
+			assert(node->help.run);
+			task_search(&node->help);
+			task_free(&node->help);
 			node->is_helping = false;
 		} else {
 			node->is_waiting = false;
@@ -269,7 +269,7 @@ void node_update(Node* node, Move *move)
 		node->bestscore = score;
 		node->bestmove = move->x;
 		if (node->height == 0) {
-			record_best_move(search, search->board, move, node->alpha, node->beta, node->depth);
+			record_best_move(search, move, node->alpha, node->beta, node->depth);
 			search->result->n_moves_left--;
 		}
 		if (score > node->alpha) node->alpha = score;
@@ -365,6 +365,8 @@ void task_search(Task *task)
 	Node *node = task->node;
 	Search *search = task->search;
 	Move *move = task->move;
+	Eval eval0;
+	Board board0;
 	int i;
 
 	search_set_state(search, node->search->stop);
@@ -375,13 +377,16 @@ void task_search(Task *task)
 		const int alpha = node->alpha;
 		if (alpha >= node->beta) break;
 
+		board0 = search->board;
+		eval0 = search->eval;
 		search_update_midgame(search, move);
 			move->score = -NWS_midgame(search, -alpha - 1, node->depth - 1, node);
 			if (alpha < move->score && move->score < node->beta) {
 				move->score = -PVS_midgame(search, -node->beta, -alpha, node->depth - 1, node);
 				assert(node->pv_node == true);
 			}
-		search_restore_midgame(search, move);
+		search_restore_midgame(search, move->x, &eval0);
+		search->board = board0;
 		if (node->height == 0) {
 			move->cost = search_get_pv_cost(search);
 			move->score = search_bound(search, move->score);
@@ -393,7 +398,7 @@ void task_search(Task *task)
 			node->bestscore = move->score;
 			node->bestmove = move->x;
 			if (node->height == 0) {
-				record_best_move(search, search->board, move, alpha, node->beta, node->depth);
+				record_best_move(search, move, alpha, node->beta, node->depth);
 				search->result->n_moves_left--;
 				if (search->options.verbosity == 4) pv_debug(search, move, stdout);
 			}
@@ -482,14 +487,14 @@ static Search* task_search_create(Task *task)
 {
 	Search *search;
 
-	search = (Search*) malloc(sizeof (Search)); // allocate the search attached to this task
+	search = (Search*) mm_malloc(sizeof (Search)); // allocate the search attached to this task
 	if (search == NULL) {
 		fatal_error("task_init: cannot allocate the search position.\n");
 	}
 	search->n_nodes = 0;
 	search->n_child = 0;
 	search->parent = NULL;
-	eval_init(search->eval);
+	// eval_init(search->eval);
 	spin_init(search);
 	search->task = task;
 	search->stop = STOP_END;
@@ -504,9 +509,9 @@ static Search* task_search_create(Task *task)
  */
 static void task_search_destroy(Search *search)
 {
-	eval_free(search->eval);
+	// eval_free(search->eval);
 	spin_free(search);
-	free(search);
+	mm_free(search);
 }
 
 /**
diff --git a/src/ybwc.h b/src/ybwc.h
index 7b85e17a..716201d2 100644
--- a/src/ybwc.h
+++ b/src/ybwc.h
@@ -63,7 +63,7 @@ typedef struct Node {
 	volatile int n_moves_done;   /**< search done */
 	volatile int n_moves_todo;   /**< search todo */
 	volatile bool is_helping;	 /**< waiting flag */
-	Task help[1];                /**< helper task */
+	Task help;                   /**< helper task */
 	Lock lock;                   /**< mutex */
 	Condition cond;              /**< condition variable */
 } Node;