tests/rotl.test.cpp

• View this file on GitHub
• Last update: 2025-03-15 22:50:56+09:00

Depends on

• Assertion macro (tools/assert_that.hpp)
• $\left\lceil \frac{x}{y} \right\rceil$ (tools/ceil.hpp)
• std::bitset with dynamic size (tools/dynamic_bitset.hpp)
• std::is_integral extended for tools::int128_t and tools::uint128_t (tools/is_integral.hpp)
• std::is_unsigned extended for tools::int128_t and tools::uint128_t (tools/is_unsigned.hpp)
• Minimum non-negative reminder (tools/mod.hpp)
• Circular shift to the left (tools/rotl.hpp)

Code

// competitive-verifier: STANDALONE

#include <bitset>
#include <cstdint>
#include <iostream>
#include "tools/assert_that.hpp"
#include "tools/dynamic_bitset.hpp"
#include "tools/rotl.hpp"

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64, -9223372036854775807 - 1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,     -9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                     -128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                     -127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      -65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      -64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      -63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       -2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       -1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                        0) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                        1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                        2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,      9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64, -9223372036854775807 - 1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,     -9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                     -128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                     -127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      -65) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      -64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      -63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       -2) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       -1) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                        0) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                        1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                        2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000100));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       63) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      127) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,      9223372036854775807) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64, -9223372036854775807 - 1) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,     -9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                     -128) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                     -127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      -65) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      -64) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      -63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       -2) == UINT64_C(0b0010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       -1) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                        0) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                        1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                        2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       63) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       64) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      127) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      128) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,      9223372036854775807) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64, -9223372036854775807 - 1) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,     -9223372036854775807) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                     -128) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                     -127) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      -65) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      -64) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      -63) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       -2) == UINT64_C(0b0001010100111111011110001000001001100010100111100111110011101101));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       -1) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                        0) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                        1) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                        2) == UINT64_C(0b0101001111110111100010000010011000101001111001111100111011010001));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       63) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       64) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       65) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      127) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      128) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,      9223372036854775807) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));

  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63, -9223372036854775807 - 1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,     -9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                     -126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                     -125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      -64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      -63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      -62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       -2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       -1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                        0) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                        1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                        2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,      9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63, -9223372036854775807 - 1) == INT64_C(0b000000010000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,     -9223372036854775807) == INT64_C(0b000000100000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                     -126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                     -125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      -64) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      -63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      -62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       -2) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       -1) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                        0) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                        1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                        2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000100));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       62) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      125) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,      9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000010000000));

  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63, -9223372036854775807 - 1) == INT64_C(0b000000001000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,     -9223372036854775807) == INT64_C(0b000000010000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                     -126) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                     -125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      -64) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      -63) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      -62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       -2) == INT64_C(0b001000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       -1) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                        0) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                        1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                        2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       62) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       63) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      125) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      126) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,      9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000001000000));

  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63, -9223372036854775807 - 1) == INT64_C(0b101101001010100111111011110001000001001100010100111100111110011));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,     -9223372036854775807) == INT64_C(0b011010010101001111110111100010000010011000101001111001111100111));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                     -126) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                     -125) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      -64) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      -63) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      -62) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       -2) == INT64_C(0b001010100111111011110001000001001100010100111100111110011101101));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       -1) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                        0) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                        1) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                        2) == INT64_C(0b101001111110111100010000010011000101001111001111100111011010010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       62) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       63) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       64) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      125) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      126) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,      9223372036854775807) == INT64_C(0b111111011110001000001001100010100111100111110011101101001010100));

  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                     -128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                     -127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      -65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      -64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      -63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       -2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       -1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                        0) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                        1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                        2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"), -9223372036854775807 - 1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),     -9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                     -128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                     -127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      -65) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      -64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      -63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       -2) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       -1) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                        0) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                        1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                        2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000100"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       63) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      127) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),      9223372036854775807) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                     -128) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                     -127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      -65) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      -64) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      -63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       -2) == std::bitset<64>("0010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       -1) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                        0) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                        1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                        2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       63) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       64) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      127) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      128) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"), -9223372036854775807 - 1) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),     -9223372036854775807) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                     -128) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                     -127) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      -65) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      -64) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      -63) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       -2) == std::bitset<64>("0001010100111111011110001000001001100010100111100111110011101101"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       -1) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                        0) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                        1) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                        2) == std::bitset<64>("0101001111110111100010000010011000101001111001111100111011010001"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       63) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       64) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       65) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      127) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      128) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),      9223372036854775807) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));

  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                     -126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                     -125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      -64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      -63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      -62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       -2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       -1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                        0) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                        1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                        2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"), -9223372036854775807 - 1) == tools::dynamic_bitset("000000010000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),     -9223372036854775807) == tools::dynamic_bitset("000000100000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                     -126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                     -125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      -64) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      -63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      -62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       -2) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       -1) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                        0) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                        1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                        2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000100"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       62) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      125) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),      9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000010000000"));

  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == tools::dynamic_bitset("000000001000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == tools::dynamic_bitset("000000010000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                     -126) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                     -125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      -64) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      -63) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      -62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       -2) == tools::dynamic_bitset("001000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       -1) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                        0) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                        1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                        2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       62) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       63) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      125) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      126) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000001000000"));

  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"), -9223372036854775807 - 1) == tools::dynamic_bitset("101101001010100111111011110001000001001100010100111100111110011"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),     -9223372036854775807) == tools::dynamic_bitset("011010010101001111110111100010000010011000101001111001111100111"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                     -126) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                     -125) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      -64) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      -63) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      -62) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       -2) == tools::dynamic_bitset("001010100111111011110001000001001100010100111100111110011101101"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       -1) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                        0) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                        1) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                        2) == tools::dynamic_bitset("101001111110111100010000010011000101001111001111100111011010010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       62) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       63) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       64) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      125) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      126) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),      9223372036854775807) == tools::dynamic_bitset("111111011110001000001001100010100111100111110011101101001010100"));

  assert_that(tools::rotl(0, 0, 9223372036854775807) == 0);
  assert_that(tools::rotl(0, 1, 9223372036854775807) == 0);
  assert_that(tools::rotl(1, 1, 9223372036854775807) == 1);

  return 0;
}

#line 1 "tests/rotl.test.cpp"
// competitive-verifier: STANDALONE

#include <bitset>
#include <cstdint>
#include <iostream>
#line 1 "tools/assert_that.hpp"



#line 5 "tools/assert_that.hpp"
#include <cstdlib>

#define assert_that_impl(cond, file, line, func) do {\
  if (!cond) {\
    ::std::cerr << file << ':' << line << ": " << func << ": Assertion `" << #cond << "' failed." << '\n';\
    ::std::exit(EXIT_FAILURE);\
  }\
} while (false)
#define assert_that(...) assert_that_impl((__VA_ARGS__), __FILE__, __LINE__, __func__)


#line 1 "tools/dynamic_bitset.hpp"



#include <algorithm>
#include <bit>
#include <cassert>
#include <cstddef>
#line 10 "tools/dynamic_bitset.hpp"
#include <iterator>
#include <limits>
#include <sstream>
#include <string>
#include <vector>
#line 1 "tools/ceil.hpp"



#line 5 "tools/ceil.hpp"
#include <type_traits>
#line 1 "tools/is_integral.hpp"



#line 5 "tools/is_integral.hpp"

namespace tools {
  template <typename T>
  struct is_integral : ::std::is_integral<T> {};

  template <typename T>
  inline constexpr bool is_integral_v = ::tools::is_integral<T>::value;
}


#line 1 "tools/is_unsigned.hpp"



#line 5 "tools/is_unsigned.hpp"

namespace tools {
  template <typename T>
  struct is_unsigned : ::std::is_unsigned<T> {};

  template <typename T>
  inline constexpr bool is_unsigned_v = ::tools::is_unsigned<T>::value;
}


#line 8 "tools/ceil.hpp"

namespace tools {
  template <typename M, typename N> requires (
    ::tools::is_integral_v<M> && !::std::is_same_v<::std::remove_cv_t<M>, bool> &&
    ::tools::is_integral_v<N> && !::std::is_same_v<::std::remove_cv_t<N>, bool>)
  constexpr ::std::common_type_t<M, N> ceil(const M x, const N y) noexcept {
    assert(y != 0);
    if (y >= 0) {
      if (x > 0) {
        return (x - 1) / y + 1;
      } else {
        if constexpr (::tools::is_unsigned_v<::std::common_type_t<M, N>>) {
          return 0;
        } else {
          return x / y;
        }
      }
    } else {
      if (x >= 0) {
        if constexpr (::tools::is_unsigned_v<::std::common_type_t<M, N>>) {
          return 0;
        } else {
          return x / y;
        }
      } else {
        return (x + 1) / y + 1;
      }
    }
  }
}


#line 16 "tools/dynamic_bitset.hpp"

namespace tools {
  class dynamic_bitset {
    constexpr static ::std::size_t W = ::std::numeric_limits<::std::uint64_t>::digits;
    ::std::size_t m_size;
    ::std::vector<::std::uint64_t> m_bits;

  public:
    class reference {
      friend class ::tools::dynamic_bitset;

      ::tools::dynamic_bitset *m_parent;
      ::std::size_t m_pos;

      reference(::tools::dynamic_bitset * const parent, const ::std::size_t pos) : m_parent(parent), m_pos(pos) {
      }

    public:
      reference(const reference&) = default;
      reference& operator=(const bool x) {
        this->m_parent->set(this->m_pos, x);
        return *this;
      }
      reference& operator=(const reference& other) {
        return *this = static_cast<bool>(other);
      }
      bool operator~() const {
        return !static_cast<bool>(*this);
      }
      operator bool() const {
        return this->m_parent->test(this->m_pos);
      }
      reference& flip() {
        this->m_parent->flip(this->m_pos);
        return *this;
      }
    };

    dynamic_bitset() : m_size(0) {}
    explicit dynamic_bitset(const ::std::size_t size) : m_size(size), m_bits(::tools::ceil(size, W), 0) {}
    explicit dynamic_bitset(const ::std::string& str) : m_size(str.size()), m_bits(::tools::ceil(str.size(), W), 0) {
      for (::std::size_t i = 0; i < str.size(); ++i) {
        const auto c = str[str.size() - 1 - i];
        assert(c == '0' || c == '1');
        if (c == '1') {
          this->m_bits[i / W] |= UINT64_C(1) << (i % W);
        }
      }
    }

    ::tools::dynamic_bitset& operator&=(const ::tools::dynamic_bitset& other) {
      assert(this->m_size == other.m_size);
      for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
        this->m_bits[i] &= other.m_bits[i];
      }
      return *this;
    }
    ::tools::dynamic_bitset& operator|=(const ::tools::dynamic_bitset& other) {
      assert(this->m_size == other.m_size);
      for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
        this->m_bits[i] |= other.m_bits[i];
      }
      return *this;
    }
    ::tools::dynamic_bitset& operator^=(const ::tools::dynamic_bitset& other) {
      assert(this->m_size == other.m_size);
      for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
        this->m_bits[i] ^= other.m_bits[i];
      }
      return *this;
    }
    ::tools::dynamic_bitset& operator<<=(const ::std::size_t pos) {
      const ::std::size_t diff = pos / W;
      if (diff < this->m_bits.size()) {
        if (pos % W > 0) {
          for (::std::size_t i = this->m_bits.size() - diff; i --> 0;) {
            this->m_bits[i] <<= pos % W;
            if (i > 0) {
              this->m_bits[i] |= this->m_bits[i - 1] >> (W - pos % W);
            }
          }
        }
        if (diff > 0) {
          for (::std::size_t i = this->m_bits.size() - diff; i --> 0;) {
            this->m_bits[i + diff] = this->m_bits[i];
          }
          ::std::fill(this->m_bits.begin(), ::std::next(this->m_bits.begin(), diff), 0);
        }
        if (this->m_size % W > 0) {
          this->m_bits.back() &= (UINT64_C(1) << (this->m_size % W)) - 1;
        }
      } else {
        ::std::fill(this->m_bits.begin(), this->m_bits.end(), 0);
      }
      return *this;
    }
    ::tools::dynamic_bitset& operator>>=(const ::std::size_t pos) {
      const ::std::size_t diff = pos / W;
      if (diff < this->m_bits.size()) {
        if (pos % W > 0) {
          for (::std::size_t i = diff; i < this->m_bits.size(); ++i) {
            this->m_bits[i] >>= pos % W;
            if (i + 1 < this->m_bits.size()) {
              this->m_bits[i] |= this->m_bits[i + 1] << (W - pos % W);
            }
          }
        }
        if (diff > 0) {
          for (::std::size_t i = diff; i < this->m_bits.size(); ++i) {
            this->m_bits[i - diff] = this->m_bits[i];
          }
          ::std::fill(::std::next(this->m_bits.begin(), this->m_bits.size() - diff), this->m_bits.end(), 0);
        }
      } else {
        ::std::fill(this->m_bits.begin(), this->m_bits.end(), 0);
      }
      return *this;
    }
    ::tools::dynamic_bitset& set() {
      ::std::fill(this->m_bits.begin(), this->m_bits.end(), ::std::numeric_limits<::std::uint64_t>::max());
      if (this->m_size % W > 0) {
        this->m_bits.back() &= (UINT64_C(1) << (this->m_size % W)) - 1;
      }
      return *this;
    }
    ::tools::dynamic_bitset& set(const ::std::size_t pos) {
      assert(pos < this->m_size);
      this->m_bits[pos / W] |= UINT64_C(1) << (pos % W);
      return *this;
    }
    ::tools::dynamic_bitset& set(const ::std::size_t pos, const bool val) {
      return val ? this->set(pos) : this->reset(pos);
    }
    ::tools::dynamic_bitset& reset() {
      ::std::fill(this->m_bits.begin(), this->m_bits.end(), 0);
      return *this;
    }
    ::tools::dynamic_bitset& reset(const ::std::size_t pos) {
      assert(pos < this->m_size);
      this->m_bits[pos / W] &= ~(UINT64_C(1) << (pos % W));
      return *this;
    }
    ::tools::dynamic_bitset operator~() const {
      return ::tools::dynamic_bitset(*this).flip();
    }
    ::tools::dynamic_bitset& flip() {
      for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
        this->m_bits[i] = ~this->m_bits[i];
      }
      if (this->m_size % W > 0) {
        this->m_bits.back() &= (UINT64_C(1) << (this->m_size % W)) - 1;
      }
      return *this;
    }
    ::tools::dynamic_bitset& flip(const ::std::size_t pos) {
      assert(pos < this->m_size);
      this->m_bits[pos / W] ^= UINT64_C(1) << (pos % W);
      return *this;
    }
    reference operator[](const ::std::size_t pos) {
      return reference(this, pos);
    }
    bool operator[](const ::std::size_t pos) const {
      return this->test(pos);
    }
    ::std::size_t count() const {
      ::std::size_t result = 0;
      for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
        result += ::std::popcount(this->m_bits[i]);
      }
      return result;
    }
    ::std::size_t size() const {
      return this->m_size;
    }
    bool test(const ::std::size_t pos) const {
      assert(pos < this->m_size);
      return (this->m_bits[pos / W] >> (pos % W)) & 1;
    }
    bool all() const {
      if (this->m_size % W > 0) {
        for (::std::size_t i = 0; i + 1 < this->m_bits.size(); ++i) {
          if (this->m_bits[i] != ::std::numeric_limits<::std::uint64_t>::max()) {
            return false;
          }
        }
        return this->m_bits.back() == (UINT64_C(1) << (this->m_size % W)) - 1;
      } else {
        for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
          if (this->m_bits[i] != ::std::numeric_limits<::std::uint64_t>::max()) {
            return false;
          }
        }
        return true;
      }
    }
    bool any() const {
      for (::std::size_t i = 0; i < this->m_bits.size(); ++i) {
        if (this->m_bits[i] != 0) {
          return true;
        }
      }
      return false;
    }
    bool none() const {
      return !this->any();
    }
    ::std::string to_string() const {
      ::std::ostringstream oss;
      oss << *this;
      return oss.str();
    }
    friend bool operator==(const ::tools::dynamic_bitset& lhs, const ::tools::dynamic_bitset& rhs) {
      return lhs.m_size == rhs.m_size && lhs.m_bits == rhs.m_bits;
    }
    friend bool operator!=(const ::tools::dynamic_bitset& lhs, const ::tools::dynamic_bitset& rhs) {
      return !(lhs == rhs);
    }
    ::tools::dynamic_bitset operator<<(const ::std::size_t pos) const {
      return ::tools::dynamic_bitset(*this) <<= pos;
    }
    ::tools::dynamic_bitset operator>>(const ::std::size_t pos) const {
      return ::tools::dynamic_bitset(*this) >>= pos;
    }
    friend ::tools::dynamic_bitset operator&(const ::tools::dynamic_bitset& lhs, const ::tools::dynamic_bitset& rhs) {
      return ::tools::dynamic_bitset(lhs) &= rhs;
    }
    friend ::tools::dynamic_bitset operator|(const ::tools::dynamic_bitset& lhs, const ::tools::dynamic_bitset& rhs) {
      return ::tools::dynamic_bitset(lhs) |= rhs;
    }
    friend ::tools::dynamic_bitset operator^(const ::tools::dynamic_bitset& lhs, const ::tools::dynamic_bitset& rhs) {
      return ::tools::dynamic_bitset(lhs) ^= rhs;
    }
    friend ::std::istream& operator>>(::std::istream& is, ::tools::dynamic_bitset& self) {
      ::std::string s;
      is >> s;
      self = ::tools::dynamic_bitset(s);
      return is;
    }
    friend ::std::ostream& operator<<(::std::ostream& os, const ::tools::dynamic_bitset& self) {
      for (::std::size_t i = self.m_bits.size(); i --> 0;) {
        for (::std::size_t j = i + 1 < self.m_bits.size() ? W : (self.m_size - 1) % W + 1; j --> 0;) {
          os << ((self.m_bits[i] >> j) & 1);
        }
      }
      return os;
    }
    bool empty() const {
      return this->m_size == 0;
    }
    void resize(const ::std::size_t size) {
      this->m_size = size;
      this->m_bits.resize(::tools::ceil(size, W));
      if (size % W > 0) {
        this->m_bits.back() &= (UINT64_C(1) << (size % W)) - 1;
      }
    }
    void shrink_to_fit() {
      this->m_bits.shrink_to_fit();
    }
  private:
    ::std::size_t Find_first(const ::std::size_t offset) const {
      for (::std::size_t i = offset; i < this->m_bits.size(); ++i) {
        if (this->m_bits[i] > 0) {
          return i * W + ::std::countr_zero(this->m_bits[i]);
        }
      }
      return this->m_size;
    }
  public:
    ::std::size_t Find_first() const {
      return this->Find_first(0);
    }
    ::std::size_t Find_next(const ::std::size_t pos) const {
      assert(pos < this->m_size);

      if (pos % W == W - 1) return this->Find_first((pos + 1) / W);
      if (const auto x = this->m_bits[pos / W] >> (pos % W + 1); x > 0) return pos + ::std::countr_zero(x) + 1;
      return this->Find_first(pos / W + 1);
    }
  };
}


#line 1 "tools/rotl.hpp"



#line 1 "tools/mod.hpp"



#line 7 "tools/mod.hpp"

namespace tools {

  template <typename M, typename N> requires (
    ::tools::is_integral_v<M> && !::std::is_same_v<::std::remove_cv_t<M>, bool> &&
    ::tools::is_integral_v<N> && !::std::is_same_v<::std::remove_cv_t<N>, bool>)
  constexpr ::std::common_type_t<M, N> mod(const M a, const N b) noexcept {
    assert(b != 0);

    using UM = ::std::make_unsigned_t<M>;
    using UN = ::std::make_unsigned_t<N>;
    const UM ua = a >= 0 ? a : static_cast<UM>(-(a + 1)) + 1;
    const UN ub = b >= 0 ? b : static_cast<UN>(-(b + 1)) + 1;
    auto r = ua % ub;
    if (a < 0 && r > 0) {
      r = ub - r;
    }
    return r;
  }
}


#line 7 "tools/rotl.hpp"

namespace tools {

  template <typename T, typename U>
  constexpr T rotl(const T x, const int n, U s) {
    assert(0 <= n && n <= ::std::numeric_limits<T>::digits);
    const T mask = (n == ::std::numeric_limits<T>::digits ? ::std::numeric_limits<T>::max() : (T(1) << n) - 1);
    assert(0 <= x && x <= mask);
    if (n == 0) return x;
    s = ::tools::mod(s, n);
    return ((x << s) | (x >> ((n - s) % n))) & mask;
  }

  template <typename T, typename U>
  T rotl(const T& x, U s) {
    if (x.size() == 0) return x;
    s = ::tools::mod(s, x.size());
    return (x << s) | (x >> ((x.size() - s) % x.size()));
  }
}


#line 9 "tests/rotl.test.cpp"

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64, -9223372036854775807 - 1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,     -9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                     -128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                     -127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      -65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      -64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      -63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       -2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       -1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                        0) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                        1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                        2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                       65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,                      128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000), 64,      9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64, -9223372036854775807 - 1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,     -9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                     -128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                     -127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      -65) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      -64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      -63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       -2) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       -1) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                        0) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                        1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                        2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000100));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       63) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       64) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                       65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      127) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,                      128) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001), 64,      9223372036854775807) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64, -9223372036854775807 - 1) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,     -9223372036854775807) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                     -128) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                     -127) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      -65) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      -64) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      -63) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       -2) == UINT64_C(0b0010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       -1) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                        0) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                        1) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                        2) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       63) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       64) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                       65) == UINT64_C(0b0000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      127) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,                      128) == UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(UINT64_C(0b1000000000000000000000000000000000000000000000000000000000000000), 64,      9223372036854775807) == UINT64_C(0b0100000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64, -9223372036854775807 - 1) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,     -9223372036854775807) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                     -128) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                     -127) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      -65) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      -64) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      -63) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       -2) == UINT64_C(0b0001010100111111011110001000001001100010100111100111110011101101));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       -1) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                        0) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                        1) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                        2) == UINT64_C(0b0101001111110111100010000010011000101001111001111100111011010001));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       63) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       64) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                       65) == UINT64_C(0b1010100111111011110001000001001100010100111100111110011101101000));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      127) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,                      128) == UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(UINT64_C(0b0101010011111101111000100000100110001010011110011111001110110100), 64,      9223372036854775807) == UINT64_C(0b0010101001111110111100010000010011000101001111001111100111011010));

  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63, -9223372036854775807 - 1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,     -9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                     -126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                     -125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      -64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      -63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      -62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       -2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       -1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                        0) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                        1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                        2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                       64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,                      126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000000), 63,      9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000000));

  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63, -9223372036854775807 - 1) == INT64_C(0b000000010000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,     -9223372036854775807) == INT64_C(0b000000100000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                     -126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                     -125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      -64) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      -63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      -62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       -2) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       -1) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                        0) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                        1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                        2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000100));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       62) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       63) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                       64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      125) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,                      126) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b000000000000000000000000000000000000000000000000000000000000001), 63,      9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000010000000));

  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63, -9223372036854775807 - 1) == INT64_C(0b000000001000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,     -9223372036854775807) == INT64_C(0b000000010000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                     -126) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                     -125) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      -64) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      -63) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      -62) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       -2) == INT64_C(0b001000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       -1) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                        0) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                        1) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                        2) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000010));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       62) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       63) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                       64) == INT64_C(0b000000000000000000000000000000000000000000000000000000000000001));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      125) == INT64_C(0b010000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,                      126) == INT64_C(0b100000000000000000000000000000000000000000000000000000000000000));
  assert_that(tools::rotl(INT64_C(0b100000000000000000000000000000000000000000000000000000000000000), 63,      9223372036854775807) == INT64_C(0b000000000000000000000000000000000000000000000000000000001000000));

  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63, -9223372036854775807 - 1) == INT64_C(0b101101001010100111111011110001000001001100010100111100111110011));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,     -9223372036854775807) == INT64_C(0b011010010101001111110111100010000010011000101001111001111100111));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                     -126) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                     -125) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      -64) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      -63) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      -62) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       -2) == INT64_C(0b001010100111111011110001000001001100010100111100111110011101101));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       -1) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                        0) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                        1) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                        2) == INT64_C(0b101001111110111100010000010011000101001111001111100111011010010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       62) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       63) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                       64) == INT64_C(0b010100111111011110001000001001100010100111100111110011101101001));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      125) == INT64_C(0b010101001111110111100010000010011000101001111001111100111011010));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,                      126) == INT64_C(0b101010011111101111000100000100110001010011110011111001110110100));
  assert_that(tools::rotl(INT64_C(0b101010011111101111000100000100110001010011110011111001110110100), 63,      9223372036854775807) == INT64_C(0b111111011110001000001001100010100111100111110011101101001010100));

  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                     -128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                     -127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      -65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      -64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      -63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       -2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       -1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                        0) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                        1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                        2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                       65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),                      128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"), -9223372036854775807 - 1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),     -9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                     -128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                     -127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      -65) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      -64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      -63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       -2) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       -1) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                        0) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                        1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                        2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000100"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       63) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       64) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                       65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      127) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),                      128) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"),      9223372036854775807) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                     -128) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                     -127) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      -65) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      -64) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      -63) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       -2) == std::bitset<64>("0010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       -1) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                        0) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                        1) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                        2) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       63) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       64) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                       65) == std::bitset<64>("0000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      127) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),                      128) == std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(std::bitset<64>("1000000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == std::bitset<64>("0100000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"), -9223372036854775807 - 1) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),     -9223372036854775807) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                     -128) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                     -127) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      -65) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      -64) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      -63) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       -2) == std::bitset<64>("0001010100111111011110001000001001100010100111100111110011101101"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       -1) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                        0) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                        1) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                        2) == std::bitset<64>("0101001111110111100010000010011000101001111001111100111011010001"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       63) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       64) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                       65) == std::bitset<64>("1010100111111011110001000001001100010100111100111110011101101000"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      127) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),                      128) == std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(std::bitset<64>("0101010011111101111000100000100110001010011110011111001110110100"),      9223372036854775807) == std::bitset<64>("0010101001111110111100010000010011000101001111001111100111011010"));

  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                     -126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                     -125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      -64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      -63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      -62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       -2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       -1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                        0) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                        1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                        2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                       64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),                      126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000000"));

  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"), -9223372036854775807 - 1) == tools::dynamic_bitset("000000010000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),     -9223372036854775807) == tools::dynamic_bitset("000000100000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                     -126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                     -125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      -64) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      -63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      -62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       -2) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       -1) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                        0) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                        1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                        2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000100"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       62) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       63) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                       64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      125) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),                      126) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"),      9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000010000000"));

  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"), -9223372036854775807 - 1) == tools::dynamic_bitset("000000001000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),     -9223372036854775807) == tools::dynamic_bitset("000000010000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                     -126) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                     -125) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      -64) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      -63) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      -62) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       -2) == tools::dynamic_bitset("001000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       -1) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                        0) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                        1) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                        2) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000010"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       62) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       63) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                       64) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000000000001"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      125) == tools::dynamic_bitset("010000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),                      126) == tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"));
  assert_that(tools::rotl(tools::dynamic_bitset("100000000000000000000000000000000000000000000000000000000000000"),      9223372036854775807) == tools::dynamic_bitset("000000000000000000000000000000000000000000000000000000001000000"));

  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"), -9223372036854775807 - 1) == tools::dynamic_bitset("101101001010100111111011110001000001001100010100111100111110011"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),     -9223372036854775807) == tools::dynamic_bitset("011010010101001111110111100010000010011000101001111001111100111"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                     -126) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                     -125) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      -64) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      -63) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      -62) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       -2) == tools::dynamic_bitset("001010100111111011110001000001001100010100111100111110011101101"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       -1) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                        0) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                        1) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                        2) == tools::dynamic_bitset("101001111110111100010000010011000101001111001111100111011010010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       62) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       63) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                       64) == tools::dynamic_bitset("010100111111011110001000001001100010100111100111110011101101001"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      125) == tools::dynamic_bitset("010101001111110111100010000010011000101001111001111100111011010"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),                      126) == tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"));
  assert_that(tools::rotl(tools::dynamic_bitset("101010011111101111000100000100110001010011110011111001110110100"),      9223372036854775807) == tools::dynamic_bitset("111111011110001000001001100010100111100111110011101101001010100"));

  assert_that(tools::rotl(0, 0, 9223372036854775807) == 0);
  assert_that(tools::rotl(0, 1, 9223372036854775807) == 0);
  assert_that(tools::rotl(1, 1, 9223372036854775807) == 1);

  return 0;
}

Back to top page