proconlib

This documentation is automatically generated by competitive-verifier/competitive-verifier

View the Project on GitHub anqooqie/proconlib

:heavy_check_mark: tests/prime_factorization/severe_cases.test.cpp

Depends on

Code

// competitive-verifier: STANDALONE

#include <cstdint>
#include <iostream>
#include <vector>
#include "tools/assert_that.hpp"
#include "tools/prime_factorization.hpp"

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

  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(1)) == std::vector<std::int8_t>{});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(2)) == std::vector<std::int8_t>{INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(3)) == std::vector<std::int8_t>{INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(4)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(5)) == std::vector<std::int8_t>{INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(6)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(7)) == std::vector<std::int8_t>{INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(8)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(9)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(10)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(11)) == std::vector<std::int8_t>{INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(12)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(13)) == std::vector<std::int8_t>{INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(14)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(15)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(16)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(17)) == std::vector<std::int8_t>{INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(18)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(19)) == std::vector<std::int8_t>{INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(20)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(21)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(22)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(23)) == std::vector<std::int8_t>{INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(24)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(25)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(26)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(27)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(28)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(29)) == std::vector<std::int8_t>{INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(30)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(31)) == std::vector<std::int8_t>{INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(32)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(33)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(34)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(35)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(36)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(37)) == std::vector<std::int8_t>{INT8_C(37)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(38)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(39)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(40)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(41)) == std::vector<std::int8_t>{INT8_C(41)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(42)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(43)) == std::vector<std::int8_t>{INT8_C(43)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(44)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(45)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(46)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(47)) == std::vector<std::int8_t>{INT8_C(47)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(48)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(49)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(50)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(51)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(52)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(53)) == std::vector<std::int8_t>{INT8_C(53)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(54)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(55)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(56)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(57)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(58)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(59)) == std::vector<std::int8_t>{INT8_C(59)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(60)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(61)) == std::vector<std::int8_t>{INT8_C(61)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(62)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(63)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(64)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(65)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(66)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(67)) == std::vector<std::int8_t>{INT8_C(67)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(68)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(69)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(70)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(71)) == std::vector<std::int8_t>{INT8_C(71)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(72)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(73)) == std::vector<std::int8_t>{INT8_C(73)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(74)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(37)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(75)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(76)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(77)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(78)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(79)) == std::vector<std::int8_t>{INT8_C(79)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(80)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(81)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(82)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(41)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(83)) == std::vector<std::int8_t>{INT8_C(83)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(84)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(85)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(86)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(43)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(87)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(88)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(89)) == std::vector<std::int8_t>{INT8_C(89)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(90)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(91)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(92)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(93)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(94)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(47)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(95)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(96)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(97)) == std::vector<std::int8_t>{INT8_C(97)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(98)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(7), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(99)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(100)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(101)) == std::vector<std::int8_t>{INT8_C(101)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(102)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(103)) == std::vector<std::int8_t>{INT8_C(103)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(104)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(105)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(5), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(106)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(53)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(107)) == std::vector<std::int8_t>{INT8_C(107)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(108)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(109)) == std::vector<std::int8_t>{INT8_C(109)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(110)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(111)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(37)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(112)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(113)) == std::vector<std::int8_t>{INT8_C(113)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(114)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(115)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(116)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(117)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(118)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(59)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(119)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(120)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(121)) == std::vector<std::int8_t>{INT8_C(11), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(122)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(61)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(123)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(41)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(124)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(125)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(126)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(127)) == std::vector<std::int8_t>{INT8_C(127)});

  assert_that(tools::prime_factorization(INT32_C(1)) == std::vector<std::int32_t>{});
  assert_that(tools::prime_factorization(INT32_C(2)) == std::vector{INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(3)) == std::vector{INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(4)) == std::vector{INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(5)) == std::vector{INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(6)) == std::vector{INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(7)) == std::vector{INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(8)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(9)) == std::vector{INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(10)) == std::vector{INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(11)) == std::vector{INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(12)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(13)) == std::vector{INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(14)) == std::vector{INT32_C(2), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(15)) == std::vector{INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(16)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(17)) == std::vector{INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(18)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(19)) == std::vector{INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(20)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(21)) == std::vector{INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(22)) == std::vector{INT32_C(2), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(23)) == std::vector{INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(24)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(25)) == std::vector{INT32_C(5), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(26)) == std::vector{INT32_C(2), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(27)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(28)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(29)) == std::vector{INT32_C(29)});
  assert_that(tools::prime_factorization(INT32_C(30)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(31)) == std::vector{INT32_C(31)});
  assert_that(tools::prime_factorization(INT32_C(32)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(33)) == std::vector{INT32_C(3), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(34)) == std::vector{INT32_C(2), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(35)) == std::vector{INT32_C(5), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(36)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(37)) == std::vector{INT32_C(37)});
  assert_that(tools::prime_factorization(INT32_C(38)) == std::vector{INT32_C(2), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(39)) == std::vector{INT32_C(3), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(40)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(41)) == std::vector{INT32_C(41)});
  assert_that(tools::prime_factorization(INT32_C(42)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(43)) == std::vector{INT32_C(43)});
  assert_that(tools::prime_factorization(INT32_C(44)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(45)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(46)) == std::vector{INT32_C(2), INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(47)) == std::vector{INT32_C(47)});
  assert_that(tools::prime_factorization(INT32_C(48)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(49)) == std::vector{INT32_C(7), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(50)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(51)) == std::vector{INT32_C(3), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(52)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(53)) == std::vector{INT32_C(53)});
  assert_that(tools::prime_factorization(INT32_C(54)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(55)) == std::vector{INT32_C(5), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(56)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(57)) == std::vector{INT32_C(3), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(58)) == std::vector{INT32_C(2), INT32_C(29)});
  assert_that(tools::prime_factorization(INT32_C(59)) == std::vector{INT32_C(59)});
  assert_that(tools::prime_factorization(INT32_C(60)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(61)) == std::vector{INT32_C(61)});
  assert_that(tools::prime_factorization(INT32_C(62)) == std::vector{INT32_C(2), INT32_C(31)});
  assert_that(tools::prime_factorization(INT32_C(63)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(64)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(65)) == std::vector{INT32_C(5), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(66)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(67)) == std::vector{INT32_C(67)});
  assert_that(tools::prime_factorization(INT32_C(68)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(69)) == std::vector{INT32_C(3), INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(70)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(71)) == std::vector{INT32_C(71)});
  assert_that(tools::prime_factorization(INT32_C(72)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(73)) == std::vector{INT32_C(73)});
  assert_that(tools::prime_factorization(INT32_C(74)) == std::vector{INT32_C(2), INT32_C(37)});
  assert_that(tools::prime_factorization(INT32_C(75)) == std::vector{INT32_C(3), INT32_C(5), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(76)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(77)) == std::vector{INT32_C(7), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(78)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(79)) == std::vector{INT32_C(79)});
  assert_that(tools::prime_factorization(INT32_C(80)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(81)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(82)) == std::vector{INT32_C(2), INT32_C(41)});
  assert_that(tools::prime_factorization(INT32_C(83)) == std::vector{INT32_C(83)});
  assert_that(tools::prime_factorization(INT32_C(84)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(85)) == std::vector{INT32_C(5), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(86)) == std::vector{INT32_C(2), INT32_C(43)});
  assert_that(tools::prime_factorization(INT32_C(87)) == std::vector{INT32_C(3), INT32_C(29)});
  assert_that(tools::prime_factorization(INT32_C(88)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(89)) == std::vector{INT32_C(89)});
  assert_that(tools::prime_factorization(INT32_C(90)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(91)) == std::vector{INT32_C(7), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(92)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(93)) == std::vector{INT32_C(3), INT32_C(31)});
  assert_that(tools::prime_factorization(INT32_C(94)) == std::vector{INT32_C(2), INT32_C(47)});
  assert_that(tools::prime_factorization(INT32_C(95)) == std::vector{INT32_C(5), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(96)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(97)) == std::vector{INT32_C(97)});
  assert_that(tools::prime_factorization(INT32_C(98)) == std::vector{INT32_C(2), INT32_C(7), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(99)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(100)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(5)});

  assert_that(tools::prime_factorization(INT32_C(2095133040)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(5), INT32_C(7), INT32_C(11), INT32_C(13), INT32_C(17), INT32_C(19)});

  assert_that(tools::prime_factorization(INT32_C(2147483548)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(7), INT32_C(76695841)});
  assert_that(tools::prime_factorization(INT32_C(2147483549)) == std::vector{INT32_C(2147483549)});
  assert_that(tools::prime_factorization(INT32_C(2147483550)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(5), INT32_C(5), INT32_C(19), INT32_C(23), INT32_C(181), INT32_C(181)});
  assert_that(tools::prime_factorization(INT32_C(2147483551)) == std::vector{INT32_C(32063), INT32_C(66977)});
  assert_that(tools::prime_factorization(INT32_C(2147483552)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(37), INT32_C(349), INT32_C(5197)});
  assert_that(tools::prime_factorization(INT32_C(2147483553)) == std::vector{INT32_C(3), INT32_C(29), INT32_C(31), INT32_C(503), INT32_C(1583)});
  assert_that(tools::prime_factorization(INT32_C(2147483554)) == std::vector{INT32_C(2), INT32_C(17), INT32_C(43), INT32_C(563), INT32_C(2609)});
  assert_that(tools::prime_factorization(INT32_C(2147483555)) == std::vector{INT32_C(5), INT32_C(7), INT32_C(7), INT32_C(7), INT32_C(1252177)});
  assert_that(tools::prime_factorization(INT32_C(2147483556)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(109), INT32_C(182423)});
  assert_that(tools::prime_factorization(INT32_C(2147483557)) == std::vector{INT32_C(3181), INT32_C(675097)});
  assert_that(tools::prime_factorization(INT32_C(2147483558)) == std::vector{INT32_C(2), INT32_C(11), INT32_C(11), INT32_C(139), INT32_C(63841)});
  assert_that(tools::prime_factorization(INT32_C(2147483559)) == std::vector{INT32_C(3), INT32_C(13), INT32_C(73), INT32_C(754297)});
  assert_that(tools::prime_factorization(INT32_C(2147483560)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(227), INT32_C(236507)});
  assert_that(tools::prime_factorization(INT32_C(2147483561)) == std::vector{INT32_C(167), INT32_C(12859183)});
  assert_that(tools::prime_factorization(INT32_C(2147483562)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(7), INT32_C(631), INT32_C(81031)});
  assert_that(tools::prime_factorization(INT32_C(2147483563)) == std::vector{INT32_C(2147483563)});
  assert_that(tools::prime_factorization(INT32_C(2147483564)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(6269), INT32_C(85639)});
  assert_that(tools::prime_factorization(INT32_C(2147483565)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(5), INT32_C(103), INT32_C(463319)});
  assert_that(tools::prime_factorization(INT32_C(2147483566)) == std::vector{INT32_C(2), INT32_C(1073741783)});
  assert_that(tools::prime_factorization(INT32_C(2147483567)) == std::vector{INT32_C(11503), INT32_C(186689)});
  assert_that(tools::prime_factorization(INT32_C(2147483568)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(41), INT32_C(83), INT32_C(13147)});
  assert_that(tools::prime_factorization(INT32_C(2147483569)) == std::vector{INT32_C(7), INT32_C(11), INT32_C(19), INT32_C(1467863)});
  assert_that(tools::prime_factorization(INT32_C(2147483570)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(214748357)});
  assert_that(tools::prime_factorization(INT32_C(2147483571)) == std::vector{INT32_C(3), INT32_C(17), INT32_C(17), INT32_C(2476913)});
  assert_that(tools::prime_factorization(INT32_C(2147483572)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(13), INT32_C(5641), INT32_C(7321)});
  assert_that(tools::prime_factorization(INT32_C(2147483573)) == std::vector{INT32_C(23), INT32_C(93368851)});
  assert_that(tools::prime_factorization(INT32_C(2147483574)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(53), INT32_C(2251031)});
  assert_that(tools::prime_factorization(INT32_C(2147483575)) == std::vector{INT32_C(5), INT32_C(5), INT32_C(85899343)});
  assert_that(tools::prime_factorization(INT32_C(2147483576)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(7), INT32_C(2341), INT32_C(16381)});
  assert_that(tools::prime_factorization(INT32_C(2147483577)) == std::vector{INT32_C(3), INT32_C(10103), INT32_C(70853)});
  assert_that(tools::prime_factorization(INT32_C(2147483578)) == std::vector{INT32_C(2), INT32_C(1073741789)});
  assert_that(tools::prime_factorization(INT32_C(2147483579)) == std::vector{INT32_C(2147483579)});
  assert_that(tools::prime_factorization(INT32_C(2147483580)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(5), INT32_C(11), INT32_C(47), INT32_C(107), INT32_C(647)});
  assert_that(tools::prime_factorization(INT32_C(2147483581)) == std::vector{INT32_C(89), INT32_C(691), INT32_C(34919)});
  assert_that(tools::prime_factorization(INT32_C(2147483582)) == std::vector{INT32_C(2), INT32_C(29), INT32_C(97), INT32_C(381707)});
  assert_that(tools::prime_factorization(INT32_C(2147483583)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(7), INT32_C(1262483)});
  assert_that(tools::prime_factorization(INT32_C(2147483584)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(31), INT32_C(601), INT32_C(1801)});
  assert_that(tools::prime_factorization(INT32_C(2147483585)) == std::vector{INT32_C(5), INT32_C(13), INT32_C(179), INT32_C(184571)});
  assert_that(tools::prime_factorization(INT32_C(2147483586)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(357913931)});
  assert_that(tools::prime_factorization(INT32_C(2147483587)) == std::vector{INT32_C(2147483587)});
  assert_that(tools::prime_factorization(INT32_C(2147483588)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(17), INT32_C(19), INT32_C(19), INT32_C(87481)});
  assert_that(tools::prime_factorization(INT32_C(2147483589)) == std::vector{INT32_C(3), INT32_C(37), INT32_C(61), INT32_C(317159)});
  assert_that(tools::prime_factorization(INT32_C(2147483590)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(7), INT32_C(877), INT32_C(34981)});
  assert_that(tools::prime_factorization(INT32_C(2147483591)) == std::vector{INT32_C(11), INT32_C(195225781)});
  assert_that(tools::prime_factorization(INT32_C(2147483592)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(4813), INT32_C(6197)});
  assert_that(tools::prime_factorization(INT32_C(2147483593)) == std::vector{INT32_C(59), INT32_C(239), INT32_C(152293)});
  assert_that(tools::prime_factorization(INT32_C(2147483594)) == std::vector{INT32_C(2), INT32_C(193), INT32_C(1021), INT32_C(5449)});
  assert_that(tools::prime_factorization(INT32_C(2147483595)) == std::vector{INT32_C(3), INT32_C(5), INT32_C(143165573)});
  assert_that(tools::prime_factorization(INT32_C(2147483596)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(23), INT32_C(23342213)});
  assert_that(tools::prime_factorization(INT32_C(2147483597)) == std::vector{INT32_C(7), INT32_C(43), INT32_C(7134497)});
  assert_that(tools::prime_factorization(INT32_C(2147483598)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(13), INT32_C(67), INT32_C(163), INT32_C(2521)});
  assert_that(tools::prime_factorization(INT32_C(2147483599)) == std::vector{INT32_C(1657), INT32_C(1296007)});
  assert_that(tools::prime_factorization(INT32_C(2147483600)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(5), INT32_C(173), INT32_C(31033)});
  assert_that(tools::prime_factorization(INT32_C(2147483601)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(238609289)});
  assert_that(tools::prime_factorization(INT32_C(2147483602)) == std::vector{INT32_C(2), INT32_C(11), INT32_C(97612891)});
  assert_that(tools::prime_factorization(INT32_C(2147483603)) == std::vector{INT32_C(1187), INT32_C(1809169)});
  assert_that(tools::prime_factorization(INT32_C(2147483604)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(7), INT32_C(7), INT32_C(197), INT32_C(18539)});
  assert_that(tools::prime_factorization(INT32_C(2147483605)) == std::vector{INT32_C(5), INT32_C(17), INT32_C(25264513)});
  assert_that(tools::prime_factorization(INT32_C(2147483606)) == std::vector{INT32_C(2), INT32_C(3671), INT32_C(292493)});
  assert_that(tools::prime_factorization(INT32_C(2147483607)) == std::vector{INT32_C(3), INT32_C(19), INT32_C(571), INT32_C(65981)});
  assert_that(tools::prime_factorization(INT32_C(2147483608)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(71), INT32_C(3780781)});
  assert_that(tools::prime_factorization(INT32_C(2147483609)) == std::vector{INT32_C(41), INT32_C(52377649)});
  assert_that(tools::prime_factorization(INT32_C(2147483610)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(5), INT32_C(313), INT32_C(25411)});
  assert_that(tools::prime_factorization(INT32_C(2147483611)) == std::vector{INT32_C(7), INT32_C(13), INT32_C(29), INT32_C(813749)});
  assert_that(tools::prime_factorization(INT32_C(2147483612)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(311), INT32_C(1726273)});
  assert_that(tools::prime_factorization(INT32_C(2147483613)) == std::vector{INT32_C(3), INT32_C(11), INT32_C(2953), INT32_C(22037)});
  assert_that(tools::prime_factorization(INT32_C(2147483614)) == std::vector{INT32_C(2), INT32_C(101), INT32_C(10631107)});
  assert_that(tools::prime_factorization(INT32_C(2147483615)) == std::vector{INT32_C(5), INT32_C(31), INT32_C(13854733)});
  assert_that(tools::prime_factorization(INT32_C(2147483616)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(2731), INT32_C(8191)});
  assert_that(tools::prime_factorization(INT32_C(2147483617)) == std::vector{INT32_C(6733), INT32_C(318949)});
  assert_that(tools::prime_factorization(INT32_C(2147483618)) == std::vector{INT32_C(2), INT32_C(7), INT32_C(367), INT32_C(417961)});
  assert_that(tools::prime_factorization(INT32_C(2147483619)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(23), INT32_C(353), INT32_C(29389)});
  assert_that(tools::prime_factorization(INT32_C(2147483620)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(4603), INT32_C(23327)});
  assert_that(tools::prime_factorization(INT32_C(2147483621)) == std::vector{INT32_C(14741), INT32_C(145681)});
  assert_that(tools::prime_factorization(INT32_C(2147483622)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(17), INT32_C(467), INT32_C(45083)});
  assert_that(tools::prime_factorization(INT32_C(2147483623)) == std::vector{INT32_C(79), INT32_C(967), INT32_C(28111)});
  assert_that(tools::prime_factorization(INT32_C(2147483624)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(11), INT32_C(13), INT32_C(1877171)});
  assert_that(tools::prime_factorization(INT32_C(2147483625)) == std::vector{INT32_C(3), INT32_C(5), INT32_C(5), INT32_C(5), INT32_C(7), INT32_C(199), INT32_C(4111)});
  assert_that(tools::prime_factorization(INT32_C(2147483626)) == std::vector{INT32_C(2), INT32_C(19), INT32_C(37), INT32_C(1527371)});
  assert_that(tools::prime_factorization(INT32_C(2147483627)) == std::vector{INT32_C(47), INT32_C(53), INT32_C(862097)});
  assert_that(tools::prime_factorization(INT32_C(2147483628)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(59652323)});
  assert_that(tools::prime_factorization(INT32_C(2147483629)) == std::vector{INT32_C(2147483629)});
  assert_that(tools::prime_factorization(INT32_C(2147483630)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(6553), INT32_C(32771)});
  assert_that(tools::prime_factorization(INT32_C(2147483631)) == std::vector{INT32_C(3), INT32_C(137), INT32_C(263), INT32_C(19867)});
  assert_that(tools::prime_factorization(INT32_C(2147483632)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(7), INT32_C(73), INT32_C(262657)});
  assert_that(tools::prime_factorization(INT32_C(2147483633)) == std::vector{INT32_C(5843), INT32_C(367531)});
  assert_that(tools::prime_factorization(INT32_C(2147483634)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(12097), INT32_C(29587)});
  assert_that(tools::prime_factorization(INT32_C(2147483635)) == std::vector{INT32_C(5), INT32_C(11), INT32_C(337), INT32_C(115861)});
  assert_that(tools::prime_factorization(INT32_C(2147483636)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(536870909)});
  assert_that(tools::prime_factorization(INT32_C(2147483637)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(13), INT32_C(6118187)});
  assert_that(tools::prime_factorization(INT32_C(2147483638)) == std::vector{INT32_C(2), INT32_C(2969), INT32_C(361651)});
  assert_that(tools::prime_factorization(INT32_C(2147483639)) == std::vector{INT32_C(7), INT32_C(17), INT32_C(18046081)});
  assert_that(tools::prime_factorization(INT32_C(2147483640)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(5), INT32_C(29), INT32_C(43), INT32_C(113), INT32_C(127)});
  assert_that(tools::prime_factorization(INT32_C(2147483641)) == std::vector{INT32_C(2699), INT32_C(795659)});
  assert_that(tools::prime_factorization(INT32_C(2147483642)) == std::vector{INT32_C(2), INT32_C(23), INT32_C(46684427)});
  assert_that(tools::prime_factorization(INT32_C(2147483643)) == std::vector{INT32_C(3), INT32_C(715827881)});
  assert_that(tools::prime_factorization(INT32_C(2147483644)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(233), INT32_C(1103), INT32_C(2089)});
  assert_that(tools::prime_factorization(INT32_C(2147483645)) == std::vector{INT32_C(5), INT32_C(19), INT32_C(22605091)});
  assert_that(tools::prime_factorization(INT32_C(2147483646)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(7), INT32_C(11), INT32_C(31), INT32_C(151), INT32_C(331)});
  assert_that(tools::prime_factorization(INT32_C(2147483647)) == std::vector{INT32_C(2147483647)});

  assert_that(tools::prime_factorization(UINT32_C(1)) == std::vector<std::uint32_t>{});
  assert_that(tools::prime_factorization(UINT32_C(2)) == std::vector{UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(3)) == std::vector{UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(4)) == std::vector{UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(5)) == std::vector{UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(6)) == std::vector{UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(7)) == std::vector{UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(8)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(9)) == std::vector{UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(10)) == std::vector{UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(11)) == std::vector{UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(12)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(13)) == std::vector{UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(14)) == std::vector{UINT32_C(2), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(15)) == std::vector{UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(16)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(17)) == std::vector{UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(18)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(19)) == std::vector{UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(20)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(21)) == std::vector{UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(22)) == std::vector{UINT32_C(2), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(23)) == std::vector{UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(24)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(25)) == std::vector{UINT32_C(5), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(26)) == std::vector{UINT32_C(2), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(27)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(28)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(29)) == std::vector{UINT32_C(29)});
  assert_that(tools::prime_factorization(UINT32_C(30)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(31)) == std::vector{UINT32_C(31)});
  assert_that(tools::prime_factorization(UINT32_C(32)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(33)) == std::vector{UINT32_C(3), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(34)) == std::vector{UINT32_C(2), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(35)) == std::vector{UINT32_C(5), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(36)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(37)) == std::vector{UINT32_C(37)});
  assert_that(tools::prime_factorization(UINT32_C(38)) == std::vector{UINT32_C(2), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(39)) == std::vector{UINT32_C(3), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(40)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(41)) == std::vector{UINT32_C(41)});
  assert_that(tools::prime_factorization(UINT32_C(42)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(43)) == std::vector{UINT32_C(43)});
  assert_that(tools::prime_factorization(UINT32_C(44)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(45)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(46)) == std::vector{UINT32_C(2), UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(47)) == std::vector{UINT32_C(47)});
  assert_that(tools::prime_factorization(UINT32_C(48)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(49)) == std::vector{UINT32_C(7), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(50)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(51)) == std::vector{UINT32_C(3), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(52)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(53)) == std::vector{UINT32_C(53)});
  assert_that(tools::prime_factorization(UINT32_C(54)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(55)) == std::vector{UINT32_C(5), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(56)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(57)) == std::vector{UINT32_C(3), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(58)) == std::vector{UINT32_C(2), UINT32_C(29)});
  assert_that(tools::prime_factorization(UINT32_C(59)) == std::vector{UINT32_C(59)});
  assert_that(tools::prime_factorization(UINT32_C(60)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(61)) == std::vector{UINT32_C(61)});
  assert_that(tools::prime_factorization(UINT32_C(62)) == std::vector{UINT32_C(2), UINT32_C(31)});
  assert_that(tools::prime_factorization(UINT32_C(63)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(64)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(65)) == std::vector{UINT32_C(5), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(66)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(67)) == std::vector{UINT32_C(67)});
  assert_that(tools::prime_factorization(UINT32_C(68)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(69)) == std::vector{UINT32_C(3), UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(70)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(71)) == std::vector{UINT32_C(71)});
  assert_that(tools::prime_factorization(UINT32_C(72)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(73)) == std::vector{UINT32_C(73)});
  assert_that(tools::prime_factorization(UINT32_C(74)) == std::vector{UINT32_C(2), UINT32_C(37)});
  assert_that(tools::prime_factorization(UINT32_C(75)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(76)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(77)) == std::vector{UINT32_C(7), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(78)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(79)) == std::vector{UINT32_C(79)});
  assert_that(tools::prime_factorization(UINT32_C(80)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(81)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(82)) == std::vector{UINT32_C(2), UINT32_C(41)});
  assert_that(tools::prime_factorization(UINT32_C(83)) == std::vector{UINT32_C(83)});
  assert_that(tools::prime_factorization(UINT32_C(84)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(85)) == std::vector{UINT32_C(5), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(86)) == std::vector{UINT32_C(2), UINT32_C(43)});
  assert_that(tools::prime_factorization(UINT32_C(87)) == std::vector{UINT32_C(3), UINT32_C(29)});
  assert_that(tools::prime_factorization(UINT32_C(88)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(89)) == std::vector{UINT32_C(89)});
  assert_that(tools::prime_factorization(UINT32_C(90)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(91)) == std::vector{UINT32_C(7), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(92)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(93)) == std::vector{UINT32_C(3), UINT32_C(31)});
  assert_that(tools::prime_factorization(UINT32_C(94)) == std::vector{UINT32_C(2), UINT32_C(47)});
  assert_that(tools::prime_factorization(UINT32_C(95)) == std::vector{UINT32_C(5), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(96)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(97)) == std::vector{UINT32_C(97)});
  assert_that(tools::prime_factorization(UINT32_C(98)) == std::vector{UINT32_C(2), UINT32_C(7), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(99)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(100)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(5)});

  assert_that(tools::prime_factorization(UINT32_C(3491888400)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(5), UINT32_C(5), UINT32_C(7), UINT32_C(11), UINT32_C(13), UINT32_C(17), UINT32_C(19)});

  assert_that(tools::prime_factorization(UINT32_C(4294967196)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(13), UINT32_C(67), UINT32_C(163), UINT32_C(2521)});
  assert_that(tools::prime_factorization(UINT32_C(4294967197)) == std::vector{UINT32_C(4294967197)});
  assert_that(tools::prime_factorization(UINT32_C(4294967198)) == std::vector{UINT32_C(2), UINT32_C(1657), UINT32_C(1296007)});
  assert_that(tools::prime_factorization(UINT32_C(4294967199)) == std::vector{UINT32_C(3), UINT32_C(31), UINT32_C(46182443)});
  assert_that(tools::prime_factorization(UINT32_C(4294967200)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(5), UINT32_C(173), UINT32_C(31033)});
  assert_that(tools::prime_factorization(UINT32_C(4294967201)) == std::vector{UINT32_C(7), UINT32_C(53), UINT32_C(11576731)});
  assert_that(tools::prime_factorization(UINT32_C(4294967202)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(238609289)});
  assert_that(tools::prime_factorization(UINT32_C(4294967203)) == std::vector{UINT32_C(157), UINT32_C(1051), UINT32_C(26029)});
  assert_that(tools::prime_factorization(UINT32_C(4294967204)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(11), UINT32_C(97612891)});
  assert_that(tools::prime_factorization(UINT32_C(4294967205)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(286331147)});
  assert_that(tools::prime_factorization(UINT32_C(4294967206)) == std::vector{UINT32_C(2), UINT32_C(1187), UINT32_C(1809169)});
  assert_that(tools::prime_factorization(UINT32_C(4294967207)) == std::vector{UINT32_C(47), UINT32_C(91382281)});
  assert_that(tools::prime_factorization(UINT32_C(4294967208)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(7), UINT32_C(7), UINT32_C(197), UINT32_C(18539)});
  assert_that(tools::prime_factorization(UINT32_C(4294967209)) == std::vector{UINT32_C(13), UINT32_C(677), UINT32_C(488009)});
  assert_that(tools::prime_factorization(UINT32_C(4294967210)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(17), UINT32_C(25264513)});
  assert_that(tools::prime_factorization(UINT32_C(4294967211)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(477218579)});
  assert_that(tools::prime_factorization(UINT32_C(4294967212)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3671), UINT32_C(292493)});
  assert_that(tools::prime_factorization(UINT32_C(4294967213)) == std::vector{UINT32_C(57139), UINT32_C(75167)});
  assert_that(tools::prime_factorization(UINT32_C(4294967214)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(19), UINT32_C(571), UINT32_C(65981)});
  assert_that(tools::prime_factorization(UINT32_C(4294967215)) == std::vector{UINT32_C(5), UINT32_C(7), UINT32_C(11), UINT32_C(23), UINT32_C(37), UINT32_C(13109)});
  assert_that(tools::prime_factorization(UINT32_C(4294967216)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(71), UINT32_C(3780781)});
  assert_that(tools::prime_factorization(UINT32_C(4294967217)) == std::vector{UINT32_C(3), UINT32_C(1431655739)});
  assert_that(tools::prime_factorization(UINT32_C(4294967218)) == std::vector{UINT32_C(2), UINT32_C(41), UINT32_C(52377649)});
  assert_that(tools::prime_factorization(UINT32_C(4294967219)) == std::vector{UINT32_C(83), UINT32_C(4327), UINT32_C(11959)});
  assert_that(tools::prime_factorization(UINT32_C(4294967220)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(5), UINT32_C(313), UINT32_C(25411)});
  assert_that(tools::prime_factorization(UINT32_C(4294967221)) == std::vector{UINT32_C(109), UINT32_C(39403369)});
  assert_that(tools::prime_factorization(UINT32_C(4294967222)) == std::vector{UINT32_C(2), UINT32_C(7), UINT32_C(13), UINT32_C(29), UINT32_C(813749)});
  assert_that(tools::prime_factorization(UINT32_C(4294967223)) == std::vector{UINT32_C(3), UINT32_C(359), UINT32_C(1291), UINT32_C(3089)});
  assert_that(tools::prime_factorization(UINT32_C(4294967224)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(311), UINT32_C(1726273)});
  assert_that(tools::prime_factorization(UINT32_C(4294967225)) == std::vector{UINT32_C(5), UINT32_C(5), UINT32_C(743), UINT32_C(231223)});
  assert_that(tools::prime_factorization(UINT32_C(4294967226)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(11), UINT32_C(2953), UINT32_C(22037)});
  assert_that(tools::prime_factorization(UINT32_C(4294967227)) == std::vector{UINT32_C(17), UINT32_C(252645131)});
  assert_that(tools::prime_factorization(UINT32_C(4294967228)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(101), UINT32_C(10631107)});
  assert_that(tools::prime_factorization(UINT32_C(4294967229)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(7), UINT32_C(977), UINT32_C(69779)});
  assert_that(tools::prime_factorization(UINT32_C(4294967230)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(31), UINT32_C(13854733)});
  assert_that(tools::prime_factorization(UINT32_C(4294967231)) == std::vector{UINT32_C(4294967231)});
  assert_that(tools::prime_factorization(UINT32_C(4294967232)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(2731), UINT32_C(8191)});
  assert_that(tools::prime_factorization(UINT32_C(4294967233)) == std::vector{UINT32_C(19), UINT32_C(103), UINT32_C(617), UINT32_C(3557)});
  assert_that(tools::prime_factorization(UINT32_C(4294967234)) == std::vector{UINT32_C(2), UINT32_C(6733), UINT32_C(318949)});
  assert_that(tools::prime_factorization(UINT32_C(4294967235)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(13), UINT32_C(22025473)});
  assert_that(tools::prime_factorization(UINT32_C(4294967236)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(7), UINT32_C(367), UINT32_C(417961)});
  assert_that(tools::prime_factorization(UINT32_C(4294967237)) == std::vector{UINT32_C(11), UINT32_C(11), UINT32_C(43), UINT32_C(825479)});
  assert_that(tools::prime_factorization(UINT32_C(4294967238)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(23), UINT32_C(353), UINT32_C(29389)});
  assert_that(tools::prime_factorization(UINT32_C(4294967239)) == std::vector{UINT32_C(61), UINT32_C(70409299)});
  assert_that(tools::prime_factorization(UINT32_C(4294967240)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(4603), UINT32_C(23327)});
  assert_that(tools::prime_factorization(UINT32_C(4294967241)) == std::vector{UINT32_C(3), UINT32_C(1431655747)});
  assert_that(tools::prime_factorization(UINT32_C(4294967242)) == std::vector{UINT32_C(2), UINT32_C(14741), UINT32_C(145681)});
  assert_that(tools::prime_factorization(UINT32_C(4294967243)) == std::vector{UINT32_C(7), UINT32_C(991), UINT32_C(619139)});
  assert_that(tools::prime_factorization(UINT32_C(4294967244)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(17), UINT32_C(467), UINT32_C(45083)});
  assert_that(tools::prime_factorization(UINT32_C(4294967245)) == std::vector{UINT32_C(5), UINT32_C(59), UINT32_C(211), UINT32_C(69001)});
  assert_that(tools::prime_factorization(UINT32_C(4294967246)) == std::vector{UINT32_C(2), UINT32_C(79), UINT32_C(967), UINT32_C(28111)});
  assert_that(tools::prime_factorization(UINT32_C(4294967247)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(809), UINT32_C(65543)});
  assert_that(tools::prime_factorization(UINT32_C(4294967248)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(11), UINT32_C(13), UINT32_C(1877171)});
  assert_that(tools::prime_factorization(UINT32_C(4294967249)) == std::vector{UINT32_C(269), UINT32_C(15966421)});
  assert_that(tools::prime_factorization(UINT32_C(4294967250)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(5), UINT32_C(5), UINT32_C(5), UINT32_C(7), UINT32_C(199), UINT32_C(4111)});
  assert_that(tools::prime_factorization(UINT32_C(4294967251)) == std::vector{UINT32_C(29), UINT32_C(89), UINT32_C(1664071)});
  assert_that(tools::prime_factorization(UINT32_C(4294967252)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(19), UINT32_C(37), UINT32_C(1527371)});
  assert_that(tools::prime_factorization(UINT32_C(4294967253)) == std::vector{UINT32_C(3), UINT32_C(1431655751)});
  assert_that(tools::prime_factorization(UINT32_C(4294967254)) == std::vector{UINT32_C(2), UINT32_C(47), UINT32_C(53), UINT32_C(862097)});
  assert_that(tools::prime_factorization(UINT32_C(4294967255)) == std::vector{UINT32_C(5), UINT32_C(139), UINT32_C(1451), UINT32_C(4259)});
  assert_that(tools::prime_factorization(UINT32_C(4294967256)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(59652323)});
  assert_that(tools::prime_factorization(UINT32_C(4294967257)) == std::vector{UINT32_C(7), UINT32_C(7), UINT32_C(1061), UINT32_C(82613)});
  assert_that(tools::prime_factorization(UINT32_C(4294967258)) == std::vector{UINT32_C(2), UINT32_C(2147483629)});
  assert_that(tools::prime_factorization(UINT32_C(4294967259)) == std::vector{UINT32_C(3), UINT32_C(11), UINT32_C(41), UINT32_C(659), UINT32_C(4817)});
  assert_that(tools::prime_factorization(UINT32_C(4294967260)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(6553), UINT32_C(32771)});
  assert_that(tools::prime_factorization(UINT32_C(4294967261)) == std::vector{UINT32_C(13), UINT32_C(17), UINT32_C(23), UINT32_C(31), UINT32_C(97), UINT32_C(281)});
  assert_that(tools::prime_factorization(UINT32_C(4294967262)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(137), UINT32_C(263), UINT32_C(19867)});
  assert_that(tools::prime_factorization(UINT32_C(4294967263)) == std::vector{UINT32_C(67), UINT32_C(64103989)});
  assert_that(tools::prime_factorization(UINT32_C(4294967264)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(7), UINT32_C(73), UINT32_C(262657)});
  assert_that(tools::prime_factorization(UINT32_C(4294967265)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(5), UINT32_C(95443717)});
  assert_that(tools::prime_factorization(UINT32_C(4294967266)) == std::vector{UINT32_C(2), UINT32_C(5843), UINT32_C(367531)});
  assert_that(tools::prime_factorization(UINT32_C(4294967267)) == std::vector{UINT32_C(107), UINT32_C(1069), UINT32_C(37549)});
  assert_that(tools::prime_factorization(UINT32_C(4294967268)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(12097), UINT32_C(29587)});
  assert_that(tools::prime_factorization(UINT32_C(4294967269)) == std::vector{UINT32_C(277), UINT32_C(433), UINT32_C(35809)});
  assert_that(tools::prime_factorization(UINT32_C(4294967270)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(11), UINT32_C(337), UINT32_C(115861)});
  assert_that(tools::prime_factorization(UINT32_C(4294967271)) == std::vector{UINT32_C(3), UINT32_C(7), UINT32_C(19), UINT32_C(3121), UINT32_C(3449)});
  assert_that(tools::prime_factorization(UINT32_C(4294967272)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(536870909)});
  assert_that(tools::prime_factorization(UINT32_C(4294967273)) == std::vector{UINT32_C(10847), UINT32_C(395959)});
  assert_that(tools::prime_factorization(UINT32_C(4294967274)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(13), UINT32_C(6118187)});
  assert_that(tools::prime_factorization(UINT32_C(4294967275)) == std::vector{UINT32_C(5), UINT32_C(5), UINT32_C(171798691)});
  assert_that(tools::prime_factorization(UINT32_C(4294967276)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2969), UINT32_C(361651)});
  assert_that(tools::prime_factorization(UINT32_C(4294967277)) == std::vector{UINT32_C(3), UINT32_C(769), UINT32_C(1861711)});
  assert_that(tools::prime_factorization(UINT32_C(4294967278)) == std::vector{UINT32_C(2), UINT32_C(7), UINT32_C(17), UINT32_C(18046081)});
  assert_that(tools::prime_factorization(UINT32_C(4294967279)) == std::vector{UINT32_C(4294967279)});
  assert_that(tools::prime_factorization(UINT32_C(4294967280)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(5), UINT32_C(29), UINT32_C(43), UINT32_C(113), UINT32_C(127)});
  assert_that(tools::prime_factorization(UINT32_C(4294967281)) == std::vector{UINT32_C(11), UINT32_C(181), UINT32_C(241), UINT32_C(8951)});
  assert_that(tools::prime_factorization(UINT32_C(4294967282)) == std::vector{UINT32_C(2), UINT32_C(2699), UINT32_C(795659)});
  assert_that(tools::prime_factorization(UINT32_C(4294967283)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(389), UINT32_C(1226783)});
  assert_that(tools::prime_factorization(UINT32_C(4294967284)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(23), UINT32_C(46684427)});
  assert_that(tools::prime_factorization(UINT32_C(4294967285)) == std::vector{UINT32_C(5), UINT32_C(7), UINT32_C(122713351)});
  assert_that(tools::prime_factorization(UINT32_C(4294967286)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(715827881)});
  assert_that(tools::prime_factorization(UINT32_C(4294967287)) == std::vector{UINT32_C(13), UINT32_C(71), UINT32_C(71), UINT32_C(65539)});
  assert_that(tools::prime_factorization(UINT32_C(4294967288)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(233), UINT32_C(1103), UINT32_C(2089)});
  assert_that(tools::prime_factorization(UINT32_C(4294967289)) == std::vector{UINT32_C(3), UINT32_C(37), UINT32_C(167), UINT32_C(223), UINT32_C(1039)});
  assert_that(tools::prime_factorization(UINT32_C(4294967290)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(19), UINT32_C(22605091)});
  assert_that(tools::prime_factorization(UINT32_C(4294967291)) == std::vector{UINT32_C(4294967291)});
  assert_that(tools::prime_factorization(UINT32_C(4294967292)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(7), UINT32_C(11), UINT32_C(31), UINT32_C(151), UINT32_C(331)});
  assert_that(tools::prime_factorization(UINT32_C(4294967293)) == std::vector{UINT32_C(9241), UINT32_C(464773)});
  assert_that(tools::prime_factorization(UINT32_C(4294967294)) == std::vector{UINT32_C(2), UINT32_C(2147483647)});
  assert_that(tools::prime_factorization(UINT32_C(4294967295)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(17), UINT32_C(257), UINT32_C(65537)});

  assert_that(tools::prime_factorization(INT64_C(1)) == std::vector<std::int64_t>{});
  assert_that(tools::prime_factorization(INT64_C(2)) == std::vector{INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(3)) == std::vector{INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(4)) == std::vector{INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(5)) == std::vector{INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(6)) == std::vector{INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(7)) == std::vector{INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(8)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(9)) == std::vector{INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(10)) == std::vector{INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(11)) == std::vector{INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(12)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(13)) == std::vector{INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(14)) == std::vector{INT64_C(2), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(15)) == std::vector{INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(16)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(17)) == std::vector{INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(18)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(19)) == std::vector{INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(20)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(21)) == std::vector{INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(22)) == std::vector{INT64_C(2), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(23)) == std::vector{INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(24)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(25)) == std::vector{INT64_C(5), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(26)) == std::vector{INT64_C(2), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(27)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(28)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(29)) == std::vector{INT64_C(29)});
  assert_that(tools::prime_factorization(INT64_C(30)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(31)) == std::vector{INT64_C(31)});
  assert_that(tools::prime_factorization(INT64_C(32)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(33)) == std::vector{INT64_C(3), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(34)) == std::vector{INT64_C(2), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(35)) == std::vector{INT64_C(5), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(36)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(37)) == std::vector{INT64_C(37)});
  assert_that(tools::prime_factorization(INT64_C(38)) == std::vector{INT64_C(2), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(39)) == std::vector{INT64_C(3), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(40)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(41)) == std::vector{INT64_C(41)});
  assert_that(tools::prime_factorization(INT64_C(42)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(43)) == std::vector{INT64_C(43)});
  assert_that(tools::prime_factorization(INT64_C(44)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(45)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(46)) == std::vector{INT64_C(2), INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(47)) == std::vector{INT64_C(47)});
  assert_that(tools::prime_factorization(INT64_C(48)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(49)) == std::vector{INT64_C(7), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(50)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(51)) == std::vector{INT64_C(3), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(52)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(53)) == std::vector{INT64_C(53)});
  assert_that(tools::prime_factorization(INT64_C(54)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(55)) == std::vector{INT64_C(5), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(56)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(57)) == std::vector{INT64_C(3), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(58)) == std::vector{INT64_C(2), INT64_C(29)});
  assert_that(tools::prime_factorization(INT64_C(59)) == std::vector{INT64_C(59)});
  assert_that(tools::prime_factorization(INT64_C(60)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(61)) == std::vector{INT64_C(61)});
  assert_that(tools::prime_factorization(INT64_C(62)) == std::vector{INT64_C(2), INT64_C(31)});
  assert_that(tools::prime_factorization(INT64_C(63)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(64)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(65)) == std::vector{INT64_C(5), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(66)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(67)) == std::vector{INT64_C(67)});
  assert_that(tools::prime_factorization(INT64_C(68)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(69)) == std::vector{INT64_C(3), INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(70)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(71)) == std::vector{INT64_C(71)});
  assert_that(tools::prime_factorization(INT64_C(72)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(73)) == std::vector{INT64_C(73)});
  assert_that(tools::prime_factorization(INT64_C(74)) == std::vector{INT64_C(2), INT64_C(37)});
  assert_that(tools::prime_factorization(INT64_C(75)) == std::vector{INT64_C(3), INT64_C(5), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(76)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(77)) == std::vector{INT64_C(7), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(78)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(79)) == std::vector{INT64_C(79)});
  assert_that(tools::prime_factorization(INT64_C(80)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(81)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(82)) == std::vector{INT64_C(2), INT64_C(41)});
  assert_that(tools::prime_factorization(INT64_C(83)) == std::vector{INT64_C(83)});
  assert_that(tools::prime_factorization(INT64_C(84)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(85)) == std::vector{INT64_C(5), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(86)) == std::vector{INT64_C(2), INT64_C(43)});
  assert_that(tools::prime_factorization(INT64_C(87)) == std::vector{INT64_C(3), INT64_C(29)});
  assert_that(tools::prime_factorization(INT64_C(88)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(89)) == std::vector{INT64_C(89)});
  assert_that(tools::prime_factorization(INT64_C(90)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(91)) == std::vector{INT64_C(7), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(92)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(93)) == std::vector{INT64_C(3), INT64_C(31)});
  assert_that(tools::prime_factorization(INT64_C(94)) == std::vector{INT64_C(2), INT64_C(47)});
  assert_that(tools::prime_factorization(INT64_C(95)) == std::vector{INT64_C(5), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(96)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(97)) == std::vector{INT64_C(97)});
  assert_that(tools::prime_factorization(INT64_C(98)) == std::vector{INT64_C(2), INT64_C(7), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(99)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(100)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(5)});

  assert_that(tools::prime_factorization(INT64_C(9200527969062830400)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(5), INT64_C(7), INT64_C(7), INT64_C(11), INT64_C(13), INT64_C(17), INT64_C(19), INT64_C(23), INT64_C(29), INT64_C(31), INT64_C(37), INT64_C(41)});

  assert_that(tools::prime_factorization(INT64_C(9223372036854775708)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(1319), INT64_C(1748175139661633)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775709)) == std::vector{INT64_C(7), INT64_C(7), INT64_C(13), INT64_C(29), INT64_C(2729), INT64_C(182956886477)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775710)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(131), INT64_C(2699), INT64_C(364289), INT64_C(795659)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775711)) == std::vector{INT64_C(1171), INT64_C(16573), INT64_C(475260479017)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775712)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(11), INT64_C(26202761468337431)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775713)) == std::vector{INT64_C(3), INT64_C(23), INT64_C(133672058505141677)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775714)) == std::vector{INT64_C(2), INT64_C(17), INT64_C(19), INT64_C(215153), INT64_C(66360523403)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775715)) == std::vector{INT64_C(5), INT64_C(1844674407370955143)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775716)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(7), INT64_C(1607), INT64_C(2067431), INT64_C(33049397)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775717)) == std::vector{INT64_C(59), INT64_C(156328339607708063)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775718)) == std::vector{INT64_C(2), INT64_C(41), INT64_C(101), INT64_C(4051), INT64_C(6199), INT64_C(44347651)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775719)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(1024819115206086191)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775720)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(4229), INT64_C(54524545027517)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775721)) == std::vector{INT64_C(53), INT64_C(1791191), INT64_C(97156521827)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775722)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(13), INT64_C(3109), INT64_C(38034210179111)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775723)) == std::vector{INT64_C(7), INT64_C(11), INT64_C(43), INT64_C(27109), INT64_C(234293), INT64_C(438589)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775724)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(124367), INT64_C(18540633843493)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775725)) == std::vector{INT64_C(3), INT64_C(5), INT64_C(5), INT64_C(47), INT64_C(47), INT64_C(55671477512327)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775726)) == std::vector{INT64_C(2), INT64_C(1087), INT64_C(4242581433695849)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775727)) == std::vector{INT64_C(11113), INT64_C(829962389710679)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775728)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(37), INT64_C(34519), INT64_C(83717), INT64_C(199679)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775729)) == std::vector{INT64_C(97), INT64_C(103), INT64_C(2707), INT64_C(32233), INT64_C(10580149)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775730)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(7), INT64_C(89), INT64_C(1480477052464651)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775731)) == std::vector{INT64_C(3), INT64_C(17), INT64_C(319856591), INT64_C(565410991)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775732)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(71), INT64_C(139), INT64_C(1193693), INT64_C(195732949)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775733)) == std::vector{INT64_C(19), INT64_C(239), INT64_C(6197), INT64_C(8209), INT64_C(39926981)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775734)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(11), INT64_C(73), INT64_C(3527), INT64_C(542772044869)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775735)) == std::vector{INT64_C(5), INT64_C(13), INT64_C(141898031336227319)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775736)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(23), INT64_C(46684427), INT64_C(1073741827)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775737)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(7), INT64_C(313), INT64_C(68329), INT64_C(6845414887)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775738)) == std::vector{INT64_C(2), INT64_C(29), INT64_C(31), INT64_C(17597), INT64_C(33289), INT64_C(8757107)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775739)) == std::vector{INT64_C(61), INT64_C(3264649), INT64_C(46315184351)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775740)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(5), INT64_C(153722867280912929)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775741)) == std::vector{INT64_C(75883), INT64_C(299881), INT64_C(405318367)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775742)) == std::vector{INT64_C(2), INT64_C(252449), INT64_C(18267792775679)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775743)) == std::vector{INT64_C(3), INT64_C(79), INT64_C(116533), INT64_C(333958463183)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775744)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(7), INT64_C(32377), INT64_C(524287), INT64_C(1212847)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775745)) == std::vector{INT64_C(5), INT64_C(11), INT64_C(199), INT64_C(11587), INT64_C(72728219243)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775746)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(179), INT64_C(23021), INT64_C(124348343983)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775747)) == std::vector{INT64_C(677), INT64_C(78919), INT64_C(172631277569)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775748)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(13), INT64_C(17), INT64_C(37359691), INT64_C(279276367)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775749)) == std::vector{INT64_C(3), INT64_C(8447), INT64_C(363970326224489)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775750)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(5), INT64_C(5), INT64_C(36893488147419103)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775751)) == std::vector{INT64_C(7), INT64_C(17659), INT64_C(74614903261427)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775752)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(19), INT64_C(93053), INT64_C(217367447189)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775753)) == std::vector{INT64_C(266416229), INT64_C(34620158357)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775754)) == std::vector{INT64_C(2), INT64_C(343242169), INT64_C(13435662733)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775755)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(68321274347072413)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775756)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(11), INT64_C(227), INT64_C(263), INT64_C(18341), INT64_C(191439889)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775757)) == std::vector{INT64_C(149), INT64_C(5987), INT64_C(10339372933139)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775758)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(7), INT64_C(7), INT64_C(43826197), INT64_C(715827881)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775759)) == std::vector{INT64_C(23), INT64_C(41), INT64_C(620441), INT64_C(15764403593)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775760)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(2663), INT64_C(43294085790719)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775761)) == std::vector{INT64_C(3), INT64_C(13), INT64_C(13), INT64_C(619), INT64_C(739), INT64_C(39769184003)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775762)) == std::vector{INT64_C(2), INT64_C(107), INT64_C(1117), INT64_C(38585379884599)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775763)) == std::vector{INT64_C(4481), INT64_C(63601), INT64_C(32363153923)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775764)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(256204778801521549)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775765)) == std::vector{INT64_C(5), INT64_C(7), INT64_C(17), INT64_C(37), INT64_C(418958529950251)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775766)) == std::vector{INT64_C(2), INT64_C(43), INT64_C(67), INT64_C(193), INT64_C(809383), INT64_C(10247197)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775767)) == std::vector{INT64_C(3), INT64_C(11), INT64_C(29), INT64_C(19473149), INT64_C(494927519)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775768)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(409), INT64_C(1793599), INT64_C(1571632781)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775769)) == std::vector{INT64_C(31), INT64_C(10037), INT64_C(29643133428427)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775770)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(5), INT64_C(986507), INT64_C(311650839337)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775771)) == std::vector{INT64_C(19), INT64_C(485440633518672409)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775772)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(7), INT64_C(47), INT64_C(8627903), INT64_C(812322689)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775773)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(1024819115206086197)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775774)) == std::vector{INT64_C(2), INT64_C(13), INT64_C(53), INT64_C(6693303364916383)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775775)) == std::vector{INT64_C(5), INT64_C(5), INT64_C(109), INT64_C(57881), INT64_C(58477284139)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775776)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(59), INT64_C(233), INT64_C(1103), INT64_C(2089), INT64_C(3033169)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775777)) == std::vector{INT64_C(584911), INT64_C(15768846947407)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775778)) == std::vector{INT64_C(2), INT64_C(11), INT64_C(137), INT64_C(547), INT64_C(5594472617641)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775779)) == std::vector{INT64_C(3), INT64_C(7), INT64_C(439208192231179799)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775780)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(461168601842738789)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775781)) == std::vector{INT64_C(773), INT64_C(2713), INT64_C(19993), INT64_C(219979633)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775782)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(17), INT64_C(23), INT64_C(319279), INT64_C(456065899)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775783)) == std::vector{INT64_C(9223372036854775783)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775784)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(1177067), INT64_C(979486728119)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775785)) == std::vector{INT64_C(3), INT64_C(5), INT64_C(24097), INT64_C(25517345276327)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775786)) == std::vector{INT64_C(2), INT64_C(7), INT64_C(181), INT64_C(229), INT64_C(3697), INT64_C(4299304283)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775787)) == std::vector{INT64_C(13), INT64_C(440303), INT64_C(1611367982233)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775788)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(643), INT64_C(1195356666259043)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775789)) == std::vector{INT64_C(11), INT64_C(3931), INT64_C(213301543369829)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775790)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(19), INT64_C(83), INT64_C(1277), INT64_C(20261), INT64_C(22605091)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775791)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(14737), INT64_C(4837853), INT64_C(14374259)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775792)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(179951), INT64_C(3203431780337)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775793)) == std::vector{INT64_C(7), INT64_C(113), INT64_C(5647), INT64_C(2064883032409)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775794)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3491), INT64_C(440340496364689)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775795)) == std::vector{INT64_C(5), INT64_C(191), INT64_C(421), INT64_C(90679), INT64_C(252986611)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775796)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(29), INT64_C(79511827903920481)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775797)) == std::vector{INT64_C(3), INT64_C(3074457345618258599)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775798)) == std::vector{INT64_C(2), INT64_C(34421), INT64_C(133978850655919)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775799)) == std::vector{INT64_C(17), INT64_C(17), INT64_C(17), INT64_C(2927), INT64_C(641387128649)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775800)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(5), INT64_C(7), INT64_C(11), INT64_C(13), INT64_C(31), INT64_C(41), INT64_C(61), INT64_C(151), INT64_C(331), INT64_C(1321)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775801)) == std::vector{INT64_C(157), INT64_C(1973), INT64_C(29775769179641)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775802)) == std::vector{INT64_C(2), INT64_C(37), INT64_C(9902437), INT64_C(12586817029)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775803)) == std::vector{INT64_C(3), INT64_C(71), INT64_C(42013), INT64_C(1030686124187)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775804)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2305843009213693951)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775805)) == std::vector{INT64_C(5), INT64_C(23), INT64_C(53301701), INT64_C(1504703107)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775806)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(715827883), INT64_C(2147483647)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775807)) == std::vector{INT64_C(7), INT64_C(7), INT64_C(73), INT64_C(127), INT64_C(337), INT64_C(92737), INT64_C(649657)});

  assert_that(tools::prime_factorization(UINT64_C(1)) == std::vector<std::uint64_t>{});
  assert_that(tools::prime_factorization(UINT64_C(2)) == std::vector{UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(3)) == std::vector{UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(4)) == std::vector{UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(5)) == std::vector{UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(6)) == std::vector{UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(7)) == std::vector{UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(8)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(9)) == std::vector{UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(10)) == std::vector{UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(11)) == std::vector{UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(12)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(13)) == std::vector{UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(14)) == std::vector{UINT64_C(2), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(15)) == std::vector{UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(16)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(17)) == std::vector{UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(18)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(19)) == std::vector{UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(20)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(21)) == std::vector{UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(22)) == std::vector{UINT64_C(2), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(23)) == std::vector{UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(24)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(25)) == std::vector{UINT64_C(5), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(26)) == std::vector{UINT64_C(2), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(27)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(28)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(29)) == std::vector{UINT64_C(29)});
  assert_that(tools::prime_factorization(UINT64_C(30)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(31)) == std::vector{UINT64_C(31)});
  assert_that(tools::prime_factorization(UINT64_C(32)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(33)) == std::vector{UINT64_C(3), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(34)) == std::vector{UINT64_C(2), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(35)) == std::vector{UINT64_C(5), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(36)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(37)) == std::vector{UINT64_C(37)});
  assert_that(tools::prime_factorization(UINT64_C(38)) == std::vector{UINT64_C(2), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(39)) == std::vector{UINT64_C(3), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(40)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(41)) == std::vector{UINT64_C(41)});
  assert_that(tools::prime_factorization(UINT64_C(42)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(43)) == std::vector{UINT64_C(43)});
  assert_that(tools::prime_factorization(UINT64_C(44)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(45)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(46)) == std::vector{UINT64_C(2), UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(47)) == std::vector{UINT64_C(47)});
  assert_that(tools::prime_factorization(UINT64_C(48)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(49)) == std::vector{UINT64_C(7), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(50)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(51)) == std::vector{UINT64_C(3), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(52)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(53)) == std::vector{UINT64_C(53)});
  assert_that(tools::prime_factorization(UINT64_C(54)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(55)) == std::vector{UINT64_C(5), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(56)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(57)) == std::vector{UINT64_C(3), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(58)) == std::vector{UINT64_C(2), UINT64_C(29)});
  assert_that(tools::prime_factorization(UINT64_C(59)) == std::vector{UINT64_C(59)});
  assert_that(tools::prime_factorization(UINT64_C(60)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(61)) == std::vector{UINT64_C(61)});
  assert_that(tools::prime_factorization(UINT64_C(62)) == std::vector{UINT64_C(2), UINT64_C(31)});
  assert_that(tools::prime_factorization(UINT64_C(63)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(64)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(65)) == std::vector{UINT64_C(5), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(66)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(67)) == std::vector{UINT64_C(67)});
  assert_that(tools::prime_factorization(UINT64_C(68)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(69)) == std::vector{UINT64_C(3), UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(70)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(71)) == std::vector{UINT64_C(71)});
  assert_that(tools::prime_factorization(UINT64_C(72)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(73)) == std::vector{UINT64_C(73)});
  assert_that(tools::prime_factorization(UINT64_C(74)) == std::vector{UINT64_C(2), UINT64_C(37)});
  assert_that(tools::prime_factorization(UINT64_C(75)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(76)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(77)) == std::vector{UINT64_C(7), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(78)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(79)) == std::vector{UINT64_C(79)});
  assert_that(tools::prime_factorization(UINT64_C(80)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(81)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(82)) == std::vector{UINT64_C(2), UINT64_C(41)});
  assert_that(tools::prime_factorization(UINT64_C(83)) == std::vector{UINT64_C(83)});
  assert_that(tools::prime_factorization(UINT64_C(84)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(85)) == std::vector{UINT64_C(5), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(86)) == std::vector{UINT64_C(2), UINT64_C(43)});
  assert_that(tools::prime_factorization(UINT64_C(87)) == std::vector{UINT64_C(3), UINT64_C(29)});
  assert_that(tools::prime_factorization(UINT64_C(88)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(89)) == std::vector{UINT64_C(89)});
  assert_that(tools::prime_factorization(UINT64_C(90)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(91)) == std::vector{UINT64_C(7), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(92)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(93)) == std::vector{UINT64_C(3), UINT64_C(31)});
  assert_that(tools::prime_factorization(UINT64_C(94)) == std::vector{UINT64_C(2), UINT64_C(47)});
  assert_that(tools::prime_factorization(UINT64_C(95)) == std::vector{UINT64_C(5), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(96)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(97)) == std::vector{UINT64_C(97)});
  assert_that(tools::prime_factorization(UINT64_C(98)) == std::vector{UINT64_C(2), UINT64_C(7), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(99)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(100)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(5)});

  assert_that(tools::prime_factorization(UINT64_C(18401055938125660800)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(5), UINT64_C(5), UINT64_C(7), UINT64_C(7), UINT64_C(11), UINT64_C(13), UINT64_C(17), UINT64_C(19), UINT64_C(23), UINT64_C(29), UINT64_C(31), UINT64_C(37), UINT64_C(41)});

  assert_that(tools::prime_factorization(UINT64_C(18446744073709551516)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(7), UINT64_C(7), UINT64_C(43826197), UINT64_C(715827881)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551517)) == std::vector{UINT64_C(397), UINT64_C(46465350311610961)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551518)) == std::vector{UINT64_C(2), UINT64_C(23), UINT64_C(41), UINT64_C(620441), UINT64_C(15764403593)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551519)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(307), UINT64_C(405029), UINT64_C(16483624697)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551520)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(2663), UINT64_C(43294085790719)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551521)) == std::vector{UINT64_C(18446744073709551521)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551522)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(13), UINT64_C(13), UINT64_C(619), UINT64_C(739), UINT64_C(39769184003)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551523)) == std::vector{UINT64_C(7), UINT64_C(11), UINT64_C(11), UINT64_C(19), UINT64_C(6897409), UINT64_C(166186879)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551524)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(107), UINT64_C(1117), UINT64_C(38585379884599)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551525)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(5), UINT64_C(4441), UINT64_C(55383154165607)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551526)) == std::vector{UINT64_C(2), UINT64_C(4481), UINT64_C(63601), UINT64_C(32363153923)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551527)) == std::vector{UINT64_C(17099), UINT64_C(1078820052266773)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551528)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(256204778801521549)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551529)) == std::vector{UINT64_C(14843), UINT64_C(13973891), UINT64_C(88936633)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551530)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(7), UINT64_C(17), UINT64_C(37), UINT64_C(418958529950251)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551531)) == std::vector{UINT64_C(3), UINT64_C(962165251), UINT64_C(6390705427)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551532)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(43), UINT64_C(67), UINT64_C(193), UINT64_C(809383), UINT64_C(10247197)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551533)) == std::vector{UINT64_C(18446744073709551533)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551534)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(11), UINT64_C(29), UINT64_C(19473149), UINT64_C(494927519)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551535)) == std::vector{UINT64_C(5), UINT64_C(13), UINT64_C(71), UINT64_C(71), UINT64_C(9629), UINT64_C(65539), UINT64_C(89209)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551536)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(409), UINT64_C(1793599), UINT64_C(1571632781)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551537)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(7), UINT64_C(101), UINT64_C(7623919), UINT64_C(126753007)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551538)) == std::vector{UINT64_C(2), UINT64_C(31), UINT64_C(10037), UINT64_C(29643133428427)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551539)) == std::vector{UINT64_C(61), UINT64_C(268909), UINT64_C(1124564966411)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551540)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(5), UINT64_C(986507), UINT64_C(311650839337)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551541)) == std::vector{UINT64_C(23), UINT64_C(73), UINT64_C(7283), UINT64_C(1508546551513)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551542)) == std::vector{UINT64_C(2), UINT64_C(19), UINT64_C(485440633518672409)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551543)) == std::vector{UINT64_C(3), UINT64_C(839), UINT64_C(7328861372153179)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551544)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(7), UINT64_C(47), UINT64_C(8627903), UINT64_C(812322689)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551545)) == std::vector{UINT64_C(5), UINT64_C(11), UINT64_C(3319), UINT64_C(36871), UINT64_C(2740721231)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551546)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(1024819115206086197)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551547)) == std::vector{UINT64_C(17), UINT64_C(211), UINT64_C(251), UINT64_C(1101431), UINT64_C(18601901)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551548)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(13), UINT64_C(53), UINT64_C(6693303364916383)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551549)) == std::vector{UINT64_C(3), UINT64_C(89), UINT64_C(69088929115017047)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551550)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(5), UINT64_C(109), UINT64_C(57881), UINT64_C(58477284139)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551551)) == std::vector{UINT64_C(7), UINT64_C(131), UINT64_C(20116405751046403)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551552)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(59), UINT64_C(233), UINT64_C(1103), UINT64_C(2089), UINT64_C(3033169)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551553)) == std::vector{UINT64_C(401), UINT64_C(119241217), UINT64_C(385788209)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551554)) == std::vector{UINT64_C(2), UINT64_C(584911), UINT64_C(15768846947407)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551555)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(5), UINT64_C(97), UINT64_C(197), UINT64_C(325957), UINT64_C(65812583)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551556)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(11), UINT64_C(137), UINT64_C(547), UINT64_C(5594472617641)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551557)) == std::vector{UINT64_C(18446744073709551557)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551558)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(7), UINT64_C(439208192231179799)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551559)) == std::vector{UINT64_C(41), UINT64_C(163), UINT64_C(269), UINT64_C(8807), UINT64_C(1165112831)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551560)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(461168601842738789)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551561)) == std::vector{UINT64_C(3), UINT64_C(13), UINT64_C(19), UINT64_C(103), UINT64_C(1811), UINT64_C(133458377137)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551562)) == std::vector{UINT64_C(2), UINT64_C(773), UINT64_C(2713), UINT64_C(19993), UINT64_C(219979633)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551563)) == std::vector{UINT64_C(29), UINT64_C(74187931), UINT64_C(8574098437)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551564)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(17), UINT64_C(23), UINT64_C(319279), UINT64_C(456065899)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551565)) == std::vector{UINT64_C(5), UINT64_C(7), UINT64_C(7), UINT64_C(79), UINT64_C(599), UINT64_C(659), UINT64_C(2414428283)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551566)) == std::vector{UINT64_C(2), UINT64_C(9223372036854775783)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551567)) == std::vector{UINT64_C(3), UINT64_C(11), UINT64_C(37), UINT64_C(167), UINT64_C(223), UINT64_C(1039), UINT64_C(6323), UINT64_C(61751)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551568)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(1177067), UINT64_C(979486728119)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551569)) == std::vector{UINT64_C(31), UINT64_C(173), UINT64_C(9419), UINT64_C(439771), UINT64_C(830387)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551570)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(5), UINT64_C(24097), UINT64_C(25517345276327)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551571)) == std::vector{UINT64_C(11071), UINT64_C(844709), UINT64_C(1972539689)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551572)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(7), UINT64_C(181), UINT64_C(229), UINT64_C(3697), UINT64_C(4299304283)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551573)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(31799), UINT64_C(64456059323003)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551574)) == std::vector{UINT64_C(2), UINT64_C(13), UINT64_C(440303), UINT64_C(1611367982233)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551575)) == std::vector{UINT64_C(5), UINT64_C(5), UINT64_C(43), UINT64_C(122099), UINT64_C(140539741759)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551576)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(643), UINT64_C(1195356666259043)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551577)) == std::vector{UINT64_C(139646831), UINT64_C(132095686967)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551578)) == std::vector{UINT64_C(2), UINT64_C(11), UINT64_C(3931), UINT64_C(213301543369829)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551579)) == std::vector{UINT64_C(3), UINT64_C(7), UINT64_C(57906439), UINT64_C(15169580441)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551580)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(19), UINT64_C(83), UINT64_C(1277), UINT64_C(20261), UINT64_C(22605091)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551581)) == std::vector{UINT64_C(17), UINT64_C(72786899), UINT64_C(14907938207)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551582)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(14737), UINT64_C(4837853), UINT64_C(14374259)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551583)) == std::vector{UINT64_C(827), UINT64_C(3894899), UINT64_C(5726879071)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551584)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(179951), UINT64_C(3203431780337)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551585)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(499), UINT64_C(2593), UINT64_C(950441521877)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551586)) == std::vector{UINT64_C(2), UINT64_C(7), UINT64_C(113), UINT64_C(5647), UINT64_C(2064883032409)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551587)) == std::vector{UINT64_C(13), UINT64_C(23), UINT64_C(23), UINT64_C(16561661), UINT64_C(161963371)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551588)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3491), UINT64_C(440340496364689)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551589)) == std::vector{UINT64_C(11), UINT64_C(13177), UINT64_C(127265442359687)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551590)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(191), UINT64_C(421), UINT64_C(90679), UINT64_C(252986611)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551591)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(47), UINT64_C(3384529), UINT64_C(4294967291)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551592)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(29), UINT64_C(79511827903920481)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551593)) == std::vector{UINT64_C(7), UINT64_C(16547), UINT64_C(159258424692517)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551594)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3074457345618258599)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551595)) == std::vector{UINT64_C(5), UINT64_C(373), UINT64_C(3301), UINT64_C(2996369460503)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551596)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(34421), UINT64_C(133978850655919)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551597)) == std::vector{UINT64_C(3), UINT64_C(6148914691236517199)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551598)) == std::vector{UINT64_C(2), UINT64_C(17), UINT64_C(17), UINT64_C(17), UINT64_C(2927), UINT64_C(641387128649)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551599)) == std::vector{UINT64_C(19), UINT64_C(67), UINT64_C(14490765179661863)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551600)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(5), UINT64_C(5), UINT64_C(7), UINT64_C(11), UINT64_C(13), UINT64_C(31), UINT64_C(41), UINT64_C(61), UINT64_C(151), UINT64_C(331), UINT64_C(1321)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551601)) == std::vector{UINT64_C(53), UINT64_C(348051774975651917)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551602)) == std::vector{UINT64_C(2), UINT64_C(157), UINT64_C(1973), UINT64_C(29775769179641)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551603)) == std::vector{UINT64_C(3), UINT64_C(139), UINT64_C(2306123), UINT64_C(19182323033)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551604)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(37), UINT64_C(9902437), UINT64_C(12586817029)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551605)) == std::vector{UINT64_C(5), UINT64_C(2551), UINT64_C(1446236305269271)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551606)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(71), UINT64_C(42013), UINT64_C(1030686124187)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551607)) == std::vector{UINT64_C(7), UINT64_C(9241), UINT64_C(464773), UINT64_C(613566757)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551608)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2305843009213693951)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551609)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(818923289), UINT64_C(2502845209)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551610)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(23), UINT64_C(53301701), UINT64_C(1504703107)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551611)) == std::vector{UINT64_C(11), UINT64_C(59), UINT64_C(98818999), UINT64_C(287630261)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551612)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(715827883), UINT64_C(2147483647)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551613)) == std::vector{UINT64_C(13), UINT64_C(3889), UINT64_C(364870227143809)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551614)) == std::vector{UINT64_C(2), UINT64_C(7), UINT64_C(7), UINT64_C(73), UINT64_C(127), UINT64_C(337), UINT64_C(92737), UINT64_C(649657)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551615)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(17), UINT64_C(257), UINT64_C(641), UINT64_C(65537), UINT64_C(6700417)});

  return 0;
}
#line 1 "tests/prime_factorization/severe_cases.test.cpp"
// competitive-verifier: STANDALONE

#include <cstdint>
#include <iostream>
#include <vector>
#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/prime_factorization.hpp"



#include <algorithm>
#include <cassert>
#include <concepts>
#include <numeric>
#include <queue>
#include <tuple>
#include <utility>
#line 1 "tools/floor_log2.hpp"



#line 1 "tools/bit_width.hpp"



#include <bit>
#line 6 "tools/bit_width.hpp"
#include <type_traits>
#line 1 "tools/is_signed.hpp"



#line 5 "tools/is_signed.hpp"

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

  template <typename T>
  inline constexpr bool is_signed_v = tools::is_signed<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 1 "tools/make_unsigned.hpp"



#line 5 "tools/make_unsigned.hpp"

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

  template <typename T>
  using make_unsigned_t = typename tools::make_unsigned<T>::type;
}


#line 1 "tools/non_bool_integral.hpp"



#line 1 "tools/integral.hpp"



#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 5 "tools/integral.hpp"

namespace tools {
  template <typename T>
  concept integral = tools::is_integral_v<T>;
}


#line 7 "tools/non_bool_integral.hpp"

namespace tools {
  template <typename T>
  concept non_bool_integral = tools::integral<T> && !std::same_as<std::remove_cv_t<T>, bool>;
}


#line 12 "tools/bit_width.hpp"

namespace tools {
  namespace detail::bit_width {
    template <tools::non_bool_integral T>
    struct impl {
      constexpr int operator()(const T x) const noexcept(noexcept(impl<tools::make_unsigned_t<T>>{}(x))) requires tools::is_signed_v<T> {
        assert(x >= 0);
        return impl<tools::make_unsigned_t<T>>{}(x);
      }
      constexpr int operator()(const T x) const noexcept(noexcept(std::bit_width(x))) requires tools::is_unsigned_v<T> {
        return std::bit_width(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) bit_width(T&& x) noexcept(noexcept(tools::detail::bit_width::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::bit_width::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 6 "tools/floor_log2.hpp"

namespace tools {
  template <typename T>
  constexpr T floor_log2(T x) noexcept {
    assert(x > 0);
    return tools::bit_width(x) - 1;
  }
}


#line 1 "tools/is_prime.hpp"



#include <array>
#line 1 "tools/prod_mod.hpp"



#line 1 "tools/uint128_t.hpp"



#line 1 "tools/detail/int128_t_and_uint128_t.hpp"



#line 6 "tools/detail/int128_t_and_uint128_t.hpp"
#include <cstddef>
#line 8 "tools/detail/int128_t_and_uint128_t.hpp"
#include <functional>
#line 10 "tools/detail/int128_t_and_uint128_t.hpp"
#include <limits>
#include <string>
#include <string_view>
#line 1 "tools/abs.hpp"



#include <cmath>
#line 7 "tools/abs.hpp"

namespace tools {
  namespace detail::abs {
    template <typename T>
    struct impl {
      constexpr decltype(auto) operator()(const T x) const noexcept(noexcept(std::abs(x))) {
        return std::abs(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) abs(T&& x) noexcept(noexcept(tools::detail::abs::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::abs::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 1 "tools/bit_ceil.hpp"



#line 12 "tools/bit_ceil.hpp"

namespace tools {
  namespace detail::bit_ceil {
    template <tools::non_bool_integral T>
    struct impl {
      constexpr T operator()(const T x) const noexcept(noexcept(impl<tools::make_unsigned_t<T>>{}(x))) requires tools::is_signed_v<T> {
        assert(x >= 0);
        return impl<tools::make_unsigned_t<T>>{}(x);
      }
      constexpr T operator()(const T x) const noexcept(noexcept(std::bit_ceil(x))) requires tools::is_unsigned_v<T> {
        return std::bit_ceil(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) bit_ceil(T&& x) noexcept(noexcept(tools::detail::bit_ceil::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::bit_ceil::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 1 "tools/bit_floor.hpp"



#line 12 "tools/bit_floor.hpp"

namespace tools {
  namespace detail::bit_floor {
    template <tools::non_bool_integral T>
    struct impl {
      constexpr T operator()(const T x) const noexcept(noexcept(impl<tools::make_unsigned_t<T>>{}(x))) requires tools::is_signed_v<T> {
        assert(x >= 0);
        return impl<tools::make_unsigned_t<T>>{}(x);
      }
      constexpr T operator()(const T x) const noexcept(noexcept(std::bit_floor(x))) requires tools::is_unsigned_v<T> {
        return std::bit_floor(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) bit_floor(T&& x) noexcept(noexcept(tools::detail::bit_floor::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::bit_floor::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 1 "tools/countr_zero.hpp"



#line 14 "tools/countr_zero.hpp"

namespace tools {
  namespace detail::countr_zero {
    template <tools::non_bool_integral T>
    struct impl {
      constexpr int operator()(const T x) const noexcept(noexcept(impl<tools::make_unsigned_t<T>>{}(x))) requires tools::is_signed_v<T> {
        assert(x >= 0);
        return std::min(impl<tools::make_unsigned_t<T>>{}(x), std::numeric_limits<T>::digits);
      }
      constexpr int operator()(const T x) const noexcept(noexcept(std::countr_zero(x))) requires tools::is_unsigned_v<T> {
        return std::countr_zero(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) countr_zero(T&& x) noexcept(noexcept(tools::detail::countr_zero::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::countr_zero::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 1 "tools/gcd.hpp"



#line 7 "tools/gcd.hpp"

namespace tools {
  namespace detail::gcd {
    template <typename M, typename N>
    struct impl {
      constexpr decltype(auto) operator()(const M m, const N n) const noexcept(noexcept(std::gcd(m, n))) {
        return std::gcd(m, n);
      }
    };
  }

  template <typename M, typename N>
  constexpr decltype(auto) gcd(M&& m, N&& n) noexcept(noexcept(tools::detail::gcd::impl<std::remove_cvref_t<M>, std::remove_cvref_t<N>>{}(std::forward<M>(m), std::forward<N>(n)))) {
    return tools::detail::gcd::impl<std::remove_cvref_t<M>, std::remove_cvref_t<N>>{}(std::forward<M>(m), std::forward<N>(n));
  }
}


#line 1 "tools/has_single_bit.hpp"



#line 12 "tools/has_single_bit.hpp"

namespace tools {
  namespace detail::has_single_bit {
    template <tools::non_bool_integral T>
    struct impl {
      constexpr bool operator()(const T x) const noexcept(noexcept(impl<tools::make_unsigned_t<T>>{}(x))) requires tools::is_signed_v<T> {
        assert(x >= 0);
        return impl<tools::make_unsigned_t<T>>{}(x);
      }
      constexpr bool operator()(const T x) const noexcept(noexcept(std::has_single_bit(x))) requires tools::is_unsigned_v<T> {
        return std::has_single_bit(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) has_single_bit(T&& x) noexcept(noexcept(tools::detail::has_single_bit::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::has_single_bit::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 1 "tools/hash_combine.hpp"



#line 6 "tools/hash_combine.hpp"

// Source: https://github.com/google/cityhash/blob/f5dc54147fcce12cefd16548c8e760d68ac04226/src/city.h
// License: MIT
// Author: Google Inc.

// Copyright (c) 2011 Google, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

namespace tools {
  template <typename T>
  void hash_combine(std::size_t& seed, const T& v) {
    static const std::hash<T> hasher;
    static constexpr std::size_t k_mul = 0x9ddfea08eb382d69ULL;
    std::size_t a = (hasher(v) ^ seed) * k_mul;
    a ^= (a >> 47);
    std::size_t b = (seed ^ a) * k_mul;
    b ^= (b >> 47);
    seed = b * k_mul;
  }
}


#line 1 "tools/make_signed.hpp"



#line 5 "tools/make_signed.hpp"

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

  template <typename T>
  using make_signed_t = typename tools::make_signed<T>::type;
}


#line 1 "tools/now.hpp"



#include <chrono>

namespace tools {
  inline long long now() {
    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
  }
}


#line 1 "tools/popcount.hpp"



#line 12 "tools/popcount.hpp"

namespace tools {
  namespace detail::popcount {
    template <tools::non_bool_integral T>
    struct impl {
      constexpr int operator()(const T x) const noexcept(noexcept(impl<tools::make_unsigned_t<T>>{}(x))) requires tools::is_signed_v<T> {
        assert(x >= 0);
        return impl<tools::make_unsigned_t<T>>{}(x);
      }
      constexpr int operator()(const T x) const noexcept(noexcept(std::popcount(x))) requires tools::is_unsigned_v<T> {
        return std::popcount(x);
      }
    };
  }

  template <typename T>
  constexpr decltype(auto) popcount(T&& x) noexcept(noexcept(tools::detail::popcount::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x)))) {
    return tools::detail::popcount::impl<std::remove_cvref_t<T>>{}(std::forward<T>(x));
  }
}


#line 31 "tools/detail/int128_t_and_uint128_t.hpp"

namespace tools {
  using uint128_t = unsigned __int128;
  using int128_t = __int128;

  template <>
  struct is_integral<tools::int128_t> : std::true_type {};
  template <>
  struct is_integral<tools::uint128_t> : std::true_type {};
  template <>
  struct is_integral<const tools::int128_t> : std::true_type {};
  template <>
  struct is_integral<const tools::uint128_t> : std::true_type {};
  template <>
  struct is_integral<volatile tools::int128_t> : std::true_type {};
  template <>
  struct is_integral<volatile tools::uint128_t> : std::true_type {};
  template <>
  struct is_integral<const volatile tools::int128_t> : std::true_type {};
  template <>
  struct is_integral<const volatile tools::uint128_t> : std::true_type {};

  template <>
  struct is_signed<tools::int128_t> : std::true_type {};
  template <>
  struct is_signed<tools::uint128_t> : std::false_type {};
  template <>
  struct is_signed<const tools::int128_t> : std::true_type {};
  template <>
  struct is_signed<const tools::uint128_t> : std::false_type {};
  template <>
  struct is_signed<volatile tools::int128_t> : std::true_type {};
  template <>
  struct is_signed<volatile tools::uint128_t> : std::false_type {};
  template <>
  struct is_signed<const volatile tools::int128_t> : std::true_type {};
  template <>
  struct is_signed<const volatile tools::uint128_t> : std::false_type {};

  template <>
  struct is_unsigned<tools::int128_t> : std::false_type {};
  template <>
  struct is_unsigned<tools::uint128_t> : std::true_type {};
  template <>
  struct is_unsigned<const tools::int128_t> : std::false_type {};
  template <>
  struct is_unsigned<const tools::uint128_t> : std::true_type {};
  template <>
  struct is_unsigned<volatile tools::int128_t> : std::false_type {};
  template <>
  struct is_unsigned<volatile tools::uint128_t> : std::true_type {};
  template <>
  struct is_unsigned<const volatile tools::int128_t> : std::false_type {};
  template <>
  struct is_unsigned<const volatile tools::uint128_t> : std::true_type {};

  template <>
  struct make_signed<tools::int128_t> {
    using type = tools::int128_t;
  };
  template <>
  struct make_signed<tools::uint128_t> {
    using type = tools::int128_t;
  };
  template <>
  struct make_signed<const tools::int128_t> {
    using type = const tools::int128_t;
  };
  template <>
  struct make_signed<const tools::uint128_t> {
    using type = const tools::int128_t;
  };
  template <>
  struct make_signed<volatile tools::int128_t> {
    using type = volatile tools::int128_t;
  };
  template <>
  struct make_signed<volatile tools::uint128_t> {
    using type = volatile tools::int128_t;
  };
  template <>
  struct make_signed<const volatile tools::int128_t> {
    using type = const volatile tools::int128_t;
  };
  template <>
  struct make_signed<const volatile tools::uint128_t> {
    using type = const volatile tools::int128_t;
  };

  template <>
  struct make_unsigned<tools::int128_t> {
    using type = tools::uint128_t;
  };
  template <>
  struct make_unsigned<tools::uint128_t> {
    using type = tools::uint128_t;
  };
  template <>
  struct make_unsigned<const tools::int128_t> {
    using type = const tools::uint128_t;
  };
  template <>
  struct make_unsigned<const tools::uint128_t> {
    using type = const tools::uint128_t;
  };
  template <>
  struct make_unsigned<volatile tools::int128_t> {
    using type = volatile tools::uint128_t;
  };
  template <>
  struct make_unsigned<volatile tools::uint128_t> {
    using type = volatile tools::uint128_t;
  };
  template <>
  struct make_unsigned<const volatile tools::int128_t> {
    using type = const volatile tools::uint128_t;
  };
  template <>
  struct make_unsigned<const volatile tools::uint128_t> {
    using type = const volatile tools::uint128_t;
  };

  namespace detail::int128_t {
    constexpr tools::uint128_t parse_unsigned(const std::string_view s) noexcept {
      assert(!s.empty());
      tools::uint128_t x = 0;
      std::size_t i = s[0] == '+';
      if (i + 1 < s.size() && s[i] == '0' && (s[i + 1] == 'x' || s[i + 1] == 'X')) {
        for (i += 2; i < s.size(); ++i) {
          assert(('0' <= s[i] && s[i] <= '9') || ('a' <= s[i] && s[i] <= 'f') || ('A' <= s[i] && s[i] <= 'F'));
          x <<= 4;
          if ('0' <= s[i] && s[i] <= '9') {
            x |= s[i] - '0';
          } else if ('a' <= s[i] && s[i] <= 'f') {
            x |= s[i] - 'a' + 10;
          } else {
            x |= s[i] - 'A' + 10;
          }
        }
      } else {
        for (; i < s.size(); ++i) {
          assert('0' <= s[i] && s[i] <= '9');
          x *= 10;
          x += s[i] - '0';
        }
      }
      return x;
    }

    constexpr tools::int128_t parse_signed(const std::string_view s) noexcept {
      assert(!s.empty());
      tools::int128_t x = 0;
      if (s[0] == '-') {
        std::size_t i = 1;
        if (i + 1 < s.size() && s[i] == '0' && (s[i + 1] == 'x' || s[i + 1] == 'X')) {
          for (i += 2; i < s.size(); ++i) {
            assert(('0' <= s[i] && s[i] <= '9') || ('a' <= s[i] && s[i] <= 'f') || ('A' <= s[i] && s[i] <= 'F'));
            x *= 16;
            if ('0' <= s[i] && s[i] <= '9') {
              x -= s[i] - '0';
            } else if ('a' <= s[i] && s[i] <= 'f') {
              x -= s[i] - 'a' + 10;
            } else {
              x -= s[i] - 'A' + 10;
            }
          }
        } else {
          for (; i < s.size(); ++i) {
            assert('0' <= s[i] && s[i] <= '9');
            x *= 10;
            x -= s[i] - '0';
          }
        }
      } else {
        std::size_t i = s[0] == '+';
        if (i + 1 < s.size() && s[i] == '0' && (s[i + 1] == 'x' || s[i + 1] == 'X')) {
          for (i += 2; i < s.size(); ++i) {
            assert(('0' <= s[i] && s[i] <= '9') || ('a' <= s[i] && s[i] <= 'f') || ('A' <= s[i] && s[i] <= 'F'));
            x <<= 4;
            if ('0' <= s[i] && s[i] <= '9') {
              x |= s[i] - '0';
            } else if ('a' <= s[i] && s[i] <= 'f') {
              x |= s[i] - 'a' + 10;
            } else {
              x |= s[i] - 'A' + 10;
            }
          }
        } else {
          for (; i < s.size(); ++i) {
            assert('0' <= s[i] && s[i] <= '9');
            x *= 10;
            x += s[i] - '0';
          }
        }
      }
      return x;
    }
  }
}

#define UINT128_C(c) tools::detail::int128_t::parse_unsigned(#c)
#define INT128_C(c) tools::detail::int128_t::parse_signed(#c)

inline std::istream& operator>>(std::istream& is, tools::uint128_t& x) {
  std::string s;
  is >> s;
  x = tools::detail::int128_t::parse_unsigned(s);
  return is;
}
inline std::istream& operator>>(std::istream& is, tools::int128_t& x) {
  std::string s;
  is >> s;
  x = tools::detail::int128_t::parse_signed(s);
  return is;
}

inline std::ostream& operator<<(std::ostream& os, tools::uint128_t x) {
  std::string s;
  if (x > 0) {
    while (x > 0) {
      s.push_back('0' + x % 10);
      x /= 10;
    }
  } else {
    s.push_back('0');
  }

  std::ranges::reverse(s);
  return os << s;
}
inline std::ostream& operator<<(std::ostream& os, tools::int128_t x) {
  std::string s;
  if (x > 0) {
    while (x > 0) {
      s.push_back('0' + x % 10);
      x /= 10;
    }
  } else if (x < 0) {
    while (x < 0) {
      s.push_back('0' + (-(x % 10)));
      x /= 10;
    }
    s.push_back('-');
  } else {
    s.push_back('0');
  }

  std::ranges::reverse(s);
  return os << s;
}

#if defined(__GLIBCXX__) && defined(__STRICT_ANSI__)
namespace std {
  template <>
  struct hash<tools::uint128_t> {
    std::size_t operator()(const tools::uint128_t& x) const {
      static const std::size_t seed = tools::now();

      std::size_t hash = seed;
      tools::hash_combine(hash, static_cast<std::uint64_t>(x >> 64));
      tools::hash_combine(hash, static_cast<std::uint64_t>(x & ((UINT128_C(1) << 64) - 1)));
      return hash;
    }
  };
  template <>
  struct hash<tools::int128_t> {
    std::size_t operator()(const tools::int128_t& x) const {
      static std::hash<tools::uint128_t> hasher;
      return hasher(static_cast<tools::uint128_t>(x));
    }
  };
}
#endif

namespace tools {
  template <>
  struct detail::abs::impl<tools::int128_t> {
    constexpr tools::int128_t operator()(const tools::int128_t& x) const noexcept {
      return x >= 0 ? x : -x;
    }
  };

#if defined(__GLIBCXX__) && defined(__STRICT_ANSI__)
  template <>
  struct detail::bit_ceil::impl<tools::uint128_t> {
    constexpr tools::uint128_t operator()(tools::uint128_t x) const noexcept {
      if (x <= 1) return 1;
      --x;
      x |= x >> 1;
      x |= x >> 2;
      x |= x >> 4;
      x |= x >> 8;
      x |= x >> 16;
      x |= x >> 32;
      x |= x >> 64;
      return ++x;
    }
  };

  template <>
  struct detail::bit_floor::impl<tools::uint128_t> {
    constexpr tools::uint128_t operator()(tools::uint128_t x) const noexcept {
      x |= x >> 1;
      x |= x >> 2;
      x |= x >> 4;
      x |= x >> 8;
      x |= x >> 16;
      x |= x >> 32;
      x |= x >> 64;
      return x & ~(x >> 1);
    }
  };

  template <>
  struct detail::bit_width::impl<tools::uint128_t> {
    constexpr int operator()(tools::uint128_t x) const noexcept {
      int w = 0;
      if (x & UINT128_C(0xffffffffffffffff0000000000000000)) {
        x >>= 64;
        w += 64;
      }
      if (x & UINT128_C(0xffffffff00000000)) {
        x >>= 32;
        w += 32;
      }
      if (x & UINT128_C(0xffff0000)) {
        x >>= 16;
        w += 16;
      }
      if (x & UINT128_C(0xff00)) {
        x >>= 8;
        w += 8;
      }
      if (x & UINT128_C(0xf0)) {
        x >>= 4;
        w += 4;
      }
      if (x & UINT128_C(0xc)) {
        x >>= 2;
        w += 2;
      }
      if (x & UINT128_C(0x2)) {
        x >>= 1;
        w += 1;
      }
      w += x;
      return w;
    }
  };

  template <>
  class detail::countr_zero::impl<tools::uint128_t> {
    using type = tools::uint128_t;
    static constexpr int shift = 120;
    static constexpr type magic = UINT128_C(0x01061438916347932a5cd9d3ead7b77f);
    static constexpr int ntz_table[255] = {
      128,   0,   1,  -1,   2,  -1,   8,  -1,   3,  -1,  15,  -1,   9,  -1,  22,  -1,
        4,  -1,  29,  -1,  16,  -1,  36,  -1,  10,  -1,  43,  -1,  23,  -1,  50,  -1,
        5,  -1,  33,  -1,  30,  -1,  57,  -1,  17,  -1,  64,  -1,  37,  -1,  71,  -1,
       11,  -1,  60,  -1,  44,  -1,  78,  -1,  24,  -1,  85,  -1,  51,  -1,  92,  -1,
       -1,   6,  -1,  20,  -1,  34,  -1,  48,  31,  -1,  -1,  69,  58,  -1,  -1,  90,
       18,  -1,  67,  -1,  65,  -1,  99,  -1,  38,  -1, 101,  -1,  72,  -1, 106,  -1,
       -1,  12,  -1,  40,  -1,  61,  -1,  82,  45,  -1,  -1, 103,  79,  -1, 113,  -1,
       -1,  25,  -1,  74,  86,  -1,  -1, 116,  -1,  52,  -1, 108,  -1,  93,  -1, 120,
      127,  -1,  -1,   7,  -1,  14,  -1,  21,  -1,  28,  -1,  35,  -1,  42,  -1,  49,
       -1,  32,  -1,  56,  -1,  63,  -1,  70,  -1,  59,  -1,  77,  -1,  84,  -1,  91,
       -1,  19,  -1,  47,  -1,  68,  -1,  89,  -1,  66,  -1,  98,  -1, 100,  -1, 105,
       -1,  39,  -1,  81,  -1, 102,  -1, 112,  -1,  73,  -1, 115,  -1, 107,  -1, 119,
      126,  -1,  13,  -1,  27,  -1,  41,  -1,  -1,  55,  62,  -1,  -1,  76,  83,  -1,
       -1,  46,  -1,  88,  -1,  97,  -1, 104,  -1,  80,  -1, 111,  -1, 114,  -1, 118,
      125,  -1,  26,  -1,  54,  -1,  75,  -1,  -1,  87,  96,  -1,  -1, 110,  -1, 117,
      124,  -1,  53,  -1,  -1,  95, 109,  -1, 123,  -1,  94,  -1, 122,  -1, 121
    };

  public:
    constexpr int operator()(const type& x) const noexcept {
      return ntz_table[static_cast<type>(magic * static_cast<type>(x & -x)) >> shift];
    }
  };

  namespace detail::gcd {
    template <>
    struct impl<tools::uint128_t, tools::uint128_t> {
      constexpr tools::uint128_t operator()(tools::uint128_t m, tools::uint128_t n) const noexcept {
        while (n != 0) {
          m %= n;
          std::swap(m, n);
        }
        return m;
      };
    };

    template <typename T>
    concept non_bool_integral_at_most_128bit = tools::non_bool_integral<T> && std::numeric_limits<T>::digits <= 128;
    template <typename T>
    concept non_bool_integral_at_most_64bit = tools::non_bool_integral<T> && std::numeric_limits<T>::digits <= 64;

    template <typename M, typename N> requires (
      (non_bool_integral_at_most_128bit<M> && non_bool_integral_at_most_128bit<N>)
      && !(non_bool_integral_at_most_64bit<M> && non_bool_integral_at_most_64bit<N>)
      && !(std::same_as<M, tools::uint128_t> && std::same_as<N, tools::uint128_t>)
    )
    struct impl<M, N> {
      constexpr std::common_type_t<M, N> operator()(const M m, const N n) const noexcept {
        return std::common_type_t<M, N>(
          tools::gcd(
            m >= 0 ? tools::uint128_t(m) : tools::uint128_t(-(m + 1)) + 1,
            n >= 0 ? tools::uint128_t(n) : tools::uint128_t(-(n + 1)) + 1
          )
        );
      }
    };
  }

  template <>
  struct detail::has_single_bit::impl<tools::uint128_t> {
    constexpr bool operator()(tools::uint128_t x) const noexcept {
      return x != 0 && (x & (x - 1)) == 0;
    }
  };

  template <>
  struct detail::popcount::impl<tools::uint128_t> {
    constexpr int operator()(tools::uint128_t x) const noexcept {
      x = (x & UINT128_C(0x55555555555555555555555555555555)) + (x >> 1 & UINT128_C(0x55555555555555555555555555555555));
      x = (x & UINT128_C(0x33333333333333333333333333333333)) + (x >> 2 & UINT128_C(0x33333333333333333333333333333333));
      x = (x & UINT128_C(0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)) + (x >> 4 & UINT128_C(0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f));
      x = (x & UINT128_C(0x00ff00ff00ff00ff00ff00ff00ff00ff)) + (x >> 8 & UINT128_C(0x00ff00ff00ff00ff00ff00ff00ff00ff));
      x = (x & UINT128_C(0x0000ffff0000ffff0000ffff0000ffff)) + (x >> 16 & UINT128_C(0x0000ffff0000ffff0000ffff0000ffff));
      x = (x & UINT128_C(0x00000000ffffffff00000000ffffffff)) + (x >> 32 & UINT128_C(0x00000000ffffffff00000000ffffffff));
      x = (x & UINT128_C(0x0000000000000000ffffffffffffffff)) + (x >> 64 & UINT128_C(0x0000000000000000ffffffffffffffff));
      return x;
    }
  };
#endif
}


#line 5 "tools/uint128_t.hpp"


#line 5 "tools/prod_mod.hpp"

namespace tools {

  template <typename T1, typename T2, typename T3>
  constexpr T3 prod_mod(const T1 x, const T2 y, const T3 m) {
    using u128 = tools::uint128_t;
    u128 prod_mod = u128(x >= 0 ? x : -x) * u128(y >= 0 ? y : -y) % u128(m);
    if ((x >= 0) ^ (y >= 0)) prod_mod = u128(m) - prod_mod;
    return prod_mod;
  }
}


#line 1 "tools/pow_mod.hpp"



#line 1 "tools/mod.hpp"



#line 7 "tools/mod.hpp"

namespace tools {
  template <tools::non_bool_integral M, tools::non_bool_integral N>
  constexpr std::common_type_t<M, N> mod(const M a, const N b) noexcept {
    assert(b != 0);

    using UM = tools::make_unsigned_t<M>;
    using UN = tools::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 6 "tools/pow_mod.hpp"

namespace tools {

  template <typename T1, typename T2, typename T3>
  constexpr T3 pow_mod(const T1 x, T2 n, const T3 m) {
    if (m == 1) return 0;
    T3 r = 1;
    T3 y = tools::mod(x, m);
    while (n > 0) {
      if ((n & 1) > 0) {
        r = tools::prod_mod(r, y, m);
      }
      y = tools::prod_mod(y, y, m);
      n /= 2;
    }
    return r;
  }
}


#line 7 "tools/is_prime.hpp"

namespace tools {

  constexpr bool is_prime(const unsigned long long n) {
    constexpr std::array<unsigned long long, 7> bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};

    if (n <= 1) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;

    auto d = n - 1;
    for (; d % 2 == 0; d /= 2);

    for (const auto a : bases) {
      if (a % n == 0) return true;

      auto power = d;
      auto target = tools::pow_mod(a, power, n);

      bool is_composite = true;
      if (target == 1) is_composite = false;
      for (; is_composite && power != n - 1; power *= 2, target = tools::prod_mod(target, target, n)) {
        if (target == n - 1) is_composite = false;
      }

      if (is_composite) {
        return false;
      }
    }

    return true;
  }
}


#line 1 "tools/pow2.hpp"



#line 7 "tools/pow2.hpp"

namespace tools {
  template <tools::integral T>
  constexpr T pow2(const T x) noexcept {
    assert(0 <= x && x < std::numeric_limits<T>::digits);
    return T(1) << x;
  }
}


#line 16 "tools/prime_factorization.hpp"

namespace tools {
  template <std::integral T>
  std::vector<T> prime_factorization(T n) {
    assert(n >= 1);
    std::vector<T> res;

    if (n == 1) return res;

    std::queue<std::pair<T, T>> factors;
    factors.emplace(n, 1);
    while (!factors.empty()) {
      const auto [factor, occurrences] = factors.front();
      factors.pop();
      if (tools::is_prime(factor)) {
        for (T i = 0; i < occurrences; ++i) {
          res.push_back(factor);
        }
      } else {
        const T m = tools::pow2((tools::floor_log2(factor) + 1) / 8);
        for (T c = 1; ; ++c) {
          const auto f = [&](T& x) {
            x = tools::prod_mod(x, x, factor);
            // (x + c) mod factor s.t. 0 <= x < factor and 1 <= c < factor
            if (x >= factor - c) {
              x -= factor - c;
            } else {
              x += c;
            }
          };
          T y = 2;
          T r = 1;
          T q = 1;
          T x, g, ys;
          do {
            x = y;
            for (T i = 0; i < r; ++i) {
              f(y);
            }
            T k = 0;
            do {
              ys = y;
              for (T i = 0; i < std::min<T>(m, r - k); ++i) {
                f(y);
                q = tools::prod_mod(q, std::max(x, y) - std::min(x, y), factor);
              }
              g = std::gcd(q, factor);
              k += m;
            } while (k < r && g == 1);
            r *= 2;
          } while (g == 1);
          if (g == factor) {
            do {
              f(ys);
              g = std::gcd(std::max(x, ys) - std::min(x, ys), factor);
            } while (g == 1);
          }
          if (g < factor) {
            T h = factor / g;
            std::tie(g, h) = std::minmax({g, h});
            T n = 1;
            while (h % g == 0) {
              h /= g;
              ++n;
            }
            factors.emplace(g, occurrences * n);
            if (h > 1) factors.emplace(h, occurrences);
            break;
          }
        }
      }
    }

    std::ranges::sort(res);
    return res;
  }
}


#line 8 "tests/prime_factorization/severe_cases.test.cpp"

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

  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(1)) == std::vector<std::int8_t>{});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(2)) == std::vector<std::int8_t>{INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(3)) == std::vector<std::int8_t>{INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(4)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(5)) == std::vector<std::int8_t>{INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(6)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(7)) == std::vector<std::int8_t>{INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(8)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(9)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(10)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(11)) == std::vector<std::int8_t>{INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(12)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(13)) == std::vector<std::int8_t>{INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(14)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(15)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(16)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(17)) == std::vector<std::int8_t>{INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(18)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(19)) == std::vector<std::int8_t>{INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(20)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(21)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(22)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(23)) == std::vector<std::int8_t>{INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(24)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(25)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(26)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(27)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(28)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(29)) == std::vector<std::int8_t>{INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(30)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(31)) == std::vector<std::int8_t>{INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(32)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(33)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(34)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(35)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(36)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(37)) == std::vector<std::int8_t>{INT8_C(37)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(38)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(39)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(40)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(41)) == std::vector<std::int8_t>{INT8_C(41)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(42)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(43)) == std::vector<std::int8_t>{INT8_C(43)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(44)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(45)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(46)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(47)) == std::vector<std::int8_t>{INT8_C(47)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(48)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(49)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(50)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(51)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(52)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(53)) == std::vector<std::int8_t>{INT8_C(53)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(54)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(55)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(56)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(57)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(58)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(59)) == std::vector<std::int8_t>{INT8_C(59)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(60)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(61)) == std::vector<std::int8_t>{INT8_C(61)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(62)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(63)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(64)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(65)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(66)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(67)) == std::vector<std::int8_t>{INT8_C(67)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(68)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(69)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(70)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(71)) == std::vector<std::int8_t>{INT8_C(71)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(72)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(73)) == std::vector<std::int8_t>{INT8_C(73)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(74)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(37)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(75)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(76)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(77)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(78)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(79)) == std::vector<std::int8_t>{INT8_C(79)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(80)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(81)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(82)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(41)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(83)) == std::vector<std::int8_t>{INT8_C(83)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(84)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(85)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(86)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(43)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(87)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(88)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(89)) == std::vector<std::int8_t>{INT8_C(89)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(90)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(91)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(92)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(93)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(94)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(47)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(95)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(96)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(97)) == std::vector<std::int8_t>{INT8_C(97)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(98)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(7), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(99)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(100)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(101)) == std::vector<std::int8_t>{INT8_C(101)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(102)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(103)) == std::vector<std::int8_t>{INT8_C(103)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(104)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(105)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(5), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(106)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(53)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(107)) == std::vector<std::int8_t>{INT8_C(107)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(108)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(3)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(109)) == std::vector<std::int8_t>{INT8_C(109)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(110)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(5), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(111)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(37)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(112)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(113)) == std::vector<std::int8_t>{INT8_C(113)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(114)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(19)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(115)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(23)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(116)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(29)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(117)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(3), INT8_C(13)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(118)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(59)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(119)) == std::vector<std::int8_t>{INT8_C(7), INT8_C(17)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(120)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(2), INT8_C(3), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(121)) == std::vector<std::int8_t>{INT8_C(11), INT8_C(11)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(122)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(61)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(123)) == std::vector<std::int8_t>{INT8_C(3), INT8_C(41)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(124)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(2), INT8_C(31)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(125)) == std::vector<std::int8_t>{INT8_C(5), INT8_C(5), INT8_C(5)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(126)) == std::vector<std::int8_t>{INT8_C(2), INT8_C(3), INT8_C(3), INT8_C(7)});
  assert_that(tools::prime_factorization<std::int8_t>(INT8_C(127)) == std::vector<std::int8_t>{INT8_C(127)});

  assert_that(tools::prime_factorization(INT32_C(1)) == std::vector<std::int32_t>{});
  assert_that(tools::prime_factorization(INT32_C(2)) == std::vector{INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(3)) == std::vector{INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(4)) == std::vector{INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(5)) == std::vector{INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(6)) == std::vector{INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(7)) == std::vector{INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(8)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(9)) == std::vector{INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(10)) == std::vector{INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(11)) == std::vector{INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(12)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(13)) == std::vector{INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(14)) == std::vector{INT32_C(2), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(15)) == std::vector{INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(16)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(17)) == std::vector{INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(18)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(19)) == std::vector{INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(20)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(21)) == std::vector{INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(22)) == std::vector{INT32_C(2), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(23)) == std::vector{INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(24)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(25)) == std::vector{INT32_C(5), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(26)) == std::vector{INT32_C(2), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(27)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(28)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(29)) == std::vector{INT32_C(29)});
  assert_that(tools::prime_factorization(INT32_C(30)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(31)) == std::vector{INT32_C(31)});
  assert_that(tools::prime_factorization(INT32_C(32)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(33)) == std::vector{INT32_C(3), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(34)) == std::vector{INT32_C(2), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(35)) == std::vector{INT32_C(5), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(36)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(37)) == std::vector{INT32_C(37)});
  assert_that(tools::prime_factorization(INT32_C(38)) == std::vector{INT32_C(2), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(39)) == std::vector{INT32_C(3), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(40)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(41)) == std::vector{INT32_C(41)});
  assert_that(tools::prime_factorization(INT32_C(42)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(43)) == std::vector{INT32_C(43)});
  assert_that(tools::prime_factorization(INT32_C(44)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(45)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(46)) == std::vector{INT32_C(2), INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(47)) == std::vector{INT32_C(47)});
  assert_that(tools::prime_factorization(INT32_C(48)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(49)) == std::vector{INT32_C(7), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(50)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(51)) == std::vector{INT32_C(3), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(52)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(53)) == std::vector{INT32_C(53)});
  assert_that(tools::prime_factorization(INT32_C(54)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(55)) == std::vector{INT32_C(5), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(56)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(57)) == std::vector{INT32_C(3), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(58)) == std::vector{INT32_C(2), INT32_C(29)});
  assert_that(tools::prime_factorization(INT32_C(59)) == std::vector{INT32_C(59)});
  assert_that(tools::prime_factorization(INT32_C(60)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(61)) == std::vector{INT32_C(61)});
  assert_that(tools::prime_factorization(INT32_C(62)) == std::vector{INT32_C(2), INT32_C(31)});
  assert_that(tools::prime_factorization(INT32_C(63)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(64)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2)});
  assert_that(tools::prime_factorization(INT32_C(65)) == std::vector{INT32_C(5), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(66)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(67)) == std::vector{INT32_C(67)});
  assert_that(tools::prime_factorization(INT32_C(68)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(69)) == std::vector{INT32_C(3), INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(70)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(71)) == std::vector{INT32_C(71)});
  assert_that(tools::prime_factorization(INT32_C(72)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(73)) == std::vector{INT32_C(73)});
  assert_that(tools::prime_factorization(INT32_C(74)) == std::vector{INT32_C(2), INT32_C(37)});
  assert_that(tools::prime_factorization(INT32_C(75)) == std::vector{INT32_C(3), INT32_C(5), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(76)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(77)) == std::vector{INT32_C(7), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(78)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(79)) == std::vector{INT32_C(79)});
  assert_that(tools::prime_factorization(INT32_C(80)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(81)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(82)) == std::vector{INT32_C(2), INT32_C(41)});
  assert_that(tools::prime_factorization(INT32_C(83)) == std::vector{INT32_C(83)});
  assert_that(tools::prime_factorization(INT32_C(84)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(85)) == std::vector{INT32_C(5), INT32_C(17)});
  assert_that(tools::prime_factorization(INT32_C(86)) == std::vector{INT32_C(2), INT32_C(43)});
  assert_that(tools::prime_factorization(INT32_C(87)) == std::vector{INT32_C(3), INT32_C(29)});
  assert_that(tools::prime_factorization(INT32_C(88)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(89)) == std::vector{INT32_C(89)});
  assert_that(tools::prime_factorization(INT32_C(90)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(5)});
  assert_that(tools::prime_factorization(INT32_C(91)) == std::vector{INT32_C(7), INT32_C(13)});
  assert_that(tools::prime_factorization(INT32_C(92)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(23)});
  assert_that(tools::prime_factorization(INT32_C(93)) == std::vector{INT32_C(3), INT32_C(31)});
  assert_that(tools::prime_factorization(INT32_C(94)) == std::vector{INT32_C(2), INT32_C(47)});
  assert_that(tools::prime_factorization(INT32_C(95)) == std::vector{INT32_C(5), INT32_C(19)});
  assert_that(tools::prime_factorization(INT32_C(96)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3)});
  assert_that(tools::prime_factorization(INT32_C(97)) == std::vector{INT32_C(97)});
  assert_that(tools::prime_factorization(INT32_C(98)) == std::vector{INT32_C(2), INT32_C(7), INT32_C(7)});
  assert_that(tools::prime_factorization(INT32_C(99)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(11)});
  assert_that(tools::prime_factorization(INT32_C(100)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(5)});

  assert_that(tools::prime_factorization(INT32_C(2095133040)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(5), INT32_C(7), INT32_C(11), INT32_C(13), INT32_C(17), INT32_C(19)});

  assert_that(tools::prime_factorization(INT32_C(2147483548)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(7), INT32_C(76695841)});
  assert_that(tools::prime_factorization(INT32_C(2147483549)) == std::vector{INT32_C(2147483549)});
  assert_that(tools::prime_factorization(INT32_C(2147483550)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(5), INT32_C(5), INT32_C(19), INT32_C(23), INT32_C(181), INT32_C(181)});
  assert_that(tools::prime_factorization(INT32_C(2147483551)) == std::vector{INT32_C(32063), INT32_C(66977)});
  assert_that(tools::prime_factorization(INT32_C(2147483552)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(37), INT32_C(349), INT32_C(5197)});
  assert_that(tools::prime_factorization(INT32_C(2147483553)) == std::vector{INT32_C(3), INT32_C(29), INT32_C(31), INT32_C(503), INT32_C(1583)});
  assert_that(tools::prime_factorization(INT32_C(2147483554)) == std::vector{INT32_C(2), INT32_C(17), INT32_C(43), INT32_C(563), INT32_C(2609)});
  assert_that(tools::prime_factorization(INT32_C(2147483555)) == std::vector{INT32_C(5), INT32_C(7), INT32_C(7), INT32_C(7), INT32_C(1252177)});
  assert_that(tools::prime_factorization(INT32_C(2147483556)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(109), INT32_C(182423)});
  assert_that(tools::prime_factorization(INT32_C(2147483557)) == std::vector{INT32_C(3181), INT32_C(675097)});
  assert_that(tools::prime_factorization(INT32_C(2147483558)) == std::vector{INT32_C(2), INT32_C(11), INT32_C(11), INT32_C(139), INT32_C(63841)});
  assert_that(tools::prime_factorization(INT32_C(2147483559)) == std::vector{INT32_C(3), INT32_C(13), INT32_C(73), INT32_C(754297)});
  assert_that(tools::prime_factorization(INT32_C(2147483560)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(227), INT32_C(236507)});
  assert_that(tools::prime_factorization(INT32_C(2147483561)) == std::vector{INT32_C(167), INT32_C(12859183)});
  assert_that(tools::prime_factorization(INT32_C(2147483562)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(7), INT32_C(631), INT32_C(81031)});
  assert_that(tools::prime_factorization(INT32_C(2147483563)) == std::vector{INT32_C(2147483563)});
  assert_that(tools::prime_factorization(INT32_C(2147483564)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(6269), INT32_C(85639)});
  assert_that(tools::prime_factorization(INT32_C(2147483565)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(5), INT32_C(103), INT32_C(463319)});
  assert_that(tools::prime_factorization(INT32_C(2147483566)) == std::vector{INT32_C(2), INT32_C(1073741783)});
  assert_that(tools::prime_factorization(INT32_C(2147483567)) == std::vector{INT32_C(11503), INT32_C(186689)});
  assert_that(tools::prime_factorization(INT32_C(2147483568)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(41), INT32_C(83), INT32_C(13147)});
  assert_that(tools::prime_factorization(INT32_C(2147483569)) == std::vector{INT32_C(7), INT32_C(11), INT32_C(19), INT32_C(1467863)});
  assert_that(tools::prime_factorization(INT32_C(2147483570)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(214748357)});
  assert_that(tools::prime_factorization(INT32_C(2147483571)) == std::vector{INT32_C(3), INT32_C(17), INT32_C(17), INT32_C(2476913)});
  assert_that(tools::prime_factorization(INT32_C(2147483572)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(13), INT32_C(5641), INT32_C(7321)});
  assert_that(tools::prime_factorization(INT32_C(2147483573)) == std::vector{INT32_C(23), INT32_C(93368851)});
  assert_that(tools::prime_factorization(INT32_C(2147483574)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(53), INT32_C(2251031)});
  assert_that(tools::prime_factorization(INT32_C(2147483575)) == std::vector{INT32_C(5), INT32_C(5), INT32_C(85899343)});
  assert_that(tools::prime_factorization(INT32_C(2147483576)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(7), INT32_C(2341), INT32_C(16381)});
  assert_that(tools::prime_factorization(INT32_C(2147483577)) == std::vector{INT32_C(3), INT32_C(10103), INT32_C(70853)});
  assert_that(tools::prime_factorization(INT32_C(2147483578)) == std::vector{INT32_C(2), INT32_C(1073741789)});
  assert_that(tools::prime_factorization(INT32_C(2147483579)) == std::vector{INT32_C(2147483579)});
  assert_that(tools::prime_factorization(INT32_C(2147483580)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(5), INT32_C(11), INT32_C(47), INT32_C(107), INT32_C(647)});
  assert_that(tools::prime_factorization(INT32_C(2147483581)) == std::vector{INT32_C(89), INT32_C(691), INT32_C(34919)});
  assert_that(tools::prime_factorization(INT32_C(2147483582)) == std::vector{INT32_C(2), INT32_C(29), INT32_C(97), INT32_C(381707)});
  assert_that(tools::prime_factorization(INT32_C(2147483583)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(7), INT32_C(1262483)});
  assert_that(tools::prime_factorization(INT32_C(2147483584)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(31), INT32_C(601), INT32_C(1801)});
  assert_that(tools::prime_factorization(INT32_C(2147483585)) == std::vector{INT32_C(5), INT32_C(13), INT32_C(179), INT32_C(184571)});
  assert_that(tools::prime_factorization(INT32_C(2147483586)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(357913931)});
  assert_that(tools::prime_factorization(INT32_C(2147483587)) == std::vector{INT32_C(2147483587)});
  assert_that(tools::prime_factorization(INT32_C(2147483588)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(17), INT32_C(19), INT32_C(19), INT32_C(87481)});
  assert_that(tools::prime_factorization(INT32_C(2147483589)) == std::vector{INT32_C(3), INT32_C(37), INT32_C(61), INT32_C(317159)});
  assert_that(tools::prime_factorization(INT32_C(2147483590)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(7), INT32_C(877), INT32_C(34981)});
  assert_that(tools::prime_factorization(INT32_C(2147483591)) == std::vector{INT32_C(11), INT32_C(195225781)});
  assert_that(tools::prime_factorization(INT32_C(2147483592)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(4813), INT32_C(6197)});
  assert_that(tools::prime_factorization(INT32_C(2147483593)) == std::vector{INT32_C(59), INT32_C(239), INT32_C(152293)});
  assert_that(tools::prime_factorization(INT32_C(2147483594)) == std::vector{INT32_C(2), INT32_C(193), INT32_C(1021), INT32_C(5449)});
  assert_that(tools::prime_factorization(INT32_C(2147483595)) == std::vector{INT32_C(3), INT32_C(5), INT32_C(143165573)});
  assert_that(tools::prime_factorization(INT32_C(2147483596)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(23), INT32_C(23342213)});
  assert_that(tools::prime_factorization(INT32_C(2147483597)) == std::vector{INT32_C(7), INT32_C(43), INT32_C(7134497)});
  assert_that(tools::prime_factorization(INT32_C(2147483598)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(13), INT32_C(67), INT32_C(163), INT32_C(2521)});
  assert_that(tools::prime_factorization(INT32_C(2147483599)) == std::vector{INT32_C(1657), INT32_C(1296007)});
  assert_that(tools::prime_factorization(INT32_C(2147483600)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(5), INT32_C(173), INT32_C(31033)});
  assert_that(tools::prime_factorization(INT32_C(2147483601)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(238609289)});
  assert_that(tools::prime_factorization(INT32_C(2147483602)) == std::vector{INT32_C(2), INT32_C(11), INT32_C(97612891)});
  assert_that(tools::prime_factorization(INT32_C(2147483603)) == std::vector{INT32_C(1187), INT32_C(1809169)});
  assert_that(tools::prime_factorization(INT32_C(2147483604)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(7), INT32_C(7), INT32_C(197), INT32_C(18539)});
  assert_that(tools::prime_factorization(INT32_C(2147483605)) == std::vector{INT32_C(5), INT32_C(17), INT32_C(25264513)});
  assert_that(tools::prime_factorization(INT32_C(2147483606)) == std::vector{INT32_C(2), INT32_C(3671), INT32_C(292493)});
  assert_that(tools::prime_factorization(INT32_C(2147483607)) == std::vector{INT32_C(3), INT32_C(19), INT32_C(571), INT32_C(65981)});
  assert_that(tools::prime_factorization(INT32_C(2147483608)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(71), INT32_C(3780781)});
  assert_that(tools::prime_factorization(INT32_C(2147483609)) == std::vector{INT32_C(41), INT32_C(52377649)});
  assert_that(tools::prime_factorization(INT32_C(2147483610)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(5), INT32_C(313), INT32_C(25411)});
  assert_that(tools::prime_factorization(INT32_C(2147483611)) == std::vector{INT32_C(7), INT32_C(13), INT32_C(29), INT32_C(813749)});
  assert_that(tools::prime_factorization(INT32_C(2147483612)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(311), INT32_C(1726273)});
  assert_that(tools::prime_factorization(INT32_C(2147483613)) == std::vector{INT32_C(3), INT32_C(11), INT32_C(2953), INT32_C(22037)});
  assert_that(tools::prime_factorization(INT32_C(2147483614)) == std::vector{INT32_C(2), INT32_C(101), INT32_C(10631107)});
  assert_that(tools::prime_factorization(INT32_C(2147483615)) == std::vector{INT32_C(5), INT32_C(31), INT32_C(13854733)});
  assert_that(tools::prime_factorization(INT32_C(2147483616)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(2731), INT32_C(8191)});
  assert_that(tools::prime_factorization(INT32_C(2147483617)) == std::vector{INT32_C(6733), INT32_C(318949)});
  assert_that(tools::prime_factorization(INT32_C(2147483618)) == std::vector{INT32_C(2), INT32_C(7), INT32_C(367), INT32_C(417961)});
  assert_that(tools::prime_factorization(INT32_C(2147483619)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(23), INT32_C(353), INT32_C(29389)});
  assert_that(tools::prime_factorization(INT32_C(2147483620)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(5), INT32_C(4603), INT32_C(23327)});
  assert_that(tools::prime_factorization(INT32_C(2147483621)) == std::vector{INT32_C(14741), INT32_C(145681)});
  assert_that(tools::prime_factorization(INT32_C(2147483622)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(17), INT32_C(467), INT32_C(45083)});
  assert_that(tools::prime_factorization(INT32_C(2147483623)) == std::vector{INT32_C(79), INT32_C(967), INT32_C(28111)});
  assert_that(tools::prime_factorization(INT32_C(2147483624)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(11), INT32_C(13), INT32_C(1877171)});
  assert_that(tools::prime_factorization(INT32_C(2147483625)) == std::vector{INT32_C(3), INT32_C(5), INT32_C(5), INT32_C(5), INT32_C(7), INT32_C(199), INT32_C(4111)});
  assert_that(tools::prime_factorization(INT32_C(2147483626)) == std::vector{INT32_C(2), INT32_C(19), INT32_C(37), INT32_C(1527371)});
  assert_that(tools::prime_factorization(INT32_C(2147483627)) == std::vector{INT32_C(47), INT32_C(53), INT32_C(862097)});
  assert_that(tools::prime_factorization(INT32_C(2147483628)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(59652323)});
  assert_that(tools::prime_factorization(INT32_C(2147483629)) == std::vector{INT32_C(2147483629)});
  assert_that(tools::prime_factorization(INT32_C(2147483630)) == std::vector{INT32_C(2), INT32_C(5), INT32_C(6553), INT32_C(32771)});
  assert_that(tools::prime_factorization(INT32_C(2147483631)) == std::vector{INT32_C(3), INT32_C(137), INT32_C(263), INT32_C(19867)});
  assert_that(tools::prime_factorization(INT32_C(2147483632)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(7), INT32_C(73), INT32_C(262657)});
  assert_that(tools::prime_factorization(INT32_C(2147483633)) == std::vector{INT32_C(5843), INT32_C(367531)});
  assert_that(tools::prime_factorization(INT32_C(2147483634)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(12097), INT32_C(29587)});
  assert_that(tools::prime_factorization(INT32_C(2147483635)) == std::vector{INT32_C(5), INT32_C(11), INT32_C(337), INT32_C(115861)});
  assert_that(tools::prime_factorization(INT32_C(2147483636)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(536870909)});
  assert_that(tools::prime_factorization(INT32_C(2147483637)) == std::vector{INT32_C(3), INT32_C(3), INT32_C(3), INT32_C(13), INT32_C(6118187)});
  assert_that(tools::prime_factorization(INT32_C(2147483638)) == std::vector{INT32_C(2), INT32_C(2969), INT32_C(361651)});
  assert_that(tools::prime_factorization(INT32_C(2147483639)) == std::vector{INT32_C(7), INT32_C(17), INT32_C(18046081)});
  assert_that(tools::prime_factorization(INT32_C(2147483640)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(2), INT32_C(3), INT32_C(5), INT32_C(29), INT32_C(43), INT32_C(113), INT32_C(127)});
  assert_that(tools::prime_factorization(INT32_C(2147483641)) == std::vector{INT32_C(2699), INT32_C(795659)});
  assert_that(tools::prime_factorization(INT32_C(2147483642)) == std::vector{INT32_C(2), INT32_C(23), INT32_C(46684427)});
  assert_that(tools::prime_factorization(INT32_C(2147483643)) == std::vector{INT32_C(3), INT32_C(715827881)});
  assert_that(tools::prime_factorization(INT32_C(2147483644)) == std::vector{INT32_C(2), INT32_C(2), INT32_C(233), INT32_C(1103), INT32_C(2089)});
  assert_that(tools::prime_factorization(INT32_C(2147483645)) == std::vector{INT32_C(5), INT32_C(19), INT32_C(22605091)});
  assert_that(tools::prime_factorization(INT32_C(2147483646)) == std::vector{INT32_C(2), INT32_C(3), INT32_C(3), INT32_C(7), INT32_C(11), INT32_C(31), INT32_C(151), INT32_C(331)});
  assert_that(tools::prime_factorization(INT32_C(2147483647)) == std::vector{INT32_C(2147483647)});

  assert_that(tools::prime_factorization(UINT32_C(1)) == std::vector<std::uint32_t>{});
  assert_that(tools::prime_factorization(UINT32_C(2)) == std::vector{UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(3)) == std::vector{UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(4)) == std::vector{UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(5)) == std::vector{UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(6)) == std::vector{UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(7)) == std::vector{UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(8)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(9)) == std::vector{UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(10)) == std::vector{UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(11)) == std::vector{UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(12)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(13)) == std::vector{UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(14)) == std::vector{UINT32_C(2), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(15)) == std::vector{UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(16)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(17)) == std::vector{UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(18)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(19)) == std::vector{UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(20)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(21)) == std::vector{UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(22)) == std::vector{UINT32_C(2), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(23)) == std::vector{UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(24)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(25)) == std::vector{UINT32_C(5), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(26)) == std::vector{UINT32_C(2), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(27)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(28)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(29)) == std::vector{UINT32_C(29)});
  assert_that(tools::prime_factorization(UINT32_C(30)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(31)) == std::vector{UINT32_C(31)});
  assert_that(tools::prime_factorization(UINT32_C(32)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(33)) == std::vector{UINT32_C(3), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(34)) == std::vector{UINT32_C(2), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(35)) == std::vector{UINT32_C(5), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(36)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(37)) == std::vector{UINT32_C(37)});
  assert_that(tools::prime_factorization(UINT32_C(38)) == std::vector{UINT32_C(2), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(39)) == std::vector{UINT32_C(3), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(40)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(41)) == std::vector{UINT32_C(41)});
  assert_that(tools::prime_factorization(UINT32_C(42)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(43)) == std::vector{UINT32_C(43)});
  assert_that(tools::prime_factorization(UINT32_C(44)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(45)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(46)) == std::vector{UINT32_C(2), UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(47)) == std::vector{UINT32_C(47)});
  assert_that(tools::prime_factorization(UINT32_C(48)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(49)) == std::vector{UINT32_C(7), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(50)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(51)) == std::vector{UINT32_C(3), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(52)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(53)) == std::vector{UINT32_C(53)});
  assert_that(tools::prime_factorization(UINT32_C(54)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(55)) == std::vector{UINT32_C(5), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(56)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(57)) == std::vector{UINT32_C(3), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(58)) == std::vector{UINT32_C(2), UINT32_C(29)});
  assert_that(tools::prime_factorization(UINT32_C(59)) == std::vector{UINT32_C(59)});
  assert_that(tools::prime_factorization(UINT32_C(60)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(61)) == std::vector{UINT32_C(61)});
  assert_that(tools::prime_factorization(UINT32_C(62)) == std::vector{UINT32_C(2), UINT32_C(31)});
  assert_that(tools::prime_factorization(UINT32_C(63)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(64)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2)});
  assert_that(tools::prime_factorization(UINT32_C(65)) == std::vector{UINT32_C(5), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(66)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(67)) == std::vector{UINT32_C(67)});
  assert_that(tools::prime_factorization(UINT32_C(68)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(69)) == std::vector{UINT32_C(3), UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(70)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(71)) == std::vector{UINT32_C(71)});
  assert_that(tools::prime_factorization(UINT32_C(72)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(73)) == std::vector{UINT32_C(73)});
  assert_that(tools::prime_factorization(UINT32_C(74)) == std::vector{UINT32_C(2), UINT32_C(37)});
  assert_that(tools::prime_factorization(UINT32_C(75)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(76)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(77)) == std::vector{UINT32_C(7), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(78)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(79)) == std::vector{UINT32_C(79)});
  assert_that(tools::prime_factorization(UINT32_C(80)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(81)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(82)) == std::vector{UINT32_C(2), UINT32_C(41)});
  assert_that(tools::prime_factorization(UINT32_C(83)) == std::vector{UINT32_C(83)});
  assert_that(tools::prime_factorization(UINT32_C(84)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(85)) == std::vector{UINT32_C(5), UINT32_C(17)});
  assert_that(tools::prime_factorization(UINT32_C(86)) == std::vector{UINT32_C(2), UINT32_C(43)});
  assert_that(tools::prime_factorization(UINT32_C(87)) == std::vector{UINT32_C(3), UINT32_C(29)});
  assert_that(tools::prime_factorization(UINT32_C(88)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(89)) == std::vector{UINT32_C(89)});
  assert_that(tools::prime_factorization(UINT32_C(90)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(5)});
  assert_that(tools::prime_factorization(UINT32_C(91)) == std::vector{UINT32_C(7), UINT32_C(13)});
  assert_that(tools::prime_factorization(UINT32_C(92)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(23)});
  assert_that(tools::prime_factorization(UINT32_C(93)) == std::vector{UINT32_C(3), UINT32_C(31)});
  assert_that(tools::prime_factorization(UINT32_C(94)) == std::vector{UINT32_C(2), UINT32_C(47)});
  assert_that(tools::prime_factorization(UINT32_C(95)) == std::vector{UINT32_C(5), UINT32_C(19)});
  assert_that(tools::prime_factorization(UINT32_C(96)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3)});
  assert_that(tools::prime_factorization(UINT32_C(97)) == std::vector{UINT32_C(97)});
  assert_that(tools::prime_factorization(UINT32_C(98)) == std::vector{UINT32_C(2), UINT32_C(7), UINT32_C(7)});
  assert_that(tools::prime_factorization(UINT32_C(99)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(11)});
  assert_that(tools::prime_factorization(UINT32_C(100)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(5)});

  assert_that(tools::prime_factorization(UINT32_C(3491888400)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(5), UINT32_C(5), UINT32_C(7), UINT32_C(11), UINT32_C(13), UINT32_C(17), UINT32_C(19)});

  assert_that(tools::prime_factorization(UINT32_C(4294967196)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(13), UINT32_C(67), UINT32_C(163), UINT32_C(2521)});
  assert_that(tools::prime_factorization(UINT32_C(4294967197)) == std::vector{UINT32_C(4294967197)});
  assert_that(tools::prime_factorization(UINT32_C(4294967198)) == std::vector{UINT32_C(2), UINT32_C(1657), UINT32_C(1296007)});
  assert_that(tools::prime_factorization(UINT32_C(4294967199)) == std::vector{UINT32_C(3), UINT32_C(31), UINT32_C(46182443)});
  assert_that(tools::prime_factorization(UINT32_C(4294967200)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(5), UINT32_C(173), UINT32_C(31033)});
  assert_that(tools::prime_factorization(UINT32_C(4294967201)) == std::vector{UINT32_C(7), UINT32_C(53), UINT32_C(11576731)});
  assert_that(tools::prime_factorization(UINT32_C(4294967202)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(238609289)});
  assert_that(tools::prime_factorization(UINT32_C(4294967203)) == std::vector{UINT32_C(157), UINT32_C(1051), UINT32_C(26029)});
  assert_that(tools::prime_factorization(UINT32_C(4294967204)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(11), UINT32_C(97612891)});
  assert_that(tools::prime_factorization(UINT32_C(4294967205)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(286331147)});
  assert_that(tools::prime_factorization(UINT32_C(4294967206)) == std::vector{UINT32_C(2), UINT32_C(1187), UINT32_C(1809169)});
  assert_that(tools::prime_factorization(UINT32_C(4294967207)) == std::vector{UINT32_C(47), UINT32_C(91382281)});
  assert_that(tools::prime_factorization(UINT32_C(4294967208)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(7), UINT32_C(7), UINT32_C(197), UINT32_C(18539)});
  assert_that(tools::prime_factorization(UINT32_C(4294967209)) == std::vector{UINT32_C(13), UINT32_C(677), UINT32_C(488009)});
  assert_that(tools::prime_factorization(UINT32_C(4294967210)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(17), UINT32_C(25264513)});
  assert_that(tools::prime_factorization(UINT32_C(4294967211)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(477218579)});
  assert_that(tools::prime_factorization(UINT32_C(4294967212)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3671), UINT32_C(292493)});
  assert_that(tools::prime_factorization(UINT32_C(4294967213)) == std::vector{UINT32_C(57139), UINT32_C(75167)});
  assert_that(tools::prime_factorization(UINT32_C(4294967214)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(19), UINT32_C(571), UINT32_C(65981)});
  assert_that(tools::prime_factorization(UINT32_C(4294967215)) == std::vector{UINT32_C(5), UINT32_C(7), UINT32_C(11), UINT32_C(23), UINT32_C(37), UINT32_C(13109)});
  assert_that(tools::prime_factorization(UINT32_C(4294967216)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(71), UINT32_C(3780781)});
  assert_that(tools::prime_factorization(UINT32_C(4294967217)) == std::vector{UINT32_C(3), UINT32_C(1431655739)});
  assert_that(tools::prime_factorization(UINT32_C(4294967218)) == std::vector{UINT32_C(2), UINT32_C(41), UINT32_C(52377649)});
  assert_that(tools::prime_factorization(UINT32_C(4294967219)) == std::vector{UINT32_C(83), UINT32_C(4327), UINT32_C(11959)});
  assert_that(tools::prime_factorization(UINT32_C(4294967220)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(5), UINT32_C(313), UINT32_C(25411)});
  assert_that(tools::prime_factorization(UINT32_C(4294967221)) == std::vector{UINT32_C(109), UINT32_C(39403369)});
  assert_that(tools::prime_factorization(UINT32_C(4294967222)) == std::vector{UINT32_C(2), UINT32_C(7), UINT32_C(13), UINT32_C(29), UINT32_C(813749)});
  assert_that(tools::prime_factorization(UINT32_C(4294967223)) == std::vector{UINT32_C(3), UINT32_C(359), UINT32_C(1291), UINT32_C(3089)});
  assert_that(tools::prime_factorization(UINT32_C(4294967224)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(311), UINT32_C(1726273)});
  assert_that(tools::prime_factorization(UINT32_C(4294967225)) == std::vector{UINT32_C(5), UINT32_C(5), UINT32_C(743), UINT32_C(231223)});
  assert_that(tools::prime_factorization(UINT32_C(4294967226)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(11), UINT32_C(2953), UINT32_C(22037)});
  assert_that(tools::prime_factorization(UINT32_C(4294967227)) == std::vector{UINT32_C(17), UINT32_C(252645131)});
  assert_that(tools::prime_factorization(UINT32_C(4294967228)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(101), UINT32_C(10631107)});
  assert_that(tools::prime_factorization(UINT32_C(4294967229)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(7), UINT32_C(977), UINT32_C(69779)});
  assert_that(tools::prime_factorization(UINT32_C(4294967230)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(31), UINT32_C(13854733)});
  assert_that(tools::prime_factorization(UINT32_C(4294967231)) == std::vector{UINT32_C(4294967231)});
  assert_that(tools::prime_factorization(UINT32_C(4294967232)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(2731), UINT32_C(8191)});
  assert_that(tools::prime_factorization(UINT32_C(4294967233)) == std::vector{UINT32_C(19), UINT32_C(103), UINT32_C(617), UINT32_C(3557)});
  assert_that(tools::prime_factorization(UINT32_C(4294967234)) == std::vector{UINT32_C(2), UINT32_C(6733), UINT32_C(318949)});
  assert_that(tools::prime_factorization(UINT32_C(4294967235)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(13), UINT32_C(22025473)});
  assert_that(tools::prime_factorization(UINT32_C(4294967236)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(7), UINT32_C(367), UINT32_C(417961)});
  assert_that(tools::prime_factorization(UINT32_C(4294967237)) == std::vector{UINT32_C(11), UINT32_C(11), UINT32_C(43), UINT32_C(825479)});
  assert_that(tools::prime_factorization(UINT32_C(4294967238)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(23), UINT32_C(353), UINT32_C(29389)});
  assert_that(tools::prime_factorization(UINT32_C(4294967239)) == std::vector{UINT32_C(61), UINT32_C(70409299)});
  assert_that(tools::prime_factorization(UINT32_C(4294967240)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(4603), UINT32_C(23327)});
  assert_that(tools::prime_factorization(UINT32_C(4294967241)) == std::vector{UINT32_C(3), UINT32_C(1431655747)});
  assert_that(tools::prime_factorization(UINT32_C(4294967242)) == std::vector{UINT32_C(2), UINT32_C(14741), UINT32_C(145681)});
  assert_that(tools::prime_factorization(UINT32_C(4294967243)) == std::vector{UINT32_C(7), UINT32_C(991), UINT32_C(619139)});
  assert_that(tools::prime_factorization(UINT32_C(4294967244)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(17), UINT32_C(467), UINT32_C(45083)});
  assert_that(tools::prime_factorization(UINT32_C(4294967245)) == std::vector{UINT32_C(5), UINT32_C(59), UINT32_C(211), UINT32_C(69001)});
  assert_that(tools::prime_factorization(UINT32_C(4294967246)) == std::vector{UINT32_C(2), UINT32_C(79), UINT32_C(967), UINT32_C(28111)});
  assert_that(tools::prime_factorization(UINT32_C(4294967247)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(809), UINT32_C(65543)});
  assert_that(tools::prime_factorization(UINT32_C(4294967248)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(11), UINT32_C(13), UINT32_C(1877171)});
  assert_that(tools::prime_factorization(UINT32_C(4294967249)) == std::vector{UINT32_C(269), UINT32_C(15966421)});
  assert_that(tools::prime_factorization(UINT32_C(4294967250)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(5), UINT32_C(5), UINT32_C(5), UINT32_C(7), UINT32_C(199), UINT32_C(4111)});
  assert_that(tools::prime_factorization(UINT32_C(4294967251)) == std::vector{UINT32_C(29), UINT32_C(89), UINT32_C(1664071)});
  assert_that(tools::prime_factorization(UINT32_C(4294967252)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(19), UINT32_C(37), UINT32_C(1527371)});
  assert_that(tools::prime_factorization(UINT32_C(4294967253)) == std::vector{UINT32_C(3), UINT32_C(1431655751)});
  assert_that(tools::prime_factorization(UINT32_C(4294967254)) == std::vector{UINT32_C(2), UINT32_C(47), UINT32_C(53), UINT32_C(862097)});
  assert_that(tools::prime_factorization(UINT32_C(4294967255)) == std::vector{UINT32_C(5), UINT32_C(139), UINT32_C(1451), UINT32_C(4259)});
  assert_that(tools::prime_factorization(UINT32_C(4294967256)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(59652323)});
  assert_that(tools::prime_factorization(UINT32_C(4294967257)) == std::vector{UINT32_C(7), UINT32_C(7), UINT32_C(1061), UINT32_C(82613)});
  assert_that(tools::prime_factorization(UINT32_C(4294967258)) == std::vector{UINT32_C(2), UINT32_C(2147483629)});
  assert_that(tools::prime_factorization(UINT32_C(4294967259)) == std::vector{UINT32_C(3), UINT32_C(11), UINT32_C(41), UINT32_C(659), UINT32_C(4817)});
  assert_that(tools::prime_factorization(UINT32_C(4294967260)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(5), UINT32_C(6553), UINT32_C(32771)});
  assert_that(tools::prime_factorization(UINT32_C(4294967261)) == std::vector{UINT32_C(13), UINT32_C(17), UINT32_C(23), UINT32_C(31), UINT32_C(97), UINT32_C(281)});
  assert_that(tools::prime_factorization(UINT32_C(4294967262)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(137), UINT32_C(263), UINT32_C(19867)});
  assert_that(tools::prime_factorization(UINT32_C(4294967263)) == std::vector{UINT32_C(67), UINT32_C(64103989)});
  assert_that(tools::prime_factorization(UINT32_C(4294967264)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(7), UINT32_C(73), UINT32_C(262657)});
  assert_that(tools::prime_factorization(UINT32_C(4294967265)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(5), UINT32_C(95443717)});
  assert_that(tools::prime_factorization(UINT32_C(4294967266)) == std::vector{UINT32_C(2), UINT32_C(5843), UINT32_C(367531)});
  assert_that(tools::prime_factorization(UINT32_C(4294967267)) == std::vector{UINT32_C(107), UINT32_C(1069), UINT32_C(37549)});
  assert_that(tools::prime_factorization(UINT32_C(4294967268)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(12097), UINT32_C(29587)});
  assert_that(tools::prime_factorization(UINT32_C(4294967269)) == std::vector{UINT32_C(277), UINT32_C(433), UINT32_C(35809)});
  assert_that(tools::prime_factorization(UINT32_C(4294967270)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(11), UINT32_C(337), UINT32_C(115861)});
  assert_that(tools::prime_factorization(UINT32_C(4294967271)) == std::vector{UINT32_C(3), UINT32_C(7), UINT32_C(19), UINT32_C(3121), UINT32_C(3449)});
  assert_that(tools::prime_factorization(UINT32_C(4294967272)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(536870909)});
  assert_that(tools::prime_factorization(UINT32_C(4294967273)) == std::vector{UINT32_C(10847), UINT32_C(395959)});
  assert_that(tools::prime_factorization(UINT32_C(4294967274)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(3), UINT32_C(13), UINT32_C(6118187)});
  assert_that(tools::prime_factorization(UINT32_C(4294967275)) == std::vector{UINT32_C(5), UINT32_C(5), UINT32_C(171798691)});
  assert_that(tools::prime_factorization(UINT32_C(4294967276)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2969), UINT32_C(361651)});
  assert_that(tools::prime_factorization(UINT32_C(4294967277)) == std::vector{UINT32_C(3), UINT32_C(769), UINT32_C(1861711)});
  assert_that(tools::prime_factorization(UINT32_C(4294967278)) == std::vector{UINT32_C(2), UINT32_C(7), UINT32_C(17), UINT32_C(18046081)});
  assert_that(tools::prime_factorization(UINT32_C(4294967279)) == std::vector{UINT32_C(4294967279)});
  assert_that(tools::prime_factorization(UINT32_C(4294967280)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(5), UINT32_C(29), UINT32_C(43), UINT32_C(113), UINT32_C(127)});
  assert_that(tools::prime_factorization(UINT32_C(4294967281)) == std::vector{UINT32_C(11), UINT32_C(181), UINT32_C(241), UINT32_C(8951)});
  assert_that(tools::prime_factorization(UINT32_C(4294967282)) == std::vector{UINT32_C(2), UINT32_C(2699), UINT32_C(795659)});
  assert_that(tools::prime_factorization(UINT32_C(4294967283)) == std::vector{UINT32_C(3), UINT32_C(3), UINT32_C(389), UINT32_C(1226783)});
  assert_that(tools::prime_factorization(UINT32_C(4294967284)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(23), UINT32_C(46684427)});
  assert_that(tools::prime_factorization(UINT32_C(4294967285)) == std::vector{UINT32_C(5), UINT32_C(7), UINT32_C(122713351)});
  assert_that(tools::prime_factorization(UINT32_C(4294967286)) == std::vector{UINT32_C(2), UINT32_C(3), UINT32_C(715827881)});
  assert_that(tools::prime_factorization(UINT32_C(4294967287)) == std::vector{UINT32_C(13), UINT32_C(71), UINT32_C(71), UINT32_C(65539)});
  assert_that(tools::prime_factorization(UINT32_C(4294967288)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(2), UINT32_C(233), UINT32_C(1103), UINT32_C(2089)});
  assert_that(tools::prime_factorization(UINT32_C(4294967289)) == std::vector{UINT32_C(3), UINT32_C(37), UINT32_C(167), UINT32_C(223), UINT32_C(1039)});
  assert_that(tools::prime_factorization(UINT32_C(4294967290)) == std::vector{UINT32_C(2), UINT32_C(5), UINT32_C(19), UINT32_C(22605091)});
  assert_that(tools::prime_factorization(UINT32_C(4294967291)) == std::vector{UINT32_C(4294967291)});
  assert_that(tools::prime_factorization(UINT32_C(4294967292)) == std::vector{UINT32_C(2), UINT32_C(2), UINT32_C(3), UINT32_C(3), UINT32_C(7), UINT32_C(11), UINT32_C(31), UINT32_C(151), UINT32_C(331)});
  assert_that(tools::prime_factorization(UINT32_C(4294967293)) == std::vector{UINT32_C(9241), UINT32_C(464773)});
  assert_that(tools::prime_factorization(UINT32_C(4294967294)) == std::vector{UINT32_C(2), UINT32_C(2147483647)});
  assert_that(tools::prime_factorization(UINT32_C(4294967295)) == std::vector{UINT32_C(3), UINT32_C(5), UINT32_C(17), UINT32_C(257), UINT32_C(65537)});

  assert_that(tools::prime_factorization(INT64_C(1)) == std::vector<std::int64_t>{});
  assert_that(tools::prime_factorization(INT64_C(2)) == std::vector{INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(3)) == std::vector{INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(4)) == std::vector{INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(5)) == std::vector{INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(6)) == std::vector{INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(7)) == std::vector{INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(8)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(9)) == std::vector{INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(10)) == std::vector{INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(11)) == std::vector{INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(12)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(13)) == std::vector{INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(14)) == std::vector{INT64_C(2), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(15)) == std::vector{INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(16)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(17)) == std::vector{INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(18)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(19)) == std::vector{INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(20)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(21)) == std::vector{INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(22)) == std::vector{INT64_C(2), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(23)) == std::vector{INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(24)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(25)) == std::vector{INT64_C(5), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(26)) == std::vector{INT64_C(2), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(27)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(28)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(29)) == std::vector{INT64_C(29)});
  assert_that(tools::prime_factorization(INT64_C(30)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(31)) == std::vector{INT64_C(31)});
  assert_that(tools::prime_factorization(INT64_C(32)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(33)) == std::vector{INT64_C(3), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(34)) == std::vector{INT64_C(2), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(35)) == std::vector{INT64_C(5), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(36)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(37)) == std::vector{INT64_C(37)});
  assert_that(tools::prime_factorization(INT64_C(38)) == std::vector{INT64_C(2), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(39)) == std::vector{INT64_C(3), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(40)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(41)) == std::vector{INT64_C(41)});
  assert_that(tools::prime_factorization(INT64_C(42)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(43)) == std::vector{INT64_C(43)});
  assert_that(tools::prime_factorization(INT64_C(44)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(45)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(46)) == std::vector{INT64_C(2), INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(47)) == std::vector{INT64_C(47)});
  assert_that(tools::prime_factorization(INT64_C(48)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(49)) == std::vector{INT64_C(7), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(50)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(51)) == std::vector{INT64_C(3), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(52)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(53)) == std::vector{INT64_C(53)});
  assert_that(tools::prime_factorization(INT64_C(54)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(55)) == std::vector{INT64_C(5), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(56)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(57)) == std::vector{INT64_C(3), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(58)) == std::vector{INT64_C(2), INT64_C(29)});
  assert_that(tools::prime_factorization(INT64_C(59)) == std::vector{INT64_C(59)});
  assert_that(tools::prime_factorization(INT64_C(60)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(61)) == std::vector{INT64_C(61)});
  assert_that(tools::prime_factorization(INT64_C(62)) == std::vector{INT64_C(2), INT64_C(31)});
  assert_that(tools::prime_factorization(INT64_C(63)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(64)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2)});
  assert_that(tools::prime_factorization(INT64_C(65)) == std::vector{INT64_C(5), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(66)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(67)) == std::vector{INT64_C(67)});
  assert_that(tools::prime_factorization(INT64_C(68)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(69)) == std::vector{INT64_C(3), INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(70)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(71)) == std::vector{INT64_C(71)});
  assert_that(tools::prime_factorization(INT64_C(72)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(73)) == std::vector{INT64_C(73)});
  assert_that(tools::prime_factorization(INT64_C(74)) == std::vector{INT64_C(2), INT64_C(37)});
  assert_that(tools::prime_factorization(INT64_C(75)) == std::vector{INT64_C(3), INT64_C(5), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(76)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(77)) == std::vector{INT64_C(7), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(78)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(79)) == std::vector{INT64_C(79)});
  assert_that(tools::prime_factorization(INT64_C(80)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(81)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(82)) == std::vector{INT64_C(2), INT64_C(41)});
  assert_that(tools::prime_factorization(INT64_C(83)) == std::vector{INT64_C(83)});
  assert_that(tools::prime_factorization(INT64_C(84)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(85)) == std::vector{INT64_C(5), INT64_C(17)});
  assert_that(tools::prime_factorization(INT64_C(86)) == std::vector{INT64_C(2), INT64_C(43)});
  assert_that(tools::prime_factorization(INT64_C(87)) == std::vector{INT64_C(3), INT64_C(29)});
  assert_that(tools::prime_factorization(INT64_C(88)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(89)) == std::vector{INT64_C(89)});
  assert_that(tools::prime_factorization(INT64_C(90)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(5)});
  assert_that(tools::prime_factorization(INT64_C(91)) == std::vector{INT64_C(7), INT64_C(13)});
  assert_that(tools::prime_factorization(INT64_C(92)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(23)});
  assert_that(tools::prime_factorization(INT64_C(93)) == std::vector{INT64_C(3), INT64_C(31)});
  assert_that(tools::prime_factorization(INT64_C(94)) == std::vector{INT64_C(2), INT64_C(47)});
  assert_that(tools::prime_factorization(INT64_C(95)) == std::vector{INT64_C(5), INT64_C(19)});
  assert_that(tools::prime_factorization(INT64_C(96)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3)});
  assert_that(tools::prime_factorization(INT64_C(97)) == std::vector{INT64_C(97)});
  assert_that(tools::prime_factorization(INT64_C(98)) == std::vector{INT64_C(2), INT64_C(7), INT64_C(7)});
  assert_that(tools::prime_factorization(INT64_C(99)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(11)});
  assert_that(tools::prime_factorization(INT64_C(100)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(5)});

  assert_that(tools::prime_factorization(INT64_C(9200527969062830400)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(5), INT64_C(7), INT64_C(7), INT64_C(11), INT64_C(13), INT64_C(17), INT64_C(19), INT64_C(23), INT64_C(29), INT64_C(31), INT64_C(37), INT64_C(41)});

  assert_that(tools::prime_factorization(INT64_C(9223372036854775708)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(1319), INT64_C(1748175139661633)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775709)) == std::vector{INT64_C(7), INT64_C(7), INT64_C(13), INT64_C(29), INT64_C(2729), INT64_C(182956886477)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775710)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(131), INT64_C(2699), INT64_C(364289), INT64_C(795659)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775711)) == std::vector{INT64_C(1171), INT64_C(16573), INT64_C(475260479017)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775712)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(11), INT64_C(26202761468337431)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775713)) == std::vector{INT64_C(3), INT64_C(23), INT64_C(133672058505141677)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775714)) == std::vector{INT64_C(2), INT64_C(17), INT64_C(19), INT64_C(215153), INT64_C(66360523403)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775715)) == std::vector{INT64_C(5), INT64_C(1844674407370955143)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775716)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(7), INT64_C(1607), INT64_C(2067431), INT64_C(33049397)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775717)) == std::vector{INT64_C(59), INT64_C(156328339607708063)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775718)) == std::vector{INT64_C(2), INT64_C(41), INT64_C(101), INT64_C(4051), INT64_C(6199), INT64_C(44347651)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775719)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(1024819115206086191)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775720)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(4229), INT64_C(54524545027517)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775721)) == std::vector{INT64_C(53), INT64_C(1791191), INT64_C(97156521827)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775722)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(13), INT64_C(3109), INT64_C(38034210179111)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775723)) == std::vector{INT64_C(7), INT64_C(11), INT64_C(43), INT64_C(27109), INT64_C(234293), INT64_C(438589)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775724)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(124367), INT64_C(18540633843493)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775725)) == std::vector{INT64_C(3), INT64_C(5), INT64_C(5), INT64_C(47), INT64_C(47), INT64_C(55671477512327)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775726)) == std::vector{INT64_C(2), INT64_C(1087), INT64_C(4242581433695849)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775727)) == std::vector{INT64_C(11113), INT64_C(829962389710679)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775728)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(37), INT64_C(34519), INT64_C(83717), INT64_C(199679)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775729)) == std::vector{INT64_C(97), INT64_C(103), INT64_C(2707), INT64_C(32233), INT64_C(10580149)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775730)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(7), INT64_C(89), INT64_C(1480477052464651)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775731)) == std::vector{INT64_C(3), INT64_C(17), INT64_C(319856591), INT64_C(565410991)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775732)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(71), INT64_C(139), INT64_C(1193693), INT64_C(195732949)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775733)) == std::vector{INT64_C(19), INT64_C(239), INT64_C(6197), INT64_C(8209), INT64_C(39926981)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775734)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(11), INT64_C(73), INT64_C(3527), INT64_C(542772044869)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775735)) == std::vector{INT64_C(5), INT64_C(13), INT64_C(141898031336227319)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775736)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(23), INT64_C(46684427), INT64_C(1073741827)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775737)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(7), INT64_C(313), INT64_C(68329), INT64_C(6845414887)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775738)) == std::vector{INT64_C(2), INT64_C(29), INT64_C(31), INT64_C(17597), INT64_C(33289), INT64_C(8757107)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775739)) == std::vector{INT64_C(61), INT64_C(3264649), INT64_C(46315184351)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775740)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(5), INT64_C(153722867280912929)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775741)) == std::vector{INT64_C(75883), INT64_C(299881), INT64_C(405318367)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775742)) == std::vector{INT64_C(2), INT64_C(252449), INT64_C(18267792775679)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775743)) == std::vector{INT64_C(3), INT64_C(79), INT64_C(116533), INT64_C(333958463183)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775744)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(7), INT64_C(32377), INT64_C(524287), INT64_C(1212847)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775745)) == std::vector{INT64_C(5), INT64_C(11), INT64_C(199), INT64_C(11587), INT64_C(72728219243)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775746)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(179), INT64_C(23021), INT64_C(124348343983)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775747)) == std::vector{INT64_C(677), INT64_C(78919), INT64_C(172631277569)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775748)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(13), INT64_C(17), INT64_C(37359691), INT64_C(279276367)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775749)) == std::vector{INT64_C(3), INT64_C(8447), INT64_C(363970326224489)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775750)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(5), INT64_C(5), INT64_C(36893488147419103)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775751)) == std::vector{INT64_C(7), INT64_C(17659), INT64_C(74614903261427)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775752)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(19), INT64_C(93053), INT64_C(217367447189)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775753)) == std::vector{INT64_C(266416229), INT64_C(34620158357)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775754)) == std::vector{INT64_C(2), INT64_C(343242169), INT64_C(13435662733)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775755)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(68321274347072413)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775756)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(11), INT64_C(227), INT64_C(263), INT64_C(18341), INT64_C(191439889)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775757)) == std::vector{INT64_C(149), INT64_C(5987), INT64_C(10339372933139)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775758)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(7), INT64_C(7), INT64_C(43826197), INT64_C(715827881)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775759)) == std::vector{INT64_C(23), INT64_C(41), INT64_C(620441), INT64_C(15764403593)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775760)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(2663), INT64_C(43294085790719)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775761)) == std::vector{INT64_C(3), INT64_C(13), INT64_C(13), INT64_C(619), INT64_C(739), INT64_C(39769184003)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775762)) == std::vector{INT64_C(2), INT64_C(107), INT64_C(1117), INT64_C(38585379884599)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775763)) == std::vector{INT64_C(4481), INT64_C(63601), INT64_C(32363153923)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775764)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(256204778801521549)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775765)) == std::vector{INT64_C(5), INT64_C(7), INT64_C(17), INT64_C(37), INT64_C(418958529950251)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775766)) == std::vector{INT64_C(2), INT64_C(43), INT64_C(67), INT64_C(193), INT64_C(809383), INT64_C(10247197)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775767)) == std::vector{INT64_C(3), INT64_C(11), INT64_C(29), INT64_C(19473149), INT64_C(494927519)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775768)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(409), INT64_C(1793599), INT64_C(1571632781)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775769)) == std::vector{INT64_C(31), INT64_C(10037), INT64_C(29643133428427)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775770)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(5), INT64_C(986507), INT64_C(311650839337)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775771)) == std::vector{INT64_C(19), INT64_C(485440633518672409)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775772)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(7), INT64_C(47), INT64_C(8627903), INT64_C(812322689)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775773)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(1024819115206086197)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775774)) == std::vector{INT64_C(2), INT64_C(13), INT64_C(53), INT64_C(6693303364916383)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775775)) == std::vector{INT64_C(5), INT64_C(5), INT64_C(109), INT64_C(57881), INT64_C(58477284139)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775776)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(59), INT64_C(233), INT64_C(1103), INT64_C(2089), INT64_C(3033169)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775777)) == std::vector{INT64_C(584911), INT64_C(15768846947407)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775778)) == std::vector{INT64_C(2), INT64_C(11), INT64_C(137), INT64_C(547), INT64_C(5594472617641)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775779)) == std::vector{INT64_C(3), INT64_C(7), INT64_C(439208192231179799)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775780)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(5), INT64_C(461168601842738789)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775781)) == std::vector{INT64_C(773), INT64_C(2713), INT64_C(19993), INT64_C(219979633)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775782)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(3), INT64_C(17), INT64_C(23), INT64_C(319279), INT64_C(456065899)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775783)) == std::vector{INT64_C(9223372036854775783)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775784)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(1177067), INT64_C(979486728119)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775785)) == std::vector{INT64_C(3), INT64_C(5), INT64_C(24097), INT64_C(25517345276327)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775786)) == std::vector{INT64_C(2), INT64_C(7), INT64_C(181), INT64_C(229), INT64_C(3697), INT64_C(4299304283)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775787)) == std::vector{INT64_C(13), INT64_C(440303), INT64_C(1611367982233)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775788)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(643), INT64_C(1195356666259043)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775789)) == std::vector{INT64_C(11), INT64_C(3931), INT64_C(213301543369829)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775790)) == std::vector{INT64_C(2), INT64_C(5), INT64_C(19), INT64_C(83), INT64_C(1277), INT64_C(20261), INT64_C(22605091)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775791)) == std::vector{INT64_C(3), INT64_C(3), INT64_C(14737), INT64_C(4837853), INT64_C(14374259)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775792)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(179951), INT64_C(3203431780337)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775793)) == std::vector{INT64_C(7), INT64_C(113), INT64_C(5647), INT64_C(2064883032409)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775794)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(3491), INT64_C(440340496364689)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775795)) == std::vector{INT64_C(5), INT64_C(191), INT64_C(421), INT64_C(90679), INT64_C(252986611)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775796)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(29), INT64_C(79511827903920481)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775797)) == std::vector{INT64_C(3), INT64_C(3074457345618258599)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775798)) == std::vector{INT64_C(2), INT64_C(34421), INT64_C(133978850655919)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775799)) == std::vector{INT64_C(17), INT64_C(17), INT64_C(17), INT64_C(2927), INT64_C(641387128649)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775800)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2), INT64_C(3), INT64_C(3), INT64_C(5), INT64_C(5), INT64_C(7), INT64_C(11), INT64_C(13), INT64_C(31), INT64_C(41), INT64_C(61), INT64_C(151), INT64_C(331), INT64_C(1321)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775801)) == std::vector{INT64_C(157), INT64_C(1973), INT64_C(29775769179641)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775802)) == std::vector{INT64_C(2), INT64_C(37), INT64_C(9902437), INT64_C(12586817029)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775803)) == std::vector{INT64_C(3), INT64_C(71), INT64_C(42013), INT64_C(1030686124187)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775804)) == std::vector{INT64_C(2), INT64_C(2), INT64_C(2305843009213693951)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775805)) == std::vector{INT64_C(5), INT64_C(23), INT64_C(53301701), INT64_C(1504703107)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775806)) == std::vector{INT64_C(2), INT64_C(3), INT64_C(715827883), INT64_C(2147483647)});
  assert_that(tools::prime_factorization(INT64_C(9223372036854775807)) == std::vector{INT64_C(7), INT64_C(7), INT64_C(73), INT64_C(127), INT64_C(337), INT64_C(92737), INT64_C(649657)});

  assert_that(tools::prime_factorization(UINT64_C(1)) == std::vector<std::uint64_t>{});
  assert_that(tools::prime_factorization(UINT64_C(2)) == std::vector{UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(3)) == std::vector{UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(4)) == std::vector{UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(5)) == std::vector{UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(6)) == std::vector{UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(7)) == std::vector{UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(8)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(9)) == std::vector{UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(10)) == std::vector{UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(11)) == std::vector{UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(12)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(13)) == std::vector{UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(14)) == std::vector{UINT64_C(2), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(15)) == std::vector{UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(16)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(17)) == std::vector{UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(18)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(19)) == std::vector{UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(20)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(21)) == std::vector{UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(22)) == std::vector{UINT64_C(2), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(23)) == std::vector{UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(24)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(25)) == std::vector{UINT64_C(5), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(26)) == std::vector{UINT64_C(2), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(27)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(28)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(29)) == std::vector{UINT64_C(29)});
  assert_that(tools::prime_factorization(UINT64_C(30)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(31)) == std::vector{UINT64_C(31)});
  assert_that(tools::prime_factorization(UINT64_C(32)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(33)) == std::vector{UINT64_C(3), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(34)) == std::vector{UINT64_C(2), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(35)) == std::vector{UINT64_C(5), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(36)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(37)) == std::vector{UINT64_C(37)});
  assert_that(tools::prime_factorization(UINT64_C(38)) == std::vector{UINT64_C(2), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(39)) == std::vector{UINT64_C(3), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(40)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(41)) == std::vector{UINT64_C(41)});
  assert_that(tools::prime_factorization(UINT64_C(42)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(43)) == std::vector{UINT64_C(43)});
  assert_that(tools::prime_factorization(UINT64_C(44)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(45)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(46)) == std::vector{UINT64_C(2), UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(47)) == std::vector{UINT64_C(47)});
  assert_that(tools::prime_factorization(UINT64_C(48)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(49)) == std::vector{UINT64_C(7), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(50)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(51)) == std::vector{UINT64_C(3), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(52)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(53)) == std::vector{UINT64_C(53)});
  assert_that(tools::prime_factorization(UINT64_C(54)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(55)) == std::vector{UINT64_C(5), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(56)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(57)) == std::vector{UINT64_C(3), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(58)) == std::vector{UINT64_C(2), UINT64_C(29)});
  assert_that(tools::prime_factorization(UINT64_C(59)) == std::vector{UINT64_C(59)});
  assert_that(tools::prime_factorization(UINT64_C(60)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(61)) == std::vector{UINT64_C(61)});
  assert_that(tools::prime_factorization(UINT64_C(62)) == std::vector{UINT64_C(2), UINT64_C(31)});
  assert_that(tools::prime_factorization(UINT64_C(63)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(64)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2)});
  assert_that(tools::prime_factorization(UINT64_C(65)) == std::vector{UINT64_C(5), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(66)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(67)) == std::vector{UINT64_C(67)});
  assert_that(tools::prime_factorization(UINT64_C(68)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(69)) == std::vector{UINT64_C(3), UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(70)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(71)) == std::vector{UINT64_C(71)});
  assert_that(tools::prime_factorization(UINT64_C(72)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(73)) == std::vector{UINT64_C(73)});
  assert_that(tools::prime_factorization(UINT64_C(74)) == std::vector{UINT64_C(2), UINT64_C(37)});
  assert_that(tools::prime_factorization(UINT64_C(75)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(76)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(77)) == std::vector{UINT64_C(7), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(78)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(79)) == std::vector{UINT64_C(79)});
  assert_that(tools::prime_factorization(UINT64_C(80)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(81)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(82)) == std::vector{UINT64_C(2), UINT64_C(41)});
  assert_that(tools::prime_factorization(UINT64_C(83)) == std::vector{UINT64_C(83)});
  assert_that(tools::prime_factorization(UINT64_C(84)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(85)) == std::vector{UINT64_C(5), UINT64_C(17)});
  assert_that(tools::prime_factorization(UINT64_C(86)) == std::vector{UINT64_C(2), UINT64_C(43)});
  assert_that(tools::prime_factorization(UINT64_C(87)) == std::vector{UINT64_C(3), UINT64_C(29)});
  assert_that(tools::prime_factorization(UINT64_C(88)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(89)) == std::vector{UINT64_C(89)});
  assert_that(tools::prime_factorization(UINT64_C(90)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(5)});
  assert_that(tools::prime_factorization(UINT64_C(91)) == std::vector{UINT64_C(7), UINT64_C(13)});
  assert_that(tools::prime_factorization(UINT64_C(92)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(23)});
  assert_that(tools::prime_factorization(UINT64_C(93)) == std::vector{UINT64_C(3), UINT64_C(31)});
  assert_that(tools::prime_factorization(UINT64_C(94)) == std::vector{UINT64_C(2), UINT64_C(47)});
  assert_that(tools::prime_factorization(UINT64_C(95)) == std::vector{UINT64_C(5), UINT64_C(19)});
  assert_that(tools::prime_factorization(UINT64_C(96)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3)});
  assert_that(tools::prime_factorization(UINT64_C(97)) == std::vector{UINT64_C(97)});
  assert_that(tools::prime_factorization(UINT64_C(98)) == std::vector{UINT64_C(2), UINT64_C(7), UINT64_C(7)});
  assert_that(tools::prime_factorization(UINT64_C(99)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(11)});
  assert_that(tools::prime_factorization(UINT64_C(100)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(5)});

  assert_that(tools::prime_factorization(UINT64_C(18401055938125660800)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(5), UINT64_C(5), UINT64_C(7), UINT64_C(7), UINT64_C(11), UINT64_C(13), UINT64_C(17), UINT64_C(19), UINT64_C(23), UINT64_C(29), UINT64_C(31), UINT64_C(37), UINT64_C(41)});

  assert_that(tools::prime_factorization(UINT64_C(18446744073709551516)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(7), UINT64_C(7), UINT64_C(43826197), UINT64_C(715827881)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551517)) == std::vector{UINT64_C(397), UINT64_C(46465350311610961)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551518)) == std::vector{UINT64_C(2), UINT64_C(23), UINT64_C(41), UINT64_C(620441), UINT64_C(15764403593)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551519)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(307), UINT64_C(405029), UINT64_C(16483624697)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551520)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(2663), UINT64_C(43294085790719)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551521)) == std::vector{UINT64_C(18446744073709551521)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551522)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(13), UINT64_C(13), UINT64_C(619), UINT64_C(739), UINT64_C(39769184003)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551523)) == std::vector{UINT64_C(7), UINT64_C(11), UINT64_C(11), UINT64_C(19), UINT64_C(6897409), UINT64_C(166186879)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551524)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(107), UINT64_C(1117), UINT64_C(38585379884599)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551525)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(5), UINT64_C(4441), UINT64_C(55383154165607)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551526)) == std::vector{UINT64_C(2), UINT64_C(4481), UINT64_C(63601), UINT64_C(32363153923)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551527)) == std::vector{UINT64_C(17099), UINT64_C(1078820052266773)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551528)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(256204778801521549)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551529)) == std::vector{UINT64_C(14843), UINT64_C(13973891), UINT64_C(88936633)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551530)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(7), UINT64_C(17), UINT64_C(37), UINT64_C(418958529950251)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551531)) == std::vector{UINT64_C(3), UINT64_C(962165251), UINT64_C(6390705427)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551532)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(43), UINT64_C(67), UINT64_C(193), UINT64_C(809383), UINT64_C(10247197)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551533)) == std::vector{UINT64_C(18446744073709551533)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551534)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(11), UINT64_C(29), UINT64_C(19473149), UINT64_C(494927519)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551535)) == std::vector{UINT64_C(5), UINT64_C(13), UINT64_C(71), UINT64_C(71), UINT64_C(9629), UINT64_C(65539), UINT64_C(89209)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551536)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(409), UINT64_C(1793599), UINT64_C(1571632781)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551537)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(7), UINT64_C(101), UINT64_C(7623919), UINT64_C(126753007)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551538)) == std::vector{UINT64_C(2), UINT64_C(31), UINT64_C(10037), UINT64_C(29643133428427)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551539)) == std::vector{UINT64_C(61), UINT64_C(268909), UINT64_C(1124564966411)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551540)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(5), UINT64_C(986507), UINT64_C(311650839337)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551541)) == std::vector{UINT64_C(23), UINT64_C(73), UINT64_C(7283), UINT64_C(1508546551513)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551542)) == std::vector{UINT64_C(2), UINT64_C(19), UINT64_C(485440633518672409)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551543)) == std::vector{UINT64_C(3), UINT64_C(839), UINT64_C(7328861372153179)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551544)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(7), UINT64_C(47), UINT64_C(8627903), UINT64_C(812322689)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551545)) == std::vector{UINT64_C(5), UINT64_C(11), UINT64_C(3319), UINT64_C(36871), UINT64_C(2740721231)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551546)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(1024819115206086197)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551547)) == std::vector{UINT64_C(17), UINT64_C(211), UINT64_C(251), UINT64_C(1101431), UINT64_C(18601901)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551548)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(13), UINT64_C(53), UINT64_C(6693303364916383)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551549)) == std::vector{UINT64_C(3), UINT64_C(89), UINT64_C(69088929115017047)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551550)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(5), UINT64_C(109), UINT64_C(57881), UINT64_C(58477284139)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551551)) == std::vector{UINT64_C(7), UINT64_C(131), UINT64_C(20116405751046403)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551552)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(59), UINT64_C(233), UINT64_C(1103), UINT64_C(2089), UINT64_C(3033169)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551553)) == std::vector{UINT64_C(401), UINT64_C(119241217), UINT64_C(385788209)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551554)) == std::vector{UINT64_C(2), UINT64_C(584911), UINT64_C(15768846947407)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551555)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(5), UINT64_C(97), UINT64_C(197), UINT64_C(325957), UINT64_C(65812583)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551556)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(11), UINT64_C(137), UINT64_C(547), UINT64_C(5594472617641)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551557)) == std::vector{UINT64_C(18446744073709551557)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551558)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(7), UINT64_C(439208192231179799)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551559)) == std::vector{UINT64_C(41), UINT64_C(163), UINT64_C(269), UINT64_C(8807), UINT64_C(1165112831)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551560)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(461168601842738789)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551561)) == std::vector{UINT64_C(3), UINT64_C(13), UINT64_C(19), UINT64_C(103), UINT64_C(1811), UINT64_C(133458377137)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551562)) == std::vector{UINT64_C(2), UINT64_C(773), UINT64_C(2713), UINT64_C(19993), UINT64_C(219979633)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551563)) == std::vector{UINT64_C(29), UINT64_C(74187931), UINT64_C(8574098437)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551564)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(17), UINT64_C(23), UINT64_C(319279), UINT64_C(456065899)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551565)) == std::vector{UINT64_C(5), UINT64_C(7), UINT64_C(7), UINT64_C(79), UINT64_C(599), UINT64_C(659), UINT64_C(2414428283)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551566)) == std::vector{UINT64_C(2), UINT64_C(9223372036854775783)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551567)) == std::vector{UINT64_C(3), UINT64_C(11), UINT64_C(37), UINT64_C(167), UINT64_C(223), UINT64_C(1039), UINT64_C(6323), UINT64_C(61751)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551568)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(1177067), UINT64_C(979486728119)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551569)) == std::vector{UINT64_C(31), UINT64_C(173), UINT64_C(9419), UINT64_C(439771), UINT64_C(830387)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551570)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(5), UINT64_C(24097), UINT64_C(25517345276327)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551571)) == std::vector{UINT64_C(11071), UINT64_C(844709), UINT64_C(1972539689)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551572)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(7), UINT64_C(181), UINT64_C(229), UINT64_C(3697), UINT64_C(4299304283)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551573)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(31799), UINT64_C(64456059323003)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551574)) == std::vector{UINT64_C(2), UINT64_C(13), UINT64_C(440303), UINT64_C(1611367982233)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551575)) == std::vector{UINT64_C(5), UINT64_C(5), UINT64_C(43), UINT64_C(122099), UINT64_C(140539741759)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551576)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(643), UINT64_C(1195356666259043)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551577)) == std::vector{UINT64_C(139646831), UINT64_C(132095686967)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551578)) == std::vector{UINT64_C(2), UINT64_C(11), UINT64_C(3931), UINT64_C(213301543369829)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551579)) == std::vector{UINT64_C(3), UINT64_C(7), UINT64_C(57906439), UINT64_C(15169580441)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551580)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(5), UINT64_C(19), UINT64_C(83), UINT64_C(1277), UINT64_C(20261), UINT64_C(22605091)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551581)) == std::vector{UINT64_C(17), UINT64_C(72786899), UINT64_C(14907938207)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551582)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(14737), UINT64_C(4837853), UINT64_C(14374259)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551583)) == std::vector{UINT64_C(827), UINT64_C(3894899), UINT64_C(5726879071)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551584)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(179951), UINT64_C(3203431780337)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551585)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(499), UINT64_C(2593), UINT64_C(950441521877)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551586)) == std::vector{UINT64_C(2), UINT64_C(7), UINT64_C(113), UINT64_C(5647), UINT64_C(2064883032409)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551587)) == std::vector{UINT64_C(13), UINT64_C(23), UINT64_C(23), UINT64_C(16561661), UINT64_C(161963371)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551588)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3491), UINT64_C(440340496364689)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551589)) == std::vector{UINT64_C(11), UINT64_C(13177), UINT64_C(127265442359687)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551590)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(191), UINT64_C(421), UINT64_C(90679), UINT64_C(252986611)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551591)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(3), UINT64_C(47), UINT64_C(3384529), UINT64_C(4294967291)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551592)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(29), UINT64_C(79511827903920481)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551593)) == std::vector{UINT64_C(7), UINT64_C(16547), UINT64_C(159258424692517)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551594)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(3074457345618258599)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551595)) == std::vector{UINT64_C(5), UINT64_C(373), UINT64_C(3301), UINT64_C(2996369460503)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551596)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(34421), UINT64_C(133978850655919)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551597)) == std::vector{UINT64_C(3), UINT64_C(6148914691236517199)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551598)) == std::vector{UINT64_C(2), UINT64_C(17), UINT64_C(17), UINT64_C(17), UINT64_C(2927), UINT64_C(641387128649)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551599)) == std::vector{UINT64_C(19), UINT64_C(67), UINT64_C(14490765179661863)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551600)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(3), UINT64_C(5), UINT64_C(5), UINT64_C(7), UINT64_C(11), UINT64_C(13), UINT64_C(31), UINT64_C(41), UINT64_C(61), UINT64_C(151), UINT64_C(331), UINT64_C(1321)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551601)) == std::vector{UINT64_C(53), UINT64_C(348051774975651917)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551602)) == std::vector{UINT64_C(2), UINT64_C(157), UINT64_C(1973), UINT64_C(29775769179641)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551603)) == std::vector{UINT64_C(3), UINT64_C(139), UINT64_C(2306123), UINT64_C(19182323033)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551604)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(37), UINT64_C(9902437), UINT64_C(12586817029)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551605)) == std::vector{UINT64_C(5), UINT64_C(2551), UINT64_C(1446236305269271)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551606)) == std::vector{UINT64_C(2), UINT64_C(3), UINT64_C(71), UINT64_C(42013), UINT64_C(1030686124187)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551607)) == std::vector{UINT64_C(7), UINT64_C(9241), UINT64_C(464773), UINT64_C(613566757)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551608)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(2), UINT64_C(2305843009213693951)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551609)) == std::vector{UINT64_C(3), UINT64_C(3), UINT64_C(818923289), UINT64_C(2502845209)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551610)) == std::vector{UINT64_C(2), UINT64_C(5), UINT64_C(23), UINT64_C(53301701), UINT64_C(1504703107)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551611)) == std::vector{UINT64_C(11), UINT64_C(59), UINT64_C(98818999), UINT64_C(287630261)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551612)) == std::vector{UINT64_C(2), UINT64_C(2), UINT64_C(3), UINT64_C(715827883), UINT64_C(2147483647)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551613)) == std::vector{UINT64_C(13), UINT64_C(3889), UINT64_C(364870227143809)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551614)) == std::vector{UINT64_C(2), UINT64_C(7), UINT64_C(7), UINT64_C(73), UINT64_C(127), UINT64_C(337), UINT64_C(92737), UINT64_C(649657)});
  assert_that(tools::prime_factorization(UINT64_C(18446744073709551615)) == std::vector{UINT64_C(3), UINT64_C(5), UINT64_C(17), UINT64_C(257), UINT64_C(641), UINT64_C(65537), UINT64_C(6700417)});

  return 0;
}
Back to top page