diff --git a/src/eval_constants.hpp b/src/eval_constants.hpp
index 1d0a188a..080de4fe 100644
--- a/src/eval_constants.hpp
+++ b/src/eval_constants.hpp
@@ -6,11 +6,11 @@ namespace Clockwork {
 
 // clang-format off
 inline const PParam PAWN_MAT   = S(183, 436);
-inline const PParam KNIGHT_MAT = S(836, 1255);
-inline const PParam BISHOP_MAT = S(870, 1315);
-inline const PParam ROOK_MAT   = S(1037, 2101);
-inline const PParam QUEEN_MAT  = S(2539, 3257);
-inline const PParam TEMPO_VAL  = S(60, 21);
+inline const PParam KNIGHT_MAT = S(834, 1255);
+inline const PParam BISHOP_MAT = S(873, 1317);
+inline const PParam ROOK_MAT   = S(1040, 2100);
+inline const PParam QUEEN_MAT  = S(2541, 3255);
+inline const PParam TEMPO_VAL  = S(31, 30);
 
 inline const PParam BISHOP_XRAY_PAWNS   = S(-13, 14);
 inline const PParam BISHOP_PAIR_VAL   = S(53, 220);
@@ -22,168 +22,170 @@ inline const PParam RESTRICTED_SQUARES = S(-23, -7);
 inline const PParam DOUBLED_PAWN_VAL = S(-13, -77);
 inline const PParam ISOLATED_PAWN_VAL = S(-17, -24);
 
-inline const PParam POTENTIAL_CHECKER_VAL = S(-50, -24);
+inline const PParam POTENTIAL_CHECKER_VAL = S(-50, -23);
 inline const PParam OUTPOST_KNIGHT_VAL    = S(52, 55);
 inline const PParam OUTPOST_BISHOP_VAL    = S(57, 39);
 
 inline const PParam PAWN_PUSH_THREAT_KNIGHT = S(37, 5);
-inline const PParam PAWN_PUSH_THREAT_BISHOP = S(45, -15);
-inline const PParam PAWN_PUSH_THREAT_ROOK   = S(24, 53);
-inline const PParam PAWN_PUSH_THREAT_QUEEN  = S(62, -42);
+inline const PParam PAWN_PUSH_THREAT_BISHOP = S(44, -15);
+inline const PParam PAWN_PUSH_THREAT_ROOK   = S(25, 52);
+inline const PParam PAWN_PUSH_THREAT_QUEEN  = S(61, -41);
 
 inline const std::array<PParam, 6> PAWN_PHALANX = {
-    S(16, 3), S(29, 35), S(58, 59), S(137, 167), S(364, 257), S(469, 510),
+    S(16, 3), S(29, 35), S(58, 59), S(138, 167), S(365, 256), S(470, 509),
 };
 inline const std::array<PParam, 5> DEFENDED_PAWN = {
-    S(44, 42), S(44, 34), S(60, 60), S(117, 162), S(413, 92),
+    S(44, 42), S(44, 34), S(60, 61), S(117, 163), S(413, 90),
 };
 inline const std::array<PParam, 6> PASSED_PAWN = {
-    S(-101, -216), S(-102, -183), S(-77, -62), S(-24, 50), S(64, 211), S(246, 301),
+    S(-103, -217), S(-104, -185), S(-78, -64), S(-26, 49), S(61, 210), S(251, 299),
 };
 inline const std::array<PParam, 6> DEFENDED_PASSED_PUSH = {
-    S(27, -41), S(23, -2), S(16, 33), S(5, 119), S(75, 236), S(171, 380),
+    S(27, -41), S(23, -2), S(16, 33), S(5, 119), S(76, 235), S(188, 378),
 };
 inline const std::array<PParam, 6> BLOCKED_PASSED_PAWN = {
-    S(15, -25), S(4, 19), S(1, -18), S(1, -46), S(-9, -136), S(-242, -244),
+    S(16, -26), S(5, 18), S(0, -17), S(1, -47), S(-9, -136), S(-250, -240),
 };
 
 inline const std::array<PParam, 8> FRIENDLY_KING_PASSED_PAWN_DISTANCE = {
-    S(0, 0), S(18, 206), S(-6, 176), S(1, 97), S(8, 58), S(15, 59), S(52, 55), S(43, 38),
+    S(0, 0), S(16, 205), S(-8, 174), S(-0, 95), S(8, 56), S(15, 57), S(51, 53), S(43, 36),
 };
 inline const std::array<PParam, 8> ENEMY_KING_PASSED_PAWN_DISTANCE = {
-    S(0, 0), S(-265, -48), S(-8, 34), S(-2, 96), S(35, 126), S(55, 150), S(65, 156), S(43, 155),
+    S(0, 0), S(-264, -45), S(-6, 37), S(-0, 98), S(37, 129), S(57, 153), S(68, 158), S(45, 158),
 };
 
 inline const std::array<PParam, 9> KNIGHT_MOBILITY = {
-    S(-102, -298), S(-40, -105), S(-11, -4), S(15, 33), S(44, 54), S(60, 88), S(80, 88), S(100, 98), S(132, 26),
+    S(-99, -298), S(-38, -106), S(-9, -4), S(16, 34), S(46, 54), S(61, 88), S(81, 88), S(101, 98), S(133, 26),
 };
 inline const std::array<PParam, 14> BISHOP_MOBILITY = {
-    S(-68, -274), S(-20, -99), S(31, -24), S(54, 25), S(75, 62), S(87, 90), S(92, 111), S(100, 123), S(102, 139), S(114, 129), S(118, 129), S(154, 80), S(159, 73), S(183, 26),
+    S(-67, -277), S(-21, -101), S(30, -26), S(53, 24), S(74, 60), S(86, 88), S(91, 109), S(99, 121), S(101, 137), S(113, 127), S(117, 127), S(153, 78), S(158, 71), S(181, 22),
 };
 inline const std::array<PParam, 15> ROOK_MOBILITY = {
-    S(105, -146), S(24, 26), S(45, 56), S(61, 67), S(71, 82), S(76, 95), S(81, 107), S(88, 110), S(93, 122), S(101, 125), S(108, 129), S(111, 136), S(113, 136), S(121, 112), S(191, 8),
+    S(104, -145), S(24, 26), S(45, 56), S(61, 67), S(71, 82), S(76, 95), S(81, 107), S(88, 110), S(93, 122), S(100, 125), S(108, 129), S(111, 136), S(113, 136), S(120, 112), S(189, 8),
 };
 inline const std::array<PParam, 28> QUEEN_MOBILITY = {
-    S(-163, -72), S(-33, 21), S(-8, 144), S(12, 256), S(27, 300), S(36, 344), S(41, 377), S(49, 385), S(52, 410), S(55, 426), S(61, 431), S(63, 441), S(68, 439), S(68, 446), S(70, 442), S(66, 446), S(64, 442), S(69, 428), S(73, 416), S(77, 403), S(75, 386), S(91, 343), S(73, 349), S(56, 299), S(27, 297), S(12, 268), S(-37, 286), S(-26, 222),
+    S(-162, -72), S(-32, 19), S(-7, 142), S(13, 256), S(27, 301), S(35, 346), S(41, 379), S(49, 388), S(52, 412), S(55, 428), S(60, 433), S(63, 444), S(68, 441), S(68, 447), S(70, 444), S(66, 446), S(65, 442), S(70, 427), S(73, 415), S(77, 402), S(74, 384), S(91, 339), S(71, 345), S(49, 299), S(19, 297), S(3, 267), S(-48, 283), S(-37, 218),
 };
 
-inline const PParam PAWN_THREAT_KNIGHT = S(205, 106);
-inline const PParam PAWN_THREAT_BISHOP = S(192, 157);
-inline const PParam PAWN_THREAT_ROOK   = S(197, 133);
-inline const PParam PAWN_THREAT_QUEEN  = S(179, -15);
+inline const PParam PAWN_THREAT_KNIGHT = S(203, 103);
+inline const PParam PAWN_THREAT_BISHOP = S(191, 152);
+inline const PParam PAWN_THREAT_ROOK   = S(202, 128);
+inline const PParam PAWN_THREAT_QUEEN  = S(175, 4);
 
-inline const PParam KNIGHT_THREAT_BISHOP = S(108, 114);
-inline const PParam KNIGHT_THREAT_ROOK   = S(222, 86);
-inline const PParam KNIGHT_THREAT_QUEEN  = S(153, -7);
+inline const PParam KNIGHT_THREAT_BISHOP = S(108, 112);
+inline const PParam KNIGHT_THREAT_ROOK   = S(227, 78);
+inline const PParam KNIGHT_THREAT_QUEEN  = S(151, 17);
 
-inline const PParam BISHOP_THREAT_KNIGHT = S(97, 72);
-inline const PParam BISHOP_THREAT_ROOK   = S(207, 142);
-inline const PParam BISHOP_THREAT_QUEEN  = S(167, 112);
+inline const PParam BISHOP_THREAT_KNIGHT = S(97, 71);
+inline const PParam BISHOP_THREAT_ROOK   = S(210, 135);
+inline const PParam BISHOP_THREAT_QUEEN  = S(165, 129);
 
 inline const std::array<PParam, 9> BISHOP_PAWNS = {
-    S(8, -26), S(0, -8), S(-3, -17), S(-6, -27), S(-11, -37), S(-14, -44), S(-16, -57), S(-21, -59), S(-34, -57),
+    S(8, -26), S(0, -8), S(-3, -17), S(-6, -27), S(-11, -37), S(-14, -44), S(-16, -57), S(-21, -59), S(-35, -56),
 };
 
-inline const PParam ROOK_LINEUP = S(16, 65);
+inline const PParam ROOK_LINEUP = S(15, 66);
 
 inline const std::array<PParam, 48> PAWN_PSQT = {
-    S(206, 227),    S(51, 280),     S(194, 212),    S(177, 182),    S(221, 108),    S(117, 201),    S(53, 252),     S(193, 191),    //
-    S(42, 30),      S(70, 44),      S(75, 13),      S(54, -52),     S(48, -83),     S(27, -34),     S(7, 23),       S(-23, 51),     //
-    S(25, -24),     S(3, -18),      S(34, -59),     S(20, -84),     S(16, -99),     S(-6, -71),     S(-51, -24),    S(-48, 3),      //
-    S(-7, -77),     S(-26, -49),    S(2, -73),      S(-11, -80),    S(-33, -82),    S(-38, -67),    S(-92, -31),    S(-82, -38),    //
-    S(-6, -108),    S(28, -110),    S(11, -54),     S(-4, -58),     S(-32, -67),    S(-48, -64),    S(-80, -50),    S(-80, -56),    //
-    S(15, -107),    S(94, -110),    S(71, -61),     S(30, -25),     S(2, -45),      S(-20, -58),    S(-50, -43),    S(-62, -42),    //
+    S(208, 225),    S(52, 279),     S(195, 212),    S(178, 181),    S(221, 108),    S(118, 199),    S(54, 250),     S(193, 191),    //
+    S(44, 29),      S(73, 43),      S(77, 12),      S(56, -52),     S(49, -84),     S(28, -34),     S(9, 22),       S(-22, 50),     //
+    S(26, -25),     S(3, -18),      S(34, -60),     S(21, -84),     S(16, -100),    S(-6, -72),     S(-51, -25),    S(-48, 3),      //
+    S(-7, -77),     S(-25, -49),    S(2, -73),      S(-11, -80),    S(-32, -83),    S(-38, -66),    S(-93, -31),    S(-83, -37),    //
+    S(-6, -109),    S(28, -110),    S(11, -54),     S(-4, -58),     S(-32, -67),    S(-49, -64),    S(-81, -50),    S(-80, -56),    //
+    S(16, -107),    S(95, -109),    S(72, -61),     S(31, -26),     S(2, -45),      S(-20, -58),    S(-50, -42),    S(-62, -41),    //
 };
 inline const std::array<PParam, 64> KNIGHT_PSQT = {
-    S(-300, -394),  S(-283, 45),    S(-234, -188),  S(-30, 42),     S(-99, 38),     S(-235, 34),    S(-402, 107),   S(-376, -272),  //
-    S(-44, -14),    S(-28, 31),     S(85, -5),      S(85, 28),      S(88, 24),      S(21, 30),      S(-43, 35),     S(-63, 6),      //
-    S(25, -20),     S(36, 11),      S(72, 63),      S(90, 59),      S(61, 83),      S(16, 80),      S(5, 19),       S(-41, 11),     //
-    S(88, 10),      S(96, 42),      S(105, 70),     S(106, 107),    S(112, 109),    S(71, 87),      S(45, 53),      S(30, 27),      //
-    S(68, 12),      S(108, -4),     S(94, 60),      S(89, 79),      S(70, 81),      S(74, 68),      S(57, 18),      S(13, 31),      //
-    S(10, -33),     S(37, -9),      S(37, 32),      S(50, 58),      S(44, 55),      S(16, 33),      S(7, -1),       S(-33, -34),    //
-    S(27, -25),     S(36, -26),     S(14, -14),     S(21, 10),      S(19, 8),       S(-7, -39),     S(-32, -7),     S(-44, -102),   //
-    S(-46, -86),    S(6, -26),      S(24, -51),     S(40, -44),     S(23, -24),     S(-11, -50),    S(-23, -33),    S(-66, -129),   //
+    S(-298, -394),  S(-283, 45),    S(-234, -186),  S(-31, 45),     S(-97, 39),     S(-233, 35),    S(-401, 108),   S(-375, -270),  //
+    S(-44, -13),    S(-27, 33),     S(86, -4),      S(86, 30),      S(90, 25),      S(22, 31),      S(-42, 35),     S(-64, 8),      //
+    S(26, -19),     S(39, 11),      S(74, 64),      S(95, 59),      S(64, 84),      S(16, 83),      S(6, 20),       S(-41, 12),     //
+    S(90, 10),      S(99, 42),      S(107, 71),     S(108, 108),    S(115, 109),    S(72, 88),      S(47, 53),      S(32, 26),      //
+    S(69, 13),      S(109, -3),     S(96, 61),      S(91, 80),      S(72, 82),      S(75, 69),      S(59, 18),      S(14, 31),      //
+    S(11, -33),     S(38, -8),      S(39, 33),      S(51, 59),      S(46, 56),      S(17, 33),      S(8, -0),       S(-31, -34),    //
+    S(27, -25),     S(37, -27),     S(15, -13),     S(23, 10),      S(20, 9),       S(-5, -39),     S(-31, -7),     S(-43, -102),   //
+    S(-45, -85),    S(7, -25),      S(26, -51),     S(41, -44),     S(25, -24),     S(-9, -51),     S(-21, -33),    S(-64, -129),   //
 };
 inline const std::array<PParam, 64> BISHOP_PSQT = {
-    S(-149, 73),    S(-170, 105),   S(-460, 177),   S(-310, 111),   S(-317, 126),   S(-343, 126),   S(-236, 119),   S(-125, 54),    //
-    S(-46, -5),     S(-85, 86),     S(-56, 46),     S(-112, 76),    S(-89, 64),     S(-59, 46),     S(-21, 36),     S(-58, 14),     //
-    S(21, 24),      S(7, 57),       S(23, 62),      S(17, 56),      S(0, 47),       S(11, 40),      S(10, 36),      S(4, 15),       //
-    S(9, 2),        S(45, 15),      S(58, 39),      S(68, 71),      S(102, 52),     S(38, 29),      S(40, -6),      S(-8, 2),       //
-    S(43, -52),     S(51, -7),      S(75, 17),      S(90, 39),      S(72, 51),      S(61, 33),      S(18, 9),       S(9, -28),      //
-    S(62, -37),     S(83, -21),     S(99, 10),      S(65, 33),      S(61, 13),      S(60, 22),      S(64, 3),       S(10, -4),      //
-    S(31, -79),     S(112, -56),    S(72, -29),     S(50, -7),      S(34, -5),      S(46, -38),     S(44, -49),     S(42, -54),     //
-    S(52, -74),     S(34, -38),     S(31, -4),      S(48, -31),     S(34, -19),     S(39, 18),      S(48, -14),     S(44, -49),     //
+    S(-149, 72),    S(-170, 104),   S(-459, 176),   S(-309, 110),   S(-315, 125),   S(-342, 125),   S(-236, 118),   S(-125, 54),    //
+    S(-48, -3),     S(-85, 85),     S(-57, 46),     S(-111, 75),    S(-89, 65),     S(-59, 47),     S(-22, 37),     S(-59, 14),     //
+    S(21, 24),      S(8, 55),       S(23, 63),      S(17, 55),      S(0, 47),       S(10, 40),      S(10, 35),      S(4, 14),       //
+    S(9, 2),        S(45, 15),      S(59, 37),      S(68, 71),      S(102, 52),     S(39, 28),      S(39, -6),      S(-8, 2),       //
+    S(42, -52),     S(51, -8),      S(75, 17),      S(91, 39),      S(72, 50),      S(61, 32),      S(17, 9),       S(9, -28),      //
+    S(61, -37),     S(83, -22),     S(98, 10),      S(64, 33),      S(60, 13),      S(59, 22),      S(63, 2),       S(9, -4),       //
+    S(31, -80),     S(111, -56),    S(72, -30),     S(49, -8),      S(34, -4),      S(45, -38),     S(44, -49),     S(41, -53),     //
+    S(52, -74),     S(34, -39),     S(30, -5),      S(48, -32),     S(34, -19),     S(39, 18),      S(47, -14),     S(44, -49),     //
 };
 inline const std::array<PParam, 64> ROOK_PSQT = {
-    S(187, 99),     S(236, 95),     S(184, 119),    S(184, 84),     S(226, 68),     S(181, 94),     S(203, 98),     S(178, 115),    //
-    S(82, 170),     S(168, 160),    S(225, 127),    S(169, 137),    S(206, 127),    S(168, 145),    S(116, 172),    S(97, 178),     //
-    S(48, 167),     S(180, 125),    S(211, 101),    S(185, 95),     S(182, 115),    S(132, 148),    S(135, 149),    S(68, 190),     //
-    S(24, 132),     S(106, 137),    S(134, 107),    S(111, 116),    S(142, 102),    S(95, 143),     S(99, 139),     S(26, 170),     //
-    S(4, 53),       S(80, 61),      S(70, 77),      S(40, 82),      S(48, 94),      S(36, 121),     S(13, 116),     S(-3, 111),     //
-    S(20, -32),     S(92, -6),      S(79, 14),      S(58, 14),      S(68, 21),      S(36, 58),      S(45, 33),      S(5, 43),       //
-    S(-74, -26),    S(64, -64),     S(67, -37),     S(55, -10),     S(57, -5),      S(45, 6),       S(35, -7),      S(4, 7),        //
-    S(-10, -46),    S(16, -24),     S(71, -35),     S(81, -37),     S(81, -27),     S(61, -6),      S(57, -12),     S(37, -6),      //
+    S(186, 100),    S(236, 96),     S(185, 119),    S(186, 84),     S(227, 68),     S(182, 93),     S(202, 99),     S(176, 117),    //
+    S(82, 170),     S(168, 160),    S(226, 128),    S(172, 135),    S(207, 126),    S(169, 145),    S(116, 172),    S(97, 178),     //
+    S(48, 167),     S(181, 124),    S(213, 100),    S(186, 94),     S(184, 113),    S(131, 148),    S(135, 149),    S(68, 190),     //
+    S(24, 131),     S(107, 136),    S(135, 107),    S(112, 115),    S(143, 101),    S(96, 142),     S(99, 139),     S(25, 170),     //
+    S(3, 53),       S(81, 60),      S(70, 77),      S(41, 82),      S(48, 93),      S(37, 120),     S(13, 115),     S(-4, 111),     //
+    S(19, -32),     S(93, -7),      S(79, 13),      S(58, 14),      S(68, 20),      S(35, 58),      S(44, 32),      S(4, 43),       //
+    S(-75, -25),    S(64, -65),     S(66, -36),     S(54, -10),     S(56, -5),      S(43, 6),       S(34, -8),      S(4, 6),        //
+    S(-11, -45),    S(15, -24),     S(71, -34),     S(80, -36),     S(80, -26),     S(60, -6),      S(56, -12),     S(37, -5),      //
 };
 inline const std::array<PParam, 64> QUEEN_PSQT = {
-    S(51, 170),     S(144, 97),     S(71, 199),     S(20, 281),     S(55, 236),     S(53, 212),     S(74, 129),     S(1, 203),      //
-    S(50, 195),     S(59, 290),     S(32, 308),     S(-95, 390),    S(-59, 388),    S(-10, 331),    S(38, 208),     S(16, 206),     //
-    S(17, 237),     S(41, 296),     S(20, 343),     S(-24, 370),    S(-16, 374),    S(37, 284),     S(55, 215),     S(62, 132),     //
-    S(34, 134),     S(36, 220),     S(-12, 296),    S(-25, 357),    S(-13, 374),    S(20, 255),     S(62, 176),     S(35, 152),     //
-    S(37, 97),      S(24, 156),     S(1, 222),      S(-21, 286),    S(-8, 312),     S(6, 262),      S(30, 172),     S(48, 99),      //
-    S(30, 20),      S(45, 66),      S(40, 147),     S(22, 154),     S(25, 180),     S(28, 211),     S(45, 148),     S(38, 97),      //
-    S(3, -96),      S(19, -43),     S(27, 6),       S(53, 36),      S(45, 85),      S(45, 63),      S(18, 101),     S(35, 72),      //
-    S(-9, -93),     S(15, -226),    S(40, -213),    S(55, -107),    S(50, -7),      S(56, -54),     S(51, -22),     S(26, 6),       //
+    S(50, 165),     S(143, 95),     S(70, 195),     S(18, 281),     S(51, 237),     S(49, 212),     S(71, 127),     S(-1, 198),     //
+    S(50, 193),     S(59, 291),     S(32, 312),     S(-93, 393),    S(-56, 388),    S(-10, 332),    S(38, 206),     S(17, 202),     //
+    S(19, 235),     S(42, 297),     S(21, 344),     S(-23, 372),    S(-16, 377),    S(37, 286),     S(55, 215),     S(62, 130),     //
+    S(36, 132),     S(37, 220),     S(-11, 299),    S(-24, 361),    S(-14, 380),    S(20, 257),     S(62, 175),     S(35, 151),     //
+    S(36, 98),      S(24, 158),     S(2, 224),      S(-21, 289),    S(-8, 316),     S(6, 264),      S(29, 171),     S(48, 98),      //
+    S(30, 19),      S(45, 67),      S(40, 148),     S(22, 155),     S(24, 181),     S(27, 212),     S(44, 147),     S(37, 98),      //
+    S(2, -96),      S(20, -44),     S(27, 6),       S(52, 36),      S(45, 84),      S(45, 61),      S(17, 99),      S(34, 73),      //
+    S(-9, -93),     S(15, -225),    S(40, -215),    S(56, -109),    S(51, -9),      S(56, -56),     S(51, -24),     S(26, 4),       //
 };
 inline const std::array<PParam, 64> KING_PSQT = {
-    S(-62, -294),   S(275, 288),    S(155, 285),    S(-18, 194),    S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(213, 6),      S(265, 239),    S(108, 287),    S(12, 192),     S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(132, 116),    S(170, 220),    S(66, 257),     S(-14, 196),    S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(-30, 58),     S(63, 152),     S(-70, 220),    S(-104, 232),   S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(-107, -12),   S(-31, 72),     S(-110, 143),   S(-201, 211),   S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(-24, -60),    S(31, 5),       S(-71, 88),     S(-130, 145),   S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(36, -114),    S(44, -42),     S(-32, 15),     S(-97, 68),     S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
-    S(-9, -214),    S(16, -110),    S(-66, -64),    S(-60, -78),    S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(-56, -294),   S(285, 285),    S(162, 283),    S(-7, 192),     S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(225, 2),      S(274, 236),    S(116, 286),    S(25, 191),     S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(138, 112),    S(177, 218),    S(72, 257),     S(-3, 195),     S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(-27, 57),     S(67, 150),     S(-62, 218),    S(-95, 232),    S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(-107, -12),   S(-30, 72),     S(-106, 143),   S(-191, 209),   S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(-28, -59),    S(27, 6),       S(-71, 88),     S(-125, 144),   S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(32, -112),    S(40, -39),     S(-33, 16),     S(-94, 68),     S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
+    S(-12, -212),   S(13, -108),    S(-67, -63),    S(-58, -78),    S(0, 0),        S(0, 0),        S(0, 0),        S(0, 0),        //
 };
 
-inline const PParam KS_NO_QUEEN = S(-86, -542);
+inline const PParam KS_NO_QUEEN = S(-84, -536);
 
 inline const std::array<PParam, 5> PT_INNER_RING_ATTACKS = {
-    S(10, -20), S(15, -27), S(14, -4), S(6, -9), S(1, -30),
+    S(10, -19), S(14, -26), S(14, -3), S(5, -9), S(1, -29),
 };
 inline const std::array<PParam, 5> PT_OUTER_RING_ATTACKS = {
-    S(4, -12), S(6, -23), S(4, -13), S(4, -0), S(4, 7),
+    S(3, -12), S(6, -23), S(4, -12), S(4, -0), S(4, 7),
 };
 
-inline const PParam KS_FLANK_ATTACK = S(4, -9);
-inline const PParam KS_FLANK_DEFENSE = S(-5, 1);
+inline const PParam KS_FLANK_ATTACK = S(4, -10);
+inline const PParam KS_FLANK_DEFENSE = S(-4, 1);
 inline const PParam KS_FLANK_DOUBLE_ATTACK   = S(3, -4);
 inline const PParam KS_FLANK_DOUBLE_DEFENSE  = S(-2, -7);
 
+inline const PParam KS_TEMPO  = S(11, -15);
+
 inline const std::array<std::array<PParam, 7>, 4> KING_SHELTER = {{
-  {{ S(17, 44), S(-4, 54), S(-2, -17), S(9, -20), S(8, -8), S(-3, -4), S(-3, 56), }},
-  {{ S(-2, 160), S(-21, -235), S(-21, -4), S(-8, 55), S(-8, 77), S(-19, -12), S(-19, -225), }},
-  {{ S(-4, 139), S(-9, -221), S(-10, 131), S(-4, 111), S(-3, 110), S(-10, 136), S(-8, -200), }},
-  {{ S(6, 124), S(-11, 85), S(0, 95), S(7, 77), S(5, 79), S(-2, 93), S(-8, 85), }},
+  {{ S(16, 45), S(-5, 53), S(-4, -15), S(8, -15), S(6, -3), S(-5, -4), S(-4, 54), }},
+  {{ S(-4, 158), S(-21, -228), S(-22, -4), S(-10, 56), S(-10, 79), S(-21, -11), S(-20, -216), }},
+  {{ S(-5, 137), S(-10, -212), S(-11, 129), S(-6, 110), S(-5, 109), S(-11, 135), S(-9, -193), }},
+  {{ S(6, 123), S(-11, 84), S(-0, 94), S(6, 78), S(4, 80), S(-2, 92), S(-7, 84), }},
 }};
 inline const std::array<PParam, 7> BLOCKED_SHELTER_STORM = {
-    S(0, 0), S(0, 0), S(9, 61), S(-11, 47), S(-11, 73), S(-1, 78), S(3, 37),
+    S(0, 0), S(0, 0), S(7, 64), S(-12, 44), S(-12, 72), S(-4, 79), S(2, 34),
 };
 inline const std::array<std::array<PParam, 7>, 4> SHELTER_STORM = {{
-  {{ S(2, 116), S(-9, 41), S(-9, 43), S(-6, 37), S(-7, 28), S(-8, 41), S(-9, 49), }},
-  {{ S(9, 9), S(1, -24), S(-9, -16), S(-3, -54), S(-4, -51), S(-7, -15), S(1, -19), }},
-  {{ S(0, 59), S(-4, 36), S(-7, 40), S(-4, 33), S(-3, 17), S(-8, 37), S(-4, 27), }},
-  {{ S(-1, 54), S(-7, 37), S(-11, 37), S(-5, 42), S(-4, 41), S(-10, 32), S(-9, 38), }},
+  {{ S(1, 115), S(-10, 41), S(-11, 46), S(-8, 41), S(-8, 31), S(-10, 44), S(-10, 47), }},
+  {{ S(7, 11), S(-1, -25), S(-10, -15), S(-5, -50), S(-6, -46), S(-9, -12), S(-1, -18), }},
+  {{ S(-2, 58), S(-5, 34), S(-8, 39), S(-6, 33), S(-5, 17), S(-9, 36), S(-5, 26), }},
+  {{ S(-3, 55), S(-8, 37), S(-12, 38), S(-7, 42), S(-6, 41), S(-12, 32), S(-10, 38), }},
 }};
 inline TunableSigmoid<32> KING_SAFETY_ACTIVATION(
-        1056, 267, -15, 92
+        1136, 269, -17, 98
 );
 
 inline VParam WINNABLE_PAWNS = V(-24);
-inline VParam WINNABLE_SYM = V(126);
+inline VParam WINNABLE_SYM = V(125);
 inline VParam WINNABLE_ASYM = V(108);
 inline VParam WINNABLE_PAWN_ENDGAME = V(191);
-inline VParam WINNABLE_BIAS = V(-487);
+inline VParam WINNABLE_BIAS = V(-484);
 
-// Epoch duration: 5.23206s
+// Epoch duration: 5.51875s
 // clang-format on
 }  // namespace Clockwork
diff --git a/src/evaltune_main.cpp b/src/evaltune_main.cpp
index 9cee708b..f6b2d53d 100644
--- a/src/evaltune_main.cpp
+++ b/src/evaltune_main.cpp
@@ -248,7 +248,7 @@ int main() {
             // Unfreeze all parameters after 24 epochs. Dont unfreeze king safety just yet
             Globals::get().unfreeze_value_range(0, counts.parameter_count);
             Globals::get().unfreeze_pair_range(
-              0, counts.pair_parameter_count - (28 + 7 + 28 + 5 + 5 + 1 + 1 + 1 + 1 + 1 + 2));
+              0, counts.pair_parameter_count - (28 + 7 + 28 + 5 + 5 + 1 + 1 + 1 + 1 + 1 + 1 + 2));
             optim.set_lr(.1);
         }
         if (epoch == 96) {
@@ -446,6 +446,8 @@ int main() {
         std::cout << "inline const PParam KS_FLANK_DOUBLE_DEFENSE  = " << KS_FLANK_DOUBLE_DEFENSE
                   << ";" << std::endl;
         std::cout << std::endl;
+        std::cout << "inline const PParam KS_TEMPO  = " << KS_TEMPO << ";" << std::endl;
+        std::cout << std::endl;
 
         print_2d_array("KING_SHELTER", KING_SHELTER);
         print_table("BLOCKED_SHELTER_STORM", BLOCKED_SHELTER_STORM);
diff --git a/src/evaluation.cpp b/src/evaluation.cpp
index 633d9650..e59cb555 100644
--- a/src/evaluation.cpp
+++ b/src/evaluation.cpp
@@ -388,9 +388,13 @@ PScore evaluate_king_safety(const Position& pos) {
     eval += KS_FLANK_DOUBLE_DEFENSE * (double_defended_by_us & flank).ipopcount();
     eval += KS_FLANK_DOUBLE_ATTACK * (double_attacked_by_them & flank).ipopcount();
 
+    // Tempo
+    eval += KS_TEMPO * (opp == pos.active_color());
+
     // King shelter evaluation
     eval += king_shelter<color>(pos);
 
+    // Reduced danger when no queen
     eval += KS_NO_QUEEN * (pos.bitboard_for(opp, PieceType::Queen).empty());
 
     return eval;