Aerobus v1.2
Loading...
Searching...
No Matches
aerobus.h
Go to the documentation of this file.
1// -*- lsst-c++ -*-
2#ifndef __INC_AEROBUS__ // NOLINT
3#define __INC_AEROBUS__
4
5#include <cstdint>
6#include <cstddef>
7#include <cstring>
8#include <type_traits>
9#include <utility>
10#include <algorithm>
11#include <functional>
12#include <string>
13#include <concepts> // NOLINT
14#include <array>
15#include <cmath>
16#include <limits>
17#include <cfenv>
18#ifdef WITH_CUDA_FP16
19#include <bit>
20#include <cuda_fp16.h>
21#endif
22
26#ifdef _MSC_VER
27#define ALIGNED(x) __declspec(align(x))
28#define INLINED __forceinline
29#else
30#define ALIGNED(x) __attribute__((aligned(x)))
31#define INLINED __attribute__((always_inline)) inline
32#endif
33
34#if defined(__CUDACC__) || defined(__HIPCC__)
35#define DEVICE __host__ __device__
36#else
37#define DEVICE
38#endif
39
41
43
45
47
49
50// aligned allocation
51namespace aerobus {
58 template<typename T>
59 T* aligned_malloc(size_t count, size_t alignment) {
60 #ifdef _MSC_VER
61 return static_cast<T*>(_aligned_malloc(count * sizeof(T), alignment));
62 #else
63 return static_cast<T*>(aligned_alloc(alignment, count * sizeof(T)));
64 #endif
65 }
66} // namespace aerobus
67
68// concepts
69namespace aerobus {
71 template <typename R>
72 concept IsRing = requires {
73 typename R::one;
74 typename R::zero;
75 typename R::template add_t<typename R::one, typename R::one>;
76 typename R::template sub_t<typename R::one, typename R::one>;
77 typename R::template mul_t<typename R::one, typename R::one>;
78 };
79
81 template <typename R>
82 concept IsEuclideanDomain = IsRing<R> && requires {
83 typename R::template div_t<typename R::one, typename R::one>;
84 typename R::template mod_t<typename R::one, typename R::one>;
85 typename R::template gcd_t<typename R::one, typename R::one>;
86 typename R::template eq_t<typename R::one, typename R::one>;
87 typename R::template pos_t<typename R::one>;
88
89 R::template pos_v<typename R::one> == true;
90 // typename R::template gt_t<typename R::one, typename R::zero>;
91 R::is_euclidean_domain == true;
92 };
93
95 template<typename R>
96 concept IsField = IsEuclideanDomain<R> && requires {
97 R::is_field == true;
98 };
99} // namespace aerobus
100
101#ifdef WITH_CUDA_FP16
102// all this shit is required because of NVIDIA bug https://developer.nvidia.com/bugs/4863696
103namespace aerobus {
104 namespace internal {
105 static constexpr DEVICE uint16_t my_internal_float2half(
106 const float f, uint32_t &sign, uint32_t &remainder) {
107 uint32_t x;
108 uint32_t u;
109 uint32_t result;
110 x = std::bit_cast<int32_t>(f);
111 u = (x & 0x7fffffffU);
112 sign = ((x >> 16U) & 0x8000U);
113 // NaN/+Inf/-Inf
114 if (u >= 0x7f800000U) {
115 remainder = 0U;
116 result = ((u == 0x7f800000U) ? (sign | 0x7c00U) : 0x7fffU);
117 } else if (u > 0x477fefffU) { // Overflows
118 remainder = 0x80000000U;
119 result = (sign | 0x7bffU);
120 } else if (u >= 0x38800000U) { // Normal numbers
121 remainder = u << 19U;
122 u -= 0x38000000U;
123 result = (sign | (u >> 13U));
124 } else if (u < 0x33000001U) { // +0/-0
125 remainder = u;
126 result = sign;
127 } else { // Denormal numbers
128 const uint32_t exponent = u >> 23U;
129 const uint32_t shift = 0x7eU - exponent;
130 uint32_t mantissa = (u & 0x7fffffU);
131 mantissa |= 0x800000U;
132 remainder = mantissa << (32U - shift);
133 result = (sign | (mantissa >> shift));
134 result &= 0x0000FFFFU;
135 }
136 return static_cast<uint16_t>(result);
137 }
138
139 static constexpr DEVICE __half my_float2half_rn(const float a) {
140 __half val;
141 __half_raw r;
142 uint32_t sign = 0U;
143 uint32_t remainder = 0U;
144 r.x = my_internal_float2half(a, sign, remainder);
145 if ((remainder > 0x80000000U) || ((remainder == 0x80000000U) && ((r.x & 0x1U) != 0U))) {
146 r.x++;
147 }
148
149 val = std::bit_cast<__half>(r);
150 return val;
151 }
152
153 template <int16_t i>
154 static constexpr __half convert_int16_to_half = my_float2half_rn(static_cast<float>(i));
155
156
157 template <typename Out, int16_t x, typename E = void>
158 struct int16_convert_helper;
159
160 template <typename Out, int16_t x>
161 struct int16_convert_helper<Out, x,
162 std::enable_if_t<!std::is_same_v<Out, __half> && !std::is_same_v<Out, __half2>>> {
163 static constexpr Out value() {
164 return static_cast<Out>(x);
165 }
166 };
167
168 template <int16_t x>
169 struct int16_convert_helper<__half, x> {
170 static constexpr __half value() {
171 return convert_int16_to_half<x>;
172 }
173 };
174
175 template <int16_t x>
176 struct int16_convert_helper<__half2, x> {
177 static constexpr __half2 value() {
178 return __half2(convert_int16_to_half<x>, convert_int16_to_half<x>);
179 }
180 };
181
182 } // namespace internal
183} // namespace aerobus
184#endif
185
186// cast
187namespace aerobus {
188 namespace internal {
189 template<typename Out, typename In>
190 struct staticcast {
191 template<auto x>
192 static constexpr INLINED DEVICE Out func() {
193 return static_cast<Out>(x);
194 }
195
196 static INLINED DEVICE Out eval(const In& x) {
197 return static_cast<Out>(x);
198 }
199 };
200
201 #ifdef WITH_CUDA_FP16
202 template<>
203 struct staticcast<__half, int16_t> {
204 template<int16_t x>
205 static constexpr INLINED DEVICE __half func() {
206 return int16_convert_helper<__half, x>::value();
207 }
208 };
209
210 template<>
211 struct staticcast<__half2, int16_t> {
212 template<int16_t x>
213 static constexpr INLINED DEVICE __half2 func() {
214 return int16_convert_helper<__half2, x>::value();
215 }
216 };
217
218 template<>
219 struct staticcast<float, __half> {
220 static INLINED DEVICE float eval(const __half& x) {
221 return __half2float(x);
222 }
223 };
224
225 template<>
226 struct staticcast<double, __half> {
227 static INLINED DEVICE double eval(const __half& x) {
228 return static_cast<double>(__half2float(x));
229 }
230 };
231
232 template<>
233 struct staticcast<__half, float> {
234 static INLINED DEVICE __half eval(const float& x) {
235 return __float2half(x);
236 }
237 };
238
239 template<>
240 struct staticcast<__half, double> {
241 static INLINED DEVICE __half eval(const double& x) {
242 return __float2half(static_cast<float>(x));
243 }
244 };
245 #endif
246 } // namespace internal
247} // namespace aerobus
248
249// fma_helper, required because nvidia fails to reconstruct fma for fp16 types
250namespace aerobus {
251 namespace internal {
252 template<typename T>
253 struct fma_helper;
254
255 template<>
256 struct fma_helper<double> {
257 static constexpr INLINED DEVICE double eval(const double x, const double y, const double z) {
258 return x * y + z;
259 }
260 };
261
262 template<>
263 struct fma_helper<long double> {
264 static constexpr INLINED DEVICE long double eval(
265 const long double x, const long double y, const long double z) {
266 return x * y + z;
267 }
268 };
269
270 template<>
271 struct fma_helper<float> {
272 static constexpr INLINED DEVICE float eval(const float x, const float y, const float z) {
273 return x * y + z;
274 }
275 };
276
277 template<>
278 struct fma_helper<int32_t> {
279 static constexpr INLINED DEVICE int16_t eval(const int16_t x, const int16_t y, const int16_t z) {
280 return x * y + z;
281 }
282 };
283
284 template<>
285 struct fma_helper<int16_t> {
286 static constexpr INLINED DEVICE int32_t eval(const int32_t x, const int32_t y, const int32_t z) {
287 return x * y + z;
288 }
289 };
290
291 template<>
292 struct fma_helper<int64_t> {
293 static constexpr INLINED DEVICE int64_t eval(const int64_t x, const int64_t y, const int64_t z) {
294 return x * y + z;
295 }
296 };
297
298 #ifdef WITH_CUDA_FP16
299 template<>
300 struct fma_helper<__half> {
301 static constexpr INLINED DEVICE __half eval(const __half x, const __half y, const __half z) {
302 #ifdef __CUDA_ARCH__
303 return __hfma(x, y, z);
304 #else
305 return x * y + z;
306 #endif
307 }
308 };
309 template<>
310 struct fma_helper<__half2> {
311 static constexpr INLINED DEVICE __half2 eval(const __half2 x, const __half2 y, const __half2 z) {
312 #ifdef __CUDA_ARCH__
313 return __hfma2(x, y, z);
314 #else
315 return x * y + z;
316 #endif
317 }
318 };
319 #endif
320 } // namespace internal
321} // namespace aerobus
322
323// arithmetic helpers
324namespace aerobus {
325 struct double_double {};
326
327 template<typename T>
328 struct arithmetic_helpers;
329
330 template<>
331 struct arithmetic_helpers<double> {
332 using integers = int64_t;
333 using upper_type = double_double;
334 static INLINED DEVICE consteval double one() { return 1.0; }
335 static INLINED DEVICE consteval double zero() { return 0.0; }
336 static INLINED DEVICE consteval double m_zero() { return -0.0; }
337 static INLINED DEVICE consteval double pi() { return 0x1.921fb54442d18p1; }
338 static INLINED DEVICE consteval double pi_2() { return 0x1.921fb54442d18p0; }
339 static INLINED DEVICE consteval double pi_4() { return 0x1.921fb54442d18p-1; }
340 static INLINED DEVICE consteval double two_pi() { return 0x1.921fb54442d18p2; }
341 static INLINED DEVICE consteval double inv_two_pi() { return 0x1.45f306dc9c883p-3; }
342 static INLINED DEVICE consteval double half() { return 0x1p-1; }
343 static INLINED DEVICE bool is_inf(double x) {
344 return std::isinf(x);
345 }
346 };
347
348 template<>
349 struct arithmetic_helpers<float> {
350 using integers = int32_t;
351 using upper_type = double;
352 static INLINED DEVICE consteval float one() { return 1.0F; }
353 static INLINED DEVICE consteval float zero() { return 0.0F; }
354 static INLINED DEVICE consteval float m_zero() { return -0x0p+0; }
355 static INLINED DEVICE consteval float pi() { return 0x1.921fb6p1f; }
356 static INLINED DEVICE consteval float pi_2() { return 0x1.921fb6p0f; }
357 static INLINED DEVICE consteval float pi_4() { return 0x1.921fb6p-1f; }
358 static INLINED DEVICE consteval float two_pi() { return 0x1.921fb6p2f; }
359 static INLINED DEVICE consteval float inv_two_pi() { return 0x1.45f306p-3f; }
360 static INLINED DEVICE consteval float half() { return 0x1p-1f; }
361 static INLINED DEVICE bool is_inf(float x) {
362 return std::isinf(x);
363 }
364 };
365
366 #ifdef WITH_CUDA_FP16
367 template<>
368 struct arithmetic_helpers<__half> {
369 using integers = int16_t;
370 using upper_type = float;
371 static INLINED DEVICE consteval __half one() { return __half_raw(0b0011110000000000); }
372 static INLINED DEVICE consteval __half zero() { return __half_raw(0b0000000000000000); }
373 static INLINED DEVICE consteval __half pi() { return __half_raw(0b0100001001001000); }
374 static INLINED DEVICE consteval __half m_zero() { return __half_raw(0b1000000000000000); }
375 static INLINED DEVICE consteval __half pi_2() { return __half_raw(0b011111001001000); }
376 static INLINED DEVICE consteval __half pi_4() { return __half_raw(0b011101001001000); }
377 static INLINED DEVICE consteval __half two_pi() { return __half_raw(0b1000110010010000); }
378 static INLINED DEVICE consteval __half inv_two_pi() { return __half_raw(0b011000100011000); }
379 static INLINED DEVICE consteval __half half() { return __half_raw(0b0011100000000000); }
380 static INLINED DEVICE bool is_inf(__half x) {
381 return __hisinf(x) != 0;
382 }
383 };
384
385 // this is for libm and needs further investigation as libm vectorization is not easy
386 // template<>
387 // struct arithmetic_helpers<__half2> {
388 // using integers = int16_t;
389 // using upper_type = float; // TODO(JeWaVe) : check for float2
390 // static constexpr __half2 one = __half2(__half_raw(0b0011110000000000), __half_raw(0b0011110000000000));
391 // static constexpr __half2 zero = __half2(__half_raw(0b0000000000000), __half_raw(0b0000000000000));
392 // static constexpr __half2 m_zero = __half2(__half_raw(0b1000000000000), __half_raw(0b1000000000000));
393 // static constexpr __half2 pi = __half2(__half_raw(0x4248), __half_raw(0x4248));
394 // static constexpr __half2 pi_2 = __half2(__half_raw(0b011111001001000), __half_raw(0b011111001001000));
395 // static constexpr __half2 pi_4 = __half2(__half_raw(0b011101001001000), __half_raw(0b011101001001000));
396 // static constexpr __half2 two_pi = __half2(__half_raw(0b100011001001000), __half_raw(0b100011001001000));
397 // static constexpr __half2 half = __half2(__half_raw(0b011100000000000), __half_raw(0b011100000000000));
398 // };
399 #endif
400
401 template<typename T>
402 struct meta_libm {
403 static INLINED DEVICE T floor(const T& f) {
404 return std::floor(f);
405 }
406 static INLINED DEVICE T fmod(const T& x, const T& d) {
407 return std::fmod(x, d);
408 }
409 };
410
411 // TODO(JeWaVe) : investigate as hfloor is pure device -- should be replaced by something different and constexpr
412 #ifdef WITH_CUDA_FP16
413 template<>
414 struct meta_libm<__half> {
415 static INLINED __device__ __half floor(const __half& f) {
416 return hfloor(f);
417 }
418
419 static INLINED __device__ __half fmod(const __half& x, const __half& d) {
420 __half i = meta_libm<__half>::floor(x / d);
421 return x - d * i;
422 }
423 };
424
425 template<>
426 struct meta_libm<__half2> {
427 static INLINED __device__ __half2 floor(const __half2& f) {
428 return h2floor(f);
429 }
430
431 static INLINED __device__ __half2 fmod(const __half2& x, const __half2& d) {
432 __half2 i = meta_libm<__half2>::floor(x / d);
433 return x - d * i;
434 }
435 };
436 #endif
437} // namespace aerobus
438
439// compensated horner utilities
440namespace aerobus {
441 namespace internal {
442 template <typename T>
443 struct FloatLayout;
444
445 #ifdef _MSC_VER
446 template <>
447 struct FloatLayout<long double> {
448 static constexpr uint8_t exponent = 11;
449 static constexpr uint8_t mantissa = 52;
450 static constexpr uint8_t r = 27; // ceil(mantissa/2)
451 static constexpr long double shift = (1LL << r) + 1;
452 };
453 #else
454 template <>
455 struct FloatLayout<long double> {
456 static constexpr uint8_t exponent = 15;
457 static constexpr uint8_t mantissa = 64;
458 static constexpr uint8_t r = 32; // ceil(mantissa/2)
459 static constexpr long double shift = (1LL << r) + 1;
460 };
461 #endif
462
463 template <>
464 struct FloatLayout<double> {
465 static constexpr uint8_t exponent = 11;
466 static constexpr uint8_t mantissa = 52;
467 static constexpr uint8_t r = 27; // ceil(mantissa/2)
468 static constexpr double shift = (1LL << r) + 1;
469 };
470
471 template <>
472 struct FloatLayout<float> {
473 static constexpr uint8_t exponent = 8;
474 static constexpr uint8_t mantissa = 23;
475 static constexpr uint8_t r = 11; // ceil(mantissa/2)
476 static constexpr float shift = (1 << r) + 1;
477 };
478
479 #ifdef WITH_CUDA_FP16
480 template<>
481 struct FloatLayout<__half> {
482 static constexpr uint8_t exponent = 5;
483 static constexpr uint8_t mantissa = 10;
484 };
485
486 template<>
487 struct FloatLayout<__half2> {
488 static constexpr uint8_t exponent = 5;
489 static constexpr uint8_t mantissa = 10;
490 };
491 #endif
492
493 template<typename T>
494 struct Split {
495 static constexpr INLINED DEVICE void func(T a, T *x, T *y) {
496 T z = a * FloatLayout<T>::shift;
497 *x = z - (z - a);
498 *y = a - *x;
499 }
500 };
501
502 #ifdef WITH_CUDA_FP16
503 template<>
504 struct Split<__half> {
505 static constexpr INLINED DEVICE void func(__half a, __half *x, __half *y) {
506 __half z = a * __half_raw(0x5280); // TODO(JeWaVe): check this value
507 *x = z - (z - a);
508 *y = a - *x;
509 }
510 };
511
512 template<>
513 struct Split<__half2> {
514 static constexpr INLINED DEVICE void func(__half2 a, __half2 *x, __half2 *y) {
515 __half2 z = a * __half2(__half_raw(0x5280), __half_raw(0x5280)); // TODO(JeWaVe): check this value
516 *x = z - (z - a);
517 *y = a - *x;
518 }
519 };
520 #endif
521
522 template<typename T>
523 static constexpr INLINED DEVICE void two_sum(T a, T b, T *x, T *y) {
524 *x = a + b;
525 T z = *x - a;
526 *y = (a - (*x - z)) + (b - z);
527 }
528
529 template<typename T>
530 static constexpr INLINED DEVICE void two_prod(T a, T b, T *x, T *y) {
531 *x = a * b;
532 #ifdef __clang__
533 *y = fma_helper<T>::eval(a, b, -*x);
534 #else
535 T ah, al, bh, bl;
536 Split<T>::func(a, &ah, &al);
537 Split<T>::func(b, &bh, &bl);
538 *y = al * bl - (((*x - ah * bh) - al * bh) - ah * bl);
539 #endif
540 }
541
542 template<typename T, size_t N>
543 static INLINED DEVICE T horner(T *p1, T *p2, T x) {
544 T r = p1[0] + p2[0];
545 for (int64_t i = N - 1; i >= 0; --i) {
546 r = r * x + p1[N - i] + p2[N - i];
547 }
548
549 return r;
550 }
551 } // namespace internal
552} // namespace aerobus
553
554// type utilities
555namespace aerobus {
556 namespace internal {
557 template<template<typename...> typename TT, typename T>
558 struct is_instantiation_of : std::false_type { };
559
560 template<template<typename...> typename TT, typename... Ts>
561 struct is_instantiation_of<TT, TT<Ts...>> : std::true_type { };
562
563 template<template<typename...> typename TT, typename T>
564 inline constexpr bool is_instantiation_of_v = is_instantiation_of<TT, T>::value;
565
566 template <int64_t i, typename T, typename... Ts>
567 struct type_at {
568 static_assert(i < sizeof...(Ts) + 1, "index out of range");
569 using type = typename type_at<i - 1, Ts...>::type;
570 };
571
572 template <typename T, typename... Ts> struct type_at<0, T, Ts...> {
573 using type = T;
574 };
575
576 template <size_t i, typename... Ts>
577 using type_at_t = typename type_at<i, Ts...>::type;
578
579
580 template<size_t n, size_t i, typename E = void>
581 struct _is_prime {};
582
583 template<size_t i>
584 struct _is_prime<0, i> {
585 static constexpr bool value = false;
586 };
587
588 template<size_t i>
589 struct _is_prime<1, i> {
590 static constexpr bool value = false;
591 };
592
593 template<size_t i>
594 struct _is_prime<2, i> {
595 static constexpr bool value = true;
596 };
597
598 template<size_t i>
599 struct _is_prime<3, i> {
600 static constexpr bool value = true;
601 };
602
603 template<size_t i>
604 struct _is_prime<5, i> {
605 static constexpr bool value = true;
606 };
607
608 template<size_t i>
609 struct _is_prime<7, i> {
610 static constexpr bool value = true;
611 };
612
613 template<size_t n, size_t i>
614 struct _is_prime<n, i, std::enable_if_t<(n != 2 && n % 2 == 0)>> {
615 static constexpr bool value = false;
616 };
617
618 template<size_t n, size_t i>
619 struct _is_prime<n, i, std::enable_if_t<(n != 2 && n != 3 && n % 2 != 0 && n % 3 == 0)>> {
620 static constexpr bool value = false;
621 };
622
623 template<size_t n, size_t i>
624 struct _is_prime<n, i, std::enable_if_t<(n >= 9 && i * i > n)>> {
625 static constexpr bool value = true;
626 };
627
628 template<size_t n, size_t i>
629 struct _is_prime<n, i, std::enable_if_t<(
630 n % i == 0 &&
631 n >= 9 &&
632 n % 3 != 0 &&
633 n % 2 != 0 &&
634 i * i > n)>> {
635 static constexpr bool value = true;
636 };
637
638 template<size_t n, size_t i>
639 struct _is_prime<n, i, std::enable_if_t<(
640 n % (i+2) == 0 &&
641 n >= 9 &&
642 n % 3 != 0 &&
643 n % 2 != 0 &&
644 i * i <= n)>> {
645 static constexpr bool value = true;
646 };
647
648 template<size_t n, size_t i>
649 struct _is_prime<n, i, std::enable_if_t<(
650 n % (i+2) != 0 &&
651 n % i != 0 &&
652 n >= 9 &&
653 n % 3 != 0 &&
654 n % 2 != 0 &&
655 (i * i <= n))>> {
656 static constexpr bool value = _is_prime<n, i+6>::value;
657 };
658 } // namespace internal
659
662 template<size_t n>
663 struct is_prime {
665 static constexpr bool value = internal::_is_prime<n, 5>::value;
666 };
667
671 template<size_t n>
672 static constexpr bool is_prime_v = is_prime<n>::value;
673
674 // gcd
675 namespace internal {
676 template <std::size_t... Is>
677 constexpr auto index_sequence_reverse(std::index_sequence<Is...> const&)
678 -> decltype(std::index_sequence<sizeof...(Is) - 1U - Is...>{});
679
680 template <std::size_t N>
681 using make_index_sequence_reverse
682 = decltype(index_sequence_reverse(std::make_index_sequence<N>{}));
683
689 template<typename Ring, typename E = void>
690 struct gcd;
691
692 template<typename Ring>
693 struct gcd<Ring, std::enable_if_t<Ring::is_euclidean_domain>> {
694 template<typename A, typename B, typename E = void>
695 struct gcd_helper {};
696
697 // B = 0, A > 0
698 template<typename A, typename B>
699 struct gcd_helper<A, B, std::enable_if_t<
700 ((B::is_zero_t::value) &&
701 (Ring::template gt_t<A, typename Ring::zero>::value))>> {
702 using type = A;
703 };
704
705 // B = 0, A < 0
706 template<typename A, typename B>
707 struct gcd_helper<A, B, std::enable_if_t<
708 ((B::is_zero_t::value) &&
709 !(Ring::template gt_t<A, typename Ring::zero>::value))>> {
710 using type = typename Ring::template sub_t<typename Ring::zero, A>;
711 };
712
713 // B != 0
714 template<typename A, typename B>
715 struct gcd_helper<A, B, std::enable_if_t<
716 (!B::is_zero_t::value)
717 >> {
718 private: // NOLINT
719 // A / B
720 using k = typename Ring::template div_t<A, B>;
721 // A - (A/B)*B = A % B
722 using m = typename Ring::template sub_t<A, typename Ring::template mul_t<k, B>>;
723
724 public:
725 using type = typename gcd_helper<B, m>::type;
726 };
727
728 template<typename A, typename B>
729 using type = typename gcd_helper<A, B>::type;
730 };
731 } // namespace internal
732
733 // vadd and vmul
734 namespace internal {
735 template<typename... vals>
736 struct vmul {};
737
738 template<typename v1, typename... vals>
739 struct vmul<v1, vals...> {
740 using type = typename v1::enclosing_type::template mul_t<v1, typename vmul<vals...>::type>;
741 };
742
743 template<typename v1>
744 struct vmul<v1> {
745 using type = v1;
746 };
747
748 template<typename... vals>
749 struct vadd {};
750
751 template<typename v1, typename... vals>
752 struct vadd<v1, vals...> {
753 using type = typename v1::enclosing_type::template add_t<v1, typename vadd<vals...>::type>;
754 };
755
756 template<typename v1>
757 struct vadd<v1> {
758 using type = v1;
759 };
760 } // namespace internal
761
764 template<typename T, typename A, typename B>
765 using gcd_t = typename internal::gcd<T>::template type<A, B>;
766
770 template<typename... vals>
771 using vadd_t = typename internal::vadd<vals...>::type;
772
776 template<typename... vals>
777 using vmul_t = typename internal::vmul<vals...>::type;
778
782 template<typename val>
783 requires IsEuclideanDomain<typename val::enclosing_type>
784 using abs_t = std::conditional_t<
785 val::enclosing_type::template pos_v<val>,
786 val, typename val::enclosing_type::template sub_t<typename val::enclosing_type::zero, val>>;
787} // namespace aerobus
788
789// embedding
790namespace aerobus {
795 template<typename Small, typename Large, typename E = void>
796 struct Embed;
797} // namespace aerobus
798
799// quotient rings
800namespace aerobus {
805 template<typename Ring, typename X>
806 requires IsRing<Ring>
807 struct Quotient {
810 template <typename V>
811 struct val {
812 public:
813 using raw_t = V;
814 using type = abs_t<typename Ring::template mod_t<V, X>>;
815 };
816
818 using zero = val<typename Ring::zero>;
819
821 using one = val<typename Ring::one>;
822
826 template<typename v1, typename v2>
827 using add_t = val<typename Ring::template add_t<typename v1::type, typename v2::type>>;
828
832 template<typename v1, typename v2>
833 using mul_t = val<typename Ring::template mul_t<typename v1::type, typename v2::type>>;
834
838 template<typename v1, typename v2>
839 using div_t = val<typename Ring::template div_t<typename v1::type, typename v2::type>>;
840
844 template<typename v1, typename v2>
845 using mod_t = val<typename Ring::template mod_t<typename v1::type, typename v2::type>>;
846
850 template<typename v1, typename v2>
851 using eq_t = typename Ring::template eq_t<typename v1::type, typename v2::type>;
852
856 template<typename v1, typename v2>
857 static constexpr bool eq_v = Ring::template eq_t<typename v1::type, typename v2::type>::value;
858
862 template<typename v1>
863 using pos_t = std::true_type;
864
868 template<typename v>
869 static constexpr bool pos_v = pos_t<v>::value;
870
872 static constexpr bool is_euclidean_domain = true;
873
877 template<auto x>
878 using inject_constant_t = val<typename Ring::template inject_constant_t<x>>;
879
883 template<typename v>
884 using inject_ring_t = val<v>;
885 };
886
890 template<typename Ring, typename X>
891 struct Embed<Quotient<Ring, X>, Ring> {
894 template<typename val>
895 using type = typename val::raw_t;
896 };
897} // namespace aerobus
898
899// type_list
900namespace aerobus {
902 template <typename... Ts>
903 struct type_list;
904
905 namespace internal {
906 template <typename T, typename... Us>
907 struct pop_front_h {
908 using tail = type_list<Us...>;
909 using head = T;
910 };
911
912 template <size_t index, typename L1, typename L2>
913 struct split_h {
914 private:
915 static_assert(index <= L2::length, "index ouf of bounds");
916 using a = typename L2::pop_front::type;
917 using b = typename L2::pop_front::tail;
918 using c = typename L1::template push_back<a>;
919
920 public:
921 using head = typename split_h<index - 1, c, b>::head;
922 using tail = typename split_h<index - 1, c, b>::tail;
923 };
924
925 template <typename L1, typename L2>
926 struct split_h<0, L1, L2> {
927 using head = L1;
928 using tail = L2;
929 };
930
931 template <size_t index, typename L, typename T>
932 struct insert_h {
933 static_assert(index <= L::length, "index ouf of bounds");
934 using s = typename L::template split<index>;
935 using left = typename s::head;
936 using right = typename s::tail;
937 using ll = typename left::template push_back<T>;
938 using type = typename ll::template concat<right>;
939 };
940
941 template <size_t index, typename L>
942 struct remove_h {
943 using s = typename L::template split<index>;
944 using left = typename s::head;
945 using right = typename s::tail;
946 using rr = typename right::pop_front::tail;
947 using type = typename left::template concat<rr>;
948 };
949 } // namespace internal
950
953 template <typename... Ts>
954 struct type_list {
955 private:
956 template <typename T>
957 struct concat_h;
958
959 template <typename... Us>
960 struct concat_h<type_list<Us...>> {
961 using type = type_list<Ts..., Us...>;
962 };
963
964 public:
966 static constexpr size_t length = sizeof...(Ts);
967
970 template <typename T>
971 using push_front = type_list<T, Ts...>;
972
975 template <size_t index>
976 using at = internal::type_at_t<index, Ts...>;
977
979 struct pop_front {
981 using type = typename internal::pop_front_h<Ts...>::head;
983 using tail = typename internal::pop_front_h<Ts...>::tail;
984 };
985
988 template <typename T>
989 using push_back = type_list<Ts..., T>;
990
993 template <typename U>
994 using concat = typename concat_h<U>::type;
995
998 template <size_t index>
999 struct split {
1000 private:
1001 using inner = internal::split_h<index, type_list<>, type_list<Ts...>>;
1002
1003 public:
1004 using head = typename inner::head;
1005 using tail = typename inner::tail;
1006 };
1007
1011 template <typename T, size_t index>
1012 using insert = typename internal::insert_h<index, type_list<Ts...>, T>::type;
1013
1016 template <size_t index>
1017 using remove = typename internal::remove_h<index, type_list<Ts...>>::type;
1018 };
1019
1021 template <>
1022 struct type_list<> {
1023 static constexpr size_t length = 0;
1024
1025 template <typename T>
1026 using push_front = type_list<T>;
1027
1028 template <typename T>
1029 using push_back = type_list<T>;
1030
1031 template <typename U>
1032 using concat = U;
1033
1034 // TODO(jewave): assert index == 0
1035 template <typename T, size_t index>
1036 using insert = type_list<T>;
1037 };
1038} // namespace aerobus
1039
1040// i16
1041#ifdef WITH_CUDA_FP16
1042// i16
1043namespace aerobus {
1045 struct i16 {
1046 using inner_type = int16_t;
1049 template<int16_t x>
1050 struct val {
1052 using enclosing_type = i16;
1054 static constexpr int16_t v = x;
1055
1058 template<typename valueType>
1059 static constexpr INLINED DEVICE valueType get() {
1060 return internal::template int16_convert_helper<valueType, x>::value();
1061 }
1062
1064 using is_zero_t = std::bool_constant<x == 0>;
1065
1067 static std::string to_string() {
1068 return std::to_string(x); // NOLINT
1069 }
1070 };
1071
1073 using zero = val<0>;
1075 using one = val<1>;
1077 static constexpr bool is_field = false;
1079 static constexpr bool is_euclidean_domain = true;
1082 template<auto x>
1083 using inject_constant_t = val<static_cast<int16_t>(x)>;
1084
1085 template<typename v>
1086 using inject_ring_t = v;
1087
1088 private:
1089 template<typename v1, typename v2>
1090 struct add {
1091 using type = val<v1::v + v2::v>;
1092 };
1093
1094 template<typename v1, typename v2>
1095 struct sub {
1096 using type = val<v1::v - v2::v>;
1097 };
1098
1099 template<typename v1, typename v2>
1100 struct mul {
1101 using type = val<v1::v* v2::v>;
1102 };
1103
1104 template<typename v1, typename v2>
1105 struct div {
1106 using type = val<v1::v / v2::v>;
1107 };
1108
1109 template<typename v1, typename v2>
1110 struct remainder {
1111 using type = val<v1::v % v2::v>;
1112 };
1113
1114 template<typename v1, typename v2>
1115 struct gt {
1116 using type = std::conditional_t<(v1::v > v2::v), std::true_type, std::false_type>;
1117 };
1118
1119 template<typename v1, typename v2>
1120 struct lt {
1121 using type = std::conditional_t<(v1::v < v2::v), std::true_type, std::false_type>;
1122 };
1123
1124 template<typename v1, typename v2>
1125 struct eq {
1126 using type = std::conditional_t<(v1::v == v2::v), std::true_type, std::false_type>;
1127 };
1128
1129 template<typename v1>
1130 struct pos {
1131 using type = std::bool_constant<(v1::v > 0)>;
1132 };
1133
1134 public:
1139 template<typename v1, typename v2>
1140 using add_t = typename add<v1, v2>::type;
1141
1146 template<typename v1, typename v2>
1147 using sub_t = typename sub<v1, v2>::type;
1148
1153 template<typename v1, typename v2>
1154 using mul_t = typename mul<v1, v2>::type;
1155
1160 template<typename v1, typename v2>
1161 using div_t = typename div<v1, v2>::type;
1162
1167 template<typename v1, typename v2>
1168 using mod_t = typename remainder<v1, v2>::type;
1169
1174 template<typename v1, typename v2>
1175 using gt_t = typename gt<v1, v2>::type;
1176
1181 template<typename v1, typename v2>
1182 using lt_t = typename lt<v1, v2>::type;
1183
1188 template<typename v1, typename v2>
1189 using eq_t = typename eq<v1, v2>::type;
1190
1194 template<typename v1, typename v2>
1195 static constexpr bool eq_v = eq_t<v1, v2>::value;
1196
1201 template<typename v1, typename v2>
1202 using gcd_t = gcd_t<i16, v1, v2>;
1203
1207 template<typename v>
1208 using pos_t = typename pos<v>::type;
1209
1213 template<typename v>
1214 static constexpr bool pos_v = pos_t<v>::value;
1215 };
1216} // namespace aerobus
1217#endif
1218
1219// i32
1220namespace aerobus {
1222 struct i32 {
1223 using inner_type = int32_t;
1226 template<int32_t x>
1227 struct val {
1229 using enclosing_type = i32;
1231 static constexpr int32_t v = x;
1232
1235 template<typename valueType>
1236 static constexpr DEVICE valueType get() {
1237 return static_cast<valueType>(x);
1238 }
1239
1241 using is_zero_t = std::bool_constant<x == 0>;
1242
1244 static std::string to_string() {
1245 return std::to_string(x);
1246 }
1247 };
1248
1250 using zero = val<0>;
1252 using one = val<1>;
1254 static constexpr bool is_field = false;
1256 static constexpr bool is_euclidean_domain = true;
1259 template<auto x>
1260 using inject_constant_t = val<static_cast<int32_t>(x)>;
1261
1262 template<typename v>
1263 using inject_ring_t = v;
1264
1265 private:
1266 template<typename v1, typename v2>
1267 struct add {
1268 using type = val<v1::v + v2::v>;
1269 };
1270
1271 template<typename v1, typename v2>
1272 struct sub {
1273 using type = val<v1::v - v2::v>;
1274 };
1275
1276 template<typename v1, typename v2>
1277 struct mul {
1278 using type = val<v1::v* v2::v>;
1279 };
1280
1281 template<typename v1, typename v2>
1282 struct div {
1283 using type = val<v1::v / v2::v>;
1284 };
1285
1286 template<typename v1, typename v2>
1287 struct remainder {
1288 using type = val<v1::v % v2::v>;
1289 };
1290
1291 template<typename v1, typename v2>
1292 struct gt {
1293 using type = std::conditional_t<(v1::v > v2::v), std::true_type, std::false_type>;
1294 };
1295
1296 template<typename v1, typename v2>
1297 struct lt {
1298 using type = std::conditional_t<(v1::v < v2::v), std::true_type, std::false_type>;
1299 };
1300
1301 template<typename v1, typename v2>
1302 struct eq {
1303 using type = std::conditional_t<(v1::v == v2::v), std::true_type, std::false_type>;
1304 };
1305
1306 template<typename v1>
1307 struct pos {
1308 using type = std::bool_constant<(v1::v > 0)>;
1309 };
1310
1311 public:
1316 template<typename v1, typename v2>
1317 using add_t = typename add<v1, v2>::type;
1318
1323 template<typename v1, typename v2>
1324 using sub_t = typename sub<v1, v2>::type;
1325
1330 template<typename v1, typename v2>
1331 using mul_t = typename mul<v1, v2>::type;
1332
1337 template<typename v1, typename v2>
1338 using div_t = typename div<v1, v2>::type;
1339
1344 template<typename v1, typename v2>
1345 using mod_t = typename remainder<v1, v2>::type;
1346
1351 template<typename v1, typename v2>
1352 using gt_t = typename gt<v1, v2>::type;
1353
1358 template<typename v1, typename v2>
1359 using lt_t = typename lt<v1, v2>::type;
1360
1365 template<typename v1, typename v2>
1366 using eq_t = typename eq<v1, v2>::type;
1367
1371 template<typename v1, typename v2>
1372 static constexpr bool eq_v = eq_t<v1, v2>::value;
1373
1378 template<typename v1, typename v2>
1379 using gcd_t = gcd_t<i32, v1, v2>;
1380
1384 template<typename v>
1385 using pos_t = typename pos<v>::type;
1386
1390 template<typename v>
1391 static constexpr bool pos_v = pos_t<v>::value;
1392 };
1393} // namespace aerobus
1394
1395// i64
1396namespace aerobus {
1398 struct i64 {
1400 using inner_type = int64_t;
1403 template<int64_t x>
1404 struct val {
1406 using inner_type = int32_t;
1408 using enclosing_type = i64;
1410 static constexpr int64_t v = x;
1411
1414 template<typename valueType>
1415 static constexpr INLINED DEVICE valueType get() {
1416 return static_cast<valueType>(x);
1417 }
1418
1420 using is_zero_t = std::bool_constant<x == 0>;
1421
1423 static std::string to_string() {
1424 return std::to_string(x);
1425 }
1426 };
1427
1430 template<auto x>
1431 using inject_constant_t = val<static_cast<int64_t>(x)>;
1432
1437 template<typename v>
1438 using inject_ring_t = v;
1439
1441 using zero = val<0>;
1443 using one = val<1>;
1445 static constexpr bool is_field = false;
1447 static constexpr bool is_euclidean_domain = true;
1448
1449 private:
1450 template<typename v1, typename v2>
1451 struct add {
1452 using type = val<v1::v + v2::v>;
1453 };
1454
1455 template<typename v1, typename v2>
1456 struct sub {
1457 using type = val<v1::v - v2::v>;
1458 };
1459
1460 template<typename v1, typename v2>
1461 struct mul {
1462 using type = val<v1::v* v2::v>;
1463 };
1464
1465 template<typename v1, typename v2>
1466 struct div {
1467 using type = val<v1::v / v2::v>;
1468 };
1469
1470 template<typename v1, typename v2>
1471 struct remainder {
1472 using type = val<v1::v% v2::v>;
1473 };
1474
1475 template<typename v1, typename v2>
1476 struct gt {
1477 using type = std::conditional_t<(v1::v > v2::v), std::true_type, std::false_type>;
1478 };
1479
1480 template<typename v1, typename v2>
1481 struct lt {
1482 using type = std::conditional_t<(v1::v < v2::v), std::true_type, std::false_type>;
1483 };
1484
1485 template<typename v1, typename v2>
1486 struct eq {
1487 using type = std::conditional_t<(v1::v == v2::v), std::true_type, std::false_type>;
1488 };
1489
1490 template<typename v>
1491 struct pos {
1492 using type = std::bool_constant<(v::v > 0)>;
1493 };
1494
1495 public:
1499 template<typename v1, typename v2>
1500 using add_t = typename add<v1, v2>::type;
1501
1505 template<typename v1, typename v2>
1506 using sub_t = typename sub<v1, v2>::type;
1507
1511 template<typename v1, typename v2>
1512 using mul_t = typename mul<v1, v2>::type;
1513
1518 template<typename v1, typename v2>
1519 using div_t = typename div<v1, v2>::type;
1520
1524 template<typename v1, typename v2>
1525 using mod_t = typename remainder<v1, v2>::type;
1526
1531 template<typename v1, typename v2>
1532 using gt_t = typename gt<v1, v2>::type;
1533
1538 template<typename v1, typename v2>
1539 static constexpr bool gt_v = gt_t<v1, v2>::value;
1540
1545 template<typename v1, typename v2>
1546 using lt_t = typename lt<v1, v2>::type;
1547
1552 template<typename v1, typename v2>
1553 static constexpr bool lt_v = lt_t<v1, v2>::value;
1554
1559 template<typename v1, typename v2>
1560 using eq_t = typename eq<v1, v2>::type;
1561
1566 template<typename v1, typename v2>
1567 static constexpr bool eq_v = eq_t<v1, v2>::value;
1568
1573 template<typename v1, typename v2>
1574 using gcd_t = gcd_t<i64, v1, v2>;
1575
1579 template<typename v>
1580 using pos_t = typename pos<v>::type;
1581
1585 template<typename v>
1586 static constexpr bool pos_v = pos_t<v>::value;
1587 };
1588
1590 template<>
1591 struct Embed<i32, i64> {
1594 template<typename val>
1595 using type = i64::val<static_cast<int64_t>(val::v)>;
1596 };
1597} // namespace aerobus
1598
1599// z/pz
1600namespace aerobus {
1606 template<int32_t p>
1607 struct zpz {
1609 using inner_type = int32_t;
1610
1613 template<int32_t x>
1614 struct val {
1616 using enclosing_type = zpz<p>;
1618 static constexpr int32_t v = x % p;
1619
1622 template<typename valueType>
1623 static constexpr INLINED DEVICE valueType get() {
1624 return static_cast<valueType>(x % p);
1625 }
1626
1628 using is_zero_t = std::bool_constant<v == 0>;
1629
1631 static constexpr bool is_zero_v = v == 0;
1632
1635 static std::string to_string() {
1636 return std::to_string(x % p);
1637 }
1638 };
1639
1642 template<auto x>
1643 using inject_constant_t = val<static_cast<int32_t>(x)>;
1644
1646 using zero = val<0>;
1647
1649 using one = val<1>;
1650
1652 static constexpr bool is_field = is_prime<p>::value;
1653
1655 static constexpr bool is_euclidean_domain = true;
1656
1657 private:
1658 template<typename v1, typename v2>
1659 struct add {
1660 using type = val<(v1::v + v2::v) % p>;
1661 };
1662
1663 template<typename v1, typename v2>
1664 struct sub {
1665 using type = val<(v1::v - v2::v) % p>;
1666 };
1667
1668 template<typename v1, typename v2>
1669 struct mul {
1670 using type = val<(v1::v* v2::v) % p>;
1671 };
1672
1673 template<typename v1, typename v2>
1674 struct div {
1675 using type = val<(v1::v% p) / (v2::v % p)>;
1676 };
1677
1678 template<typename v1, typename v2>
1679 struct remainder {
1680 using type = val<(v1::v% v2::v) % p>;
1681 };
1682
1683 template<typename v1, typename v2>
1684 struct gt {
1685 using type = std::conditional_t<(v1::v% p > v2::v% p), std::true_type, std::false_type>;
1686 };
1687
1688 template<typename v1, typename v2>
1689 struct lt {
1690 using type = std::conditional_t<(v1::v% p < v2::v% p), std::true_type, std::false_type>;
1691 };
1692
1693 template<typename v1, typename v2>
1694 struct eq {
1695 using type = std::conditional_t<(v1::v% p == v2::v % p), std::true_type, std::false_type>;
1696 };
1697
1698 template<typename v1>
1699 struct pos {
1700 using type = std::bool_constant<(v1::v > 0)>;
1701 };
1702
1703 public:
1707 template<typename v1, typename v2>
1708 using add_t = typename add<v1, v2>::type;
1709
1713 template<typename v1, typename v2>
1714 using sub_t = typename sub<v1, v2>::type;
1715
1719 template<typename v1, typename v2>
1720 using mul_t = typename mul<v1, v2>::type;
1721
1725 template<typename v1, typename v2>
1726 using div_t = typename div<v1, v2>::type;
1727
1731 template<typename v1, typename v2>
1732 using mod_t = typename remainder<v1, v2>::type;
1733
1737 template<typename v1, typename v2>
1738 using gt_t = typename gt<v1, v2>::type;
1739
1743 template<typename v1, typename v2>
1744 static constexpr bool gt_v = gt_t<v1, v2>::value;
1745
1749 template<typename v1, typename v2>
1750 using lt_t = typename lt<v1, v2>::type;
1751
1755 template<typename v1, typename v2>
1756 static constexpr bool lt_v = lt_t<v1, v2>::value;
1757
1761 template<typename v1, typename v2>
1762 using eq_t = typename eq<v1, v2>::type;
1763
1767 template<typename v1, typename v2>
1768 static constexpr bool eq_v = eq_t<v1, v2>::value;
1769
1773 template<typename v1, typename v2>
1774 using gcd_t = gcd_t<i32, v1, v2>;
1775
1778 template<typename v1>
1779 using pos_t = typename pos<v1>::type;
1780
1783 template<typename v>
1784 static constexpr bool pos_v = pos_t<v>::value;
1785 };
1786
1789 template<int32_t x>
1790 struct Embed<zpz<x>, i32> {
1793 template <typename val>
1794 using type = i32::val<val::v>;
1795 };
1796} // namespace aerobus
1797
1798// polynomial
1799namespace aerobus {
1800 // coeffN x^N + ...
1805 template<typename Ring>
1806 requires IsEuclideanDomain<Ring>
1807 struct polynomial {
1808 static constexpr bool is_field = false;
1809 static constexpr bool is_euclidean_domain = Ring::is_euclidean_domain;
1810
1813 template<typename P>
1814 struct horner_reduction_t {
1815 template<size_t index, size_t stop>
1816 struct inner {
1817 template<typename accum, typename x>
1818 using type = typename horner_reduction_t<P>::template inner<index + 1, stop>
1819 ::template type<
1820 typename Ring::template add_t<
1821 typename Ring::template mul_t<x, accum>,
1822 typename P::template coeff_at_t<P::degree - index>
1823 >, x>;
1824 };
1825
1826 template<size_t stop>
1827 struct inner<stop, stop> {
1828 template<typename accum, typename x>
1829 using type = accum;
1830 };
1831 };
1832
1836 template<typename coeffN, typename... coeffs>
1837 struct val {
1839 using ring_type = Ring;
1841 using enclosing_type = polynomial<Ring>;
1843 static constexpr size_t degree = sizeof...(coeffs);
1845 using aN = coeffN;
1847 using strip = val<coeffs...>;
1849 using is_zero_t = std::bool_constant<(degree == 0) && (aN::is_zero_t::value)>;
1851 static constexpr bool is_zero_v = is_zero_t::value;
1852
1853 private:
1854 template<size_t index, typename E = void>
1855 struct coeff_at {};
1856
1857 template<size_t index>
1858 struct coeff_at<index, std::enable_if_t<(index >= 0 && index <= sizeof...(coeffs))>> {
1859 using type = internal::type_at_t<sizeof...(coeffs) - index, coeffN, coeffs...>;
1860 };
1861
1862 template<size_t index>
1863 struct coeff_at<index, std::enable_if_t<(index < 0 || index > sizeof...(coeffs))>> {
1864 using type = typename Ring::zero;
1865 };
1866
1867 public:
1870 template<size_t index>
1871 using coeff_at_t = typename coeff_at<index>::type;
1872
1875 static std::string to_string() {
1876 return string_helper<coeffN, coeffs...>::func();
1877 }
1878
1883 template<typename arithmeticType>
1884 static constexpr DEVICE INLINED arithmeticType eval(const arithmeticType& x) {
1885 #ifdef WITH_CUDA_FP16
1886 arithmeticType start;
1887 if constexpr (std::is_same_v<arithmeticType, __half2>) {
1888 start = __half2(0, 0);
1889 } else {
1890 start = static_cast<arithmeticType>(0);
1891 }
1892 #else
1893 arithmeticType start = static_cast<arithmeticType>(0);
1894 #endif
1895 return horner_evaluation<arithmeticType, val>
1896 ::template inner<0, degree + 1>
1897 ::func(start, x);
1898 }
1899
1912 template<typename arithmeticType>
1913 static DEVICE INLINED arithmeticType compensated_eval(const arithmeticType& x) {
1914 return compensated_horner<arithmeticType, val>::func(x);
1915 }
1916
1917 template<typename x>
1918 using value_at_t = horner_reduction_t<val>
1919 ::template inner<0, degree + 1>
1920 ::template type<typename Ring::zero, x>;
1921 };
1922
1925 template<typename coeffN>
1926 struct val<coeffN> {
1928 using ring_type = Ring;
1930 using enclosing_type = polynomial<Ring>;
1932 static constexpr size_t degree = 0;
1933 using aN = coeffN;
1934 using strip = val<coeffN>;
1935 using is_zero_t = std::bool_constant<aN::is_zero_t::value>;
1936
1937 static constexpr bool is_zero_v = is_zero_t::value;
1938
1939 template<size_t index, typename E = void>
1940 struct coeff_at {};
1941
1942 template<size_t index>
1943 struct coeff_at<index, std::enable_if_t<(index == 0)>> {
1944 using type = aN;
1945 };
1946
1947 template<size_t index>
1948 struct coeff_at<index, std::enable_if_t<(index < 0 || index > 0)>> {
1949 using type = typename Ring::zero;
1950 };
1951
1952 template<size_t index>
1953 using coeff_at_t = typename coeff_at<index>::type;
1954
1955 static std::string to_string() {
1956 return string_helper<coeffN>::func();
1957 }
1958
1959 template<typename arithmeticType>
1960 static constexpr DEVICE INLINED arithmeticType eval(const arithmeticType& x) {
1961 return coeffN::template get<arithmeticType>();
1962 }
1963
1964 template<typename arithmeticType>
1965 static DEVICE INLINED arithmeticType compensated_eval(const arithmeticType& x) {
1966 return coeffN::template get<arithmeticType>();
1967 }
1968
1969 template<typename x>
1970 using value_at_t = coeffN;
1971 };
1972
1974 using zero = val<typename Ring::zero>;
1976 using one = val<typename Ring::one>;
1978 using X = val<typename Ring::one, typename Ring::zero>;
1979
1980 private:
1981 template<typename P, typename E = void>
1982 struct simplify;
1983
1984 template <typename P1, typename P2, typename I>
1985 struct add_low;
1986
1987 template<typename P1, typename P2>
1988 struct add {
1989 using type = typename simplify<typename add_low<
1990 P1,
1991 P2,
1992 internal::make_index_sequence_reverse<
1993 std::max(P1::degree, P2::degree) + 1
1994 >>::type>::type;
1995 };
1996
1997 template <typename P1, typename P2, typename I>
1998 struct sub_low;
1999
2000 template <typename P1, typename P2, typename I>
2001 struct mul_low;
2002
2003 template<typename v1, typename v2>
2004 struct mul {
2005 using type = typename mul_low<
2006 v1,
2007 v2,
2008 internal::make_index_sequence_reverse<
2009 v1::degree + v2::degree + 1
2010 >>::type;
2011 };
2012
2013 template<typename coeff, size_t deg>
2014 struct monomial;
2015
2016 template<typename v, typename E = void>
2017 struct derive_helper {};
2018
2019 template<typename v>
2020 struct derive_helper<v, std::enable_if_t<v::degree == 0>> {
2021 using type = zero;
2022 };
2023
2024 template<typename v>
2025 struct derive_helper<v, std::enable_if_t<v::degree != 0>> {
2026 using type = typename add<
2027 typename derive_helper<typename simplify<typename v::strip>::type>::type,
2028 typename monomial<
2029 typename Ring::template mul_t<
2030 typename v::aN,
2031 typename Ring::template inject_constant_t<(v::degree)>
2032 >,
2033 v::degree - 1
2034 >::type
2035 >::type;
2036 };
2037
2038 template<typename v1, typename v2, typename E = void>
2039 struct eq_helper {};
2040
2041 template<typename v1, typename v2>
2042 struct eq_helper<v1, v2, std::enable_if_t<v1::degree != v2::degree>> {
2043 using type = std::false_type;
2044 };
2045
2046
2047 template<typename v1, typename v2>
2048 struct eq_helper<v1, v2, std::enable_if_t<
2049 v1::degree == v2::degree &&
2050 (v1::degree != 0 || v2::degree != 0) &&
2051 std::is_same<
2052 typename Ring::template eq_t<typename v1::aN, typename v2::aN>,
2053 std::false_type
2054 >::value
2055 >
2056 > {
2057 using type = std::false_type;
2058 };
2059
2060 template<typename v1, typename v2>
2061 struct eq_helper<v1, v2, std::enable_if_t<
2062 v1::degree == v2::degree &&
2063 (v1::degree != 0 || v2::degree != 0) &&
2064 std::is_same<
2065 typename Ring::template eq_t<typename v1::aN, typename v2::aN>,
2066 std::true_type
2067 >::value
2068 >> {
2069 using type = typename eq_helper<typename v1::strip, typename v2::strip>::type;
2070 };
2071
2072 template<typename v1, typename v2>
2073 struct eq_helper<v1, v2, std::enable_if_t<
2074 v1::degree == v2::degree &&
2075 (v1::degree == 0)
2076 >> {
2077 using type = typename Ring::template eq_t<typename v1::aN, typename v2::aN>;
2078 };
2079
2080 template<typename v1, typename v2, typename E = void>
2081 struct lt_helper {};
2082
2083 template<typename v1, typename v2>
2084 struct lt_helper<v1, v2, std::enable_if_t<(v1::degree < v2::degree)>> {
2085 using type = std::true_type;
2086 };
2087
2088 template<typename v1, typename v2>
2089 struct lt_helper<v1, v2, std::enable_if_t<(v1::degree == v2::degree)>> {
2090 using type = typename Ring::template lt_t<typename v1::aN, typename v2::aN>;
2091 };
2092
2093 template<typename v1, typename v2>
2094 struct lt_helper<v1, v2, std::enable_if_t<(v1::degree > v2::degree)>> {
2095 using type = std::false_type;
2096 };
2097
2098 template<typename v1, typename v2, typename E = void>
2099 struct gt_helper {};
2100
2101 template<typename v1, typename v2>
2102 struct gt_helper<v1, v2, std::enable_if_t<(v1::degree > v2::degree)>> {
2103 using type = std::true_type;
2104 };
2105
2106 template<typename v1, typename v2>
2107 struct gt_helper<v1, v2, std::enable_if_t<(v1::degree == v2::degree)>> {
2108 using type = std::false_type;
2109 };
2110
2111 template<typename v1, typename v2>
2112 struct gt_helper<v1, v2, std::enable_if_t<(v1::degree < v2::degree)>> {
2113 using type = std::false_type;
2114 };
2115
2116 // when high power is zero : strip
2117 template<typename P>
2118 struct simplify<P, std::enable_if_t<
2119 std::is_same<
2120 typename Ring::zero,
2121 typename P::aN
2122 >::value && (P::degree > 0)
2123 >> {
2124 using type = typename simplify<typename P::strip>::type;
2125 };
2126
2127 // otherwise : do nothing
2128 template<typename P>
2129 struct simplify<P, std::enable_if_t<
2130 !std::is_same<
2131 typename Ring::zero,
2132 typename P::aN
2133 >::value && (P::degree > 0)
2134 >> {
2135 using type = P;
2136 };
2137
2138 // do not simplify constants
2139 template<typename P>
2140 struct simplify<P, std::enable_if_t<P::degree == 0>> {
2141 using type = P;
2142 };
2143
2144 // addition at
2145 template<typename P1, typename P2, size_t index>
2146 struct add_at {
2147 using type =
2148 typename Ring::template add_t<
2149 typename P1::template coeff_at_t<index>,
2150 typename P2::template coeff_at_t<index>>;
2151 };
2152
2153 template<typename P1, typename P2, size_t index>
2154 using add_at_t = typename add_at<P1, P2, index>::type;
2155
2156 template<typename P1, typename P2, std::size_t... I>
2157 struct add_low<P1, P2, std::index_sequence<I...>> {
2158 using type = val<add_at_t<P1, P2, I>...>;
2159 };
2160
2161 // substraction at
2162 template<typename P1, typename P2, size_t index>
2163 struct sub_at {
2164 using type =
2165 typename Ring::template sub_t<
2166 typename P1::template coeff_at_t<index>,
2167 typename P2::template coeff_at_t<index>>;
2168 };
2169
2170 template<typename P1, typename P2, size_t index>
2171 using sub_at_t = typename sub_at<P1, P2, index>::type;
2172
2173 template<typename P1, typename P2, std::size_t... I>
2174 struct sub_low<P1, P2, std::index_sequence<I...>> {
2175 using type = val<sub_at_t<P1, P2, I>...>;
2176 };
2177
2178 template<typename P1, typename P2>
2179 struct sub {
2180 using type = typename simplify<typename sub_low<
2181 P1,
2182 P2,
2183 internal::make_index_sequence_reverse<
2184 std::max(P1::degree, P2::degree) + 1
2185 >>::type>::type;
2186 };
2187
2188 // multiplication at
2189 template<typename v1, typename v2, size_t k, size_t index, size_t stop>
2190 struct mul_at_loop_helper {
2191 using type = typename Ring::template add_t<
2192 typename Ring::template mul_t<
2193 typename v1::template coeff_at_t<index>,
2194 typename v2::template coeff_at_t<k - index>
2195 >,
2196 typename mul_at_loop_helper<v1, v2, k, index + 1, stop>::type
2197 >;
2198 };
2199
2200 template<typename v1, typename v2, size_t k, size_t stop>
2201 struct mul_at_loop_helper<v1, v2, k, stop, stop> {
2202 using type = typename Ring::template mul_t<
2203 typename v1::template coeff_at_t<stop>,
2204 typename v2::template coeff_at_t<0>>;
2205 };
2206
2207 template <typename v1, typename v2, size_t k, typename E = void>
2208 struct mul_at {};
2209
2210 template<typename v1, typename v2, size_t k>
2211 struct mul_at<v1, v2, k, std::enable_if_t<(k < 0) || (k > v1::degree + v2::degree)>> {
2212 using type = typename Ring::zero;
2213 };
2214
2215 template<typename v1, typename v2, size_t k>
2216 struct mul_at<v1, v2, k, std::enable_if_t<(k >= 0) && (k <= v1::degree + v2::degree)>> {
2217 using type = typename mul_at_loop_helper<v1, v2, k, 0, k>::type;
2218 };
2219
2220 template<typename P1, typename P2, size_t index>
2221 using mul_at_t = typename mul_at<P1, P2, index>::type;
2222
2223 template<typename P1, typename P2, std::size_t... I>
2224 struct mul_low<P1, P2, std::index_sequence<I...>> {
2225 using type = val<mul_at_t<P1, P2, I>...>;
2226 };
2227
2228 // division helper
2229 template< typename A, typename B, typename Q, typename R, typename E = void>
2230 struct div_helper {};
2231
2232 template<typename A, typename B, typename Q, typename R>
2233 struct div_helper<A, B, Q, R, std::enable_if_t<
2234 (R::degree < B::degree) ||
2235 (R::degree == 0 && std::is_same<typename R::aN, typename Ring::zero>::value)>> {
2236 using q_type = Q;
2237 using mod_type = R;
2238 using gcd_type = B;
2239 };
2240
2241 template<typename A, typename B, typename Q, typename R>
2242 struct div_helper<A, B, Q, R, std::enable_if_t<
2243 (R::degree >= B::degree) &&
2244 !(R::degree == 0 && std::is_same<typename R::aN, typename Ring::zero>::value)>> {
2245 private: // NOLINT
2246 using rN = typename R::aN;
2247 using bN = typename B::aN;
2248 using pT = typename monomial<typename Ring::template div_t<rN, bN>, R::degree - B::degree>::type;
2249 using rr = typename sub<R, typename mul<pT, B>::type>::type;
2250 using qq = typename add<Q, pT>::type;
2251
2252 public:
2253 using q_type = typename div_helper<A, B, qq, rr>::q_type;
2254 using mod_type = typename div_helper<A, B, qq, rr>::mod_type;
2255 using gcd_type = rr;
2256 };
2257
2258 template<typename A, typename B>
2259 struct div {
2260 static_assert(Ring::is_euclidean_domain, "cannot divide in that type of Ring");
2261 using q_type = typename div_helper<A, B, zero, A>::q_type;
2262 using m_type = typename div_helper<A, B, zero, A>::mod_type;
2263 };
2264
2265 template<typename P>
2266 struct make_unit {
2267 using type = typename div<P, val<typename P::aN>>::q_type;
2268 };
2269
2270 template<typename coeff, size_t deg>
2271 struct monomial {
2272 using type = typename mul<X, typename monomial<coeff, deg - 1>::type>::type;
2273 };
2274
2275 template<typename coeff>
2276 struct monomial<coeff, 0> {
2277 using type = val<coeff>;
2278 };
2279
2280 template<typename arithmeticType, typename P>
2281 struct horner_evaluation {
2282 template<size_t index, size_t stop>
2283 struct inner {
2284 static constexpr DEVICE INLINED arithmeticType func(
2285 const arithmeticType& accum, const arithmeticType& x) {
2286 return horner_evaluation<arithmeticType, P>::template inner<index + 1, stop>::func(
2287 internal::fma_helper<arithmeticType>::eval(
2288 x,
2289 accum,
2290 P::template coeff_at_t<P::degree - index>::template get<arithmeticType>()), x);
2291 }
2292 };
2293
2294 template<size_t stop>
2295 struct inner<stop, stop> {
2296 static constexpr DEVICE INLINED arithmeticType func(
2297 const arithmeticType& accum, const arithmeticType& x) {
2298 return accum;
2299 }
2300 };
2301 };
2302
2303 template<typename arithmeticType, typename P>
2304 struct compensated_horner {
2305 template<int64_t index, int ghost>
2306 struct EFTHorner {
2307 static INLINED DEVICE void func(
2308 arithmeticType x, arithmeticType *pi, arithmeticType *sigma, arithmeticType *r) {
2309 arithmeticType p;
2310 internal::two_prod(*r, x, &p, pi + P::degree - index - 1);
2311 constexpr arithmeticType coeff = P::template coeff_at_t<index>::template get<arithmeticType>();
2312 internal::two_sum<arithmeticType>(
2313 p, coeff,
2314 r, sigma + P::degree - index - 1);
2315 EFTHorner<index - 1, ghost>::func(x, pi, sigma, r);
2316 }
2317 };
2318
2319 template<int ghost>
2320 struct EFTHorner<-1, ghost> {
2321 static INLINED DEVICE void func(
2322 arithmeticType x, arithmeticType *pi, arithmeticType *sigma, arithmeticType *r) {
2323 }
2324 };
2325
2326 static INLINED DEVICE arithmeticType func(arithmeticType x) {
2327 arithmeticType pi[P::degree], sigma[P::degree];
2328 arithmeticType r = P::template coeff_at_t<P::degree>::template get<arithmeticType>();
2329 EFTHorner<P::degree - 1, 0>::func(x, pi, sigma, &r);
2330 arithmeticType c = internal::horner<arithmeticType, P::degree - 1>(pi, sigma, x);
2331 return r + c;
2332 }
2333 };
2334
2335 template<typename coeff, typename... coeffs>
2336 struct string_helper {
2337 static std::string func() {
2338 std::string tail = string_helper<coeffs...>::func();
2339 std::string result = "";
2340 if (Ring::template eq_t<coeff, typename Ring::zero>::value) {
2341 return tail;
2342 } else if (Ring::template eq_t<coeff, typename Ring::one>::value) {
2343 if (sizeof...(coeffs) == 1) {
2344 result += "x";
2345 } else {
2346 result += "x^" + std::to_string(sizeof...(coeffs));
2347 }
2348 } else {
2349 if (sizeof...(coeffs) == 1) {
2350 result += coeff::to_string() + " x";
2351 } else {
2352 result += coeff::to_string()
2353 + " x^" + std::to_string(sizeof...(coeffs));
2354 }
2355 }
2356
2357 if (!tail.empty()) {
2358 if (tail.at(0) != '-') {
2359 result += " + " + tail;
2360 } else {
2361 result += " - " + tail.substr(1);
2362 }
2363 }
2364
2365 return result;
2366 }
2367 };
2368
2369 template<typename coeff>
2370 struct string_helper<coeff> {
2371 static std::string func() {
2372 if (!std::is_same<coeff, typename Ring::zero>::value) {
2373 return coeff::to_string();
2374 } else {
2375 return "";
2376 }
2377 }
2378 };
2379
2380 public:
2383 template<typename P>
2384 using simplify_t = typename simplify<P>::type;
2385
2389 template<typename v1, typename v2>
2390 using add_t = typename add<v1, v2>::type;
2391
2395 template<typename v1, typename v2>
2396 using sub_t = typename sub<v1, v2>::type;
2397
2401 template<typename v1, typename v2>
2402 using mul_t = typename mul<v1, v2>::type;
2403
2407 template<typename v1, typename v2>
2408 using eq_t = typename eq_helper<v1, v2>::type;
2409
2413 template<typename v1, typename v2>
2414 using lt_t = typename lt_helper<v1, v2>::type;
2415
2419 template<typename v1, typename v2>
2420 using gt_t = typename gt_helper<v1, v2>::type;
2421
2425 template<typename v1, typename v2>
2426 using div_t = typename div<v1, v2>::q_type;
2427
2431 template<typename v1, typename v2>
2432 using mod_t = typename div_helper<v1, v2, zero, v1>::mod_type;
2433
2437 template<typename coeff, size_t deg>
2438 using monomial_t = typename monomial<coeff, deg>::type;
2439
2442 template<typename v>
2443 using derive_t = typename derive_helper<v>::type;
2444
2447 template<typename v>
2448 using pos_t = typename Ring::template pos_t<typename v::aN>;
2449
2452 template<typename v>
2453 static constexpr bool pos_v = pos_t<v>::value;
2454
2458 template<typename v1, typename v2>
2459 using gcd_t = std::conditional_t<
2460 Ring::is_euclidean_domain,
2461 typename make_unit<gcd_t<polynomial<Ring>, v1, v2>>::type,
2462 void>;
2463
2466 template<auto x>
2467 using inject_constant_t = val<typename Ring::template inject_constant_t<x>>;
2468
2471 template<typename v>
2472 using inject_ring_t = val<v>;
2473 };
2474} // namespace aerobus
2475
2476// fraction field
2477namespace aerobus {
2478 namespace internal {
2479 template<typename Ring, typename E = void>
2480 requires IsEuclideanDomain<Ring>
2481 struct _FractionField {};
2482
2483 template<typename Ring>
2484 requires IsEuclideanDomain<Ring>
2485 struct _FractionField<Ring, std::enable_if_t<Ring::is_euclidean_domain>> {
2487 static constexpr bool is_field = true;
2488 static constexpr bool is_euclidean_domain = true;
2489
2490 private:
2491 template<typename val1, typename val2, typename E = void>
2492 struct to_string_helper {};
2493
2494 template<typename val1, typename val2>
2495 struct to_string_helper <val1, val2,
2496 std::enable_if_t<
2497 Ring::template eq_t<
2498 val2, typename Ring::one
2499 >::value
2500 >
2501 > {
2502 static std::string func() {
2503 return val1::to_string();
2504 }
2505 };
2506
2507 template<typename val1, typename val2>
2508 struct to_string_helper<val1, val2,
2509 std::enable_if_t<
2510 !Ring::template eq_t<
2511 val2,
2512 typename Ring::one
2513 >::value
2514 >
2515 > {
2516 static std::string func() {
2517 return "(" + val1::to_string() + ") / (" + val2::to_string() + ")";
2518 }
2519 };
2520
2521 public:
2525 template<typename val1, typename val2>
2526 struct val {
2528 using x = val1;
2530 using y = val2;
2532 using is_zero_t = typename val1::is_zero_t;
2534 static constexpr bool is_zero_v = val1::is_zero_t::value;
2535
2537 using ring_type = Ring;
2538 using enclosing_type = _FractionField<Ring>;
2539
2542 static constexpr bool is_integer = std::is_same_v<val2, typename Ring::one>;
2543
2544 template<typename valueType, int ghost = 0>
2545 struct get_helper {
2546 static constexpr INLINED DEVICE valueType get() {
2547 return internal::staticcast<valueType, typename ring_type::inner_type>::template func<x::v>() /
2548 internal::staticcast<valueType, typename ring_type::inner_type>::template func<y::v>();
2549 }
2550 };
2551
2552 #ifdef WITH_CUDA_FP16
2553 template<int ghost>
2554 struct get_helper<__half, ghost> {
2555 static constexpr INLINED DEVICE __half get() {
2556 return internal::my_float2half_rn(
2557 internal::staticcast<float, typename ring_type::inner_type>::template func<x::v>() /
2558 internal::staticcast<float, typename ring_type::inner_type>::template func<y::v>());
2559 }
2560 };
2561
2562 template<int ghost>
2563 struct get_helper<__half2, ghost> {
2564 static constexpr INLINED DEVICE __half2 get() {
2565 constexpr __half tmp = internal::my_float2half_rn(
2566 internal::staticcast<float, typename ring_type::inner_type>::template func<x::v>() /
2567 internal::staticcast<float, typename ring_type::inner_type>::template func<y::v>());
2568 return __half2(tmp, tmp);
2569 }
2570 };
2571 #endif
2572
2576 template<typename valueType>
2577 static constexpr INLINED DEVICE valueType get() {
2578 return get_helper<valueType, 0>::get();
2579 }
2580
2583 static std::string to_string() {
2584 return to_string_helper<val1, val2>::func();
2585 }
2586
2591 template<typename arithmeticType>
2592 static constexpr DEVICE INLINED arithmeticType eval(const arithmeticType& v) {
2593 return x::eval(v) / y::eval(v);
2594 }
2595 };
2596
2598 using zero = val<typename Ring::zero, typename Ring::one>;
2600 using one = val<typename Ring::one, typename Ring::one>;
2601
2604 template<typename v>
2605 using inject_t = val<v, typename Ring::one>;
2606
2609 template<auto x>
2610 using inject_constant_t = val<typename Ring::template inject_constant_t<x>, typename Ring::one>;
2611
2614 template<typename v>
2615 using inject_ring_t = val<typename Ring::template inject_ring_t<v>, typename Ring::one>;
2616
2618 using ring_type = Ring;
2619
2620 private:
2621 template<typename v, typename E = void>
2622 struct simplify {};
2623
2624 // x = 0
2625 template<typename v>
2626 struct simplify<v, std::enable_if_t<v::x::is_zero_t::value>> {
2627 using type = typename _FractionField<Ring>::zero;
2628 };
2629
2630 // x != 0
2631 template<typename v>
2632 struct simplify<v, std::enable_if_t<!v::x::is_zero_t::value>> {
2633 private:
2634 using _gcd = typename Ring::template gcd_t<typename v::x, typename v::y>;
2635 using newx = typename Ring::template div_t<typename v::x, _gcd>;
2636 using newy = typename Ring::template div_t<typename v::y, _gcd>;
2637
2638 using posx = std::conditional_t<
2639 !Ring::template pos_v<newy>,
2640 typename Ring::template sub_t<typename Ring::zero, newx>,
2641 newx>;
2642 using posy = std::conditional_t<
2643 !Ring::template pos_v<newy>,
2644 typename Ring::template sub_t<typename Ring::zero, newy>,
2645 newy>;
2646 public:
2647 using type = typename _FractionField<Ring>::template val<posx, posy>;
2648 };
2649
2650 public:
2653 template<typename v>
2654 using simplify_t = typename simplify<v>::type;
2655
2656 private:
2657 template<typename v1, typename v2>
2658 struct add {
2659 private:
2660 using a = typename Ring::template mul_t<typename v1::x, typename v2::y>;
2661 using b = typename Ring::template mul_t<typename v1::y, typename v2::x>;
2662 using dividend = typename Ring::template add_t<a, b>;
2663 using diviser = typename Ring::template mul_t<typename v1::y, typename v2::y>;
2664 using g = typename Ring::template gcd_t<dividend, diviser>;
2665
2666 public:
2667 using type = typename _FractionField<Ring>::template simplify_t<val<dividend, diviser>>;
2668 };
2669
2670 template<typename v>
2671 struct pos {
2672 using type = std::conditional_t<
2673 (Ring::template pos_v<typename v::x> && Ring::template pos_v<typename v::y>) ||
2674 (!Ring::template pos_v<typename v::x> && !Ring::template pos_v<typename v::y>),
2675 std::true_type,
2676 std::false_type>;
2677 };
2678
2679 template<typename v1, typename v2>
2680 struct sub {
2681 private:
2682 using a = typename Ring::template mul_t<typename v1::x, typename v2::y>;
2683 using b = typename Ring::template mul_t<typename v1::y, typename v2::x>;
2684 using dividend = typename Ring::template sub_t<a, b>;
2685 using diviser = typename Ring::template mul_t<typename v1::y, typename v2::y>;
2686 using g = typename Ring::template gcd_t<dividend, diviser>;
2687
2688 public:
2689 using type = typename _FractionField<Ring>::template simplify_t<val<dividend, diviser>>;
2690 };
2691
2692 template<typename v1, typename v2>
2693 struct mul {
2694 private:
2695 using a = typename Ring::template mul_t<typename v1::x, typename v2::x>;
2696 using b = typename Ring::template mul_t<typename v1::y, typename v2::y>;
2697
2698 public:
2699 using type = typename _FractionField<Ring>::template simplify_t<val<a, b>>;
2700 };
2701
2702 template<typename v1, typename v2, typename E = void>
2703 struct div {};
2704
2705 template<typename v1, typename v2>
2706 struct div<v1, v2, std::enable_if_t<!std::is_same<v2, typename _FractionField<Ring>::zero>::value>> {
2707 private:
2708 using a = typename Ring::template mul_t<typename v1::x, typename v2::y>;
2709 using b = typename Ring::template mul_t<typename v1::y, typename v2::x>;
2710
2711 public:
2712 using type = typename _FractionField<Ring>::template simplify_t<val<a, b>>;
2713 };
2714
2715 template<typename v1, typename v2>
2716 struct div<v1, v2, std::enable_if_t<
2717 std::is_same<zero, v1>::value && std::is_same<v2, zero>::value>> {
2718 using type = one;
2719 };
2720
2721 template<typename v1, typename v2>
2722 struct eq {
2723 using type = std::conditional_t<
2724 std::is_same<typename simplify_t<v1>::x, typename simplify_t<v2>::x>::value &&
2725 std::is_same<typename simplify_t<v1>::y, typename simplify_t<v2>::y>::value,
2726 std::true_type,
2727 std::false_type>;
2728 };
2729
2730 template<typename v1, typename v2, typename E = void>
2731 struct gt;
2732
2733 template<typename v1, typename v2>
2734 struct gt<v1, v2, std::enable_if_t<
2735 (eq<v1, v2>::type::value)
2736 >> {
2737 using type = std::false_type;
2738 };
2739
2740 template<typename v1, typename v2>
2741 struct gt<v1, v2, std::enable_if_t<
2742 (!eq<v1, v2>::type::value) &&
2743 (!pos<v1>::type::value) && (!pos<v2>::type::value)
2744 >> {
2745 using type = typename gt<
2746 typename sub<zero, v1>::type, typename sub<zero, v2>::type
2747 >::type;
2748 };
2749
2750 template<typename v1, typename v2>
2751 struct gt<v1, v2, std::enable_if_t<
2752 (!eq<v1, v2>::type::value) &&
2753 (pos<v1>::type::value) && (!pos<v2>::type::value)
2754 >> {
2755 using type = std::true_type;
2756 };
2757
2758 template<typename v1, typename v2>
2759 struct gt<v1, v2, std::enable_if_t<
2760 (!eq<v1, v2>::type::value) &&
2761 (!pos<v1>::type::value) && (pos<v2>::type::value)
2762 >> {
2763 using type = std::false_type;
2764 };
2765
2766 template<typename v1, typename v2>
2767 struct gt<v1, v2, std::enable_if_t<
2768 (!eq<v1, v2>::type::value) &&
2769 (pos<v1>::type::value) && (pos<v2>::type::value)
2770 >> {
2771 using type = typename Ring::template gt_t<
2772 typename Ring::template mul_t<v1::x, v2::y>,
2773 typename Ring::template mul_t<v2::y, v2::x>
2774 >;
2775 };
2776
2777 public:
2781 template<typename v1, typename v2>
2782 using add_t = typename add<v1, v2>::type;
2783
2788 template<typename v1, typename v2>
2789 using mod_t = zero;
2790
2795 template<typename v1, typename v2>
2796 using gcd_t = v1;
2797
2801 template<typename v1, typename v2>
2802 using sub_t = typename sub<v1, v2>::type;
2803
2807 template<typename v1, typename v2>
2808 using mul_t = typename mul<v1, v2>::type;
2809
2813 template<typename v1, typename v2>
2814 using div_t = typename div<v1, v2>::type;
2815
2819 template<typename v1, typename v2>
2820 using eq_t = typename eq<v1, v2>::type;
2821
2825 template<typename v1, typename v2>
2826 static constexpr bool eq_v = eq<v1, v2>::type::value;
2827
2831 template<typename v1, typename v2>
2832 using gt_t = typename gt<v1, v2>::type;
2833
2837 template<typename v1, typename v2>
2838 static constexpr bool gt_v = gt<v1, v2>::type::value;
2839
2842 template<typename v1>
2843 using pos_t = typename pos<v1>::type;
2844
2847 template<typename v>
2848 static constexpr bool pos_v = pos_t<v>::value;
2849 };
2850
2851 template<typename Ring, typename E = void>
2852 requires IsEuclideanDomain<Ring>
2853 struct FractionFieldImpl {};
2854
2855 // fraction field of a field is the field itself
2856 template<typename Field>
2857 requires IsEuclideanDomain<Field>
2858 struct FractionFieldImpl<Field, std::enable_if_t<Field::is_field>> {
2859 using type = Field;
2860 template<typename v>
2861 using inject_t = v;
2862 };
2863
2864 // fraction field of a ring is the actual fraction field
2865 template<typename Ring>
2866 requires IsEuclideanDomain<Ring>
2867 struct FractionFieldImpl<Ring, std::enable_if_t<!Ring::is_field>> {
2868 using type = _FractionField<Ring>;
2869 };
2870 } // namespace internal
2871
2874 template<typename Ring>
2875 requires IsEuclideanDomain<Ring>
2876 using FractionField = typename internal::FractionFieldImpl<Ring>::type;
2877
2880 template<typename Ring>
2881 struct Embed<Ring, FractionField<Ring>> {
2884 template<typename v>
2885 using type = typename FractionField<Ring>::template val<v, typename Ring::one>;
2886 };
2887} // namespace aerobus
2888
2889
2890// short names for common types
2891namespace aerobus {
2895 template<typename X, typename Y>
2896 requires IsRing<typename X::enclosing_type> &&
2897 (std::is_same_v<typename X::enclosing_type, typename Y::enclosing_type>)
2898 using add_t = typename X::enclosing_type::template add_t<X, Y>;
2899
2903 template<typename X, typename Y>
2904 requires IsRing<typename X::enclosing_type> &&
2905 (std::is_same_v<typename X::enclosing_type, typename Y::enclosing_type>)
2906 using sub_t = typename X::enclosing_type::template sub_t<X, Y>;
2907
2911 template<typename X, typename Y>
2912 requires IsRing<typename X::enclosing_type> &&
2913 (std::is_same_v<typename X::enclosing_type, typename Y::enclosing_type>)
2914 using mul_t = typename X::enclosing_type::template mul_t<X, Y>;
2915
2919 template<typename X, typename Y>
2920 requires IsEuclideanDomain<typename X::enclosing_type> &&
2921 (std::is_same_v<typename X::enclosing_type, typename Y::enclosing_type>)
2922 using div_t = typename X::enclosing_type::template div_t<X, Y>;
2923
2926 using q32 = FractionField<i32>;
2927
2930 using fpq32 = FractionField<polynomial<q32>>;
2931
2934 using q64 = FractionField<i64>;
2935
2937 using pi64 = polynomial<i64>;
2938
2940 using pq64 = polynomial<q64>;
2941
2943 using fpq64 = FractionField<polynomial<q64>>;
2944
2949 template<typename Ring, typename v1, typename v2>
2950 using makefraction_t = typename FractionField<Ring>::template val<v1, v2>;
2951
2958 template<typename v>
2959 using embed_int_poly_in_fractions_t =
2960 typename Embed<
2961 polynomial<typename v::ring_type>,
2962 polynomial<FractionField<typename v::ring_type>>>::template type<v>;
2963
2967 template<int64_t p, int64_t q>
2968 using make_q64_t = typename q64::template simplify_t<
2969 typename q64::val<i64::inject_constant_t<p>, i64::inject_constant_t<q>>>;
2970
2974 template<int32_t p, int32_t q>
2975 using make_q32_t = typename q32::template simplify_t<
2976 typename q32::val<i32::inject_constant_t<p>, i32::inject_constant_t<q>>>;
2977
2978 #ifdef WITH_CUDA_FP16
2980 using q16 = FractionField<i16>;
2981
2985 template<int16_t p, int16_t q>
2986 using make_q16_t = typename q16::template simplify_t<
2987 typename q16::val<i16::inject_constant_t<p>, i16::inject_constant_t<q>>>;
2988
2989 #endif
2994 template<typename Ring, typename v1, typename v2>
2995 using addfractions_t = typename FractionField<Ring>::template add_t<v1, v2>;
3000 template<typename Ring, typename v1, typename v2>
3001 using mulfractions_t = typename FractionField<Ring>::template mul_t<v1, v2>;
3002
3004 template<>
3005 struct Embed<q32, q64> {
3008 template<typename v>
3009 using type = make_q64_t<static_cast<int64_t>(v::x::v), static_cast<int64_t>(v::y::v)>;
3010 };
3011
3015 template<typename Small, typename Large>
3016 struct Embed<polynomial<Small>, polynomial<Large>> {
3017 private:
3018 template<typename v, typename i>
3019 struct at_low;
3020
3021 template<typename v, size_t i>
3022 struct at_index {
3023 using type = typename Embed<Small, Large>::template type<typename v::template coeff_at_t<i>>;
3024 };
3025
3026 template<typename v, size_t... Is>
3027 struct at_low<v, std::index_sequence<Is...>> {
3028 using type = typename polynomial<Large>::template val<typename at_index<v, Is>::type...>;
3029 };
3030
3031 public:
3034 template<typename v>
3035 using type = typename at_low<v, typename internal::make_index_sequence_reverse<v::degree + 1>>::type;
3036 };
3037
3041 template<typename Ring, auto... xs>
3042 using make_int_polynomial_t = typename polynomial<Ring>::template val<
3043 typename Ring::template inject_constant_t<xs>...>;
3044
3048 template<typename Ring, auto... xs>
3049 using make_frac_polynomial_t = typename polynomial<FractionField<Ring>>::template val<
3050 typename FractionField<Ring>::template inject_constant_t<xs>...>;
3051} // namespace aerobus
3052
3053// taylor series and common integers (factorial, bernoulli...) appearing in taylor coefficients
3054namespace aerobus {
3055 namespace internal {
3056 template<typename T, size_t x, typename E = void>
3057 struct factorial {};
3058
3059 template<typename T, size_t x>
3060 struct factorial<T, x, std::enable_if_t<(x > 0)>> {
3061 private:
3062 template<typename, size_t, typename>
3063 friend struct factorial;
3064 public:
3065 using type = typename T::template mul_t<typename T::template val<x>, typename factorial<T, x - 1>::type>;
3066 static constexpr typename T::inner_type value = type::template get<typename T::inner_type>();
3067 };
3068
3069 template<typename T>
3070 struct factorial<T, 0> {
3071 public:
3072 using type = typename T::one;
3073 static constexpr typename T::inner_type value = type::template get<typename T::inner_type>();
3074 };
3075 } // namespace internal
3076
3080 template<typename T, size_t i>
3081 using factorial_t = typename internal::factorial<T, i>::type;
3082
3086 template<typename T, size_t i>
3087 inline constexpr typename T::inner_type factorial_v = internal::factorial<T, i>::value;
3088
3089 namespace internal {
3090 template<typename T, size_t k, size_t n, typename E = void>
3091 struct combination_helper {};
3092
3093 template<typename T, size_t k, size_t n>
3094 struct combination_helper<T, k, n, std::enable_if_t<(n >= 0 && k <= (n / 2) && k > 0)>> {
3095 using type = typename FractionField<T>::template mul_t<
3096 typename combination_helper<T, k - 1, n - 1>::type,
3097 makefraction_t<T, typename T::template val<n>, typename T::template val<k>>>;
3098 };
3099
3100 template<typename T, size_t k, size_t n>
3101 struct combination_helper<T, k, n, std::enable_if_t<(n >= 0 && k > (n / 2) && k > 0)>> {
3102 using type = typename combination_helper<T, n - k, n>::type;
3103 };
3104
3105 template<typename T, size_t n>
3106 struct combination_helper<T, 0, n> {
3107 using type = typename FractionField<T>::one;
3108 };
3109
3110 template<typename T, size_t k, size_t n>
3111 struct combination {
3112 using type = typename internal::combination_helper<T, k, n>::type::x;
3113 static constexpr typename T::inner_type value =
3114 internal::combination_helper<T, k, n>::type::template get<typename T::inner_type>();
3115 };
3116 } // namespace internal
3117
3120 template<typename T, size_t k, size_t n>
3121 using combination_t = typename internal::combination<T, k, n>::type;
3122
3127 template<typename T, size_t k, size_t n>
3128 inline constexpr typename T::inner_type combination_v = internal::combination<T, k, n>::value;
3129
3130 namespace internal {
3131 template<typename T, size_t m>
3132 struct bernoulli;
3133
3134 template<typename T, typename accum, size_t k, size_t m>
3135 struct bernoulli_helper {
3136 using type = typename bernoulli_helper<
3137 T,
3138 addfractions_t<T,
3139 accum,
3140 mulfractions_t<T,
3141 makefraction_t<T,
3142 combination_t<T, k, m + 1>,
3143 typename T::one>,
3144 typename bernoulli<T, k>::type
3145 >
3146 >,
3147 k + 1,
3148 m>::type;
3149 };
3150
3151 template<typename T, typename accum, size_t m>
3152 struct bernoulli_helper<T, accum, m, m> {
3153 using type = accum;
3154 };
3155
3156
3157
3158 template<typename T, size_t m>
3159 struct bernoulli {
3160 using type = typename FractionField<T>::template mul_t<
3161 typename internal::bernoulli_helper<T, typename FractionField<T>::zero, 0, m>::type,
3162 makefraction_t<T,
3163 typename T::template val<static_cast<typename T::inner_type>(-1)>,
3164 typename T::template val<static_cast<typename T::inner_type>(m + 1)>
3165 >
3166 >;
3167
3168 template<typename floatType>
3169 static constexpr floatType value = type::template get<floatType>();
3170 };
3171
3172 template<typename T>
3173 struct bernoulli<T, 0> {
3174 using type = typename FractionField<T>::one;
3175
3176 template<typename floatType>
3177 static constexpr floatType value = type::template get<floatType>();
3178 };
3179 } // namespace internal
3180
3184 template<typename T, size_t n>
3185 using bernoulli_t = typename internal::bernoulli<T, n>::type;
3186
3191 template<typename FloatType, typename T, size_t n >
3192 inline constexpr FloatType bernoulli_v = internal::bernoulli<T, n>::template value<FloatType>;
3193
3194 // bell numbers
3195 namespace internal {
3196 template<typename T, size_t n, typename E = void>
3197 struct bell_helper;
3198
3199 template <typename T, size_t n>
3200 struct bell_helper<T, n, std::enable_if_t<(n > 1)>> {
3201 template<typename accum, size_t i, size_t stop>
3202 struct sum_helper {
3203 private:
3204 using left = typename T::template mul_t<
3205 combination_t<T, i, n-1>,
3206 typename bell_helper<T, i>::type>;
3207 using new_accum = typename T::template add_t<accum, left>;
3208 public:
3209 using type = typename sum_helper<new_accum, i+1, stop>::type;
3210 };
3211
3212 template<typename accum, size_t stop>
3213 struct sum_helper<accum, stop, stop> {
3214 using type = accum;
3215 };
3216
3217 using type = typename sum_helper<typename T::zero, 0, n>::type;
3218 };
3219
3220 template<typename T>
3221 struct bell_helper<T, 0> {
3222 using type = typename T::one;
3223 };
3224
3225 template<typename T>
3226 struct bell_helper<T, 1> {
3227 using type = typename T::one;
3228 };
3229 } // namespace internal
3230
3234 template<typename T, size_t n>
3235 using bell_t = typename internal::bell_helper<T, n>::type;
3236
3240 template<typename T, size_t n>
3241 static constexpr typename T::inner_type bell_v = bell_t<T, n>::v;
3242
3243 namespace internal {
3244 template<typename T, int k, typename E = void>
3245 struct alternate {};
3246
3247 template<typename T, int k>
3248 struct alternate<T, k, std::enable_if_t<k % 2 == 0>> {
3249 using type = typename T::one;
3250 static constexpr typename T::inner_type value = type::template get<typename T::inner_type>();
3251 };
3252
3253 template<typename T, int k>
3254 struct alternate<T, k, std::enable_if_t<k % 2 != 0>> {
3255 using type = typename T::template sub_t<typename T::zero, typename T::one>;
3256 static constexpr typename T::inner_type value = type::template get<typename T::inner_type>();
3257 };
3258 } // namespace internal
3259
3262 template<typename T, int k>
3263 using alternate_t = typename internal::alternate<T, k>::type;
3264
3267 template<typename T, size_t k>
3268 inline constexpr typename T::inner_type alternate_v = internal::alternate<T, k>::value;
3269
3270 namespace internal {
3271 template<typename T, int n, int k, typename E = void>
3272 struct stirling_1_helper {};
3273
3274 template<typename T>
3275 struct stirling_1_helper<T, 0, 0> {
3276 using type = typename T::one;
3277 };
3278
3279 template<typename T, int n>
3280 struct stirling_1_helper<T, n, 0, std::enable_if_t<(n > 0)>> {
3281 using type = typename T::zero;
3282 };
3283
3284 template<typename T, int n>
3285 struct stirling_1_helper<T, 0, n, std::enable_if_t<(n > 0)>> {
3286 using type = typename T::zero;
3287 };
3288
3289 template<typename T, int n, int k>
3290 struct stirling_1_helper<T, n, k, std::enable_if_t<(k > 0) && (n > 0)>> {
3291 using type = typename T::template sub_t<
3292 typename stirling_1_helper<T, n-1, k-1>::type,
3293 typename T::template mul_t<
3294 typename T::template inject_constant_t<n-1>,
3295 typename stirling_1_helper<T, n-1, k>::type
3296 >>;
3297 };
3298 } // namespace internal
3299
3304 template<typename T, int n, int k>
3305 using stirling_1_signed_t = typename internal::stirling_1_helper<T, n, k>::type;
3306
3311 template<typename T, int n, int k>
3312 using stirling_1_unsigned_t = abs_t<typename internal::stirling_1_helper<T, n, k>::type>;
3313
3318 template<typename T, int n, int k>
3319 static constexpr typename T::inner_type stirling_1_unsigned_v = stirling_1_unsigned_t<T, n, k>::v;
3320
3325 template<typename T, int n, int k>
3326 static constexpr typename T::inner_type stirling_1_signed_v = stirling_1_signed_t<T, n, k>::v;
3327
3328 namespace internal {
3329 template<typename T, int n, int k, typename E = void>
3330 struct stirling_2_helper {};
3331
3332 template<typename T, int n>
3333 struct stirling_2_helper<T, n, n, std::enable_if_t<(n >= 0)>> {
3334 using type = typename T::one;
3335 };
3336
3337 template<typename T, int n>
3338 struct stirling_2_helper<T, n, 0, std::enable_if_t<(n > 0)>> {
3339 using type = typename T::zero;
3340 };
3341
3342 template<typename T, int n>
3343 struct stirling_2_helper<T, 0, n, std::enable_if_t<(n > 0)>> {
3344 using type = typename T::zero;
3345 };
3346
3347 template<typename T, int n, int k>
3348 struct stirling_2_helper<T, n, k, std::enable_if_t<(k > 0) && (n > 0) && (k < n)>> {
3349 using type = typename T::template add_t<
3350 typename stirling_2_helper<T, n-1, k-1>::type,
3351 typename T::template mul_t<
3352 typename T::template inject_constant_t<k>,
3353 typename stirling_2_helper<T, n-1, k>::type
3354 >>;
3355 };
3356 } // namespace internal
3357
3362 template<typename T, int n, int k>
3363 using stirling_2_t = typename internal::stirling_2_helper<T, n, k>::type;
3364
3369 template<typename T, int n, int k>
3370 static constexpr typename T::inner_type stirling_2_v = stirling_2_t<T, n, k>::v;
3371
3372 namespace internal {
3373 template<typename T>
3374 struct pow_scalar {
3375 template<size_t p>
3376 static constexpr DEVICE INLINED T func(const T& x) { return p == 0 ? static_cast<T>(1) :
3377 p % 2 == 0 ? func<p/2>(x) * func<p/2>(x) :
3378 x * func<p/2>(x) * func<p/2>(x);
3379 }
3380 };
3381
3382 template<typename T, typename p, size_t n, typename E = void>
3383 requires IsEuclideanDomain<T>
3384 struct pow;
3385
3386 template<typename T, typename p, size_t n>
3387 struct pow<T, p, n, std::enable_if_t<(n > 0 && n % 2 == 0)>> {
3388 using type = typename T::template mul_t<
3389 typename pow<T, p, n/2>::type,
3390 typename pow<T, p, n/2>::type
3391 >;
3392 };
3393
3394 template<typename T, typename p, size_t n>
3395 struct pow<T, p, n, std::enable_if_t<(n % 2 == 1)>> {
3396 using type = typename T::template mul_t<
3397 p,
3398 typename T::template mul_t<
3399 typename pow<T, p, n/2>::type,
3400 typename pow<T, p, n/2>::type
3401 >
3402 >;
3403 };
3404
3405 template<typename T, typename p, size_t n>
3406 struct pow<T, p, n, std::enable_if_t<n == 0>> { using type = typename T::one; };
3407 } // namespace internal
3408
3413 template<typename T, typename p, size_t n>
3414 using pow_t = typename internal::pow<T, p, n>::type;
3415
3420 template<typename T, typename p, size_t n>
3421 static constexpr typename T::inner_type pow_v = internal::pow<T, p, n>::type::v;
3422
3423 template<typename T, size_t p>
3424 static constexpr DEVICE INLINED T pow_scalar(const T& x) { return internal::pow_scalar<T>::template func<p>(x); }
3425
3426 namespace internal {
3427 template<typename, template<typename, size_t> typename, class>
3428 struct make_taylor_impl;
3429
3430 template<typename T, template<typename, size_t> typename coeff_at, size_t... Is>
3431 struct make_taylor_impl<T, coeff_at, std::integer_sequence<size_t, Is...>> {
3432 using type = typename polynomial<FractionField<T>>::template val<typename coeff_at<T, Is>::type...>;
3433 };
3434 }
3435
3440 template<typename T, template<typename, size_t index> typename coeff_at, size_t deg>
3441 using taylor = typename internal::make_taylor_impl<
3442 T,
3443 coeff_at,
3444 internal::make_index_sequence_reverse<deg + 1>>::type;
3445
3446 namespace internal {
3447 template<typename T, size_t i>
3448 struct exp_coeff {
3449 using type = makefraction_t<T, typename T::one, factorial_t<T, i>>;
3450 };
3451
3452 template<typename T, size_t i, typename E = void>
3453 struct sin_coeff_helper {};
3454
3455 template<typename T, size_t i>
3456 struct sin_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3457 using type = typename FractionField<T>::zero;
3458 };
3459
3460 template<typename T, size_t i>
3461 struct sin_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3462 using type = makefraction_t<T, alternate_t<T, i / 2>, factorial_t<T, i>>;
3463 };
3464
3465 template<typename T, size_t i>
3466 struct sin_coeff {
3467 using type = typename sin_coeff_helper<T, i>::type;
3468 };
3469
3470 template<typename T, size_t i, typename E = void>
3471 struct sh_coeff_helper {};
3472
3473 template<typename T, size_t i>
3474 struct sh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3475 using type = typename FractionField<T>::zero;
3476 };
3477
3478 template<typename T, size_t i>
3479 struct sh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3480 using type = makefraction_t<T, typename T::one, factorial_t<T, i>>;
3481 };
3482
3483 template<typename T, size_t i>
3484 struct sh_coeff {
3485 using type = typename sh_coeff_helper<T, i>::type;
3486 };
3487
3488 template<typename T, size_t i, typename E = void>
3489 struct cos_coeff_helper {};
3490
3491 template<typename T, size_t i>
3492 struct cos_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3493 using type = typename FractionField<T>::zero;
3494 };
3495
3496 template<typename T, size_t i>
3497 struct cos_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3498 using type = makefraction_t<T, alternate_t<T, i / 2>, factorial_t<T, i>>;
3499 };
3500
3501 template<typename T, size_t i>
3502 struct cos_coeff {
3503 using type = typename cos_coeff_helper<T, i>::type;
3504 };
3505
3506 template<typename T, size_t i, typename E = void>
3507 struct cosh_coeff_helper {};
3508
3509 template<typename T, size_t i>
3510 struct cosh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3511 using type = typename FractionField<T>::zero;
3512 };
3513
3514 template<typename T, size_t i>
3515 struct cosh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3516 using type = makefraction_t<T, typename T::one, factorial_t<T, i>>;
3517 };
3518
3519 template<typename T, size_t i>
3520 struct cosh_coeff {
3521 using type = typename cosh_coeff_helper<T, i>::type;
3522 };
3523
3524 template<typename T, size_t i>
3525 struct geom_coeff { using type = typename FractionField<T>::one; };
3526
3527
3528 template<typename T, size_t i, typename E = void>
3529 struct atan_coeff_helper;
3530
3531 template<typename T, size_t i>
3532 struct atan_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3533 using type = makefraction_t<T, alternate_t<T, i / 2>, typename T::template val<i>>;
3534 };
3535
3536 template<typename T, size_t i>
3537 struct atan_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3538 using type = typename FractionField<T>::zero;
3539 };
3540
3541 template<typename T, size_t i>
3542 struct atan_coeff { using type = typename atan_coeff_helper<T, i>::type; };
3543
3544 template<typename T, size_t i, typename E = void>
3545 struct asin_coeff_helper;
3546
3547 template<typename T, size_t i>
3548 struct asin_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3549 using type = makefraction_t<T,
3550 factorial_t<T, i - 1>,
3551 typename T::template mul_t<
3552 typename T::template val<i>,
3553 T::template mul_t<
3554 pow_t<T, typename T::template inject_constant_t<4>, i / 2>,
3555 pow<T, factorial_t<T, i / 2>, 2
3556 >
3557 >
3558 >>;
3559 };
3560
3561 template<typename T, size_t i>
3562 struct asin_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3563 using type = typename FractionField<T>::zero;
3564 };
3565
3566 template<typename T, size_t i>
3567 struct asin_coeff {
3568 using type = typename asin_coeff_helper<T, i>::type;
3569 };
3570
3571 template<typename T, size_t i>
3572 struct lnp1_coeff {
3573 using type = makefraction_t<T,
3574 alternate_t<T, i + 1>,
3575 typename T::template val<i>>;
3576 };
3577
3578 template<typename T>
3579 struct lnp1_coeff<T, 0> { using type = typename FractionField<T>::zero; };
3580
3581 template<typename T, size_t i, typename E = void>
3582 struct asinh_coeff_helper;
3583
3584 template<typename T, size_t i>
3585 struct asinh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3586 using type = makefraction_t<T,
3587 typename T::template mul_t<
3588 alternate_t<T, i / 2>,
3589 factorial_t<T, i - 1>
3590 >,
3591 typename T::template mul_t<
3592 typename T::template mul_t<
3593 typename T::template val<i>,
3594 pow_t<T, factorial_t<T, i / 2>, 2>
3595 >,
3596 pow_t<T, typename T::template inject_constant_t<4>, i / 2>
3597 >
3598 >;
3599 };
3600
3601 template<typename T, size_t i>
3602 struct asinh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3603 using type = typename FractionField<T>::zero;
3604 };
3605
3606 template<typename T, size_t i>
3607 struct asinh_coeff {
3608 using type = typename asinh_coeff_helper<T, i>::type;
3609 };
3610
3611 template<typename T, size_t i, typename E = void>
3612 struct atanh_coeff_helper;
3613
3614 template<typename T, size_t i>
3615 struct atanh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 1>> {
3616 // 1/i
3617 using type = typename FractionField<T>:: template val<
3618 typename T::one,
3619 typename T::template inject_constant_t<i>>;
3620 };
3621
3622 template<typename T, size_t i>
3623 struct atanh_coeff_helper<T, i, std::enable_if_t<(i & 1) == 0>> {
3624 using type = typename FractionField<T>::zero;
3625 };
3626
3627 template<typename T, size_t i>
3628 struct atanh_coeff {
3629 using type = typename atanh_coeff_helper<T, i>::type;
3630 };
3631
3632 template<typename T, size_t i, typename E = void>
3633 struct tan_coeff_helper;
3634
3635 template<typename T, size_t i>
3636 struct tan_coeff_helper<T, i, std::enable_if_t<(i % 2) == 0>> {
3637 using type = typename FractionField<T>::zero;
3638 };
3639
3640 template<typename T, size_t i>
3641 struct tan_coeff_helper<T, i, std::enable_if_t<(i % 2) != 0>> {
3642 private:
3643 // 4^((i+1)/2)
3644 using _4p = typename FractionField<T>::template inject_t<
3645 pow_t<T, typename T::template inject_constant_t<4>, (i + 1) / 2>>;
3646 // 4^((i+1)/2) - 1
3647 using _4pm1 = typename FractionField<T>::template sub_t<_4p, typename FractionField<T>::one>;
3648 // (-1)^((i-1)/2)
3649 using altp = typename FractionField<T>::template inject_t<alternate_t<T, (i - 1) / 2>>;
3650 using dividend = typename FractionField<T>::template mul_t<
3651 altp,
3652 FractionField<T>::template mul_t<
3653 _4p,
3654 FractionField<T>::template mul_t<
3655 _4pm1,
3656 bernoulli_t<T, (i + 1)>
3657 >
3658 >
3659 >;
3660 public:
3661 using type = typename FractionField<T>::template div_t<dividend,
3662 typename FractionField<T>::template inject_t<factorial_t<T, i + 1>>>;
3663 };
3664
3665 template<typename T, size_t i>
3666 struct tan_coeff {
3667 using type = typename tan_coeff_helper<T, i>::type;
3668 };
3669
3670 template<typename T, size_t i, typename E = void>
3671 struct tanh_coeff_helper;
3672
3673 template<typename T, size_t i>
3674 struct tanh_coeff_helper<T, i, std::enable_if_t<(i % 2) == 0>> {
3675 using type = typename FractionField<T>::zero;
3676 };
3677
3678 template<typename T, size_t i>
3679 struct tanh_coeff_helper<T, i, std::enable_if_t<(i % 2) != 0>> {
3680 private:
3681 using _4p = typename FractionField<T>::template inject_t<
3682 pow_t<T, typename T::template inject_constant_t<4>, (i + 1) / 2>>;
3683 using _4pm1 = typename FractionField<T>::template sub_t<_4p, typename FractionField<T>::one>;
3684 using dividend =
3685 typename FractionField<T>::template mul_t<
3686 _4p,
3687 typename FractionField<T>::template mul_t<
3688 _4pm1,
3689 bernoulli_t<T, (i + 1)>>>::type;
3690 public:
3691 using type = typename FractionField<T>::template div_t<dividend,
3692 FractionField<T>::template inject_t<factorial_t<T, i + 1>>>;
3693 };
3694
3695 template<typename T, size_t i>
3696 struct tanh_coeff {
3697 using type = typename tanh_coeff_helper<T, i>::type;
3698 };
3699 } // namespace internal
3700
3704 template<typename Integers, size_t deg>
3705 using exp = taylor<Integers, internal::exp_coeff, deg>;
3706
3710 template<typename Integers, size_t deg>
3711 using expm1 = typename polynomial<FractionField<Integers>>::template sub_t<
3712 exp<Integers, deg>,
3713 typename polynomial<FractionField<Integers>>::one>;
3714
3718 template<typename Integers, size_t deg>
3719 using lnp1 = taylor<Integers, internal::lnp1_coeff, deg>;
3720
3724 template<typename Integers, size_t deg>
3725 using atan = taylor<Integers, internal::atan_coeff, deg>;
3726
3730 template<typename Integers, size_t deg>
3731 using sin = taylor<Integers, internal::sin_coeff, deg>;
3732
3736 template<typename Integers, size_t deg>
3737 using sinh = taylor<Integers, internal::sh_coeff, deg>;
3738
3743 template<typename Integers, size_t deg>
3744 using cosh = taylor<Integers, internal::cosh_coeff, deg>;
3745
3750 template<typename Integers, size_t deg>
3751 using cos = taylor<Integers, internal::cos_coeff, deg>;
3752
3757 template<typename Integers, size_t deg>
3758 using geometric_sum = taylor<Integers, internal::geom_coeff, deg>;
3759
3764 template<typename Integers, size_t deg>
3765 using asin = taylor<Integers, internal::asin_coeff, deg>;
3766
3771 template<typename Integers, size_t deg>
3772 using asinh = taylor<Integers, internal::asinh_coeff, deg>;
3773
3778 template<typename Integers, size_t deg>
3779 using atanh = taylor<Integers, internal::atanh_coeff, deg>;
3780
3785 template<typename Integers, size_t deg>
3786 using tan = taylor<Integers, internal::tan_coeff, deg>;
3787
3792 template<typename Integers, size_t deg>
3793 using tanh = taylor<Integers, internal::tanh_coeff, deg>;
3794} // namespace aerobus
3795
3796// continued fractions
3797namespace aerobus {
3800 template<int64_t... values>
3801 struct ContinuedFraction {};
3802
3805 template<int64_t a0>
3806 struct ContinuedFraction<a0> {
3808 using type = typename q64::template inject_constant_t<a0>;
3810 static constexpr double val = static_cast<double>(a0);
3811 };
3812
3816 template<int64_t a0, int64_t... rest>
3817 struct ContinuedFraction<a0, rest...> {
3819 using type = q64::template add_t<
3820 typename q64::template inject_constant_t<a0>,
3821 typename q64::template div_t<
3822 typename q64::one,
3823 typename ContinuedFraction<rest...>::type
3824 >>;
3825
3827 static constexpr double val = type::template get<double>();
3828 };
3829
3833 using PI_fraction = ContinuedFraction<3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 2, 1, 1, 2, 2, 2, 2, 1>;
3835 using E_fraction = ContinuedFraction<2, 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, 1, 1, 10, 1, 1, 12, 1, 1, 14, 1, 1>;
3837 using SQRT2_fraction = ContinuedFraction<1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2>;
3839 using SQRT3_fraction = ContinuedFraction<1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2>; // NOLINT
3840} // namespace aerobus
3841
3842// known polynomials
3843namespace aerobus {
3844 // CChebyshev
3845 namespace internal {
3846 template<int kind, size_t deg, typename I>
3847 struct chebyshev_helper {
3848 using type = typename polynomial<I>::template sub_t<
3849 typename polynomial<I>::template mul_t<
3850 typename polynomial<I>::template mul_t<
3851 typename polynomial<I>::template inject_constant_t<2>,
3852 typename polynomial<I>::X>,
3853 typename chebyshev_helper<kind, deg - 1, I>::type
3854 >,
3855 typename chebyshev_helper<kind, deg - 2, I>::type
3856 >;
3857 };
3858
3859 template<typename I>
3860 struct chebyshev_helper<1, 0, I> {
3861 using type = typename polynomial<I>::one;
3862 };
3863
3864 template<typename I>
3865 struct chebyshev_helper<1, 1, I> {
3866 using type = typename polynomial<I>::X;
3867 };
3868
3869 template<typename I>
3870 struct chebyshev_helper<2, 0, I> {
3871 using type = typename polynomial<I>::one;
3872 };
3873
3874 template<typename I>
3875 struct chebyshev_helper<2, 1, I> {
3876 using type = typename polynomial<I>::template mul_t<
3877 typename polynomial<I>::template inject_constant_t<2>,
3878 typename polynomial<I>::X>;
3879 };
3880 } // namespace internal
3881
3882 // Laguerre
3883 namespace internal {
3884 template<size_t deg, typename I>
3885 struct laguerre_helper {
3886 using Q = FractionField<I>;
3887 using PQ = polynomial<Q>;
3888
3889 private:
3890 // Lk = (1 / k) * ((2 * k - 1 - x) * lkm1 - (k - 2)Lkm2)
3891 using lnm2 = typename laguerre_helper<deg - 2, I>::type;
3892 using lnm1 = typename laguerre_helper<deg - 1, I>::type;
3893 // -x + 2k-1
3894 using p = typename PQ::template val<
3895 typename Q::template inject_constant_t<-1>,
3896 typename Q::template inject_constant_t<2 * deg - 1>>;
3897 // 1/n
3898 using factor = typename PQ::template inject_ring_t<
3899 typename Q::template val<typename I::one, typename I::template inject_constant_t<deg>>>;
3900
3901 public:
3902 using type = typename PQ::template mul_t <
3903 factor,
3904 typename PQ::template sub_t<
3905 typename PQ::template mul_t<
3906 p,
3907 lnm1
3908 >,
3909 typename PQ::template mul_t<
3910 typename PQ::template inject_constant_t<deg-1>,
3911 lnm2
3912 >
3913 >
3914 >;
3915 };
3916
3917 template<typename I>
3918 struct laguerre_helper<0, I> {
3919 using type = typename polynomial<FractionField<I>>::one;
3920 };
3921
3922 template<typename I>
3923 struct laguerre_helper<1, I> {
3924 private:
3925 using PQ = polynomial<FractionField<I>>;
3926 public:
3927 using type = typename PQ::template sub_t<typename PQ::one, typename PQ::X>;
3928 };
3929 } // namespace internal
3930
3931 // Bernstein
3932 namespace internal {
3933 template<size_t i, size_t m, typename I, typename E = void>
3934 struct bernstein_helper {};
3935
3936 template<typename I>
3937 struct bernstein_helper<0, 0, I> {
3938 using type = typename polynomial<I>::one;
3939 };
3940
3941 template<size_t i, size_t m, typename I>
3942 struct bernstein_helper<i, m, I, std::enable_if_t<
3943 (m > 0) && (i == 0)>> {
3944 private:
3945 using P = polynomial<I>;
3946 public:
3947 using type = typename P::template mul_t<
3948 typename P::template sub_t<typename P::one, typename P::X>,
3949 typename bernstein_helper<i, m-1, I>::type>;
3950 };
3951
3952 template<size_t i, size_t m, typename I>
3953 struct bernstein_helper<i, m, I, std::enable_if_t<
3954 (m > 0) && (i == m)>> {
3955 private:
3956 using P = polynomial<I>;
3957 public:
3958 using type = typename P::template mul_t<
3959 typename P::X,
3960 typename bernstein_helper<i-1, m-1, I>::type>;
3961 };
3962
3963 template<size_t i, size_t m, typename I>
3964 struct bernstein_helper<i, m, I, std::enable_if_t<
3965 (m > 0) && (i > 0) && (i < m)>> {
3966 private:
3967 using P = polynomial<I>;
3968 public:
3969 using type = typename P::template add_t<
3970 typename P::template mul_t<
3971 typename P::template sub_t<typename P::one, typename P::X>,
3972 typename bernstein_helper<i, m-1, I>::type>,
3973 typename P::template mul_t<
3974 typename P::X,
3975 typename bernstein_helper<i-1, m-1, I>::type>>;
3976 };
3977 } // namespace internal
3978
3979 // AllOne polynomials
3980 namespace internal {
3981 template<size_t deg, typename I>
3982 struct AllOneHelper {
3983 using type = aerobus::add_t<
3984 typename polynomial<I>::one,
3985 typename aerobus::mul_t<
3986 typename polynomial<I>::X,
3987 typename AllOneHelper<deg-1, I>::type
3988 >>;
3989 };
3990
3991 template<typename I>
3992 struct AllOneHelper<0, I> {
3993 using type = typename polynomial<I>::one;
3994 };
3995 } // namespace internal
3996
3997 // Bessel polynomials
3998 namespace internal {
3999 template<size_t deg, typename I>
4000 struct BesselHelper {
4001 private:
4002 using P = polynomial<I>;
4003 using factor = typename P::template monomial_t<
4004 typename I::template inject_constant_t<(2*deg - 1)>,
4005 1>;
4006 public:
4007 using type = typename P::template add_t<
4008 typename P::template mul_t<
4009 factor,
4010 typename BesselHelper<deg-1, I>::type
4011 >,
4012 typename BesselHelper<deg-2, I>::type
4013 >;
4014 };
4015
4016 template<typename I>
4017 struct BesselHelper<0, I> {
4018 using type = typename polynomial<I>::one;
4019 };
4020
4021 template<typename I>
4022 struct BesselHelper<1, I> {
4023 private:
4024 using P = polynomial<I>;
4025 public:
4026 using type = typename P::template add_t<
4027 typename P::one,
4028 typename P::X
4029 >;
4030 };
4031 } // namespace internal
4032
4033 namespace known_polynomials {
4041 }
4042
4043 // hermite
4044 namespace internal {
4045 template<size_t deg, known_polynomials::hermite_kind kind, typename I>
4046 struct hermite_helper {};
4047
4048 template<size_t deg, typename I>
4049 struct hermite_helper<deg, known_polynomials::hermite_kind::probabilist, I> {
4050 private:
4051 using hnm1 = typename hermite_helper<deg - 1, known_polynomials::hermite_kind::probabilist, I>::type;
4052 using hnm2 = typename hermite_helper<deg - 2, known_polynomials::hermite_kind::probabilist, I>::type;
4053
4054 public:
4055 using type = typename polynomial<I>::template sub_t<
4056 typename polynomial<I>::template mul_t<typename polynomial<I>::X, hnm1>,
4057 typename polynomial<I>::template mul_t<
4058 typename polynomial<I>::template inject_constant_t<deg - 1>,
4059 hnm2
4060 >
4061 >;
4062 };
4063
4064 template<size_t deg, typename I>
4065 struct hermite_helper<deg, known_polynomials::hermite_kind::physicist, I> {
4066 private:
4067 using hnm1 = typename hermite_helper<deg - 1, known_polynomials::hermite_kind::physicist, I>::type;
4068 using hnm2 = typename hermite_helper<deg - 2, known_polynomials::hermite_kind::physicist, I>::type;
4069
4070 public:
4071 using type = typename polynomial<I>::template sub_t<
4072 // 2X Hn-1
4073 typename polynomial<I>::template mul_t<
4074 typename pi64::val<typename I::template inject_constant_t<2>,
4075 typename I::zero>, hnm1>,
4076
4077 typename polynomial<I>::template mul_t<
4078 typename polynomial<I>::template inject_constant_t<2*(deg - 1)>,
4079 hnm2
4080 >
4081 >;
4082 };
4083
4084 template<typename I>
4085 struct hermite_helper<0, known_polynomials::hermite_kind::probabilist, I> {
4086 using type = typename polynomial<I>::one;
4087 };
4088
4089 template<typename I>
4090 struct hermite_helper<1, known_polynomials::hermite_kind::probabilist, I> {
4091 using type = typename polynomial<I>::X;
4092 };
4093
4094 template<typename I>
4095 struct hermite_helper<0, known_polynomials::hermite_kind::physicist, I> {
4096 using type = typename pi64::one;
4097 };
4098
4099 template<typename I>
4100 struct hermite_helper<1, known_polynomials::hermite_kind::physicist, I> {
4101 // 2X
4102 using type = typename polynomial<I>::template val<
4103 typename I::template inject_constant_t<2>,
4104 typename I::zero>;
4105 };
4106 } // namespace internal
4107
4108 // legendre
4109 namespace internal {
4110 template<size_t n, typename I>
4111 struct legendre_helper {
4112 private:
4113 using Q = FractionField<I>;
4114 using PQ = polynomial<Q>;
4115 // 1/n constant
4116 // (2n-1)/n X
4117 using fact_left = typename PQ::template monomial_t<
4118 makefraction_t<I,
4119 typename I::template inject_constant_t<2*n-1>,
4120 typename I::template inject_constant_t<n>
4121 >,
4122 1>;
4123 // (n-1) / n
4124 using fact_right = typename PQ::template val<
4125 makefraction_t<I,
4126 typename I::template inject_constant_t<n-1>,
4127 typename I::template inject_constant_t<n>>>;
4128
4129 public:
4130 using type = PQ::template sub_t<
4131 typename PQ::template mul_t<
4132 fact_left,
4133 typename legendre_helper<n-1, I>::type
4134 >,
4135 typename PQ::template mul_t<
4136 fact_right,
4137 typename legendre_helper<n-2, I>::type
4138 >
4139 >;
4140 };
4141
4142 template<typename I>
4143 struct legendre_helper<0, I> {
4144 using type = typename polynomial<FractionField<I>>::one;
4145 };
4146
4147 template<typename I>
4148 struct legendre_helper<1, I> {
4149 using type = typename polynomial<FractionField<I>>::X;
4150 };
4151 } // namespace internal
4152
4153 // bernoulli polynomials
4154 namespace internal {
4155 template<size_t n>
4156 struct bernoulli_coeff {
4157 template<typename T, size_t i>
4158 struct inner {
4159 private:
4160 using F = FractionField<T>;
4161 public:
4162 using type = typename F::template mul_t<
4163 typename F::template inject_ring_t<combination_t<T, i, n>>,
4164 bernoulli_t<T, n-i>
4165 >;
4166 };
4167 };
4168 } // namespace internal
4169
4170 namespace internal {
4171 template<size_t n>
4172 struct touchard_coeff {
4173 template<typename T, size_t i>
4174 struct inner {
4175 using type = stirling_2_t<T, n, i>;
4176 };
4177 };
4178 } // namespace internal
4179
4180 namespace internal {
4181 template<typename I = aerobus::i64>
4182 struct AbelHelper {
4183 private:
4184 using P = aerobus::polynomial<I>;
4185
4186 public:
4187 // to keep recursion working, we need to operate on a*n and not just a
4188 template<size_t deg, I::inner_type an>
4189 struct Inner {
4190 // abel(n, a) = (x-an) * abel(n-1, a)
4191 using type = typename aerobus::mul_t<
4192 typename Inner<deg-1, an>::type,
4193 typename aerobus::sub_t<typename P::X, typename P::template inject_constant_t<an>>
4194 >;
4195 };
4196
4197 // abel(0, a) = 1
4198 template<I::inner_type an>
4199 struct Inner<0, an> {
4200 using type = P::one;
4201 };
4202
4203 // abel(1, a) = X
4204 template<I::inner_type an>
4205 struct Inner<1, an> {
4206 using type = P::X;
4207 };
4208 };
4209 } // namespace internal
4210
4212 namespace known_polynomials {
4213
4222 template<size_t n, auto a, typename I = aerobus::i64>
4223 using abel = typename internal::AbelHelper<I>::template Inner<n, a*n>::type;
4224
4232 template <size_t deg, typename I = aerobus::i64>
4233 using chebyshev_T = typename internal::chebyshev_helper<1, deg, I>::type;
4234
4244 template <size_t deg, typename I = aerobus::i64>
4245 using chebyshev_U = typename internal::chebyshev_helper<2, deg, I>::type;
4246
4256 template <size_t deg, typename I = aerobus::i64>
4257 using laguerre = typename internal::laguerre_helper<deg, I>::type;
4258
4265 template <size_t deg, typename I = aerobus::i64>
4266 using hermite_prob = typename internal::hermite_helper<deg, hermite_kind::probabilist, I>::type;
4267
4274 template <size_t deg, typename I = aerobus::i64>
4275 using hermite_phys = typename internal::hermite_helper<deg, hermite_kind::physicist, I>::type;
4276
4287 template<size_t i, size_t m, typename I = aerobus::i64>
4288 using bernstein = typename internal::bernstein_helper<i, m, I>::type;
4289
4299 template<size_t deg, typename I = aerobus::i64>
4300 using legendre = typename internal::legendre_helper<deg, I>::type;
4301
4311 template<size_t deg, typename I = aerobus::i64>
4312 using bernoulli = taylor<I, internal::bernoulli_coeff<deg>::template inner, deg>;
4313
4320 template<size_t deg, typename I = aerobus::i64>
4321 using allone = typename internal::AllOneHelper<deg, I>::type;
4322
4330 template<size_t deg, typename I = aerobus::i64>
4331 using bessel = typename internal::BesselHelper<deg, I>::type;
4332
4340 template<size_t deg, typename I = aerobus::i64>
4341 using touchard = taylor<I, internal::touchard_coeff<deg>::template inner, deg>;
4342 } // namespace known_polynomials
4343} // namespace aerobus
4344
4345// libm
4346namespace aerobus {
4347 namespace libm {
4348 namespace internal {
4349 // template<typename T>
4350 // struct exp2_poly;
4351
4352 // template<>
4353 // struct exp2_poly<double> {
4354 // using type = aerobus::polynomial<aerobus::q64>::template val<
4355 // aerobus::make_q64_t<388, 10641171255427>,
4356 // aerobus::make_q64_t<2296, 5579977897299>,
4357 // aerobus::make_q64_t<4963, 697799188641>,
4358 // aerobus::make_q64_t<15551, 152884735543>,
4359 // aerobus::make_q64_t<21273, 16096444733>,
4360 // aerobus::make_q64_t<683500, 44811710339>,
4361 // aerobus::make_q64_t<44397656049575, 288230376151711744>,
4362 // aerobus::make_q64_t<192156823709857, 144115188075855872>,
4363 // aerobus::make_q64_t<693059242663871, 72057594037927936>,
4364 // aerobus::make_q64_t<1999746264802375, 36028797018963968>,
4365 // aerobus::make_q64_t<4327536028902111, 18014398509481984>,
4366 // aerobus::make_q64_t<6243314768165359, 9007199254740992>,
4367 // aerobus::q64::one>;
4368 // };
4369
4370 // template<>
4371 // struct exp2_poly<float> {
4372 // using type = aerobus::polynomial<aerobus::q32>::template val<
4373 // aerobus::make_q32_t<8, 375115>,
4374 // aerobus::make_q32_t<30, 208117>,
4375 // aerobus::make_q32_t<109, 81261>,
4376 // aerobus::make_q32_t<5161841, 536870912>,
4377 // aerobus::make_q32_t<3724869, 67108864>,
4378 // aerobus::make_q32_t<16121323, 67108864>,
4379 // aerobus::make_q32_t<1453635, 2097152>,
4380 // aerobus::q32::one>;
4381 // };
4382
4383 // #ifdef WITH_CUDA_FP16
4384 // template<>
4385 // struct exp2_poly<__half> {
4386 // using type = aerobus::polynomial<aerobus::q16>::template val<
4387 // aerobus::make_q16_t<3, 212>,
4388 // aerobus::make_q16_t<13, 256>,
4389 // aerobus::make_q16_t<31, 128>,
4390 // aerobus::make_q16_t<1419, 2048>,
4391 // aerobus::q16::one>;
4392 // };
4393
4394 // template<>
4395 // struct exp2_poly<__half2> {
4396 // using type = aerobus::polynomial<aerobus::q16>::template val<
4397 // aerobus::make_q16_t<3, 212>,
4398 // aerobus::make_q16_t<13, 256>,
4399 // aerobus::make_q16_t<31, 128>,
4400 // aerobus::make_q16_t<1419, 2048>,
4401 // aerobus::q16::one>;
4402 // };
4403 // #endif
4404
4405 template<typename P>
4406 struct sin_poly;
4407
4408 template<>
4409 struct sin_poly<double> {
4410 // approximates sin(x)/x over [-pi/4, pi/4] with precision 9.318608669702093e-20
4411 using type = typename aerobus::polynomial<aerobus::q64>::simplify_t<
4412 typename aerobus::polynomial<aerobus::q64>:: template val<
4413 aerobus::make_q64_t<-43, 1042171195712159>,
4414 aerobus::make_q64_t<-89, 136637767615782>,
4415 aerobus::make_q64_t<123, 766493207966>,
4416 aerobus::make_q64_t<-18133, 723813242548>,
4417 aerobus::make_q64_t<122341, 44395102410>,
4418 aerobus::make_q64_t<-11252871, 56714469841>,
4419 aerobus::make_q64_t<2401919801264179, 288230376151711744>,
4420 aerobus::make_q64_t<-6004799503160661, 36028797018963968>,
4421 aerobus::q64::one>>;
4422 };
4423
4424 template<>
4425 struct sin_poly<float> {
4426 // approximates sin(x)/x over [-pi/4, pi/4] with precision 2.2889598e-11
4427 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4428 using type = typename aerobus::polynomial<aerobus::q32>::simplify_t<
4429 typename aerobus::polynomial<aerobus::q32>:: template val<
4430 aerobus::make_q32_t<14858575, 1073741824>,
4431 aerobus::q32::zero,
4432 aerobus::make_q32_t<-14207751, 268435456>,
4433 aerobus::q32::zero,
4434 aerobus::make_q32_t<11935291, 134217728>,
4435 aerobus::q32::zero,
4436 aerobus::make_q32_t<-11575033, 134217728>,
4437 aerobus::q32::zero,
4438 aerobus::make_q32_t<1790113, 33554432>,
4439 aerobus::q32::zero,
4440 aerobus::make_q32_t<-5893293, 268435456>,
4441 aerobus::q32::zero,
4442 aerobus::make_q32_t<3264339, 536870912>,
4443 aerobus::q32::zero,
4444 aerobus::make_q32_t<-40, 35687>,
4445 aerobus::q32::zero,
4446 aerobus::make_q32_t<50, 368859>,
4447 aerobus::q32::zero,
4448 aerobus::make_q32_t<-63, 303103>,
4449 aerobus::q32::zero,
4450 aerobus::make_q32_t<4474113, 536870912>,
4451 aerobus::q32::zero,
4452 aerobus::make_q32_t<-11184811, 67108864>,
4453 aerobus::q32::zero,
4454 aerobus::q32::one>>;
4455 };
4456
4457 #ifdef WITH_CUDA_FP16
4458 template<>
4459 struct sin_poly<__half> {
4460 // approximates sin(x)/x over [-pi/4, pi/4] with precision 6.389e-6
4461 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4462 using type = typename aerobus::polynomial<aerobus::q16>::simplify_t<
4463 typename aerobus::polynomial<aerobus::q16>:: template val<
4464 aerobus::make_q16_t<1, 123>,
4465 aerobus::make_q16_t<-1365, 8192>,
4466 aerobus::q16::one>>;
4467 };
4468
4469 template<>
4470 struct sin_poly<__half2> {
4471 // approximates sin(x)/x over [-pi/4, pi/4] with precision 6.389e-6
4472 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4473 using type = typename aerobus::polynomial<aerobus::q16>::simplify_t<
4474 typename aerobus::polynomial<aerobus::q16>:: template val<
4475 aerobus::make_q16_t<1, 123>,
4476 aerobus::make_q16_t<-1365, 8192>,
4477 aerobus::q16::one>>;
4478 };
4479 #endif
4480
4481 template<typename T>
4482 struct cos_poly;
4483
4484 template <>
4485 struct cos_poly<double> {
4486 // approximates (cos(x) - 1)/x^2
4487 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4488 using type = typename aerobus::polynomial<aerobus::q64>::simplify_t<
4489 typename aerobus::polynomial<aerobus::q64>:: template val<
4490 aerobus::make_q64_t<19, 422768485870472>,
4491 aerobus::make_q64_t<-79, 6890654285274>,
4492 aerobus::make_q64_t<2261, 1083025291545>,
4493 aerobus::make_q64_t<-14921, 54145325246>,
4494 aerobus::make_q64_t<1177848, 47490831361>,
4495 aerobus::make_q64_t<-1601279867509443, 1152921504606846976>,
4496 aerobus::make_q64_t<6004799503160661, 144115188075855872>,
4497 aerobus::make_q64_t<-1, 2>>>;
4498 };
4499
4500 template <>
4501 struct cos_poly<float> {
4502 // approximates (cos(x) - 1)/x^4
4503 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4504 using type = typename aerobus::polynomial<aerobus::q32>::simplify_t<
4505 typename aerobus::polynomial<aerobus::q32>:: template val<
4506 aerobus::make_q32_t<1, 12936953>,
4507 aerobus::make_q32_t<-1, 2521425>,
4508 aerobus::make_q32_t<22, 884589>,
4509 aerobus::make_q32_t<-119, 85679>,
4510 aerobus::make_q32_t<11184811, 268435456>,
4511 aerobus::make_q32_t<-1, 2>>>;
4512 };
4513
4514#ifdef WITH_CUDA_FP16
4515 template<>
4516 struct cos_poly<__half> {
4517 // approximates (cos(x) - 1)/x^2
4518 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4519 using type = typename aerobus::polynomial<aerobus::q16>::simplify_t<
4520 typename aerobus::polynomial<aerobus::q16>:: template val<
4521 aerobus::make_q16_t<-1, 1589>,
4522 aerobus::make_q16_t<1, 992>,
4523 aerobus::make_q16_t<-1, 1821>,
4524 aerobus::make_q16_t<-1, 795>,
4525 aerobus::make_q16_t<1, 24>,
4526 aerobus::make_q16_t<-1, 2>>>;
4527 };
4528
4529 template<>
4530 struct cos_poly<__half2> {
4531 // approximates (cos(x) - 1)/x^2
4532 // must be evaluated in x*x as we removed half the coefficients to have a dense polynomial
4533 using type = typename aerobus::polynomial<aerobus::q16>::simplify_t<
4534 typename aerobus::polynomial<aerobus::q16>:: template val<
4535 aerobus::make_q16_t<-1, 1589>,
4536 aerobus::make_q16_t<1, 992>,
4537 aerobus::make_q16_t<-1, 1821>,
4538 aerobus::make_q16_t<-1, 795>,
4539 aerobus::make_q16_t<1, 24>,
4540 aerobus::make_q16_t<-1, 2>>>;
4541 };
4542 #endif
4543 } // namespace internal
4544
4545 // template<typename T>
4546 // static T exp2(const T&x) {
4547 // using poly = internal::exp2_poly<T>::type;
4548 // if (x >= (aerobus::arithmetic_helpers<T>::zero) &&
4549 // x < (aerobus::arithmetic_helpers<T>::one)) {
4550 // return poly::eval(x);
4551 // } else {
4552 // // TODO(JeWaVe): handle denormals
4553 // auto i = static_cast<typename aerobus::arithmetic_helpers<T>::integers>(
4554 // aerobus::meta_libm<T>::floor(x));
4555 // T eps = x - i;
4556 // T mantissa = poly::eval(eps);
4557 // uint64_t* p = reinterpret_cast<uint64_t*>(&mantissa);
4558 // uint64_t exponent = (*p >> 52) & 0x7FF;
4559 // exponent += i;
4560 // *p &= ~(0x7FFULL << 52);
4561 // *p |= (exponent & 0x7FF) << 52;
4562 // return mantissa;
4563 // }
4564 // }
4565
4566 template<typename T>
4567 static DEVICE T cos(const T& x);
4568
4569 template<typename T>
4570 static DEVICE T fast_cos(const T& x);
4571
4572 // works only in [-pi/4, pi/4]
4573 // purpose is to allow vectorization
4574 template<typename T>
4575 static DEVICE INLINED T fast_sin(const T& x) {
4576 #if !defined(__CUDACC__) && !defined(__HIPCC__)
4577 // how to do that in CUDA/HIP??
4578 // auto rounding = std::fegetround();
4579 // std::fesetround(FE_TOWARDZERO);
4580 #endif
4581 using poly = internal::sin_poly<T>::type;
4582 auto result = x * poly::eval(x);
4583 #if !defined(__CUDACC__) && !defined(__HIPCC__)
4584 // std::fesetround(rounding);
4585 #endif
4586 return result;
4587 }
4588
4589 template<typename T>
4590 struct sin_reduction {
4591 using upper_type = aerobus::arithmetic_helpers<T>::upper_type;
4592 using u_constants = aerobus::arithmetic_helpers<upper_type>;
4593 using constants = aerobus::arithmetic_helpers<T>;
4594
4595 struct behavior {
4596 bool negate = false;
4597 bool return_x = false;
4598 bool return_fast_sin = false;
4599 bool return_fast_cos = false;
4600 upper_type transform = u_constants::zero();
4601 };
4602
4603 static constexpr upper_type pi = u_constants::pi();
4604 static constexpr upper_type two_pi = u_constants::two_pi();
4605 static constexpr upper_type pi_2 = u_constants::pi_2();
4606 static constexpr upper_type pi_4 = u_constants::pi_4();
4607
4608 static DEVICE behavior eval(upper_type u_x, T x) {
4609 const T eps = std::numeric_limits<T>::epsilon();
4610 behavior result {};
4611 while (true) {
4612 // std::cout << std::hexfloat << "entering reduction with " << u_x << " - " << x << std::endl;
4613 if (x <= eps && x >= -eps) {
4614 result.return_x = true;
4615 result.transform = u_x;
4616 return result;
4617 } else if (x < -eps) {
4618 u_x = -u_x;
4619 x = -x;
4620 result.negate = !result.negate;
4621 continue;
4622 } else if (u_x < pi_4) {
4623 result.return_fast_sin = true;
4624 result.transform = u_x;
4625 // std::cout << "returning from reduction with " << u_x << " and return_fast_sin" << std::endl;
4626 return result;
4627 } else if (u_x < pi_2) {
4628 result.return_fast_cos = true;
4629 result.transform = pi_2 - u_x;
4630 // std::cout << "returning from reduction with " << u_x << " and return_fast_cos" << std::endl;
4631 return result;
4632 } else if (x < constants::pi() - eps) {
4633 u_x = pi - u_x;
4634 x = static_cast<T>(u_x);
4635 continue;
4636 } else if (x < constants::pi() + eps) {
4637 result.negate = true;
4638 result.return_x = true;
4639 result.transform = u_x - pi;
4640 return result;
4641 } else if (u_x < two_pi) {
4642 u_x = two_pi - u_x;
4643 x = static_cast<T>(u_x);
4644 result.negate = !result.negate;
4645 continue;
4646 } else {
4647 u_x = aerobus::meta_libm<upper_type>::fmod(u_x, u_constants::two_pi());
4648 x = static_cast<T>(u_x);
4649 continue;
4650 }
4651 }
4652 }
4653 };
4654
4655 template<typename T>
4656 static DEVICE T sin(const T& x) {
4657 if (x != x) { // NaN
4658 return x;
4659 } else if (aerobus::arithmetic_helpers<T>::is_inf(x)) {
4660 return NAN;
4661 }
4662 // TODO(JeWaVe) : final rounding -- see https://k0d.cc/storage/books/Algorithms/Elementary%20Functions.pdf
4663 using upper_type = aerobus::arithmetic_helpers<T>::upper_type;
4664 upper_type X = aerobus::internal::staticcast<upper_type, T>::eval(x);
4665 auto behavior = sin_reduction<T>::eval(X, x);
4666 if (behavior.return_x) {
4667 T result = static_cast<T>(behavior.transform);
4668 return behavior.negate ? -result : result;
4669 } else if (behavior.return_fast_cos) {
4670 T result = aerobus::libm::fast_cos(static_cast<T>(behavior.transform));
4671 return behavior.negate ? -result : result;
4672 } else if (behavior.return_fast_sin) {
4673 T result = aerobus::libm::fast_sin(static_cast<T>(behavior.transform));
4674 return behavior.negate ? -result : result;
4675 } else {
4676 return NAN;
4677 }
4678 } // NOLINT
4679
4680 template<typename T>
4681 static DEVICE T fast_cos(const T& x) {
4682 using poly = internal::cos_poly<T>::type;
4683 using constants = aerobus::arithmetic_helpers<T>;
4684 T one = constants::one();
4685 T x2 = x*x;
4686 return aerobus::internal::fma_helper<T>::eval(x2, poly::eval(x2), one);
4687 }
4688
4689 // TODO(JeWaVe) : range reduction in upper_type
4690 template<typename T>
4691 static DEVICE T cos(const T& x) {
4692 using upper_type = aerobus::arithmetic_helpers<T>::upper_type;
4693 using u_constants = aerobus::arithmetic_helpers<upper_type>;
4694 upper_type pi_4 = u_constants::pi_4();
4695 upper_type pi = u_constants::pi();
4696 upper_type two_pi = u_constants::two_pi();
4697 upper_type pi_2 = u_constants::pi_2();
4698 upper_type X = aerobus::internal::staticcast<upper_type, T>::eval(x);
4699 // domain reduction
4700 if (x != x) { // NaN
4701 return x;
4702 } else if (aerobus::arithmetic_helpers<T>::is_inf(x)) {
4703 return NAN;
4704 } else if (x <= std::numeric_limits<T>::epsilon() && x >= -std::numeric_limits<T>::epsilon()) {
4705 return aerobus::arithmetic_helpers<T>::one();
4706 } else if (x < -std::numeric_limits<T>::epsilon()) {
4707 return aerobus::libm::cos(static_cast<T>(-X));
4708 } else if (X <= pi_4) {
4709 return aerobus::libm::fast_cos(x);
4710 } else if (X <= pi_2) {
4711 return aerobus::libm::sin(static_cast<T>(pi_2 - X));
4712 } else if (X <= pi) {
4713 return -aerobus::libm::cos(static_cast<T>(X - pi));
4714 } else if (X <= two_pi) {
4715 return -aerobus::libm::cos(static_cast<T>(pi - X));
4716 } else {
4717 T i = static_cast<T>(aerobus::meta_libm<upper_type>::fmod(X, two_pi));
4718 return aerobus::libm::cos(i);
4719 }
4720 }
4721 } // namespace libm
4722} // namespace aerobus
4723
4724#ifdef AEROBUS_CONWAY_IMPORTS
4725
4726// conway polynomials
4727namespace aerobus {
4731 template<int p, int n>
4732 struct ConwayPolynomial {};
4733
4734#ifndef DO_NOT_DOCUMENT
4735 #define ZPZV ZPZ::template val
4736 #define POLYV aerobus::polynomial<ZPZ>::template val
4737 template<> struct ConwayPolynomial<2, 1> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<1>>; }; // NOLINT
4738 template<> struct ConwayPolynomial<2, 2> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4739 template<> struct ConwayPolynomial<2, 3> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4740 template<> struct ConwayPolynomial<2, 4> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4741 template<> struct ConwayPolynomial<2, 5> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4742 template<> struct ConwayPolynomial<2, 6> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4743 template<> struct ConwayPolynomial<2, 7> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4744 template<> struct ConwayPolynomial<2, 8> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4745 template<> struct ConwayPolynomial<2, 9> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4746 template<> struct ConwayPolynomial<2, 10> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4747 template<> struct ConwayPolynomial<2, 11> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4748 template<> struct ConwayPolynomial<2, 12> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4749 template<> struct ConwayPolynomial<2, 13> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4750 template<> struct ConwayPolynomial<2, 14> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4751 template<> struct ConwayPolynomial<2, 15> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4752 template<> struct ConwayPolynomial<2, 16> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4753 template<> struct ConwayPolynomial<2, 17> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4754 template<> struct ConwayPolynomial<2, 18> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4755 template<> struct ConwayPolynomial<2, 19> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4756 template<> struct ConwayPolynomial<2, 20> { using ZPZ = aerobus::zpz<2>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4757 template<> struct ConwayPolynomial<3, 1> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<1>>; }; // NOLINT
4758 template<> struct ConwayPolynomial<3, 2> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<2>, ZPZV<2>>; }; // NOLINT
4759 template<> struct ConwayPolynomial<3, 3> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<1>>; }; // NOLINT
4760 template<> struct ConwayPolynomial<3, 4> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<2>, ZPZV<0>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
4761 template<> struct ConwayPolynomial<3, 5> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<1>>; }; // NOLINT
4762 template<> struct ConwayPolynomial<3, 6> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<1>, ZPZV<2>, ZPZV<2>>; }; // NOLINT
4763 template<> struct ConwayPolynomial<3, 7> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4764 template<> struct ConwayPolynomial<3, 8> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<2>>; }; // NOLINT
4765 template<> struct ConwayPolynomial<3, 9> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4766 template<> struct ConwayPolynomial<3, 10> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<2>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4767 template<> struct ConwayPolynomial<3, 11> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4768 template<> struct ConwayPolynomial<3, 12> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
4769 template<> struct ConwayPolynomial<3, 13> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<1>>; }; // NOLINT
4770 template<> struct ConwayPolynomial<3, 14> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<1>, ZPZV<1>, ZPZV<2>, ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<1>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
4771 template<> struct ConwayPolynomial<3, 15> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<1>, ZPZV<1>>; }; // NOLINT
4772 template<> struct ConwayPolynomial<3, 16> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<2>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4773 template<> struct ConwayPolynomial<3, 17> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<1>>; }; // NOLINT
4774 template<> struct ConwayPolynomial<3, 18> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<2>, ZPZV<1>, ZPZV<2>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
4775 template<> struct ConwayPolynomial<3, 19> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<1>>; }; // NOLINT
4776 template<> struct ConwayPolynomial<3, 20> { using ZPZ = aerobus::zpz<3>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<2>, ZPZV<0>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4777 template<> struct ConwayPolynomial<5, 1> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<3>>; }; // NOLINT
4778 template<> struct ConwayPolynomial<5, 2> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
4779 template<> struct ConwayPolynomial<5, 3> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4780 template<> struct ConwayPolynomial<5, 4> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
4781 template<> struct ConwayPolynomial<5, 5> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<3>>; }; // NOLINT
4782 template<> struct ConwayPolynomial<5, 6> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<4>, ZPZV<1>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
4783 template<> struct ConwayPolynomial<5, 7> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4784 template<> struct ConwayPolynomial<5, 8> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
4785 template<> struct ConwayPolynomial<5, 9> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<1>, ZPZV<3>>; }; // NOLINT
4786 template<> struct ConwayPolynomial<5, 10> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<3>, ZPZV<2>, ZPZV<4>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4787 template<> struct ConwayPolynomial<5, 11> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4788 template<> struct ConwayPolynomial<5, 12> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<4>, ZPZV<3>, ZPZV<2>, ZPZV<2>>; }; // NOLINT
4789 template<> struct ConwayPolynomial<5, 13> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4790 template<> struct ConwayPolynomial<5, 14> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<4>, ZPZV<2>, ZPZV<3>, ZPZV<0>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4791 template<> struct ConwayPolynomial<5, 15> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<3>, ZPZV<3>, ZPZV<4>, ZPZV<3>>; }; // NOLINT
4792 template<> struct ConwayPolynomial<5, 16> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<4>, ZPZV<4>, ZPZV<4>, ZPZV<2>, ZPZV<4>, ZPZV<4>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4793 template<> struct ConwayPolynomial<5, 17> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<2>, ZPZV<3>>; }; // NOLINT
4794 template<> struct ConwayPolynomial<5, 18> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<1>, ZPZV<2>, ZPZV<0>, ZPZV<2>, ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<2>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
4795 template<> struct ConwayPolynomial<5, 19> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<3>>; }; // NOLINT
4796 template<> struct ConwayPolynomial<5, 20> { using ZPZ = aerobus::zpz<5>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<0>, ZPZV<4>, ZPZV<3>, ZPZV<2>, ZPZV<0>, ZPZV<3>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<0>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4797 template<> struct ConwayPolynomial<7, 1> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<4>>; }; // NOLINT
4798 template<> struct ConwayPolynomial<7, 2> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<6>, ZPZV<3>>; }; // NOLINT
4799 template<> struct ConwayPolynomial<7, 3> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<6>, ZPZV<0>, ZPZV<4>>; }; // NOLINT
4800 template<> struct ConwayPolynomial<7, 4> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<4>, ZPZV<3>>; }; // NOLINT
4801 template<> struct ConwayPolynomial<7, 5> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<4>>; }; // NOLINT
4802 template<> struct ConwayPolynomial<7, 6> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<5>, ZPZV<4>, ZPZV<6>, ZPZV<3>>; }; // NOLINT
4803 template<> struct ConwayPolynomial<7, 7> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<4>>; }; // NOLINT
4804 template<> struct ConwayPolynomial<7, 8> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<6>, ZPZV<2>, ZPZV<3>>; }; // NOLINT
4805 template<> struct ConwayPolynomial<7, 9> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<4>>; }; // NOLINT
4806 template<> struct ConwayPolynomial<7, 10> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<4>, ZPZV<1>, ZPZV<2>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4807 template<> struct ConwayPolynomial<7, 11> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<4>>; }; // NOLINT
4808 template<> struct ConwayPolynomial<7, 12> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<5>, ZPZV<3>, ZPZV<2>, ZPZV<4>, ZPZV<0>, ZPZV<5>, ZPZV<0>, ZPZV<3>>; }; // NOLINT
4809 template<> struct ConwayPolynomial<7, 13> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<0>, ZPZV<4>>; }; // NOLINT
4810 template<> struct ConwayPolynomial<7, 14> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<0>, ZPZV<6>, ZPZV<2>, ZPZV<0>, ZPZV<3>, ZPZV<6>, ZPZV<3>>; }; // NOLINT
4811 template<> struct ConwayPolynomial<7, 15> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<6>, ZPZV<6>, ZPZV<4>, ZPZV<1>, ZPZV<2>, ZPZV<4>>; }; // NOLINT
4812 template<> struct ConwayPolynomial<7, 16> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<5>, ZPZV<3>, ZPZV<4>, ZPZV<1>, ZPZV<6>, ZPZV<2>, ZPZV<4>, ZPZV<3>>; }; // NOLINT
4813 template<> struct ConwayPolynomial<7, 17> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<4>>; }; // NOLINT
4814 template<> struct ConwayPolynomial<7, 18> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<2>, ZPZV<6>, ZPZV<1>, ZPZV<6>, ZPZV<5>, ZPZV<1>, ZPZV<3>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<2>, ZPZV<3>>; }; // NOLINT
4815 template<> struct ConwayPolynomial<7, 19> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<0>, ZPZV<4>>; }; // NOLINT
4816 template<> struct ConwayPolynomial<7, 20> { using ZPZ = aerobus::zpz<7>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<6>, ZPZV<2>, ZPZV<5>, ZPZV<2>, ZPZV<3>, ZPZV<1>, ZPZV<3>, ZPZV<0>, ZPZV<3>, ZPZV<0>, ZPZV<1>, ZPZV<3>>; }; // NOLINT
4817 template<> struct ConwayPolynomial<11, 1> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<9>>; }; // NOLINT
4818 template<> struct ConwayPolynomial<11, 2> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<7>, ZPZV<2>>; }; // NOLINT
4819 template<> struct ConwayPolynomial<11, 3> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<9>>; }; // NOLINT
4820 template<> struct ConwayPolynomial<11, 4> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
4821 template<> struct ConwayPolynomial<11, 5> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<0>, ZPZV<9>>; }; // NOLINT
4822 template<> struct ConwayPolynomial<11, 6> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<4>, ZPZV<6>, ZPZV<7>, ZPZV<2>>; }; // NOLINT
4823 template<> struct ConwayPolynomial<11, 7> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<9>>; }; // NOLINT
4824 template<> struct ConwayPolynomial<11, 8> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<7>, ZPZV<1>, ZPZV<7>, ZPZV<2>>; }; // NOLINT
4825 template<> struct ConwayPolynomial<11, 9> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<8>, ZPZV<9>>; }; // NOLINT
4826 template<> struct ConwayPolynomial<11, 10> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<8>, ZPZV<10>, ZPZV<6>, ZPZV<6>, ZPZV<2>>; }; // NOLINT
4827 template<> struct ConwayPolynomial<11, 11> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<9>>; }; // NOLINT
4828 template<> struct ConwayPolynomial<11, 12> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<4>, ZPZV<2>, ZPZV<5>, ZPZV<5>, ZPZV<6>, ZPZV<5>, ZPZV<2>>; }; // NOLINT
4829 template<> struct ConwayPolynomial<11, 13> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<9>>; }; // NOLINT
4830 template<> struct ConwayPolynomial<11, 14> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<9>, ZPZV<6>, ZPZV<4>, ZPZV<8>, ZPZV<6>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
4831 template<> struct ConwayPolynomial<11, 15> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<7>, ZPZV<0>, ZPZV<5>, ZPZV<0>, ZPZV<0>, ZPZV<9>>; }; // NOLINT
4832 template<> struct ConwayPolynomial<11, 16> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<10>, ZPZV<1>, ZPZV<3>, ZPZV<5>, ZPZV<3>, ZPZV<10>, ZPZV<9>, ZPZV<2>>; }; // NOLINT
4833 template<> struct ConwayPolynomial<11, 17> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<9>>; }; // NOLINT
4834 template<> struct ConwayPolynomial<11, 18> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<8>, ZPZV<10>, ZPZV<8>, ZPZV<3>, ZPZV<9>, ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<9>, ZPZV<8>, ZPZV<2>, ZPZV<2>>; }; // NOLINT
4835 template<> struct ConwayPolynomial<11, 19> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<2>, ZPZV<9>>; }; // NOLINT
4836 template<> struct ConwayPolynomial<11, 20> { using ZPZ = aerobus::zpz<11>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<10>, ZPZV<9>, ZPZV<1>, ZPZV<5>, ZPZV<7>, ZPZV<2>, ZPZV<4>, ZPZV<5>, ZPZV<5>, ZPZV<6>, ZPZV<5>, ZPZV<2>>; }; // NOLINT
4837 template<> struct ConwayPolynomial<13, 1> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<11>>; }; // NOLINT
4838 template<> struct ConwayPolynomial<13, 2> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<12>, ZPZV<2>>; }; // NOLINT
4839 template<> struct ConwayPolynomial<13, 3> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<11>>; }; // NOLINT
4840 template<> struct ConwayPolynomial<13, 4> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<12>, ZPZV<2>>; }; // NOLINT
4841 template<> struct ConwayPolynomial<13, 5> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<11>>; }; // NOLINT
4842 template<> struct ConwayPolynomial<13, 6> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<11>, ZPZV<11>, ZPZV<2>>; }; // NOLINT
4843 template<> struct ConwayPolynomial<13, 7> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<11>>; }; // NOLINT
4844 template<> struct ConwayPolynomial<13, 8> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<12>, ZPZV<2>, ZPZV<3>, ZPZV<2>>; }; // NOLINT
4845 template<> struct ConwayPolynomial<13, 9> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<8>, ZPZV<12>, ZPZV<12>, ZPZV<11>>; }; // NOLINT
4846 template<> struct ConwayPolynomial<13, 10> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<5>, ZPZV<8>, ZPZV<1>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4847 template<> struct ConwayPolynomial<13, 11> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<11>>; }; // NOLINT
4848 template<> struct ConwayPolynomial<13, 12> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<5>, ZPZV<8>, ZPZV<11>, ZPZV<3>, ZPZV<1>, ZPZV<1>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
4849 template<> struct ConwayPolynomial<13, 13> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<11>>; }; // NOLINT
4850 template<> struct ConwayPolynomial<13, 14> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<0>, ZPZV<6>, ZPZV<11>, ZPZV<7>, ZPZV<10>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
4851 template<> struct ConwayPolynomial<13, 15> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<12>, ZPZV<2>, ZPZV<11>, ZPZV<10>, ZPZV<11>, ZPZV<8>, ZPZV<11>>; }; // NOLINT
4852 template<> struct ConwayPolynomial<13, 16> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<12>, ZPZV<8>, ZPZV<2>, ZPZV<12>, ZPZV<9>, ZPZV<12>, ZPZV<6>, ZPZV<2>>; }; // NOLINT
4853 template<> struct ConwayPolynomial<13, 17> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<6>, ZPZV<11>>; }; // NOLINT
4854 template<> struct ConwayPolynomial<13, 18> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<4>, ZPZV<11>, ZPZV<11>, ZPZV<9>, ZPZV<5>, ZPZV<3>, ZPZV<5>, ZPZV<6>, ZPZV<0>, ZPZV<9>, ZPZV<2>>; }; // NOLINT
4855 template<> struct ConwayPolynomial<13, 19> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<11>>; }; // NOLINT
4856 template<> struct ConwayPolynomial<13, 20> { using ZPZ = aerobus::zpz<13>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<12>, ZPZV<9>, ZPZV<0>, ZPZV<7>, ZPZV<8>, ZPZV<7>, ZPZV<4>, ZPZV<0>, ZPZV<4>, ZPZV<8>, ZPZV<11>, ZPZV<2>>; }; // NOLINT
4857 template<> struct ConwayPolynomial<17, 1> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<14>>; }; // NOLINT
4858 template<> struct ConwayPolynomial<17, 2> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<16>, ZPZV<3>>; }; // NOLINT
4859 template<> struct ConwayPolynomial<17, 3> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<14>>; }; // NOLINT
4860 template<> struct ConwayPolynomial<17, 4> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<10>, ZPZV<3>>; }; // NOLINT
4861 template<> struct ConwayPolynomial<17, 5> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<14>>; }; // NOLINT
4862 template<> struct ConwayPolynomial<17, 6> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<10>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4863 template<> struct ConwayPolynomial<17, 7> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<14>>; }; // NOLINT
4864 template<> struct ConwayPolynomial<17, 8> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<12>, ZPZV<0>, ZPZV<6>, ZPZV<3>>; }; // NOLINT
4865 template<> struct ConwayPolynomial<17, 9> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<8>, ZPZV<14>>; }; // NOLINT
4866 template<> struct ConwayPolynomial<17, 10> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<6>, ZPZV<5>, ZPZV<9>, ZPZV<12>, ZPZV<3>>; }; // NOLINT
4867 template<> struct ConwayPolynomial<17, 11> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<14>>; }; // NOLINT
4868 template<> struct ConwayPolynomial<17, 12> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<4>, ZPZV<14>, ZPZV<14>, ZPZV<13>, ZPZV<6>, ZPZV<14>, ZPZV<9>, ZPZV<3>>; }; // NOLINT
4869 template<> struct ConwayPolynomial<17, 13> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<14>>; }; // NOLINT
4870 template<> struct ConwayPolynomial<17, 14> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<11>, ZPZV<1>, ZPZV<8>, ZPZV<16>, ZPZV<13>, ZPZV<9>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
4871 template<> struct ConwayPolynomial<17, 15> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<4>, ZPZV<16>, ZPZV<6>, ZPZV<14>, ZPZV<14>, ZPZV<14>>; }; // NOLINT
4872 template<> struct ConwayPolynomial<17, 16> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<13>, ZPZV<5>, ZPZV<2>, ZPZV<12>, ZPZV<13>, ZPZV<12>, ZPZV<1>, ZPZV<3>>; }; // NOLINT
4873 template<> struct ConwayPolynomial<17, 17> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<14>>; }; // NOLINT
4874 template<> struct ConwayPolynomial<17, 18> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<16>, ZPZV<7>, ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<11>, ZPZV<13>, ZPZV<13>, ZPZV<9>, ZPZV<3>>; }; // NOLINT
4875 template<> struct ConwayPolynomial<17, 19> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<14>>; }; // NOLINT
4876 template<> struct ConwayPolynomial<17, 20> { using ZPZ = aerobus::zpz<17>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<5>, ZPZV<16>, ZPZV<14>, ZPZV<13>, ZPZV<3>, ZPZV<14>, ZPZV<9>, ZPZV<1>, ZPZV<13>, ZPZV<2>, ZPZV<5>, ZPZV<3>>; }; // NOLINT
4877 template<> struct ConwayPolynomial<19, 1> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<17>>; }; // NOLINT
4878 template<> struct ConwayPolynomial<19, 2> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<18>, ZPZV<2>>; }; // NOLINT
4879 template<> struct ConwayPolynomial<19, 3> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<17>>; }; // NOLINT
4880 template<> struct ConwayPolynomial<19, 4> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<11>, ZPZV<2>>; }; // NOLINT
4881 template<> struct ConwayPolynomial<19, 5> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<17>>; }; // NOLINT
4882 template<> struct ConwayPolynomial<19, 6> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<17>, ZPZV<6>, ZPZV<2>>; }; // NOLINT
4883 template<> struct ConwayPolynomial<19, 7> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<17>>; }; // NOLINT
4884 template<> struct ConwayPolynomial<19, 8> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<12>, ZPZV<10>, ZPZV<3>, ZPZV<2>>; }; // NOLINT
4885 template<> struct ConwayPolynomial<19, 9> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<14>, ZPZV<16>, ZPZV<17>>; }; // NOLINT
4886 template<> struct ConwayPolynomial<19, 10> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<13>, ZPZV<17>, ZPZV<3>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
4887 template<> struct ConwayPolynomial<19, 11> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<17>>; }; // NOLINT
4888 template<> struct ConwayPolynomial<19, 12> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<2>, ZPZV<18>, ZPZV<2>, ZPZV<9>, ZPZV<16>, ZPZV<7>, ZPZV<2>>; }; // NOLINT
4889 template<> struct ConwayPolynomial<19, 13> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<17>>; }; // NOLINT
4890 template<> struct ConwayPolynomial<19, 14> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<11>, ZPZV<11>, ZPZV<1>, ZPZV<5>, ZPZV<16>, ZPZV<7>, ZPZV<2>>; }; // NOLINT
4891 template<> struct ConwayPolynomial<19, 15> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<10>, ZPZV<11>, ZPZV<13>, ZPZV<15>, ZPZV<14>, ZPZV<0>, ZPZV<17>>; }; // NOLINT
4892 template<> struct ConwayPolynomial<19, 16> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<13>, ZPZV<0>, ZPZV<15>, ZPZV<9>, ZPZV<6>, ZPZV<14>, ZPZV<2>>; }; // NOLINT
4893 template<> struct ConwayPolynomial<19, 17> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<17>>; }; // NOLINT
4894 template<> struct ConwayPolynomial<19, 18> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<9>, ZPZV<7>, ZPZV<17>, ZPZV<5>, ZPZV<0>, ZPZV<16>, ZPZV<5>, ZPZV<7>, ZPZV<3>, ZPZV<14>, ZPZV<2>>; }; // NOLINT
4895 template<> struct ConwayPolynomial<19, 19> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<17>>; }; // NOLINT
4896 template<> struct ConwayPolynomial<19, 20> { using ZPZ = aerobus::zpz<19>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<13>, ZPZV<0>, ZPZV<4>, ZPZV<7>, ZPZV<8>, ZPZV<6>, ZPZV<0>, ZPZV<3>, ZPZV<6>, ZPZV<11>, ZPZV<2>>; }; // NOLINT
4897 template<> struct ConwayPolynomial<23, 1> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<18>>; }; // NOLINT
4898 template<> struct ConwayPolynomial<23, 2> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<21>, ZPZV<5>>; }; // NOLINT
4899 template<> struct ConwayPolynomial<23, 3> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<18>>; }; // NOLINT
4900 template<> struct ConwayPolynomial<23, 4> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<19>, ZPZV<5>>; }; // NOLINT
4901 template<> struct ConwayPolynomial<23, 5> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<18>>; }; // NOLINT
4902 template<> struct ConwayPolynomial<23, 6> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<9>, ZPZV<9>, ZPZV<1>, ZPZV<5>>; }; // NOLINT
4903 template<> struct ConwayPolynomial<23, 7> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<21>, ZPZV<18>>; }; // NOLINT
4904 template<> struct ConwayPolynomial<23, 8> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<20>, ZPZV<5>, ZPZV<3>, ZPZV<5>>; }; // NOLINT
4905 template<> struct ConwayPolynomial<23, 9> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<8>, ZPZV<9>, ZPZV<18>>; }; // NOLINT
4906 template<> struct ConwayPolynomial<23, 10> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<5>, ZPZV<15>, ZPZV<6>, ZPZV<1>, ZPZV<5>>; }; // NOLINT
4907 template<> struct ConwayPolynomial<23, 11> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<7>, ZPZV<18>>; }; // NOLINT
4908 template<> struct ConwayPolynomial<23, 12> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<21>, ZPZV<21>, ZPZV<15>, ZPZV<14>, ZPZV<12>, ZPZV<18>, ZPZV<12>, ZPZV<5>>; }; // NOLINT
4909 template<> struct ConwayPolynomial<23, 13> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<18>>; }; // NOLINT
4910 template<> struct ConwayPolynomial<23, 14> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<5>, ZPZV<16>, ZPZV<1>, ZPZV<18>, ZPZV<19>, ZPZV<1>, ZPZV<22>, ZPZV<5>>; }; // NOLINT
4911 template<> struct ConwayPolynomial<23, 15> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<8>, ZPZV<15>, ZPZV<9>, ZPZV<7>, ZPZV<18>, ZPZV<18>>; }; // NOLINT
4912 template<> struct ConwayPolynomial<23, 16> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<19>, ZPZV<16>, ZPZV<13>, ZPZV<1>, ZPZV<14>, ZPZV<17>, ZPZV<5>>; }; // NOLINT
4913 template<> struct ConwayPolynomial<23, 17> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<18>>; }; // NOLINT
4914 template<> struct ConwayPolynomial<23, 18> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<18>, ZPZV<2>, ZPZV<1>, ZPZV<18>, ZPZV<3>, ZPZV<16>, ZPZV<21>, ZPZV<0>, ZPZV<11>, ZPZV<3>, ZPZV<19>, ZPZV<5>>; }; // NOLINT
4915 template<> struct ConwayPolynomial<23, 19> { using ZPZ = aerobus::zpz<23>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<18>>; }; // NOLINT
4916 template<> struct ConwayPolynomial<29, 1> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<27>>; }; // NOLINT
4917 template<> struct ConwayPolynomial<29, 2> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<24>, ZPZV<2>>; }; // NOLINT
4918 template<> struct ConwayPolynomial<29, 3> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<27>>; }; // NOLINT
4919 template<> struct ConwayPolynomial<29, 4> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<15>, ZPZV<2>>; }; // NOLINT
4920 template<> struct ConwayPolynomial<29, 5> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<27>>; }; // NOLINT
4921 template<> struct ConwayPolynomial<29, 6> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<25>, ZPZV<17>, ZPZV<13>, ZPZV<2>>; }; // NOLINT
4922 template<> struct ConwayPolynomial<29, 7> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<27>>; }; // NOLINT
4923 template<> struct ConwayPolynomial<29, 8> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<24>, ZPZV<26>, ZPZV<23>, ZPZV<2>>; }; // NOLINT
4924 template<> struct ConwayPolynomial<29, 9> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<22>, ZPZV<22>, ZPZV<27>>; }; // NOLINT
4925 template<> struct ConwayPolynomial<29, 10> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<25>, ZPZV<8>, ZPZV<17>, ZPZV<2>, ZPZV<22>, ZPZV<2>>; }; // NOLINT
4926 template<> struct ConwayPolynomial<29, 11> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<8>, ZPZV<27>>; }; // NOLINT
4927 template<> struct ConwayPolynomial<29, 12> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<19>, ZPZV<28>, ZPZV<9>, ZPZV<16>, ZPZV<25>, ZPZV<1>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4928 template<> struct ConwayPolynomial<29, 13> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<27>>; }; // NOLINT
4929 template<> struct ConwayPolynomial<29, 14> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<3>, ZPZV<14>, ZPZV<10>, ZPZV<21>, ZPZV<18>, ZPZV<27>, ZPZV<5>, ZPZV<2>>; }; // NOLINT
4930 template<> struct ConwayPolynomial<29, 15> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<14>, ZPZV<8>, ZPZV<1>, ZPZV<12>, ZPZV<26>, ZPZV<27>>; }; // NOLINT
4931 template<> struct ConwayPolynomial<29, 16> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<27>, ZPZV<2>, ZPZV<18>, ZPZV<23>, ZPZV<1>, ZPZV<27>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
4932 template<> struct ConwayPolynomial<29, 17> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<27>>; }; // NOLINT
4933 template<> struct ConwayPolynomial<29, 18> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<1>, ZPZV<1>, ZPZV<6>, ZPZV<26>, ZPZV<2>, ZPZV<10>, ZPZV<8>, ZPZV<16>, ZPZV<19>, ZPZV<14>, ZPZV<2>>; }; // NOLINT
4934 template<> struct ConwayPolynomial<29, 19> { using ZPZ = aerobus::zpz<29>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<27>>; }; // NOLINT
4935 template<> struct ConwayPolynomial<31, 1> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<28>>; }; // NOLINT
4936 template<> struct ConwayPolynomial<31, 2> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<29>, ZPZV<3>>; }; // NOLINT
4937 template<> struct ConwayPolynomial<31, 3> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<28>>; }; // NOLINT
4938 template<> struct ConwayPolynomial<31, 4> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<16>, ZPZV<3>>; }; // NOLINT
4939 template<> struct ConwayPolynomial<31, 5> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<28>>; }; // NOLINT
4940 template<> struct ConwayPolynomial<31, 6> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<16>, ZPZV<8>, ZPZV<3>>; }; // NOLINT
4941 template<> struct ConwayPolynomial<31, 7> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<28>>; }; // NOLINT
4942 template<> struct ConwayPolynomial<31, 8> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<25>, ZPZV<12>, ZPZV<24>, ZPZV<3>>; }; // NOLINT
4943 template<> struct ConwayPolynomial<31, 9> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<20>, ZPZV<29>, ZPZV<28>>; }; // NOLINT
4944 template<> struct ConwayPolynomial<31, 10> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<30>, ZPZV<26>, ZPZV<13>, ZPZV<13>, ZPZV<13>, ZPZV<3>>; }; // NOLINT
4945 template<> struct ConwayPolynomial<31, 11> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<28>>; }; // NOLINT
4946 template<> struct ConwayPolynomial<31, 12> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<14>, ZPZV<28>, ZPZV<2>, ZPZV<9>, ZPZV<25>, ZPZV<12>, ZPZV<3>>; }; // NOLINT
4947 template<> struct ConwayPolynomial<31, 13> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<28>>; }; // NOLINT
4948 template<> struct ConwayPolynomial<31, 14> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<5>, ZPZV<1>, ZPZV<1>, ZPZV<18>, ZPZV<18>, ZPZV<6>, ZPZV<3>>; }; // NOLINT
4949 template<> struct ConwayPolynomial<31, 15> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<30>, ZPZV<29>, ZPZV<12>, ZPZV<13>, ZPZV<23>, ZPZV<25>, ZPZV<28>>; }; // NOLINT
4950 template<> struct ConwayPolynomial<31, 16> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<24>, ZPZV<26>, ZPZV<28>, ZPZV<11>, ZPZV<19>, ZPZV<27>, ZPZV<3>>; }; // NOLINT
4951 template<> struct ConwayPolynomial<31, 17> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<28>>; }; // NOLINT
4952 template<> struct ConwayPolynomial<31, 18> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<27>, ZPZV<5>, ZPZV<24>, ZPZV<2>, ZPZV<7>, ZPZV<12>, ZPZV<11>, ZPZV<25>, ZPZV<25>, ZPZV<10>, ZPZV<6>, ZPZV<3>>; }; // NOLINT
4953 template<> struct ConwayPolynomial<31, 19> { using ZPZ = aerobus::zpz<31>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<28>>; }; // NOLINT
4954 template<> struct ConwayPolynomial<37, 1> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<35>>; }; // NOLINT
4955 template<> struct ConwayPolynomial<37, 2> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<33>, ZPZV<2>>; }; // NOLINT
4956 template<> struct ConwayPolynomial<37, 3> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<35>>; }; // NOLINT
4957 template<> struct ConwayPolynomial<37, 4> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<24>, ZPZV<2>>; }; // NOLINT
4958 template<> struct ConwayPolynomial<37, 5> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<35>>; }; // NOLINT
4959 template<> struct ConwayPolynomial<37, 6> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<35>, ZPZV<4>, ZPZV<30>, ZPZV<2>>; }; // NOLINT
4960 template<> struct ConwayPolynomial<37, 7> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<35>>; }; // NOLINT
4961 template<> struct ConwayPolynomial<37, 8> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<20>, ZPZV<27>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
4962 template<> struct ConwayPolynomial<37, 9> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<20>, ZPZV<32>, ZPZV<35>>; }; // NOLINT
4963 template<> struct ConwayPolynomial<37, 10> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<29>, ZPZV<18>, ZPZV<11>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
4964 template<> struct ConwayPolynomial<37, 11> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<35>>; }; // NOLINT
4965 template<> struct ConwayPolynomial<37, 12> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<31>, ZPZV<10>, ZPZV<23>, ZPZV<23>, ZPZV<18>, ZPZV<33>, ZPZV<2>>; }; // NOLINT
4966 template<> struct ConwayPolynomial<37, 13> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<35>>; }; // NOLINT
4967 template<> struct ConwayPolynomial<37, 14> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<35>, ZPZV<35>, ZPZV<1>, ZPZV<32>, ZPZV<16>, ZPZV<1>, ZPZV<9>, ZPZV<2>>; }; // NOLINT
4968 template<> struct ConwayPolynomial<37, 15> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<31>, ZPZV<28>, ZPZV<27>, ZPZV<13>, ZPZV<34>, ZPZV<33>, ZPZV<35>>; }; // NOLINT
4969 template<> struct ConwayPolynomial<37, 17> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<35>>; }; // NOLINT
4970 template<> struct ConwayPolynomial<37, 18> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<8>, ZPZV<19>, ZPZV<15>, ZPZV<1>, ZPZV<22>, ZPZV<20>, ZPZV<12>, ZPZV<32>, ZPZV<14>, ZPZV<27>, ZPZV<20>, ZPZV<2>>; }; // NOLINT
4971 template<> struct ConwayPolynomial<37, 19> { using ZPZ = aerobus::zpz<37>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<36>, ZPZV<23>, ZPZV<35>>; }; // NOLINT
4972 template<> struct ConwayPolynomial<41, 1> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<35>>; }; // NOLINT
4973 template<> struct ConwayPolynomial<41, 2> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<38>, ZPZV<6>>; }; // NOLINT
4974 template<> struct ConwayPolynomial<41, 3> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<35>>; }; // NOLINT
4975 template<> struct ConwayPolynomial<41, 4> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<23>, ZPZV<6>>; }; // NOLINT
4976 template<> struct ConwayPolynomial<41, 5> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<40>, ZPZV<14>, ZPZV<35>>; }; // NOLINT
4977 template<> struct ConwayPolynomial<41, 6> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<33>, ZPZV<39>, ZPZV<6>, ZPZV<6>>; }; // NOLINT
4978 template<> struct ConwayPolynomial<41, 7> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<35>>; }; // NOLINT
4979 template<> struct ConwayPolynomial<41, 8> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<32>, ZPZV<20>, ZPZV<6>, ZPZV<6>>; }; // NOLINT
4980 template<> struct ConwayPolynomial<41, 9> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<31>, ZPZV<5>, ZPZV<35>>; }; // NOLINT
4981 template<> struct ConwayPolynomial<41, 10> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<31>, ZPZV<8>, ZPZV<20>, ZPZV<30>, ZPZV<6>>; }; // NOLINT
4982 template<> struct ConwayPolynomial<41, 11> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<35>>; }; // NOLINT
4983 template<> struct ConwayPolynomial<41, 12> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<26>, ZPZV<13>, ZPZV<34>, ZPZV<24>, ZPZV<21>, ZPZV<27>, ZPZV<6>>; }; // NOLINT
4984 template<> struct ConwayPolynomial<41, 13> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<35>>; }; // NOLINT
4985 template<> struct ConwayPolynomial<41, 14> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<15>, ZPZV<4>, ZPZV<27>, ZPZV<11>, ZPZV<39>, ZPZV<10>, ZPZV<6>>; }; // NOLINT
4986 template<> struct ConwayPolynomial<41, 15> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<29>, ZPZV<16>, ZPZV<2>, ZPZV<35>, ZPZV<10>, ZPZV<21>, ZPZV<35>>; }; // NOLINT
4987 template<> struct ConwayPolynomial<41, 17> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<35>>; }; // NOLINT
4988 template<> struct ConwayPolynomial<41, 18> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<7>, ZPZV<20>, ZPZV<23>, ZPZV<35>, ZPZV<38>, ZPZV<24>, ZPZV<12>, ZPZV<29>, ZPZV<10>, ZPZV<6>, ZPZV<6>>; }; // NOLINT
4989 template<> struct ConwayPolynomial<41, 19> { using ZPZ = aerobus::zpz<41>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<35>>; }; // NOLINT
4990 template<> struct ConwayPolynomial<43, 1> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<40>>; }; // NOLINT
4991 template<> struct ConwayPolynomial<43, 2> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<42>, ZPZV<3>>; }; // NOLINT
4992 template<> struct ConwayPolynomial<43, 3> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<40>>; }; // NOLINT
4993 template<> struct ConwayPolynomial<43, 4> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<42>, ZPZV<3>>; }; // NOLINT
4994 template<> struct ConwayPolynomial<43, 5> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<40>>; }; // NOLINT
4995 template<> struct ConwayPolynomial<43, 6> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<28>, ZPZV<21>, ZPZV<3>>; }; // NOLINT
4996 template<> struct ConwayPolynomial<43, 7> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<42>, ZPZV<7>, ZPZV<40>>; }; // NOLINT
4997 template<> struct ConwayPolynomial<43, 8> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<39>, ZPZV<20>, ZPZV<24>, ZPZV<3>>; }; // NOLINT
4998 template<> struct ConwayPolynomial<43, 9> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<39>, ZPZV<1>, ZPZV<40>>; }; // NOLINT
4999 template<> struct ConwayPolynomial<43, 10> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<26>, ZPZV<36>, ZPZV<5>, ZPZV<27>, ZPZV<24>, ZPZV<3>>; }; // NOLINT
5000 template<> struct ConwayPolynomial<43, 11> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<40>>; }; // NOLINT
5001 template<> struct ConwayPolynomial<43, 12> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<34>, ZPZV<27>, ZPZV<16>, ZPZV<17>, ZPZV<6>, ZPZV<23>, ZPZV<38>, ZPZV<3>>; }; // NOLINT
5002 template<> struct ConwayPolynomial<43, 13> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<40>>; }; // NOLINT
5003 template<> struct ConwayPolynomial<43, 14> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<38>, ZPZV<22>, ZPZV<24>, ZPZV<37>, ZPZV<18>, ZPZV<4>, ZPZV<19>, ZPZV<3>>; }; // NOLINT
5004 template<> struct ConwayPolynomial<43, 15> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<37>, ZPZV<22>, ZPZV<42>, ZPZV<4>, ZPZV<15>, ZPZV<37>, ZPZV<40>>; }; // NOLINT
5005 template<> struct ConwayPolynomial<43, 17> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<36>, ZPZV<40>>; }; // NOLINT
5006 template<> struct ConwayPolynomial<43, 18> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<3>, ZPZV<28>, ZPZV<41>, ZPZV<24>, ZPZV<7>, ZPZV<24>, ZPZV<29>, ZPZV<16>, ZPZV<34>, ZPZV<37>, ZPZV<18>, ZPZV<3>>; }; // NOLINT
5007 template<> struct ConwayPolynomial<43, 19> { using ZPZ = aerobus::zpz<43>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<30>, ZPZV<40>>; }; // NOLINT
5008 template<> struct ConwayPolynomial<47, 1> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<42>>; }; // NOLINT
5009 template<> struct ConwayPolynomial<47, 2> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<45>, ZPZV<5>>; }; // NOLINT
5010 template<> struct ConwayPolynomial<47, 3> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<42>>; }; // NOLINT
5011 template<> struct ConwayPolynomial<47, 4> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<40>, ZPZV<5>>; }; // NOLINT
5012 template<> struct ConwayPolynomial<47, 5> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<42>>; }; // NOLINT
5013 template<> struct ConwayPolynomial<47, 6> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<35>, ZPZV<9>, ZPZV<41>, ZPZV<5>>; }; // NOLINT
5014 template<> struct ConwayPolynomial<47, 7> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<42>>; }; // NOLINT
5015 template<> struct ConwayPolynomial<47, 8> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<29>, ZPZV<19>, ZPZV<3>, ZPZV<5>>; }; // NOLINT
5016 template<> struct ConwayPolynomial<47, 9> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<19>, ZPZV<1>, ZPZV<42>>; }; // NOLINT
5017 template<> struct ConwayPolynomial<47, 10> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<42>, ZPZV<14>, ZPZV<18>, ZPZV<45>, ZPZV<45>, ZPZV<5>>; }; // NOLINT
5018 template<> struct ConwayPolynomial<47, 11> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<42>>; }; // NOLINT
5019 template<> struct ConwayPolynomial<47, 12> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<46>, ZPZV<40>, ZPZV<35>, ZPZV<12>, ZPZV<46>, ZPZV<14>, ZPZV<9>, ZPZV<5>>; }; // NOLINT
5020 template<> struct ConwayPolynomial<47, 13> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<42>>; }; // NOLINT
5021 template<> struct ConwayPolynomial<47, 14> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<36>, ZPZV<20>, ZPZV<30>, ZPZV<17>, ZPZV<24>, ZPZV<9>, ZPZV<32>, ZPZV<5>>; }; // NOLINT
5022 template<> struct ConwayPolynomial<47, 15> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<43>, ZPZV<31>, ZPZV<14>, ZPZV<42>, ZPZV<13>, ZPZV<17>, ZPZV<42>>; }; // NOLINT
5023 template<> struct ConwayPolynomial<47, 17> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<42>>; }; // NOLINT
5024 template<> struct ConwayPolynomial<47, 18> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<41>, ZPZV<42>, ZPZV<26>, ZPZV<44>, ZPZV<24>, ZPZV<22>, ZPZV<11>, ZPZV<5>, ZPZV<45>, ZPZV<33>, ZPZV<5>>; }; // NOLINT
5025 template<> struct ConwayPolynomial<47, 19> { using ZPZ = aerobus::zpz<47>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<35>, ZPZV<42>>; }; // NOLINT
5026 template<> struct ConwayPolynomial<53, 1> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<51>>; }; // NOLINT
5027 template<> struct ConwayPolynomial<53, 2> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<49>, ZPZV<2>>; }; // NOLINT
5028 template<> struct ConwayPolynomial<53, 3> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<51>>; }; // NOLINT
5029 template<> struct ConwayPolynomial<53, 4> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<38>, ZPZV<2>>; }; // NOLINT
5030 template<> struct ConwayPolynomial<53, 5> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<51>>; }; // NOLINT
5031 template<> struct ConwayPolynomial<53, 6> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<7>, ZPZV<4>, ZPZV<45>, ZPZV<2>>; }; // NOLINT
5032 template<> struct ConwayPolynomial<53, 7> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<51>>; }; // NOLINT
5033 template<> struct ConwayPolynomial<53, 8> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<29>, ZPZV<18>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
5034 template<> struct ConwayPolynomial<53, 9> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<5>, ZPZV<51>>; }; // NOLINT
5035 template<> struct ConwayPolynomial<53, 10> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<27>, ZPZV<15>, ZPZV<29>, ZPZV<2>>; }; // NOLINT
5036 template<> struct ConwayPolynomial<53, 11> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<51>>; }; // NOLINT
5037 template<> struct ConwayPolynomial<53, 12> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<34>, ZPZV<4>, ZPZV<13>, ZPZV<10>, ZPZV<42>, ZPZV<34>, ZPZV<41>, ZPZV<2>>; }; // NOLINT
5038 template<> struct ConwayPolynomial<53, 13> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<52>, ZPZV<28>, ZPZV<51>>; }; // NOLINT
5039 template<> struct ConwayPolynomial<53, 14> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<45>, ZPZV<23>, ZPZV<52>, ZPZV<0>, ZPZV<37>, ZPZV<12>, ZPZV<23>, ZPZV<2>>; }; // NOLINT
5040 template<> struct ConwayPolynomial<53, 15> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<31>, ZPZV<15>, ZPZV<11>, ZPZV<20>, ZPZV<4>, ZPZV<51>>; }; // NOLINT
5041 template<> struct ConwayPolynomial<53, 17> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<51>>; }; // NOLINT
5042 template<> struct ConwayPolynomial<53, 18> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<52>, ZPZV<31>, ZPZV<51>, ZPZV<27>, ZPZV<0>, ZPZV<39>, ZPZV<44>, ZPZV<6>, ZPZV<8>, ZPZV<16>, ZPZV<11>, ZPZV<2>>; }; // NOLINT
5043 template<> struct ConwayPolynomial<53, 19> { using ZPZ = aerobus::zpz<53>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<51>>; }; // NOLINT
5044 template<> struct ConwayPolynomial<59, 1> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<57>>; }; // NOLINT
5045 template<> struct ConwayPolynomial<59, 2> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<58>, ZPZV<2>>; }; // NOLINT
5046 template<> struct ConwayPolynomial<59, 3> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<57>>; }; // NOLINT
5047 template<> struct ConwayPolynomial<59, 4> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<40>, ZPZV<2>>; }; // NOLINT
5048 template<> struct ConwayPolynomial<59, 5> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<57>>; }; // NOLINT
5049 template<> struct ConwayPolynomial<59, 6> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<18>, ZPZV<38>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
5050 template<> struct ConwayPolynomial<59, 7> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<57>>; }; // NOLINT
5051 template<> struct ConwayPolynomial<59, 8> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<32>, ZPZV<2>, ZPZV<50>, ZPZV<2>>; }; // NOLINT
5052 template<> struct ConwayPolynomial<59, 9> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<32>, ZPZV<47>, ZPZV<57>>; }; // NOLINT
5053 template<> struct ConwayPolynomial<59, 10> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<28>, ZPZV<25>, ZPZV<4>, ZPZV<39>, ZPZV<15>, ZPZV<2>>; }; // NOLINT
5054 template<> struct ConwayPolynomial<59, 11> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<57>>; }; // NOLINT
5055 template<> struct ConwayPolynomial<59, 12> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<39>, ZPZV<25>, ZPZV<51>, ZPZV<21>, ZPZV<38>, ZPZV<8>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
5056 template<> struct ConwayPolynomial<59, 13> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<57>>; }; // NOLINT
5057 template<> struct ConwayPolynomial<59, 14> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<33>, ZPZV<51>, ZPZV<11>, ZPZV<13>, ZPZV<25>, ZPZV<32>, ZPZV<26>, ZPZV<2>>; }; // NOLINT
5058 template<> struct ConwayPolynomial<59, 15> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<57>, ZPZV<24>, ZPZV<23>, ZPZV<13>, ZPZV<39>, ZPZV<58>, ZPZV<57>>; }; // NOLINT
5059 template<> struct ConwayPolynomial<59, 17> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<57>>; }; // NOLINT
5060 template<> struct ConwayPolynomial<59, 18> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<37>, ZPZV<38>, ZPZV<27>, ZPZV<11>, ZPZV<14>, ZPZV<7>, ZPZV<44>, ZPZV<16>, ZPZV<47>, ZPZV<34>, ZPZV<32>, ZPZV<2>>; }; // NOLINT
5061 template<> struct ConwayPolynomial<59, 19> { using ZPZ = aerobus::zpz<59>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<57>>; }; // NOLINT
5062 template<> struct ConwayPolynomial<61, 1> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<59>>; }; // NOLINT
5063 template<> struct ConwayPolynomial<61, 2> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<60>, ZPZV<2>>; }; // NOLINT
5064 template<> struct ConwayPolynomial<61, 3> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<59>>; }; // NOLINT
5065 template<> struct ConwayPolynomial<61, 4> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<40>, ZPZV<2>>; }; // NOLINT
5066 template<> struct ConwayPolynomial<61, 5> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<59>>; }; // NOLINT
5067 template<> struct ConwayPolynomial<61, 6> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<49>, ZPZV<3>, ZPZV<29>, ZPZV<2>>; }; // NOLINT
5068 template<> struct ConwayPolynomial<61, 7> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<59>>; }; // NOLINT
5069 template<> struct ConwayPolynomial<61, 8> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<57>, ZPZV<1>, ZPZV<56>, ZPZV<2>>; }; // NOLINT
5070 template<> struct ConwayPolynomial<61, 9> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<50>, ZPZV<18>, ZPZV<59>>; }; // NOLINT
5071 template<> struct ConwayPolynomial<61, 10> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<15>, ZPZV<44>, ZPZV<16>, ZPZV<6>, ZPZV<2>>; }; // NOLINT
5072 template<> struct ConwayPolynomial<61, 11> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<59>>; }; // NOLINT
5073 template<> struct ConwayPolynomial<61, 12> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<42>, ZPZV<33>, ZPZV<8>, ZPZV<38>, ZPZV<14>, ZPZV<1>, ZPZV<15>, ZPZV<2>>; }; // NOLINT
5074 template<> struct ConwayPolynomial<61, 13> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<59>>; }; // NOLINT
5075 template<> struct ConwayPolynomial<61, 14> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<48>, ZPZV<26>, ZPZV<11>, ZPZV<8>, ZPZV<30>, ZPZV<54>, ZPZV<48>, ZPZV<2>>; }; // NOLINT
5076 template<> struct ConwayPolynomial<61, 15> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<39>, ZPZV<35>, ZPZV<44>, ZPZV<25>, ZPZV<23>, ZPZV<51>, ZPZV<59>>; }; // NOLINT
5077 template<> struct ConwayPolynomial<61, 17> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<59>>; }; // NOLINT
5078 template<> struct ConwayPolynomial<61, 18> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<35>, ZPZV<36>, ZPZV<13>, ZPZV<36>, ZPZV<4>, ZPZV<32>, ZPZV<57>, ZPZV<42>, ZPZV<25>, ZPZV<25>, ZPZV<52>, ZPZV<2>>; }; // NOLINT
5079 template<> struct ConwayPolynomial<61, 19> { using ZPZ = aerobus::zpz<61>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<59>>; }; // NOLINT
5080 template<> struct ConwayPolynomial<67, 1> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<65>>; }; // NOLINT
5081 template<> struct ConwayPolynomial<67, 2> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<63>, ZPZV<2>>; }; // NOLINT
5082 template<> struct ConwayPolynomial<67, 3> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<65>>; }; // NOLINT
5083 template<> struct ConwayPolynomial<67, 4> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<54>, ZPZV<2>>; }; // NOLINT
5084 template<> struct ConwayPolynomial<67, 5> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<65>>; }; // NOLINT
5085 template<> struct ConwayPolynomial<67, 6> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<63>, ZPZV<49>, ZPZV<55>, ZPZV<2>>; }; // NOLINT
5086 template<> struct ConwayPolynomial<67, 7> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<65>>; }; // NOLINT
5087 template<> struct ConwayPolynomial<67, 8> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<46>, ZPZV<17>, ZPZV<64>, ZPZV<2>>; }; // NOLINT
5088 template<> struct ConwayPolynomial<67, 9> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<25>, ZPZV<49>, ZPZV<55>, ZPZV<65>>; }; // NOLINT
5089 template<> struct ConwayPolynomial<67, 10> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<21>, ZPZV<0>, ZPZV<16>, ZPZV<7>, ZPZV<23>, ZPZV<2>>; }; // NOLINT
5090 template<> struct ConwayPolynomial<67, 11> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<66>, ZPZV<9>, ZPZV<65>>; }; // NOLINT
5091 template<> struct ConwayPolynomial<67, 12> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<57>, ZPZV<27>, ZPZV<4>, ZPZV<55>, ZPZV<64>, ZPZV<21>, ZPZV<27>, ZPZV<2>>; }; // NOLINT
5092 template<> struct ConwayPolynomial<67, 13> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<65>>; }; // NOLINT
5093 template<> struct ConwayPolynomial<67, 14> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<22>, ZPZV<5>, ZPZV<56>, ZPZV<0>, ZPZV<1>, ZPZV<37>, ZPZV<2>>; }; // NOLINT
5094 template<> struct ConwayPolynomial<67, 15> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<1>, ZPZV<52>, ZPZV<41>, ZPZV<20>, ZPZV<21>, ZPZV<46>, ZPZV<65>>; }; // NOLINT
5095 template<> struct ConwayPolynomial<67, 17> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<65>>; }; // NOLINT
5096 template<> struct ConwayPolynomial<67, 18> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<63>, ZPZV<52>, ZPZV<18>, ZPZV<33>, ZPZV<55>, ZPZV<28>, ZPZV<29>, ZPZV<51>, ZPZV<6>, ZPZV<59>, ZPZV<13>, ZPZV<2>>; }; // NOLINT
5097 template<> struct ConwayPolynomial<67, 19> { using ZPZ = aerobus::zpz<67>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<65>>; }; // NOLINT
5098 template<> struct ConwayPolynomial<71, 1> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<64>>; }; // NOLINT
5099 template<> struct ConwayPolynomial<71, 2> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<69>, ZPZV<7>>; }; // NOLINT
5100 template<> struct ConwayPolynomial<71, 3> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<64>>; }; // NOLINT
5101 template<> struct ConwayPolynomial<71, 4> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<41>, ZPZV<7>>; }; // NOLINT
5102 template<> struct ConwayPolynomial<71, 5> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<64>>; }; // NOLINT
5103 template<> struct ConwayPolynomial<71, 6> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<10>, ZPZV<13>, ZPZV<29>, ZPZV<7>>; }; // NOLINT
5104 template<> struct ConwayPolynomial<71, 7> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<64>>; }; // NOLINT
5105 template<> struct ConwayPolynomial<71, 8> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<53>, ZPZV<22>, ZPZV<19>, ZPZV<7>>; }; // NOLINT
5106 template<> struct ConwayPolynomial<71, 9> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<43>, ZPZV<62>, ZPZV<64>>; }; // NOLINT
5107 template<> struct ConwayPolynomial<71, 10> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<53>, ZPZV<17>, ZPZV<26>, ZPZV<1>, ZPZV<40>, ZPZV<7>>; }; // NOLINT
5108 template<> struct ConwayPolynomial<71, 11> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<48>, ZPZV<64>>; }; // NOLINT
5109 template<> struct ConwayPolynomial<71, 12> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<28>, ZPZV<29>, ZPZV<55>, ZPZV<21>, ZPZV<58>, ZPZV<23>, ZPZV<7>>; }; // NOLINT
5110 template<> struct ConwayPolynomial<71, 13> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<27>, ZPZV<64>>; }; // NOLINT
5111 template<> struct ConwayPolynomial<71, 15> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<32>, ZPZV<18>, ZPZV<52>, ZPZV<67>, ZPZV<49>, ZPZV<64>>; }; // NOLINT
5112 template<> struct ConwayPolynomial<71, 17> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<64>>; }; // NOLINT
5113 template<> struct ConwayPolynomial<71, 19> { using ZPZ = aerobus::zpz<71>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<64>>; }; // NOLINT
5114 template<> struct ConwayPolynomial<73, 1> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<68>>; }; // NOLINT
5115 template<> struct ConwayPolynomial<73, 2> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<70>, ZPZV<5>>; }; // NOLINT
5116 template<> struct ConwayPolynomial<73, 3> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<68>>; }; // NOLINT
5117 template<> struct ConwayPolynomial<73, 4> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<16>, ZPZV<56>, ZPZV<5>>; }; // NOLINT
5118 template<> struct ConwayPolynomial<73, 5> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<68>>; }; // NOLINT
5119 template<> struct ConwayPolynomial<73, 6> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<45>, ZPZV<23>, ZPZV<48>, ZPZV<5>>; }; // NOLINT
5120 template<> struct ConwayPolynomial<73, 7> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<68>>; }; // NOLINT
5121 template<> struct ConwayPolynomial<73, 8> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<53>, ZPZV<39>, ZPZV<18>, ZPZV<5>>; }; // NOLINT
5122 template<> struct ConwayPolynomial<73, 9> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<72>, ZPZV<15>, ZPZV<68>>; }; // NOLINT
5123 template<> struct ConwayPolynomial<73, 10> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<15>, ZPZV<23>, ZPZV<33>, ZPZV<32>, ZPZV<69>, ZPZV<5>>; }; // NOLINT
5124 template<> struct ConwayPolynomial<73, 11> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<68>>; }; // NOLINT
5125 template<> struct ConwayPolynomial<73, 12> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<69>, ZPZV<52>, ZPZV<26>, ZPZV<20>, ZPZV<46>, ZPZV<29>, ZPZV<25>, ZPZV<5>>; }; // NOLINT
5126 template<> struct ConwayPolynomial<73, 13> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<68>>; }; // NOLINT
5127 template<> struct ConwayPolynomial<73, 15> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<33>, ZPZV<57>, ZPZV<57>, ZPZV<62>, ZPZV<68>>; }; // NOLINT
5128 template<> struct ConwayPolynomial<73, 17> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<68>>; }; // NOLINT
5129 template<> struct ConwayPolynomial<73, 19> { using ZPZ = aerobus::zpz<73>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<25>, ZPZV<68>>; }; // NOLINT
5130 template<> struct ConwayPolynomial<79, 1> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<76>>; }; // NOLINT
5131 template<> struct ConwayPolynomial<79, 2> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<78>, ZPZV<3>>; }; // NOLINT
5132 template<> struct ConwayPolynomial<79, 3> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<76>>; }; // NOLINT
5133 template<> struct ConwayPolynomial<79, 4> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<66>, ZPZV<3>>; }; // NOLINT
5134 template<> struct ConwayPolynomial<79, 5> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<76>>; }; // NOLINT
5135 template<> struct ConwayPolynomial<79, 6> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<28>, ZPZV<68>, ZPZV<3>>; }; // NOLINT
5136 template<> struct ConwayPolynomial<79, 7> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<76>>; }; // NOLINT
5137 template<> struct ConwayPolynomial<79, 8> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<60>, ZPZV<59>, ZPZV<48>, ZPZV<3>>; }; // NOLINT
5138 template<> struct ConwayPolynomial<79, 9> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<57>, ZPZV<19>, ZPZV<76>>; }; // NOLINT
5139 template<> struct ConwayPolynomial<79, 10> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<44>, ZPZV<51>, ZPZV<1>, ZPZV<30>, ZPZV<42>, ZPZV<3>>; }; // NOLINT
5140 template<> struct ConwayPolynomial<79, 11> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<76>>; }; // NOLINT
5141 template<> struct ConwayPolynomial<79, 12> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<29>, ZPZV<45>, ZPZV<52>, ZPZV<7>, ZPZV<40>, ZPZV<59>, ZPZV<62>, ZPZV<3>>; }; // NOLINT
5142 template<> struct ConwayPolynomial<79, 13> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<78>, ZPZV<4>, ZPZV<76>>; }; // NOLINT
5143 template<> struct ConwayPolynomial<79, 17> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<25>, ZPZV<76>>; }; // NOLINT
5144 template<> struct ConwayPolynomial<79, 19> { using ZPZ = aerobus::zpz<79>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<25>, ZPZV<76>>; }; // NOLINT
5145 template<> struct ConwayPolynomial<83, 1> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<81>>; }; // NOLINT
5146 template<> struct ConwayPolynomial<83, 2> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<82>, ZPZV<2>>; }; // NOLINT
5147 template<> struct ConwayPolynomial<83, 3> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<81>>; }; // NOLINT
5148 template<> struct ConwayPolynomial<83, 4> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<42>, ZPZV<2>>; }; // NOLINT
5149 template<> struct ConwayPolynomial<83, 5> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<81>>; }; // NOLINT
5150 template<> struct ConwayPolynomial<83, 6> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<76>, ZPZV<32>, ZPZV<17>, ZPZV<2>>; }; // NOLINT
5151 template<> struct ConwayPolynomial<83, 7> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<81>>; }; // NOLINT
5152 template<> struct ConwayPolynomial<83, 8> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<65>, ZPZV<23>, ZPZV<42>, ZPZV<2>>; }; // NOLINT
5153 template<> struct ConwayPolynomial<83, 9> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<24>, ZPZV<18>, ZPZV<81>>; }; // NOLINT
5154 template<> struct ConwayPolynomial<83, 10> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<0>, ZPZV<73>, ZPZV<0>, ZPZV<53>, ZPZV<2>>; }; // NOLINT
5155 template<> struct ConwayPolynomial<83, 11> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<81>>; }; // NOLINT
5156 template<> struct ConwayPolynomial<83, 12> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<35>, ZPZV<12>, ZPZV<31>, ZPZV<19>, ZPZV<65>, ZPZV<55>, ZPZV<75>, ZPZV<2>>; }; // NOLINT
5157 template<> struct ConwayPolynomial<83, 13> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<81>>; }; // NOLINT
5158 template<> struct ConwayPolynomial<83, 17> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<81>>; }; // NOLINT
5159 template<> struct ConwayPolynomial<83, 19> { using ZPZ = aerobus::zpz<83>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<47>, ZPZV<81>>; }; // NOLINT
5160 template<> struct ConwayPolynomial<89, 1> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<86>>; }; // NOLINT
5161 template<> struct ConwayPolynomial<89, 2> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<82>, ZPZV<3>>; }; // NOLINT
5162 template<> struct ConwayPolynomial<89, 3> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<86>>; }; // NOLINT
5163 template<> struct ConwayPolynomial<89, 4> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<72>, ZPZV<3>>; }; // NOLINT
5164 template<> struct ConwayPolynomial<89, 5> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<86>>; }; // NOLINT
5165 template<> struct ConwayPolynomial<89, 6> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<82>, ZPZV<80>, ZPZV<15>, ZPZV<3>>; }; // NOLINT
5166 template<> struct ConwayPolynomial<89, 7> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<86>>; }; // NOLINT
5167 template<> struct ConwayPolynomial<89, 8> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<65>, ZPZV<40>, ZPZV<79>, ZPZV<3>>; }; // NOLINT
5168 template<> struct ConwayPolynomial<89, 9> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<12>, ZPZV<6>, ZPZV<86>>; }; // NOLINT
5169 template<> struct ConwayPolynomial<89, 10> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<16>, ZPZV<33>, ZPZV<82>, ZPZV<52>, ZPZV<4>, ZPZV<3>>; }; // NOLINT
5170 template<> struct ConwayPolynomial<89, 11> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<88>, ZPZV<26>, ZPZV<86>>; }; // NOLINT
5171 template<> struct ConwayPolynomial<89, 12> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<85>, ZPZV<15>, ZPZV<44>, ZPZV<51>, ZPZV<8>, ZPZV<70>, ZPZV<52>, ZPZV<3>>; }; // NOLINT
5172 template<> struct ConwayPolynomial<89, 13> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<86>>; }; // NOLINT
5173 template<> struct ConwayPolynomial<89, 17> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<86>>; }; // NOLINT
5174 template<> struct ConwayPolynomial<89, 19> { using ZPZ = aerobus::zpz<89>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<34>, ZPZV<86>>; }; // NOLINT
5175 template<> struct ConwayPolynomial<97, 1> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<92>>; }; // NOLINT
5176 template<> struct ConwayPolynomial<97, 2> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<96>, ZPZV<5>>; }; // NOLINT
5177 template<> struct ConwayPolynomial<97, 3> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<92>>; }; // NOLINT
5178 template<> struct ConwayPolynomial<97, 4> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<80>, ZPZV<5>>; }; // NOLINT
5179 template<> struct ConwayPolynomial<97, 5> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<92>>; }; // NOLINT
5180 template<> struct ConwayPolynomial<97, 6> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<92>, ZPZV<58>, ZPZV<88>, ZPZV<5>>; }; // NOLINT
5181 template<> struct ConwayPolynomial<97, 7> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<92>>; }; // NOLINT
5182 template<> struct ConwayPolynomial<97, 8> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<65>, ZPZV<1>, ZPZV<32>, ZPZV<5>>; }; // NOLINT
5183 template<> struct ConwayPolynomial<97, 9> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<59>, ZPZV<7>, ZPZV<92>>; }; // NOLINT
5184 template<> struct ConwayPolynomial<97, 10> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<66>, ZPZV<34>, ZPZV<34>, ZPZV<20>, ZPZV<5>>; }; // NOLINT
5185 template<> struct ConwayPolynomial<97, 11> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<92>>; }; // NOLINT
5186 template<> struct ConwayPolynomial<97, 12> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<30>, ZPZV<59>, ZPZV<81>, ZPZV<0>, ZPZV<86>, ZPZV<78>, ZPZV<94>, ZPZV<5>>; }; // NOLINT
5187 template<> struct ConwayPolynomial<97, 13> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<92>>; }; // NOLINT
5188 template<> struct ConwayPolynomial<97, 17> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<92>>; }; // NOLINT
5189 template<> struct ConwayPolynomial<97, 19> { using ZPZ = aerobus::zpz<97>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<92>>; }; // NOLINT
5190 template<> struct ConwayPolynomial<101, 1> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<99>>; }; // NOLINT
5191 template<> struct ConwayPolynomial<101, 2> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<97>, ZPZV<2>>; }; // NOLINT
5192 template<> struct ConwayPolynomial<101, 3> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<99>>; }; // NOLINT
5193 template<> struct ConwayPolynomial<101, 4> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<78>, ZPZV<2>>; }; // NOLINT
5194 template<> struct ConwayPolynomial<101, 5> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<99>>; }; // NOLINT
5195 template<> struct ConwayPolynomial<101, 6> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<90>, ZPZV<20>, ZPZV<67>, ZPZV<2>>; }; // NOLINT
5196 template<> struct ConwayPolynomial<101, 7> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<99>>; }; // NOLINT
5197 template<> struct ConwayPolynomial<101, 8> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<76>, ZPZV<29>, ZPZV<24>, ZPZV<2>>; }; // NOLINT
5198 template<> struct ConwayPolynomial<101, 9> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<64>, ZPZV<47>, ZPZV<99>>; }; // NOLINT
5199 template<> struct ConwayPolynomial<101, 10> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<67>, ZPZV<49>, ZPZV<100>, ZPZV<100>, ZPZV<52>, ZPZV<2>>; }; // NOLINT
5200 template<> struct ConwayPolynomial<101, 11> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<31>, ZPZV<99>>; }; // NOLINT
5201 template<> struct ConwayPolynomial<101, 12> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<79>, ZPZV<64>, ZPZV<39>, ZPZV<78>, ZPZV<48>, ZPZV<84>, ZPZV<21>, ZPZV<2>>; }; // NOLINT
5202 template<> struct ConwayPolynomial<101, 13> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<99>>; }; // NOLINT
5203 template<> struct ConwayPolynomial<101, 17> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<31>, ZPZV<99>>; }; // NOLINT
5204 template<> struct ConwayPolynomial<101, 19> { using ZPZ = aerobus::zpz<101>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<99>>; }; // NOLINT
5205 template<> struct ConwayPolynomial<103, 1> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<98>>; }; // NOLINT
5206 template<> struct ConwayPolynomial<103, 2> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<102>, ZPZV<5>>; }; // NOLINT
5207 template<> struct ConwayPolynomial<103, 3> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<98>>; }; // NOLINT
5208 template<> struct ConwayPolynomial<103, 4> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<88>, ZPZV<5>>; }; // NOLINT
5209 template<> struct ConwayPolynomial<103, 5> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<98>>; }; // NOLINT
5210 template<> struct ConwayPolynomial<103, 6> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<96>, ZPZV<9>, ZPZV<30>, ZPZV<5>>; }; // NOLINT
5211 template<> struct ConwayPolynomial<103, 7> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<98>>; }; // NOLINT
5212 template<> struct ConwayPolynomial<103, 8> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<70>, ZPZV<71>, ZPZV<49>, ZPZV<5>>; }; // NOLINT
5213 template<> struct ConwayPolynomial<103, 9> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<97>, ZPZV<51>, ZPZV<98>>; }; // NOLINT
5214 template<> struct ConwayPolynomial<103, 10> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<101>, ZPZV<86>, ZPZV<101>, ZPZV<94>, ZPZV<11>, ZPZV<5>>; }; // NOLINT
5215 template<> struct ConwayPolynomial<103, 11> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<98>>; }; // NOLINT
5216 template<> struct ConwayPolynomial<103, 12> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<74>, ZPZV<23>, ZPZV<94>, ZPZV<20>, ZPZV<81>, ZPZV<29>, ZPZV<88>, ZPZV<5>>; }; // NOLINT
5217 template<> struct ConwayPolynomial<103, 13> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<98>>; }; // NOLINT
5218 template<> struct ConwayPolynomial<103, 17> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<102>, ZPZV<8>, ZPZV<98>>; }; // NOLINT
5219 template<> struct ConwayPolynomial<103, 19> { using ZPZ = aerobus::zpz<103>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<98>>; }; // NOLINT
5220 template<> struct ConwayPolynomial<107, 1> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<105>>; }; // NOLINT
5221 template<> struct ConwayPolynomial<107, 2> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<103>, ZPZV<2>>; }; // NOLINT
5222 template<> struct ConwayPolynomial<107, 3> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<105>>; }; // NOLINT
5223 template<> struct ConwayPolynomial<107, 4> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<13>, ZPZV<79>, ZPZV<2>>; }; // NOLINT
5224 template<> struct ConwayPolynomial<107, 5> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<105>>; }; // NOLINT
5225 template<> struct ConwayPolynomial<107, 6> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<52>, ZPZV<22>, ZPZV<79>, ZPZV<2>>; }; // NOLINT
5226 template<> struct ConwayPolynomial<107, 7> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<105>>; }; // NOLINT
5227 template<> struct ConwayPolynomial<107, 8> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<105>, ZPZV<24>, ZPZV<95>, ZPZV<2>>; }; // NOLINT
5228 template<> struct ConwayPolynomial<107, 9> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<3>, ZPZV<66>, ZPZV<105>>; }; // NOLINT
5229 template<> struct ConwayPolynomial<107, 10> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<94>, ZPZV<61>, ZPZV<83>, ZPZV<83>, ZPZV<95>, ZPZV<2>>; }; // NOLINT
5230 template<> struct ConwayPolynomial<107, 11> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<105>>; }; // NOLINT
5231 template<> struct ConwayPolynomial<107, 12> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<37>, ZPZV<48>, ZPZV<6>, ZPZV<0>, ZPZV<61>, ZPZV<42>, ZPZV<57>, ZPZV<2>>; }; // NOLINT
5232 template<> struct ConwayPolynomial<107, 13> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<105>>; }; // NOLINT
5233 template<> struct ConwayPolynomial<107, 17> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<105>>; }; // NOLINT
5234 template<> struct ConwayPolynomial<107, 19> { using ZPZ = aerobus::zpz<107>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<105>>; }; // NOLINT
5235 template<> struct ConwayPolynomial<109, 1> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<103>>; }; // NOLINT
5236 template<> struct ConwayPolynomial<109, 2> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<108>, ZPZV<6>>; }; // NOLINT
5237 template<> struct ConwayPolynomial<109, 3> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<103>>; }; // NOLINT
5238 template<> struct ConwayPolynomial<109, 4> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<98>, ZPZV<6>>; }; // NOLINT
5239 template<> struct ConwayPolynomial<109, 5> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<103>>; }; // NOLINT
5240 template<> struct ConwayPolynomial<109, 6> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<107>, ZPZV<102>, ZPZV<66>, ZPZV<6>>; }; // NOLINT
5241 template<> struct ConwayPolynomial<109, 7> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<103>>; }; // NOLINT
5242 template<> struct ConwayPolynomial<109, 8> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<102>, ZPZV<34>, ZPZV<86>, ZPZV<6>>; }; // NOLINT
5243 template<> struct ConwayPolynomial<109, 9> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<93>, ZPZV<87>, ZPZV<103>>; }; // NOLINT
5244 template<> struct ConwayPolynomial<109, 10> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<71>, ZPZV<55>, ZPZV<16>, ZPZV<75>, ZPZV<69>, ZPZV<6>>; }; // NOLINT
5245 template<> struct ConwayPolynomial<109, 11> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<103>>; }; // NOLINT
5246 template<> struct ConwayPolynomial<109, 12> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<50>, ZPZV<53>, ZPZV<37>, ZPZV<8>, ZPZV<65>, ZPZV<103>, ZPZV<28>, ZPZV<6>>; }; // NOLINT
5247 template<> struct ConwayPolynomial<109, 13> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<103>>; }; // NOLINT
5248 template<> struct ConwayPolynomial<109, 17> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<103>>; }; // NOLINT
5249 template<> struct ConwayPolynomial<109, 19> { using ZPZ = aerobus::zpz<109>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<103>>; }; // NOLINT
5250 template<> struct ConwayPolynomial<113, 1> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<110>>; }; // NOLINT
5251 template<> struct ConwayPolynomial<113, 2> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<101>, ZPZV<3>>; }; // NOLINT
5252 template<> struct ConwayPolynomial<113, 3> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<110>>; }; // NOLINT
5253 template<> struct ConwayPolynomial<113, 4> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<62>, ZPZV<3>>; }; // NOLINT
5254 template<> struct ConwayPolynomial<113, 5> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<110>>; }; // NOLINT
5255 template<> struct ConwayPolynomial<113, 6> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<59>, ZPZV<30>, ZPZV<71>, ZPZV<3>>; }; // NOLINT
5256 template<> struct ConwayPolynomial<113, 7> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<110>>; }; // NOLINT
5257 template<> struct ConwayPolynomial<113, 8> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<98>, ZPZV<38>, ZPZV<28>, ZPZV<3>>; }; // NOLINT
5258 template<> struct ConwayPolynomial<113, 9> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<87>, ZPZV<71>, ZPZV<110>>; }; // NOLINT
5259 template<> struct ConwayPolynomial<113, 10> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<108>, ZPZV<57>, ZPZV<45>, ZPZV<83>, ZPZV<56>, ZPZV<3>>; }; // NOLINT
5260 template<> struct ConwayPolynomial<113, 11> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<110>>; }; // NOLINT
5261 template<> struct ConwayPolynomial<113, 12> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<23>, ZPZV<62>, ZPZV<4>, ZPZV<98>, ZPZV<56>, ZPZV<10>, ZPZV<27>, ZPZV<3>>; }; // NOLINT
5262 template<> struct ConwayPolynomial<113, 13> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<110>>; }; // NOLINT
5263 template<> struct ConwayPolynomial<113, 17> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<110>>; }; // NOLINT
5264 template<> struct ConwayPolynomial<113, 19> { using ZPZ = aerobus::zpz<113>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<110>>; }; // NOLINT
5265 template<> struct ConwayPolynomial<127, 1> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<124>>; }; // NOLINT
5266 template<> struct ConwayPolynomial<127, 2> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<126>, ZPZV<3>>; }; // NOLINT
5267 template<> struct ConwayPolynomial<127, 3> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<124>>; }; // NOLINT
5268 template<> struct ConwayPolynomial<127, 4> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<97>, ZPZV<3>>; }; // NOLINT
5269 template<> struct ConwayPolynomial<127, 5> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<124>>; }; // NOLINT
5270 template<> struct ConwayPolynomial<127, 6> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<84>, ZPZV<115>, ZPZV<82>, ZPZV<3>>; }; // NOLINT
5271 template<> struct ConwayPolynomial<127, 7> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<124>>; }; // NOLINT
5272 template<> struct ConwayPolynomial<127, 8> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<104>, ZPZV<55>, ZPZV<8>, ZPZV<3>>; }; // NOLINT
5273 template<> struct ConwayPolynomial<127, 9> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<119>, ZPZV<126>, ZPZV<124>>; }; // NOLINT
5274 template<> struct ConwayPolynomial<127, 10> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<107>, ZPZV<64>, ZPZV<95>, ZPZV<60>, ZPZV<4>, ZPZV<3>>; }; // NOLINT
5275 template<> struct ConwayPolynomial<127, 11> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<124>>; }; // NOLINT
5276 template<> struct ConwayPolynomial<127, 12> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<119>, ZPZV<25>, ZPZV<33>, ZPZV<97>, ZPZV<15>, ZPZV<99>, ZPZV<8>, ZPZV<3>>; }; // NOLINT
5277 template<> struct ConwayPolynomial<127, 13> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<124>>; }; // NOLINT
5278 template<> struct ConwayPolynomial<127, 17> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<124>>; }; // NOLINT
5279 template<> struct ConwayPolynomial<127, 19> { using ZPZ = aerobus::zpz<127>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<30>, ZPZV<124>>; }; // NOLINT
5280 template<> struct ConwayPolynomial<131, 1> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<129>>; }; // NOLINT
5281 template<> struct ConwayPolynomial<131, 2> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<127>, ZPZV<2>>; }; // NOLINT
5282 template<> struct ConwayPolynomial<131, 3> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<129>>; }; // NOLINT
5283 template<> struct ConwayPolynomial<131, 4> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<109>, ZPZV<2>>; }; // NOLINT
5284 template<> struct ConwayPolynomial<131, 5> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<129>>; }; // NOLINT
5285 template<> struct ConwayPolynomial<131, 6> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<66>, ZPZV<4>, ZPZV<22>, ZPZV<2>>; }; // NOLINT
5286 template<> struct ConwayPolynomial<131, 7> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<129>>; }; // NOLINT
5287 template<> struct ConwayPolynomial<131, 8> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<72>, ZPZV<116>, ZPZV<104>, ZPZV<2>>; }; // NOLINT
5288 template<> struct ConwayPolynomial<131, 9> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<6>, ZPZV<19>, ZPZV<129>>; }; // NOLINT
5289 template<> struct ConwayPolynomial<131, 10> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<124>, ZPZV<97>, ZPZV<9>, ZPZV<126>, ZPZV<44>, ZPZV<2>>; }; // NOLINT
5290 template<> struct ConwayPolynomial<131, 11> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<129>>; }; // NOLINT
5291 template<> struct ConwayPolynomial<131, 12> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<50>, ZPZV<122>, ZPZV<40>, ZPZV<83>, ZPZV<125>, ZPZV<28>, ZPZV<103>, ZPZV<2>>; }; // NOLINT
5292 template<> struct ConwayPolynomial<131, 13> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<129>>; }; // NOLINT
5293 template<> struct ConwayPolynomial<131, 17> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<129>>; }; // NOLINT
5294 template<> struct ConwayPolynomial<131, 19> { using ZPZ = aerobus::zpz<131>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<129>>; }; // NOLINT
5295 template<> struct ConwayPolynomial<137, 1> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<134>>; }; // NOLINT
5296 template<> struct ConwayPolynomial<137, 2> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<131>, ZPZV<3>>; }; // NOLINT
5297 template<> struct ConwayPolynomial<137, 3> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<134>>; }; // NOLINT
5298 template<> struct ConwayPolynomial<137, 4> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<95>, ZPZV<3>>; }; // NOLINT
5299 template<> struct ConwayPolynomial<137, 5> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<134>>; }; // NOLINT
5300 template<> struct ConwayPolynomial<137, 6> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<116>, ZPZV<102>, ZPZV<3>, ZPZV<3>>; }; // NOLINT
5301 template<> struct ConwayPolynomial<137, 7> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<134>>; }; // NOLINT
5302 template<> struct ConwayPolynomial<137, 8> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<105>, ZPZV<21>, ZPZV<34>, ZPZV<3>>; }; // NOLINT
5303 template<> struct ConwayPolynomial<137, 9> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<80>, ZPZV<122>, ZPZV<134>>; }; // NOLINT
5304 template<> struct ConwayPolynomial<137, 10> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<0>, ZPZV<20>, ZPZV<67>, ZPZV<93>, ZPZV<119>, ZPZV<3>>; }; // NOLINT
5305 template<> struct ConwayPolynomial<137, 11> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<134>>; }; // NOLINT
5306 template<> struct ConwayPolynomial<137, 12> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<61>, ZPZV<40>, ZPZV<40>, ZPZV<12>, ZPZV<36>, ZPZV<135>, ZPZV<61>, ZPZV<3>>; }; // NOLINT
5307 template<> struct ConwayPolynomial<137, 13> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<134>>; }; // NOLINT
5308 template<> struct ConwayPolynomial<137, 17> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<136>, ZPZV<4>, ZPZV<134>>; }; // NOLINT
5309 template<> struct ConwayPolynomial<137, 19> { using ZPZ = aerobus::zpz<137>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<134>>; }; // NOLINT
5310 template<> struct ConwayPolynomial<139, 1> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<137>>; }; // NOLINT
5311 template<> struct ConwayPolynomial<139, 2> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<138>, ZPZV<2>>; }; // NOLINT
5312 template<> struct ConwayPolynomial<139, 3> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<137>>; }; // NOLINT
5313 template<> struct ConwayPolynomial<139, 4> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<96>, ZPZV<2>>; }; // NOLINT
5314 template<> struct ConwayPolynomial<139, 5> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<137>>; }; // NOLINT
5315 template<> struct ConwayPolynomial<139, 6> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<46>, ZPZV<10>, ZPZV<118>, ZPZV<2>>; }; // NOLINT
5316 template<> struct ConwayPolynomial<139, 7> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<137>>; }; // NOLINT
5317 template<> struct ConwayPolynomial<139, 8> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<103>, ZPZV<36>, ZPZV<21>, ZPZV<2>>; }; // NOLINT
5318 template<> struct ConwayPolynomial<139, 9> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<70>, ZPZV<87>, ZPZV<137>>; }; // NOLINT
5319 template<> struct ConwayPolynomial<139, 10> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<110>, ZPZV<48>, ZPZV<130>, ZPZV<66>, ZPZV<106>, ZPZV<2>>; }; // NOLINT
5320 template<> struct ConwayPolynomial<139, 11> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<137>>; }; // NOLINT
5321 template<> struct ConwayPolynomial<139, 12> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<120>, ZPZV<75>, ZPZV<41>, ZPZV<77>, ZPZV<106>, ZPZV<8>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
5322 template<> struct ConwayPolynomial<139, 13> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<137>>; }; // NOLINT
5323 template<> struct ConwayPolynomial<139, 17> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<137>>; }; // NOLINT
5324 template<> struct ConwayPolynomial<139, 19> { using ZPZ = aerobus::zpz<139>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<23>, ZPZV<137>>; }; // NOLINT
5325 template<> struct ConwayPolynomial<149, 1> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<147>>; }; // NOLINT
5326 template<> struct ConwayPolynomial<149, 2> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<145>, ZPZV<2>>; }; // NOLINT
5327 template<> struct ConwayPolynomial<149, 3> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<147>>; }; // NOLINT
5328 template<> struct ConwayPolynomial<149, 4> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<107>, ZPZV<2>>; }; // NOLINT
5329 template<> struct ConwayPolynomial<149, 5> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<147>>; }; // NOLINT
5330 template<> struct ConwayPolynomial<149, 6> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<105>, ZPZV<33>, ZPZV<55>, ZPZV<2>>; }; // NOLINT
5331 template<> struct ConwayPolynomial<149, 7> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<147>>; }; // NOLINT
5332 template<> struct ConwayPolynomial<149, 8> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<140>, ZPZV<25>, ZPZV<123>, ZPZV<2>>; }; // NOLINT
5333 template<> struct ConwayPolynomial<149, 9> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<146>, ZPZV<20>, ZPZV<147>>; }; // NOLINT
5334 template<> struct ConwayPolynomial<149, 10> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<74>, ZPZV<42>, ZPZV<148>, ZPZV<143>, ZPZV<51>, ZPZV<2>>; }; // NOLINT
5335 template<> struct ConwayPolynomial<149, 11> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<33>, ZPZV<147>>; }; // NOLINT
5336 template<> struct ConwayPolynomial<149, 12> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<121>, ZPZV<91>, ZPZV<52>, ZPZV<9>, ZPZV<104>, ZPZV<110>, ZPZV<2>>; }; // NOLINT
5337 template<> struct ConwayPolynomial<149, 13> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<147>>; }; // NOLINT
5338 template<> struct ConwayPolynomial<149, 17> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<29>, ZPZV<147>>; }; // NOLINT
5339 template<> struct ConwayPolynomial<149, 19> { using ZPZ = aerobus::zpz<149>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<147>>; }; // NOLINT
5340 template<> struct ConwayPolynomial<151, 1> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<145>>; }; // NOLINT
5341 template<> struct ConwayPolynomial<151, 2> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<149>, ZPZV<6>>; }; // NOLINT
5342 template<> struct ConwayPolynomial<151, 3> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<145>>; }; // NOLINT
5343 template<> struct ConwayPolynomial<151, 4> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<13>, ZPZV<89>, ZPZV<6>>; }; // NOLINT
5344 template<> struct ConwayPolynomial<151, 5> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<145>>; }; // NOLINT
5345 template<> struct ConwayPolynomial<151, 6> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<125>, ZPZV<18>, ZPZV<15>, ZPZV<6>>; }; // NOLINT
5346 template<> struct ConwayPolynomial<151, 7> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<145>>; }; // NOLINT
5347 template<> struct ConwayPolynomial<151, 8> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<140>, ZPZV<122>, ZPZV<43>, ZPZV<6>>; }; // NOLINT
5348 template<> struct ConwayPolynomial<151, 9> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<126>, ZPZV<96>, ZPZV<145>>; }; // NOLINT
5349 template<> struct ConwayPolynomial<151, 10> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<21>, ZPZV<104>, ZPZV<49>, ZPZV<20>, ZPZV<142>, ZPZV<6>>; }; // NOLINT
5350 template<> struct ConwayPolynomial<151, 11> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<145>>; }; // NOLINT
5351 template<> struct ConwayPolynomial<151, 12> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<109>, ZPZV<121>, ZPZV<101>, ZPZV<6>, ZPZV<77>, ZPZV<107>, ZPZV<147>, ZPZV<6>>; }; // NOLINT
5352 template<> struct ConwayPolynomial<151, 13> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<145>>; }; // NOLINT
5353 template<> struct ConwayPolynomial<151, 17> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<145>>; }; // NOLINT
5354 template<> struct ConwayPolynomial<151, 19> { using ZPZ = aerobus::zpz<151>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<145>>; }; // NOLINT
5355 template<> struct ConwayPolynomial<157, 1> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<152>>; }; // NOLINT
5356 template<> struct ConwayPolynomial<157, 2> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<152>, ZPZV<5>>; }; // NOLINT
5357 template<> struct ConwayPolynomial<157, 3> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<152>>; }; // NOLINT
5358 template<> struct ConwayPolynomial<157, 4> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<136>, ZPZV<5>>; }; // NOLINT
5359 template<> struct ConwayPolynomial<157, 5> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<152>>; }; // NOLINT
5360 template<> struct ConwayPolynomial<157, 6> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<130>, ZPZV<43>, ZPZV<144>, ZPZV<5>>; }; // NOLINT
5361 template<> struct ConwayPolynomial<157, 7> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<152>>; }; // NOLINT
5362 template<> struct ConwayPolynomial<157, 8> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<97>, ZPZV<40>, ZPZV<153>, ZPZV<5>>; }; // NOLINT
5363 template<> struct ConwayPolynomial<157, 9> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<114>, ZPZV<52>, ZPZV<152>>; }; // NOLINT
5364 template<> struct ConwayPolynomial<157, 10> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<61>, ZPZV<22>, ZPZV<124>, ZPZV<61>, ZPZV<93>, ZPZV<5>>; }; // NOLINT
5365 template<> struct ConwayPolynomial<157, 11> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<29>, ZPZV<152>>; }; // NOLINT
5366 template<> struct ConwayPolynomial<157, 12> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<77>, ZPZV<110>, ZPZV<72>, ZPZV<137>, ZPZV<43>, ZPZV<152>, ZPZV<57>, ZPZV<5>>; }; // NOLINT
5367 template<> struct ConwayPolynomial<157, 13> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<156>, ZPZV<9>, ZPZV<152>>; }; // NOLINT
5368 template<> struct ConwayPolynomial<157, 17> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<152>>; }; // NOLINT
5369 template<> struct ConwayPolynomial<157, 19> { using ZPZ = aerobus::zpz<157>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<152>>; }; // NOLINT
5370 template<> struct ConwayPolynomial<163, 1> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<161>>; }; // NOLINT
5371 template<> struct ConwayPolynomial<163, 2> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<159>, ZPZV<2>>; }; // NOLINT
5372 template<> struct ConwayPolynomial<163, 3> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<161>>; }; // NOLINT
5373 template<> struct ConwayPolynomial<163, 4> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<91>, ZPZV<2>>; }; // NOLINT
5374 template<> struct ConwayPolynomial<163, 5> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<161>>; }; // NOLINT
5375 template<> struct ConwayPolynomial<163, 6> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<83>, ZPZV<25>, ZPZV<156>, ZPZV<2>>; }; // NOLINT
5376 template<> struct ConwayPolynomial<163, 7> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<161>>; }; // NOLINT
5377 template<> struct ConwayPolynomial<163, 8> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<132>, ZPZV<83>, ZPZV<6>, ZPZV<2>>; }; // NOLINT
5378 template<> struct ConwayPolynomial<163, 9> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<162>, ZPZV<127>, ZPZV<161>>; }; // NOLINT
5379 template<> struct ConwayPolynomial<163, 10> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<111>, ZPZV<120>, ZPZV<125>, ZPZV<15>, ZPZV<0>, ZPZV<2>>; }; // NOLINT
5380 template<> struct ConwayPolynomial<163, 11> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<161>>; }; // NOLINT
5381 template<> struct ConwayPolynomial<163, 12> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<39>, ZPZV<112>, ZPZV<31>, ZPZV<38>, ZPZV<103>, ZPZV<10>, ZPZV<69>, ZPZV<2>>; }; // NOLINT
5382 template<> struct ConwayPolynomial<163, 13> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<161>>; }; // NOLINT
5383 template<> struct ConwayPolynomial<163, 17> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<71>, ZPZV<161>>; }; // NOLINT
5384 template<> struct ConwayPolynomial<163, 19> { using ZPZ = aerobus::zpz<163>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<161>>; }; // NOLINT
5385 template<> struct ConwayPolynomial<167, 1> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<162>>; }; // NOLINT
5386 template<> struct ConwayPolynomial<167, 2> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<166>, ZPZV<5>>; }; // NOLINT
5387 template<> struct ConwayPolynomial<167, 3> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<162>>; }; // NOLINT
5388 template<> struct ConwayPolynomial<167, 4> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<120>, ZPZV<5>>; }; // NOLINT
5389 template<> struct ConwayPolynomial<167, 5> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<162>>; }; // NOLINT
5390 template<> struct ConwayPolynomial<167, 6> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<75>, ZPZV<38>, ZPZV<2>, ZPZV<5>>; }; // NOLINT
5391 template<> struct ConwayPolynomial<167, 7> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<162>>; }; // NOLINT
5392 template<> struct ConwayPolynomial<167, 8> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<149>, ZPZV<56>, ZPZV<113>, ZPZV<5>>; }; // NOLINT
5393 template<> struct ConwayPolynomial<167, 9> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<165>, ZPZV<122>, ZPZV<162>>; }; // NOLINT
5394 template<> struct ConwayPolynomial<167, 10> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<85>, ZPZV<68>, ZPZV<109>, ZPZV<143>, ZPZV<148>, ZPZV<5>>; }; // NOLINT
5395 template<> struct ConwayPolynomial<167, 11> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<162>>; }; // NOLINT
5396 template<> struct ConwayPolynomial<167, 12> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<142>, ZPZV<10>, ZPZV<142>, ZPZV<131>, ZPZV<140>, ZPZV<41>, ZPZV<57>, ZPZV<5>>; }; // NOLINT
5397 template<> struct ConwayPolynomial<167, 13> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<162>>; }; // NOLINT
5398 template<> struct ConwayPolynomial<167, 17> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<32>, ZPZV<162>>; }; // NOLINT
5399 template<> struct ConwayPolynomial<167, 19> { using ZPZ = aerobus::zpz<167>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<162>>; }; // NOLINT
5400 template<> struct ConwayPolynomial<173, 1> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<171>>; }; // NOLINT
5401 template<> struct ConwayPolynomial<173, 2> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<169>, ZPZV<2>>; }; // NOLINT
5402 template<> struct ConwayPolynomial<173, 3> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<171>>; }; // NOLINT
5403 template<> struct ConwayPolynomial<173, 4> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<102>, ZPZV<2>>; }; // NOLINT
5404 template<> struct ConwayPolynomial<173, 5> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<171>>; }; // NOLINT
5405 template<> struct ConwayPolynomial<173, 6> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<27>, ZPZV<134>, ZPZV<107>, ZPZV<2>>; }; // NOLINT
5406 template<> struct ConwayPolynomial<173, 7> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<171>>; }; // NOLINT
5407 template<> struct ConwayPolynomial<173, 8> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<125>, ZPZV<158>, ZPZV<27>, ZPZV<2>>; }; // NOLINT
5408 template<> struct ConwayPolynomial<173, 9> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<56>, ZPZV<104>, ZPZV<171>>; }; // NOLINT
5409 template<> struct ConwayPolynomial<173, 10> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<156>, ZPZV<164>, ZPZV<48>, ZPZV<106>, ZPZV<58>, ZPZV<2>>; }; // NOLINT
5410 template<> struct ConwayPolynomial<173, 11> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<171>>; }; // NOLINT
5411 template<> struct ConwayPolynomial<173, 12> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<29>, ZPZV<64>, ZPZV<46>, ZPZV<166>, ZPZV<0>, ZPZV<159>, ZPZV<22>, ZPZV<2>>; }; // NOLINT
5412 template<> struct ConwayPolynomial<173, 13> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<171>>; }; // NOLINT
5413 template<> struct ConwayPolynomial<173, 17> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<171>>; }; // NOLINT
5414 template<> struct ConwayPolynomial<173, 19> { using ZPZ = aerobus::zpz<173>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<171>>; }; // NOLINT
5415 template<> struct ConwayPolynomial<179, 1> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<177>>; }; // NOLINT
5416 template<> struct ConwayPolynomial<179, 2> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<172>, ZPZV<2>>; }; // NOLINT
5417 template<> struct ConwayPolynomial<179, 3> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<177>>; }; // NOLINT
5418 template<> struct ConwayPolynomial<179, 4> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<109>, ZPZV<2>>; }; // NOLINT
5419 template<> struct ConwayPolynomial<179, 5> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<177>>; }; // NOLINT
5420 template<> struct ConwayPolynomial<179, 6> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<91>, ZPZV<55>, ZPZV<109>, ZPZV<2>>; }; // NOLINT
5421 template<> struct ConwayPolynomial<179, 7> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<177>>; }; // NOLINT
5422 template<> struct ConwayPolynomial<179, 8> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<163>, ZPZV<144>, ZPZV<73>, ZPZV<2>>; }; // NOLINT
5423 template<> struct ConwayPolynomial<179, 9> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<40>, ZPZV<64>, ZPZV<177>>; }; // NOLINT
5424 template<> struct ConwayPolynomial<179, 10> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<115>, ZPZV<71>, ZPZV<150>, ZPZV<49>, ZPZV<87>, ZPZV<2>>; }; // NOLINT
5425 template<> struct ConwayPolynomial<179, 11> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<177>>; }; // NOLINT
5426 template<> struct ConwayPolynomial<179, 12> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<103>, ZPZV<83>, ZPZV<43>, ZPZV<76>, ZPZV<8>, ZPZV<177>, ZPZV<1>, ZPZV<2>>; }; // NOLINT
5427 template<> struct ConwayPolynomial<179, 13> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<177>>; }; // NOLINT
5428 template<> struct ConwayPolynomial<179, 17> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<177>>; }; // NOLINT
5429 template<> struct ConwayPolynomial<179, 19> { using ZPZ = aerobus::zpz<179>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<177>>; }; // NOLINT
5430 template<> struct ConwayPolynomial<181, 1> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<179>>; }; // NOLINT
5431 template<> struct ConwayPolynomial<181, 2> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<177>, ZPZV<2>>; }; // NOLINT
5432 template<> struct ConwayPolynomial<181, 3> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<179>>; }; // NOLINT
5433 template<> struct ConwayPolynomial<181, 4> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<105>, ZPZV<2>>; }; // NOLINT
5434 template<> struct ConwayPolynomial<181, 5> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<21>, ZPZV<179>>; }; // NOLINT
5435 template<> struct ConwayPolynomial<181, 6> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<177>, ZPZV<163>, ZPZV<169>, ZPZV<2>>; }; // NOLINT
5436 template<> struct ConwayPolynomial<181, 7> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<179>>; }; // NOLINT
5437 template<> struct ConwayPolynomial<181, 8> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<108>, ZPZV<22>, ZPZV<149>, ZPZV<2>>; }; // NOLINT
5438 template<> struct ConwayPolynomial<181, 9> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<107>, ZPZV<168>, ZPZV<179>>; }; // NOLINT
5439 template<> struct ConwayPolynomial<181, 10> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<154>, ZPZV<104>, ZPZV<94>, ZPZV<57>, ZPZV<88>, ZPZV<2>>; }; // NOLINT
5440 template<> struct ConwayPolynomial<181, 11> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<179>>; }; // NOLINT
5441 template<> struct ConwayPolynomial<181, 12> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<171>, ZPZV<141>, ZPZV<45>, ZPZV<122>, ZPZV<175>, ZPZV<12>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
5442 template<> struct ConwayPolynomial<181, 13> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<179>>; }; // NOLINT
5443 template<> struct ConwayPolynomial<181, 17> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<179>>; }; // NOLINT
5444 template<> struct ConwayPolynomial<181, 19> { using ZPZ = aerobus::zpz<181>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<36>, ZPZV<179>>; }; // NOLINT
5445 template<> struct ConwayPolynomial<191, 1> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<172>>; }; // NOLINT
5446 template<> struct ConwayPolynomial<191, 2> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<190>, ZPZV<19>>; }; // NOLINT
5447 template<> struct ConwayPolynomial<191, 3> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<172>>; }; // NOLINT
5448 template<> struct ConwayPolynomial<191, 4> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<100>, ZPZV<19>>; }; // NOLINT
5449 template<> struct ConwayPolynomial<191, 5> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<172>>; }; // NOLINT
5450 template<> struct ConwayPolynomial<191, 6> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<110>, ZPZV<10>, ZPZV<10>, ZPZV<19>>; }; // NOLINT
5451 template<> struct ConwayPolynomial<191, 7> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<172>>; }; // NOLINT
5452 template<> struct ConwayPolynomial<191, 8> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<164>, ZPZV<139>, ZPZV<171>, ZPZV<19>>; }; // NOLINT
5453 template<> struct ConwayPolynomial<191, 9> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<62>, ZPZV<124>, ZPZV<172>>; }; // NOLINT
5454 template<> struct ConwayPolynomial<191, 10> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<113>, ZPZV<47>, ZPZV<173>, ZPZV<74>, ZPZV<156>, ZPZV<19>>; }; // NOLINT
5455 template<> struct ConwayPolynomial<191, 11> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<172>>; }; // NOLINT
5456 template<> struct ConwayPolynomial<191, 12> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<79>, ZPZV<168>, ZPZV<25>, ZPZV<49>, ZPZV<90>, ZPZV<7>, ZPZV<151>, ZPZV<19>>; }; // NOLINT
5457 template<> struct ConwayPolynomial<191, 13> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<172>>; }; // NOLINT
5458 template<> struct ConwayPolynomial<191, 17> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<172>>; }; // NOLINT
5459 template<> struct ConwayPolynomial<191, 19> { using ZPZ = aerobus::zpz<191>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<190>, ZPZV<2>, ZPZV<172>>; }; // NOLINT
5460 template<> struct ConwayPolynomial<193, 1> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<188>>; }; // NOLINT
5461 template<> struct ConwayPolynomial<193, 2> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<192>, ZPZV<5>>; }; // NOLINT
5462 template<> struct ConwayPolynomial<193, 3> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<188>>; }; // NOLINT
5463 template<> struct ConwayPolynomial<193, 4> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<148>, ZPZV<5>>; }; // NOLINT
5464 template<> struct ConwayPolynomial<193, 5> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<188>>; }; // NOLINT
5465 template<> struct ConwayPolynomial<193, 6> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<149>, ZPZV<8>, ZPZV<172>, ZPZV<5>>; }; // NOLINT
5466 template<> struct ConwayPolynomial<193, 7> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<188>>; }; // NOLINT
5467 template<> struct ConwayPolynomial<193, 8> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<145>, ZPZV<34>, ZPZV<154>, ZPZV<5>>; }; // NOLINT
5468 template<> struct ConwayPolynomial<193, 9> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<168>, ZPZV<27>, ZPZV<188>>; }; // NOLINT
5469 template<> struct ConwayPolynomial<193, 10> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<51>, ZPZV<77>, ZPZV<0>, ZPZV<89>, ZPZV<5>>; }; // NOLINT
5470 template<> struct ConwayPolynomial<193, 11> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<188>>; }; // NOLINT
5471 template<> struct ConwayPolynomial<193, 12> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<155>, ZPZV<52>, ZPZV<135>, ZPZV<152>, ZPZV<90>, ZPZV<46>, ZPZV<28>, ZPZV<5>>; }; // NOLINT
5472 template<> struct ConwayPolynomial<193, 13> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<39>, ZPZV<188>>; }; // NOLINT
5473 template<> struct ConwayPolynomial<193, 17> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<188>>; }; // NOLINT
5474 template<> struct ConwayPolynomial<193, 19> { using ZPZ = aerobus::zpz<193>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<188>>; }; // NOLINT
5475 template<> struct ConwayPolynomial<197, 1> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<195>>; }; // NOLINT
5476 template<> struct ConwayPolynomial<197, 2> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<192>, ZPZV<2>>; }; // NOLINT
5477 template<> struct ConwayPolynomial<197, 3> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<195>>; }; // NOLINT
5478 template<> struct ConwayPolynomial<197, 4> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<16>, ZPZV<124>, ZPZV<2>>; }; // NOLINT
5479 template<> struct ConwayPolynomial<197, 5> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<195>>; }; // NOLINT
5480 template<> struct ConwayPolynomial<197, 6> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<124>, ZPZV<79>, ZPZV<173>, ZPZV<2>>; }; // NOLINT
5481 template<> struct ConwayPolynomial<197, 7> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<195>>; }; // NOLINT
5482 template<> struct ConwayPolynomial<197, 8> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<176>, ZPZV<96>, ZPZV<29>, ZPZV<2>>; }; // NOLINT
5483 template<> struct ConwayPolynomial<197, 9> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<127>, ZPZV<8>, ZPZV<195>>; }; // NOLINT
5484 template<> struct ConwayPolynomial<197, 10> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<121>, ZPZV<137>, ZPZV<8>, ZPZV<73>, ZPZV<42>, ZPZV<2>>; }; // NOLINT
5485 template<> struct ConwayPolynomial<197, 11> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<195>>; }; // NOLINT
5486 template<> struct ConwayPolynomial<197, 12> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<168>, ZPZV<15>, ZPZV<130>, ZPZV<141>, ZPZV<9>, ZPZV<90>, ZPZV<163>, ZPZV<2>>; }; // NOLINT
5487 template<> struct ConwayPolynomial<197, 13> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<39>, ZPZV<195>>; }; // NOLINT
5488 template<> struct ConwayPolynomial<197, 17> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<35>, ZPZV<195>>; }; // NOLINT
5489 template<> struct ConwayPolynomial<197, 19> { using ZPZ = aerobus::zpz<197>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<195>>; }; // NOLINT
5490 template<> struct ConwayPolynomial<199, 1> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<196>>; }; // NOLINT
5491 template<> struct ConwayPolynomial<199, 2> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<193>, ZPZV<3>>; }; // NOLINT
5492 template<> struct ConwayPolynomial<199, 3> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<196>>; }; // NOLINT
5493 template<> struct ConwayPolynomial<199, 4> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<162>, ZPZV<3>>; }; // NOLINT
5494 template<> struct ConwayPolynomial<199, 5> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<196>>; }; // NOLINT
5495 template<> struct ConwayPolynomial<199, 6> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<90>, ZPZV<58>, ZPZV<79>, ZPZV<3>>; }; // NOLINT
5496 template<> struct ConwayPolynomial<199, 7> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<196>>; }; // NOLINT
5497 template<> struct ConwayPolynomial<199, 8> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<160>, ZPZV<23>, ZPZV<159>, ZPZV<3>>; }; // NOLINT
5498 template<> struct ConwayPolynomial<199, 9> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<177>, ZPZV<141>, ZPZV<196>>; }; // NOLINT
5499 template<> struct ConwayPolynomial<199, 10> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<171>, ZPZV<158>, ZPZV<31>, ZPZV<54>, ZPZV<9>, ZPZV<3>>; }; // NOLINT
5500 template<> struct ConwayPolynomial<199, 11> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<196>>; }; // NOLINT
5501 template<> struct ConwayPolynomial<199, 12> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<33>, ZPZV<192>, ZPZV<197>, ZPZV<138>, ZPZV<69>, ZPZV<57>, ZPZV<151>, ZPZV<3>>; }; // NOLINT
5502 template<> struct ConwayPolynomial<199, 13> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<196>>; }; // NOLINT
5503 template<> struct ConwayPolynomial<199, 17> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<196>>; }; // NOLINT
5504 template<> struct ConwayPolynomial<199, 19> { using ZPZ = aerobus::zpz<199>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<196>>; }; // NOLINT
5505 template<> struct ConwayPolynomial<211, 1> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<209>>; }; // NOLINT
5506 template<> struct ConwayPolynomial<211, 2> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<207>, ZPZV<2>>; }; // NOLINT
5507 template<> struct ConwayPolynomial<211, 3> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<209>>; }; // NOLINT
5508 template<> struct ConwayPolynomial<211, 4> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<161>, ZPZV<2>>; }; // NOLINT
5509 template<> struct ConwayPolynomial<211, 5> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<209>>; }; // NOLINT
5510 template<> struct ConwayPolynomial<211, 6> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<81>, ZPZV<194>, ZPZV<133>, ZPZV<2>>; }; // NOLINT
5511 template<> struct ConwayPolynomial<211, 7> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<209>>; }; // NOLINT
5512 template<> struct ConwayPolynomial<211, 8> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<200>, ZPZV<87>, ZPZV<29>, ZPZV<2>>; }; // NOLINT
5513 template<> struct ConwayPolynomial<211, 9> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<139>, ZPZV<26>, ZPZV<209>>; }; // NOLINT
5514 template<> struct ConwayPolynomial<211, 10> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<30>, ZPZV<61>, ZPZV<148>, ZPZV<87>, ZPZV<125>, ZPZV<2>>; }; // NOLINT
5515 template<> struct ConwayPolynomial<211, 11> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<209>>; }; // NOLINT
5516 template<> struct ConwayPolynomial<211, 12> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<50>, ZPZV<145>, ZPZV<126>, ZPZV<184>, ZPZV<84>, ZPZV<27>, ZPZV<2>>; }; // NOLINT
5517 template<> struct ConwayPolynomial<211, 13> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<209>>; }; // NOLINT
5518 template<> struct ConwayPolynomial<211, 17> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<209>>; }; // NOLINT
5519 template<> struct ConwayPolynomial<211, 19> { using ZPZ = aerobus::zpz<211>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<209>>; }; // NOLINT
5520 template<> struct ConwayPolynomial<223, 1> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<220>>; }; // NOLINT
5521 template<> struct ConwayPolynomial<223, 2> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<221>, ZPZV<3>>; }; // NOLINT
5522 template<> struct ConwayPolynomial<223, 3> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<220>>; }; // NOLINT
5523 template<> struct ConwayPolynomial<223, 4> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<163>, ZPZV<3>>; }; // NOLINT
5524 template<> struct ConwayPolynomial<223, 5> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<220>>; }; // NOLINT
5525 template<> struct ConwayPolynomial<223, 6> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<68>, ZPZV<24>, ZPZV<196>, ZPZV<3>>; }; // NOLINT
5526 template<> struct ConwayPolynomial<223, 7> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<220>>; }; // NOLINT
5527 template<> struct ConwayPolynomial<223, 8> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<139>, ZPZV<98>, ZPZV<138>, ZPZV<3>>; }; // NOLINT
5528 template<> struct ConwayPolynomial<223, 9> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<164>, ZPZV<64>, ZPZV<220>>; }; // NOLINT
5529 template<> struct ConwayPolynomial<223, 10> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<118>, ZPZV<177>, ZPZV<87>, ZPZV<99>, ZPZV<62>, ZPZV<3>>; }; // NOLINT
5530 template<> struct ConwayPolynomial<223, 11> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<220>>; }; // NOLINT
5531 template<> struct ConwayPolynomial<223, 12> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<64>, ZPZV<94>, ZPZV<11>, ZPZV<105>, ZPZV<64>, ZPZV<151>, ZPZV<213>, ZPZV<3>>; }; // NOLINT
5532 template<> struct ConwayPolynomial<223, 13> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<23>, ZPZV<220>>; }; // NOLINT
5533 template<> struct ConwayPolynomial<223, 17> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<220>>; }; // NOLINT
5534 template<> struct ConwayPolynomial<223, 19> { using ZPZ = aerobus::zpz<223>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<220>>; }; // NOLINT
5535 template<> struct ConwayPolynomial<227, 1> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<225>>; }; // NOLINT
5536 template<> struct ConwayPolynomial<227, 2> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<220>, ZPZV<2>>; }; // NOLINT
5537 template<> struct ConwayPolynomial<227, 3> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<225>>; }; // NOLINT
5538 template<> struct ConwayPolynomial<227, 4> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<143>, ZPZV<2>>; }; // NOLINT
5539 template<> struct ConwayPolynomial<227, 5> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<225>>; }; // NOLINT
5540 template<> struct ConwayPolynomial<227, 6> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<174>, ZPZV<24>, ZPZV<135>, ZPZV<2>>; }; // NOLINT
5541 template<> struct ConwayPolynomial<227, 7> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<225>>; }; // NOLINT
5542 template<> struct ConwayPolynomial<227, 8> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<151>, ZPZV<176>, ZPZV<106>, ZPZV<2>>; }; // NOLINT
5543 template<> struct ConwayPolynomial<227, 9> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<24>, ZPZV<183>, ZPZV<225>>; }; // NOLINT
5544 template<> struct ConwayPolynomial<227, 10> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<199>, ZPZV<12>, ZPZV<93>, ZPZV<77>, ZPZV<2>>; }; // NOLINT
5545 template<> struct ConwayPolynomial<227, 11> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<225>>; }; // NOLINT
5546 template<> struct ConwayPolynomial<227, 12> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<123>, ZPZV<99>, ZPZV<160>, ZPZV<96>, ZPZV<127>, ZPZV<142>, ZPZV<94>, ZPZV<2>>; }; // NOLINT
5547 template<> struct ConwayPolynomial<227, 13> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<225>>; }; // NOLINT
5548 template<> struct ConwayPolynomial<227, 17> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<225>>; }; // NOLINT
5549 template<> struct ConwayPolynomial<227, 19> { using ZPZ = aerobus::zpz<227>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<34>, ZPZV<225>>; }; // NOLINT
5550 template<> struct ConwayPolynomial<229, 1> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<223>>; }; // NOLINT
5551 template<> struct ConwayPolynomial<229, 2> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<228>, ZPZV<6>>; }; // NOLINT
5552 template<> struct ConwayPolynomial<229, 3> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<223>>; }; // NOLINT
5553 template<> struct ConwayPolynomial<229, 4> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<162>, ZPZV<6>>; }; // NOLINT
5554 template<> struct ConwayPolynomial<229, 5> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<223>>; }; // NOLINT
5555 template<> struct ConwayPolynomial<229, 6> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<160>, ZPZV<186>, ZPZV<6>>; }; // NOLINT
5556 template<> struct ConwayPolynomial<229, 7> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<223>>; }; // NOLINT
5557 template<> struct ConwayPolynomial<229, 8> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<193>, ZPZV<62>, ZPZV<205>, ZPZV<6>>; }; // NOLINT
5558 template<> struct ConwayPolynomial<229, 9> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<117>, ZPZV<50>, ZPZV<223>>; }; // NOLINT
5559 template<> struct ConwayPolynomial<229, 10> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<185>, ZPZV<135>, ZPZV<158>, ZPZV<167>, ZPZV<98>, ZPZV<6>>; }; // NOLINT
5560 template<> struct ConwayPolynomial<229, 11> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<223>>; }; // NOLINT
5561 template<> struct ConwayPolynomial<229, 12> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<131>, ZPZV<140>, ZPZV<25>, ZPZV<6>, ZPZV<172>, ZPZV<9>, ZPZV<145>, ZPZV<6>>; }; // NOLINT
5562 template<> struct ConwayPolynomial<229, 13> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<47>, ZPZV<223>>; }; // NOLINT
5563 template<> struct ConwayPolynomial<229, 17> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<223>>; }; // NOLINT
5564 template<> struct ConwayPolynomial<229, 19> { using ZPZ = aerobus::zpz<229>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<228>, ZPZV<15>, ZPZV<223>>; }; // NOLINT
5565 template<> struct ConwayPolynomial<233, 1> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<230>>; }; // NOLINT
5566 template<> struct ConwayPolynomial<233, 2> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<232>, ZPZV<3>>; }; // NOLINT
5567 template<> struct ConwayPolynomial<233, 3> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<230>>; }; // NOLINT
5568 template<> struct ConwayPolynomial<233, 4> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<158>, ZPZV<3>>; }; // NOLINT
5569 template<> struct ConwayPolynomial<233, 5> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<230>>; }; // NOLINT
5570 template<> struct ConwayPolynomial<233, 6> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<122>, ZPZV<215>, ZPZV<32>, ZPZV<3>>; }; // NOLINT
5571 template<> struct ConwayPolynomial<233, 7> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<230>>; }; // NOLINT
5572 template<> struct ConwayPolynomial<233, 8> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<202>, ZPZV<135>, ZPZV<181>, ZPZV<3>>; }; // NOLINT
5573 template<> struct ConwayPolynomial<233, 9> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<56>, ZPZV<146>, ZPZV<230>>; }; // NOLINT
5574 template<> struct ConwayPolynomial<233, 10> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<28>, ZPZV<71>, ZPZV<102>, ZPZV<3>, ZPZV<48>, ZPZV<3>>; }; // NOLINT
5575 template<> struct ConwayPolynomial<233, 11> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<230>>; }; // NOLINT
5576 template<> struct ConwayPolynomial<233, 12> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<96>, ZPZV<21>, ZPZV<114>, ZPZV<31>, ZPZV<19>, ZPZV<216>, ZPZV<20>, ZPZV<3>>; }; // NOLINT
5577 template<> struct ConwayPolynomial<233, 13> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<230>>; }; // NOLINT
5578 template<> struct ConwayPolynomial<233, 17> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<230>>; }; // NOLINT
5579 template<> struct ConwayPolynomial<233, 19> { using ZPZ = aerobus::zpz<233>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<25>, ZPZV<230>>; }; // NOLINT
5580 template<> struct ConwayPolynomial<239, 1> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<232>>; }; // NOLINT
5581 template<> struct ConwayPolynomial<239, 2> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<237>, ZPZV<7>>; }; // NOLINT
5582 template<> struct ConwayPolynomial<239, 3> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<232>>; }; // NOLINT
5583 template<> struct ConwayPolynomial<239, 4> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<132>, ZPZV<7>>; }; // NOLINT
5584 template<> struct ConwayPolynomial<239, 5> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<232>>; }; // NOLINT
5585 template<> struct ConwayPolynomial<239, 6> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<237>, ZPZV<60>, ZPZV<200>, ZPZV<7>>; }; // NOLINT
5586 template<> struct ConwayPolynomial<239, 7> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<232>>; }; // NOLINT
5587 template<> struct ConwayPolynomial<239, 8> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<201>, ZPZV<202>, ZPZV<54>, ZPZV<7>>; }; // NOLINT
5588 template<> struct ConwayPolynomial<239, 9> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<2>, ZPZV<88>, ZPZV<232>>; }; // NOLINT
5589 template<> struct ConwayPolynomial<239, 10> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<57>, ZPZV<68>, ZPZV<226>, ZPZV<127>, ZPZV<108>, ZPZV<7>>; }; // NOLINT
5590 template<> struct ConwayPolynomial<239, 11> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<232>>; }; // NOLINT
5591 template<> struct ConwayPolynomial<239, 12> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<235>, ZPZV<14>, ZPZV<113>, ZPZV<182>, ZPZV<101>, ZPZV<81>, ZPZV<216>, ZPZV<7>>; }; // NOLINT
5592 template<> struct ConwayPolynomial<239, 13> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<232>>; }; // NOLINT
5593 template<> struct ConwayPolynomial<239, 17> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<232>>; }; // NOLINT
5594 template<> struct ConwayPolynomial<239, 19> { using ZPZ = aerobus::zpz<239>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<232>>; }; // NOLINT
5595 template<> struct ConwayPolynomial<241, 1> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<234>>; }; // NOLINT
5596 template<> struct ConwayPolynomial<241, 2> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<238>, ZPZV<7>>; }; // NOLINT
5597 template<> struct ConwayPolynomial<241, 3> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<234>>; }; // NOLINT
5598 template<> struct ConwayPolynomial<241, 4> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<14>, ZPZV<152>, ZPZV<7>>; }; // NOLINT
5599 template<> struct ConwayPolynomial<241, 5> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<234>>; }; // NOLINT
5600 template<> struct ConwayPolynomial<241, 6> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<83>, ZPZV<6>, ZPZV<5>, ZPZV<7>>; }; // NOLINT
5601 template<> struct ConwayPolynomial<241, 7> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<234>>; }; // NOLINT
5602 template<> struct ConwayPolynomial<241, 8> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<173>, ZPZV<212>, ZPZV<153>, ZPZV<7>>; }; // NOLINT
5603 template<> struct ConwayPolynomial<241, 9> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<236>, ZPZV<125>, ZPZV<234>>; }; // NOLINT
5604 template<> struct ConwayPolynomial<241, 10> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<29>, ZPZV<27>, ZPZV<145>, ZPZV<208>, ZPZV<55>, ZPZV<7>>; }; // NOLINT
5605 template<> struct ConwayPolynomial<241, 11> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<234>>; }; // NOLINT
5606 template<> struct ConwayPolynomial<241, 12> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<42>, ZPZV<10>, ZPZV<109>, ZPZV<168>, ZPZV<22>, ZPZV<197>, ZPZV<17>, ZPZV<7>>; }; // NOLINT
5607 template<> struct ConwayPolynomial<241, 13> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<234>>; }; // NOLINT
5608 template<> struct ConwayPolynomial<241, 17> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<234>>; }; // NOLINT
5609 template<> struct ConwayPolynomial<241, 19> { using ZPZ = aerobus::zpz<241>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<234>>; }; // NOLINT
5610 template<> struct ConwayPolynomial<251, 1> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<245>>; }; // NOLINT
5611 template<> struct ConwayPolynomial<251, 2> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<242>, ZPZV<6>>; }; // NOLINT
5612 template<> struct ConwayPolynomial<251, 3> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<245>>; }; // NOLINT
5613 template<> struct ConwayPolynomial<251, 4> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<200>, ZPZV<6>>; }; // NOLINT
5614 template<> struct ConwayPolynomial<251, 5> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<245>>; }; // NOLINT
5615 template<> struct ConwayPolynomial<251, 6> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<247>, ZPZV<151>, ZPZV<179>, ZPZV<6>>; }; // NOLINT
5616 template<> struct ConwayPolynomial<251, 7> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<245>>; }; // NOLINT
5617 template<> struct ConwayPolynomial<251, 8> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<142>, ZPZV<215>, ZPZV<173>, ZPZV<6>>; }; // NOLINT
5618 template<> struct ConwayPolynomial<251, 9> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<187>, ZPZV<106>, ZPZV<245>>; }; // NOLINT
5619 template<> struct ConwayPolynomial<251, 10> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<138>, ZPZV<110>, ZPZV<45>, ZPZV<34>, ZPZV<149>, ZPZV<6>>; }; // NOLINT
5620 template<> struct ConwayPolynomial<251, 11> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<26>, ZPZV<245>>; }; // NOLINT
5621 template<> struct ConwayPolynomial<251, 12> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<192>, ZPZV<53>, ZPZV<20>, ZPZV<20>, ZPZV<15>, ZPZV<201>, ZPZV<232>, ZPZV<6>>; }; // NOLINT
5622 template<> struct ConwayPolynomial<251, 13> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<245>>; }; // NOLINT
5623 template<> struct ConwayPolynomial<251, 17> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<245>>; }; // NOLINT
5624 template<> struct ConwayPolynomial<251, 19> { using ZPZ = aerobus::zpz<251>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<245>>; }; // NOLINT
5625 template<> struct ConwayPolynomial<257, 1> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<254>>; }; // NOLINT
5626 template<> struct ConwayPolynomial<257, 2> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<251>, ZPZV<3>>; }; // NOLINT
5627 template<> struct ConwayPolynomial<257, 3> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<254>>; }; // NOLINT
5628 template<> struct ConwayPolynomial<257, 4> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<16>, ZPZV<187>, ZPZV<3>>; }; // NOLINT
5629 template<> struct ConwayPolynomial<257, 5> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<254>>; }; // NOLINT
5630 template<> struct ConwayPolynomial<257, 6> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<62>, ZPZV<18>, ZPZV<138>, ZPZV<3>>; }; // NOLINT
5631 template<> struct ConwayPolynomial<257, 7> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<31>, ZPZV<254>>; }; // NOLINT
5632 template<> struct ConwayPolynomial<257, 8> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<179>, ZPZV<140>, ZPZV<162>, ZPZV<3>>; }; // NOLINT
5633 template<> struct ConwayPolynomial<257, 9> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<201>, ZPZV<50>, ZPZV<254>>; }; // NOLINT
5634 template<> struct ConwayPolynomial<257, 10> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<97>, ZPZV<12>, ZPZV<225>, ZPZV<180>, ZPZV<20>, ZPZV<3>>; }; // NOLINT
5635 template<> struct ConwayPolynomial<257, 11> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<40>, ZPZV<254>>; }; // NOLINT
5636 template<> struct ConwayPolynomial<257, 12> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<13>, ZPZV<225>, ZPZV<215>, ZPZV<173>, ZPZV<249>, ZPZV<148>, ZPZV<20>, ZPZV<3>>; }; // NOLINT
5637 template<> struct ConwayPolynomial<257, 13> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<254>>; }; // NOLINT
5638 template<> struct ConwayPolynomial<257, 17> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<254>>; }; // NOLINT
5639 template<> struct ConwayPolynomial<257, 19> { using ZPZ = aerobus::zpz<257>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<254>>; }; // NOLINT
5640 template<> struct ConwayPolynomial<263, 1> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<258>>; }; // NOLINT
5641 template<> struct ConwayPolynomial<263, 2> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<261>, ZPZV<5>>; }; // NOLINT
5642 template<> struct ConwayPolynomial<263, 3> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<14>, ZPZV<258>>; }; // NOLINT
5643 template<> struct ConwayPolynomial<263, 4> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<171>, ZPZV<5>>; }; // NOLINT
5644 template<> struct ConwayPolynomial<263, 5> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<258>>; }; // NOLINT
5645 template<> struct ConwayPolynomial<263, 6> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<222>, ZPZV<250>, ZPZV<225>, ZPZV<5>>; }; // NOLINT
5646 template<> struct ConwayPolynomial<263, 7> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<258>>; }; // NOLINT
5647 template<> struct ConwayPolynomial<263, 8> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<227>, ZPZV<170>, ZPZV<7>, ZPZV<5>>; }; // NOLINT
5648 template<> struct ConwayPolynomial<263, 9> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<261>, ZPZV<29>, ZPZV<258>>; }; // NOLINT
5649 template<> struct ConwayPolynomial<263, 10> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<245>, ZPZV<231>, ZPZV<198>, ZPZV<145>, ZPZV<119>, ZPZV<5>>; }; // NOLINT
5650 template<> struct ConwayPolynomial<263, 11> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<258>>; }; // NOLINT
5651 template<> struct ConwayPolynomial<263, 12> { using ZPZ = aerobus::zpz<263>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<172>, ZPZV<174>, ZPZV<162>, ZPZV<252>, ZPZV<47>, ZPZV<45>, ZPZV<180>, ZPZV<5>>; }; // NOLINT
5652 template<> struct ConwayPolynomial<269, 1> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<267>>; }; // NOLINT
5653 template<> struct ConwayPolynomial<269, 2> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<268>, ZPZV<2>>; }; // NOLINT
5654 template<> struct ConwayPolynomial<269, 3> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<267>>; }; // NOLINT
5655 template<> struct ConwayPolynomial<269, 4> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<262>, ZPZV<2>>; }; // NOLINT
5656 template<> struct ConwayPolynomial<269, 5> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<267>>; }; // NOLINT
5657 template<> struct ConwayPolynomial<269, 6> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<120>, ZPZV<101>, ZPZV<206>, ZPZV<2>>; }; // NOLINT
5658 template<> struct ConwayPolynomial<269, 7> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<267>>; }; // NOLINT
5659 template<> struct ConwayPolynomial<269, 8> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<220>, ZPZV<131>, ZPZV<232>, ZPZV<2>>; }; // NOLINT
5660 template<> struct ConwayPolynomial<269, 9> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<214>, ZPZV<267>, ZPZV<267>>; }; // NOLINT
5661 template<> struct ConwayPolynomial<269, 10> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<264>, ZPZV<243>, ZPZV<186>, ZPZV<61>, ZPZV<10>, ZPZV<2>>; }; // NOLINT
5662 template<> struct ConwayPolynomial<269, 11> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<267>>; }; // NOLINT
5663 template<> struct ConwayPolynomial<269, 12> { using ZPZ = aerobus::zpz<269>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<126>, ZPZV<165>, ZPZV<63>, ZPZV<215>, ZPZV<132>, ZPZV<180>, ZPZV<150>, ZPZV<2>>; }; // NOLINT
5664 template<> struct ConwayPolynomial<271, 1> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<265>>; }; // NOLINT
5665 template<> struct ConwayPolynomial<271, 2> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<269>, ZPZV<6>>; }; // NOLINT
5666 template<> struct ConwayPolynomial<271, 3> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<265>>; }; // NOLINT
5667 template<> struct ConwayPolynomial<271, 4> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<205>, ZPZV<6>>; }; // NOLINT
5668 template<> struct ConwayPolynomial<271, 5> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<265>>; }; // NOLINT
5669 template<> struct ConwayPolynomial<271, 6> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<207>, ZPZV<207>, ZPZV<81>, ZPZV<6>>; }; // NOLINT
5670 template<> struct ConwayPolynomial<271, 7> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<22>, ZPZV<265>>; }; // NOLINT
5671 template<> struct ConwayPolynomial<271, 8> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<199>, ZPZV<114>, ZPZV<69>, ZPZV<6>>; }; // NOLINT
5672 template<> struct ConwayPolynomial<271, 9> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<266>, ZPZV<186>, ZPZV<265>>; }; // NOLINT
5673 template<> struct ConwayPolynomial<271, 10> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<133>, ZPZV<10>, ZPZV<256>, ZPZV<74>, ZPZV<126>, ZPZV<6>>; }; // NOLINT
5674 template<> struct ConwayPolynomial<271, 11> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<265>>; }; // NOLINT
5675 template<> struct ConwayPolynomial<271, 12> { using ZPZ = aerobus::zpz<271>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<162>, ZPZV<210>, ZPZV<116>, ZPZV<205>, ZPZV<237>, ZPZV<256>, ZPZV<130>, ZPZV<6>>; }; // NOLINT
5676 template<> struct ConwayPolynomial<277, 1> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<272>>; }; // NOLINT
5677 template<> struct ConwayPolynomial<277, 2> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<274>, ZPZV<5>>; }; // NOLINT
5678 template<> struct ConwayPolynomial<277, 3> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<272>>; }; // NOLINT
5679 template<> struct ConwayPolynomial<277, 4> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<222>, ZPZV<5>>; }; // NOLINT
5680 template<> struct ConwayPolynomial<277, 5> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<272>>; }; // NOLINT
5681 template<> struct ConwayPolynomial<277, 6> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<33>, ZPZV<9>, ZPZV<118>, ZPZV<5>>; }; // NOLINT
5682 template<> struct ConwayPolynomial<277, 7> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<272>>; }; // NOLINT
5683 template<> struct ConwayPolynomial<277, 8> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<187>, ZPZV<159>, ZPZV<176>, ZPZV<5>>; }; // NOLINT
5684 template<> struct ConwayPolynomial<277, 9> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<177>, ZPZV<110>, ZPZV<272>>; }; // NOLINT
5685 template<> struct ConwayPolynomial<277, 10> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<206>, ZPZV<253>, ZPZV<237>, ZPZV<241>, ZPZV<260>, ZPZV<5>>; }; // NOLINT
5686 template<> struct ConwayPolynomial<277, 11> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<272>>; }; // NOLINT
5687 template<> struct ConwayPolynomial<277, 12> { using ZPZ = aerobus::zpz<277>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<183>, ZPZV<218>, ZPZV<240>, ZPZV<40>, ZPZV<180>, ZPZV<115>, ZPZV<202>, ZPZV<5>>; }; // NOLINT
5688 template<> struct ConwayPolynomial<281, 1> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<278>>; }; // NOLINT
5689 template<> struct ConwayPolynomial<281, 2> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<280>, ZPZV<3>>; }; // NOLINT
5690 template<> struct ConwayPolynomial<281, 3> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<278>>; }; // NOLINT
5691 template<> struct ConwayPolynomial<281, 4> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<176>, ZPZV<3>>; }; // NOLINT
5692 template<> struct ConwayPolynomial<281, 5> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<278>>; }; // NOLINT
5693 template<> struct ConwayPolynomial<281, 6> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<151>, ZPZV<13>, ZPZV<27>, ZPZV<3>>; }; // NOLINT
5694 template<> struct ConwayPolynomial<281, 7> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<278>>; }; // NOLINT
5695 template<> struct ConwayPolynomial<281, 8> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<195>, ZPZV<279>, ZPZV<140>, ZPZV<3>>; }; // NOLINT
5696 template<> struct ConwayPolynomial<281, 9> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<148>, ZPZV<70>, ZPZV<278>>; }; // NOLINT
5697 template<> struct ConwayPolynomial<281, 10> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<258>, ZPZV<145>, ZPZV<13>, ZPZV<138>, ZPZV<191>, ZPZV<3>>; }; // NOLINT
5698 template<> struct ConwayPolynomial<281, 11> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<36>, ZPZV<278>>; }; // NOLINT
5699 template<> struct ConwayPolynomial<281, 12> { using ZPZ = aerobus::zpz<281>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<202>, ZPZV<68>, ZPZV<103>, ZPZV<116>, ZPZV<58>, ZPZV<28>, ZPZV<191>, ZPZV<3>>; }; // NOLINT
5700 template<> struct ConwayPolynomial<283, 1> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<280>>; }; // NOLINT
5701 template<> struct ConwayPolynomial<283, 2> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<282>, ZPZV<3>>; }; // NOLINT
5702 template<> struct ConwayPolynomial<283, 3> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<280>>; }; // NOLINT
5703 template<> struct ConwayPolynomial<283, 4> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<238>, ZPZV<3>>; }; // NOLINT
5704 template<> struct ConwayPolynomial<283, 5> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<280>>; }; // NOLINT
5705 template<> struct ConwayPolynomial<283, 6> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<199>, ZPZV<68>, ZPZV<73>, ZPZV<3>>; }; // NOLINT
5706 template<> struct ConwayPolynomial<283, 7> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<280>>; }; // NOLINT
5707 template<> struct ConwayPolynomial<283, 8> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<179>, ZPZV<32>, ZPZV<232>, ZPZV<3>>; }; // NOLINT
5708 template<> struct ConwayPolynomial<283, 9> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<136>, ZPZV<65>, ZPZV<280>>; }; // NOLINT
5709 template<> struct ConwayPolynomial<283, 10> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<271>, ZPZV<185>, ZPZV<68>, ZPZV<100>, ZPZV<219>, ZPZV<3>>; }; // NOLINT
5710 template<> struct ConwayPolynomial<283, 11> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<280>>; }; // NOLINT
5711 template<> struct ConwayPolynomial<283, 12> { using ZPZ = aerobus::zpz<283>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<20>, ZPZV<8>, ZPZV<96>, ZPZV<229>, ZPZV<49>, ZPZV<14>, ZPZV<56>, ZPZV<3>>; }; // NOLINT
5712 template<> struct ConwayPolynomial<293, 1> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<291>>; }; // NOLINT
5713 template<> struct ConwayPolynomial<293, 2> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<292>, ZPZV<2>>; }; // NOLINT
5714 template<> struct ConwayPolynomial<293, 3> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<291>>; }; // NOLINT
5715 template<> struct ConwayPolynomial<293, 4> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<166>, ZPZV<2>>; }; // NOLINT
5716 template<> struct ConwayPolynomial<293, 5> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<291>>; }; // NOLINT
5717 template<> struct ConwayPolynomial<293, 6> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<128>, ZPZV<210>, ZPZV<260>, ZPZV<2>>; }; // NOLINT
5718 template<> struct ConwayPolynomial<293, 7> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<291>>; }; // NOLINT
5719 template<> struct ConwayPolynomial<293, 8> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<29>, ZPZV<175>, ZPZV<195>, ZPZV<239>, ZPZV<2>>; }; // NOLINT
5720 template<> struct ConwayPolynomial<293, 9> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<208>, ZPZV<190>, ZPZV<291>>; }; // NOLINT
5721 template<> struct ConwayPolynomial<293, 10> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<186>, ZPZV<28>, ZPZV<46>, ZPZV<184>, ZPZV<24>, ZPZV<2>>; }; // NOLINT
5722 template<> struct ConwayPolynomial<293, 11> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<291>>; }; // NOLINT
5723 template<> struct ConwayPolynomial<293, 12> { using ZPZ = aerobus::zpz<293>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<159>, ZPZV<210>, ZPZV<125>, ZPZV<212>, ZPZV<167>, ZPZV<144>, ZPZV<157>, ZPZV<2>>; }; // NOLINT
5724 template<> struct ConwayPolynomial<307, 1> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<302>>; }; // NOLINT
5725 template<> struct ConwayPolynomial<307, 2> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<306>, ZPZV<5>>; }; // NOLINT
5726 template<> struct ConwayPolynomial<307, 3> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<302>>; }; // NOLINT
5727 template<> struct ConwayPolynomial<307, 4> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<239>, ZPZV<5>>; }; // NOLINT
5728 template<> struct ConwayPolynomial<307, 5> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<302>>; }; // NOLINT
5729 template<> struct ConwayPolynomial<307, 6> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<213>, ZPZV<172>, ZPZV<61>, ZPZV<5>>; }; // NOLINT
5730 template<> struct ConwayPolynomial<307, 7> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<302>>; }; // NOLINT
5731 template<> struct ConwayPolynomial<307, 8> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<283>, ZPZV<232>, ZPZV<131>, ZPZV<5>>; }; // NOLINT
5732 template<> struct ConwayPolynomial<307, 9> { using ZPZ = aerobus::zpz<307>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<165>, ZPZV<70>, ZPZV<302>>; }; // NOLINT
5733 template<> struct ConwayPolynomial<311, 1> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<294>>; }; // NOLINT
5734 template<> struct ConwayPolynomial<311, 2> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<310>, ZPZV<17>>; }; // NOLINT
5735 template<> struct ConwayPolynomial<311, 3> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<294>>; }; // NOLINT
5736 template<> struct ConwayPolynomial<311, 4> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<163>, ZPZV<17>>; }; // NOLINT
5737 template<> struct ConwayPolynomial<311, 5> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<294>>; }; // NOLINT
5738 template<> struct ConwayPolynomial<311, 6> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<27>, ZPZV<167>, ZPZV<152>, ZPZV<17>>; }; // NOLINT
5739 template<> struct ConwayPolynomial<311, 7> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<294>>; }; // NOLINT
5740 template<> struct ConwayPolynomial<311, 8> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<162>, ZPZV<118>, ZPZV<2>, ZPZV<17>>; }; // NOLINT
5741 template<> struct ConwayPolynomial<311, 9> { using ZPZ = aerobus::zpz<311>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<287>, ZPZV<74>, ZPZV<294>>; }; // NOLINT
5742 template<> struct ConwayPolynomial<313, 1> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<303>>; }; // NOLINT
5743 template<> struct ConwayPolynomial<313, 2> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<310>, ZPZV<10>>; }; // NOLINT
5744 template<> struct ConwayPolynomial<313, 3> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<303>>; }; // NOLINT
5745 template<> struct ConwayPolynomial<313, 4> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<239>, ZPZV<10>>; }; // NOLINT
5746 template<> struct ConwayPolynomial<313, 5> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<303>>; }; // NOLINT
5747 template<> struct ConwayPolynomial<313, 6> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<196>, ZPZV<213>, ZPZV<253>, ZPZV<10>>; }; // NOLINT
5748 template<> struct ConwayPolynomial<313, 7> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<303>>; }; // NOLINT
5749 template<> struct ConwayPolynomial<313, 8> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<306>, ZPZV<99>, ZPZV<106>, ZPZV<10>>; }; // NOLINT
5750 template<> struct ConwayPolynomial<313, 9> { using ZPZ = aerobus::zpz<313>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<267>, ZPZV<300>, ZPZV<303>>; }; // NOLINT
5751 template<> struct ConwayPolynomial<317, 1> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<315>>; }; // NOLINT
5752 template<> struct ConwayPolynomial<317, 2> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<313>, ZPZV<2>>; }; // NOLINT
5753 template<> struct ConwayPolynomial<317, 3> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<315>>; }; // NOLINT
5754 template<> struct ConwayPolynomial<317, 4> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<178>, ZPZV<2>>; }; // NOLINT
5755 template<> struct ConwayPolynomial<317, 5> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<315>>; }; // NOLINT
5756 template<> struct ConwayPolynomial<317, 6> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<195>, ZPZV<156>, ZPZV<4>, ZPZV<2>>; }; // NOLINT
5757 template<> struct ConwayPolynomial<317, 7> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<315>>; }; // NOLINT
5758 template<> struct ConwayPolynomial<317, 8> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<207>, ZPZV<85>, ZPZV<31>, ZPZV<2>>; }; // NOLINT
5759 template<> struct ConwayPolynomial<317, 9> { using ZPZ = aerobus::zpz<317>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<284>, ZPZV<296>, ZPZV<315>>; }; // NOLINT
5760 template<> struct ConwayPolynomial<331, 1> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<328>>; }; // NOLINT
5761 template<> struct ConwayPolynomial<331, 2> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<326>, ZPZV<3>>; }; // NOLINT
5762 template<> struct ConwayPolynomial<331, 3> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<328>>; }; // NOLINT
5763 template<> struct ConwayPolynomial<331, 4> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<290>, ZPZV<3>>; }; // NOLINT
5764 template<> struct ConwayPolynomial<331, 5> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<328>>; }; // NOLINT
5765 template<> struct ConwayPolynomial<331, 6> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<283>, ZPZV<205>, ZPZV<159>, ZPZV<3>>; }; // NOLINT
5766 template<> struct ConwayPolynomial<331, 7> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<328>>; }; // NOLINT
5767 template<> struct ConwayPolynomial<331, 8> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<249>, ZPZV<308>, ZPZV<78>, ZPZV<3>>; }; // NOLINT
5768 template<> struct ConwayPolynomial<331, 9> { using ZPZ = aerobus::zpz<331>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<194>, ZPZV<210>, ZPZV<328>>; }; // NOLINT
5769 template<> struct ConwayPolynomial<337, 1> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<327>>; }; // NOLINT
5770 template<> struct ConwayPolynomial<337, 2> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<332>, ZPZV<10>>; }; // NOLINT
5771 template<> struct ConwayPolynomial<337, 3> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<327>>; }; // NOLINT
5772 template<> struct ConwayPolynomial<337, 4> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<25>, ZPZV<224>, ZPZV<10>>; }; // NOLINT
5773 template<> struct ConwayPolynomial<337, 5> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<327>>; }; // NOLINT
5774 template<> struct ConwayPolynomial<337, 6> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<216>, ZPZV<127>, ZPZV<109>, ZPZV<10>>; }; // NOLINT
5775 template<> struct ConwayPolynomial<337, 7> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<327>>; }; // NOLINT
5776 template<> struct ConwayPolynomial<337, 8> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<331>, ZPZV<246>, ZPZV<251>, ZPZV<10>>; }; // NOLINT
5777 template<> struct ConwayPolynomial<337, 9> { using ZPZ = aerobus::zpz<337>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<148>, ZPZV<98>, ZPZV<327>>; }; // NOLINT
5778 template<> struct ConwayPolynomial<347, 1> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<345>>; }; // NOLINT
5779 template<> struct ConwayPolynomial<347, 2> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<343>, ZPZV<2>>; }; // NOLINT
5780 template<> struct ConwayPolynomial<347, 3> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<345>>; }; // NOLINT
5781 template<> struct ConwayPolynomial<347, 4> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<13>, ZPZV<295>, ZPZV<2>>; }; // NOLINT
5782 template<> struct ConwayPolynomial<347, 5> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<345>>; }; // NOLINT
5783 template<> struct ConwayPolynomial<347, 6> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<343>, ZPZV<26>, ZPZV<56>, ZPZV<2>>; }; // NOLINT
5784 template<> struct ConwayPolynomial<347, 7> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<345>>; }; // NOLINT
5785 template<> struct ConwayPolynomial<347, 8> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<187>, ZPZV<213>, ZPZV<117>, ZPZV<2>>; }; // NOLINT
5786 template<> struct ConwayPolynomial<347, 9> { using ZPZ = aerobus::zpz<347>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<235>, ZPZV<252>, ZPZV<345>>; }; // NOLINT
5787 template<> struct ConwayPolynomial<349, 1> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<347>>; }; // NOLINT
5788 template<> struct ConwayPolynomial<349, 2> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<348>, ZPZV<2>>; }; // NOLINT
5789 template<> struct ConwayPolynomial<349, 3> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<347>>; }; // NOLINT
5790 template<> struct ConwayPolynomial<349, 4> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<279>, ZPZV<2>>; }; // NOLINT
5791 template<> struct ConwayPolynomial<349, 5> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<347>>; }; // NOLINT
5792 template<> struct ConwayPolynomial<349, 6> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<135>, ZPZV<177>, ZPZV<316>, ZPZV<2>>; }; // NOLINT
5793 template<> struct ConwayPolynomial<349, 7> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<347>>; }; // NOLINT
5794 template<> struct ConwayPolynomial<349, 8> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<308>, ZPZV<328>, ZPZV<268>, ZPZV<2>>; }; // NOLINT
5795 template<> struct ConwayPolynomial<349, 9> { using ZPZ = aerobus::zpz<349>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<36>, ZPZV<290>, ZPZV<130>, ZPZV<347>>; }; // NOLINT
5796 template<> struct ConwayPolynomial<353, 1> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<350>>; }; // NOLINT
5797 template<> struct ConwayPolynomial<353, 2> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<348>, ZPZV<3>>; }; // NOLINT
5798 template<> struct ConwayPolynomial<353, 3> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<350>>; }; // NOLINT
5799 template<> struct ConwayPolynomial<353, 4> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<199>, ZPZV<3>>; }; // NOLINT
5800 template<> struct ConwayPolynomial<353, 5> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<350>>; }; // NOLINT
5801 template<> struct ConwayPolynomial<353, 6> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<215>, ZPZV<226>, ZPZV<295>, ZPZV<3>>; }; // NOLINT
5802 template<> struct ConwayPolynomial<353, 7> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<350>>; }; // NOLINT
5803 template<> struct ConwayPolynomial<353, 8> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<182>, ZPZV<26>, ZPZV<37>, ZPZV<3>>; }; // NOLINT
5804 template<> struct ConwayPolynomial<353, 9> { using ZPZ = aerobus::zpz<353>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<319>, ZPZV<49>, ZPZV<350>>; }; // NOLINT
5805 template<> struct ConwayPolynomial<359, 1> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<352>>; }; // NOLINT
5806 template<> struct ConwayPolynomial<359, 2> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<358>, ZPZV<7>>; }; // NOLINT
5807 template<> struct ConwayPolynomial<359, 3> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<352>>; }; // NOLINT
5808 template<> struct ConwayPolynomial<359, 4> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<229>, ZPZV<7>>; }; // NOLINT
5809 template<> struct ConwayPolynomial<359, 5> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<352>>; }; // NOLINT
5810 template<> struct ConwayPolynomial<359, 6> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<309>, ZPZV<327>, ZPZV<327>, ZPZV<7>>; }; // NOLINT
5811 template<> struct ConwayPolynomial<359, 7> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<352>>; }; // NOLINT
5812 template<> struct ConwayPolynomial<359, 8> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<301>, ZPZV<143>, ZPZV<271>, ZPZV<7>>; }; // NOLINT
5813 template<> struct ConwayPolynomial<359, 9> { using ZPZ = aerobus::zpz<359>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<356>, ZPZV<165>, ZPZV<352>>; }; // NOLINT
5814 template<> struct ConwayPolynomial<367, 1> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<361>>; }; // NOLINT
5815 template<> struct ConwayPolynomial<367, 2> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<366>, ZPZV<6>>; }; // NOLINT
5816 template<> struct ConwayPolynomial<367, 3> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<10>, ZPZV<361>>; }; // NOLINT
5817 template<> struct ConwayPolynomial<367, 4> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<295>, ZPZV<6>>; }; // NOLINT
5818 template<> struct ConwayPolynomial<367, 5> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<361>>; }; // NOLINT
5819 template<> struct ConwayPolynomial<367, 6> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<222>, ZPZV<321>, ZPZV<324>, ZPZV<6>>; }; // NOLINT
5820 template<> struct ConwayPolynomial<367, 7> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<361>>; }; // NOLINT
5821 template<> struct ConwayPolynomial<367, 8> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<335>, ZPZV<282>, ZPZV<50>, ZPZV<6>>; }; // NOLINT
5822 template<> struct ConwayPolynomial<367, 9> { using ZPZ = aerobus::zpz<367>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<213>, ZPZV<268>, ZPZV<361>>; }; // NOLINT
5823 template<> struct ConwayPolynomial<373, 1> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<371>>; }; // NOLINT
5824 template<> struct ConwayPolynomial<373, 2> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<369>, ZPZV<2>>; }; // NOLINT
5825 template<> struct ConwayPolynomial<373, 3> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<371>>; }; // NOLINT
5826 template<> struct ConwayPolynomial<373, 4> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<15>, ZPZV<304>, ZPZV<2>>; }; // NOLINT
5827 template<> struct ConwayPolynomial<373, 5> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<371>>; }; // NOLINT
5828 template<> struct ConwayPolynomial<373, 6> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<126>, ZPZV<83>, ZPZV<108>, ZPZV<2>>; }; // NOLINT
5829 template<> struct ConwayPolynomial<373, 7> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<371>>; }; // NOLINT
5830 template<> struct ConwayPolynomial<373, 8> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<203>, ZPZV<219>, ZPZV<66>, ZPZV<2>>; }; // NOLINT
5831 template<> struct ConwayPolynomial<373, 9> { using ZPZ = aerobus::zpz<373>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<238>, ZPZV<370>, ZPZV<371>>; }; // NOLINT
5832 template<> struct ConwayPolynomial<379, 1> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<377>>; }; // NOLINT
5833 template<> struct ConwayPolynomial<379, 2> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<374>, ZPZV<2>>; }; // NOLINT
5834 template<> struct ConwayPolynomial<379, 3> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<377>>; }; // NOLINT
5835 template<> struct ConwayPolynomial<379, 4> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<327>, ZPZV<2>>; }; // NOLINT
5836 template<> struct ConwayPolynomial<379, 5> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<377>>; }; // NOLINT
5837 template<> struct ConwayPolynomial<379, 6> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<374>, ZPZV<364>, ZPZV<246>, ZPZV<2>>; }; // NOLINT
5838 template<> struct ConwayPolynomial<379, 7> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<377>>; }; // NOLINT
5839 template<> struct ConwayPolynomial<379, 8> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<210>, ZPZV<194>, ZPZV<173>, ZPZV<2>>; }; // NOLINT
5840 template<> struct ConwayPolynomial<379, 9> { using ZPZ = aerobus::zpz<379>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<362>, ZPZV<369>, ZPZV<377>>; }; // NOLINT
5841 template<> struct ConwayPolynomial<383, 1> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<378>>; }; // NOLINT
5842 template<> struct ConwayPolynomial<383, 2> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<382>, ZPZV<5>>; }; // NOLINT
5843 template<> struct ConwayPolynomial<383, 3> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<378>>; }; // NOLINT
5844 template<> struct ConwayPolynomial<383, 4> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<309>, ZPZV<5>>; }; // NOLINT
5845 template<> struct ConwayPolynomial<383, 5> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<378>>; }; // NOLINT
5846 template<> struct ConwayPolynomial<383, 6> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<69>, ZPZV<8>, ZPZV<158>, ZPZV<5>>; }; // NOLINT
5847 template<> struct ConwayPolynomial<383, 7> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<378>>; }; // NOLINT
5848 template<> struct ConwayPolynomial<383, 8> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<281>, ZPZV<332>, ZPZV<296>, ZPZV<5>>; }; // NOLINT
5849 template<> struct ConwayPolynomial<383, 9> { using ZPZ = aerobus::zpz<383>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<137>, ZPZV<76>, ZPZV<378>>; }; // NOLINT
5850 template<> struct ConwayPolynomial<389, 1> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<387>>; }; // NOLINT
5851 template<> struct ConwayPolynomial<389, 2> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<379>, ZPZV<2>>; }; // NOLINT
5852 template<> struct ConwayPolynomial<389, 3> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<387>>; }; // NOLINT
5853 template<> struct ConwayPolynomial<389, 4> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<266>, ZPZV<2>>; }; // NOLINT
5854 template<> struct ConwayPolynomial<389, 5> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<387>>; }; // NOLINT
5855 template<> struct ConwayPolynomial<389, 6> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<218>, ZPZV<339>, ZPZV<255>, ZPZV<2>>; }; // NOLINT
5856 template<> struct ConwayPolynomial<389, 7> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<387>>; }; // NOLINT
5857 template<> struct ConwayPolynomial<389, 8> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<351>, ZPZV<19>, ZPZV<290>, ZPZV<2>>; }; // NOLINT
5858 template<> struct ConwayPolynomial<389, 9> { using ZPZ = aerobus::zpz<389>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<258>, ZPZV<308>, ZPZV<387>>; }; // NOLINT
5859 template<> struct ConwayPolynomial<397, 1> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<392>>; }; // NOLINT
5860 template<> struct ConwayPolynomial<397, 2> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<392>, ZPZV<5>>; }; // NOLINT
5861 template<> struct ConwayPolynomial<397, 3> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<392>>; }; // NOLINT
5862 template<> struct ConwayPolynomial<397, 4> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<363>, ZPZV<5>>; }; // NOLINT
5863 template<> struct ConwayPolynomial<397, 5> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<392>>; }; // NOLINT
5864 template<> struct ConwayPolynomial<397, 6> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<382>, ZPZV<274>, ZPZV<287>, ZPZV<5>>; }; // NOLINT
5865 template<> struct ConwayPolynomial<397, 7> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<392>>; }; // NOLINT
5866 template<> struct ConwayPolynomial<397, 8> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<375>, ZPZV<255>, ZPZV<203>, ZPZV<5>>; }; // NOLINT
5867 template<> struct ConwayPolynomial<397, 9> { using ZPZ = aerobus::zpz<397>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<166>, ZPZV<252>, ZPZV<392>>; }; // NOLINT
5868 template<> struct ConwayPolynomial<401, 1> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<398>>; }; // NOLINT
5869 template<> struct ConwayPolynomial<401, 2> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<396>, ZPZV<3>>; }; // NOLINT
5870 template<> struct ConwayPolynomial<401, 3> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<398>>; }; // NOLINT
5871 template<> struct ConwayPolynomial<401, 4> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<372>, ZPZV<3>>; }; // NOLINT
5872 template<> struct ConwayPolynomial<401, 5> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<398>>; }; // NOLINT
5873 template<> struct ConwayPolynomial<401, 6> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<115>, ZPZV<81>, ZPZV<51>, ZPZV<3>>; }; // NOLINT
5874 template<> struct ConwayPolynomial<401, 7> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<398>>; }; // NOLINT
5875 template<> struct ConwayPolynomial<401, 8> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<380>, ZPZV<113>, ZPZV<164>, ZPZV<3>>; }; // NOLINT
5876 template<> struct ConwayPolynomial<401, 9> { using ZPZ = aerobus::zpz<401>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<199>, ZPZV<158>, ZPZV<398>>; }; // NOLINT
5877 template<> struct ConwayPolynomial<409, 1> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<388>>; }; // NOLINT
5878 template<> struct ConwayPolynomial<409, 2> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<404>, ZPZV<21>>; }; // NOLINT
5879 template<> struct ConwayPolynomial<409, 3> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<388>>; }; // NOLINT
5880 template<> struct ConwayPolynomial<409, 4> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<407>, ZPZV<21>>; }; // NOLINT
5881 template<> struct ConwayPolynomial<409, 5> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<388>>; }; // NOLINT
5882 template<> struct ConwayPolynomial<409, 6> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<372>, ZPZV<53>, ZPZV<364>, ZPZV<21>>; }; // NOLINT
5883 template<> struct ConwayPolynomial<409, 7> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<388>>; }; // NOLINT
5884 template<> struct ConwayPolynomial<409, 8> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<256>, ZPZV<69>, ZPZV<396>, ZPZV<21>>; }; // NOLINT
5885 template<> struct ConwayPolynomial<409, 9> { using ZPZ = aerobus::zpz<409>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<318>, ZPZV<211>, ZPZV<388>>; }; // NOLINT
5886 template<> struct ConwayPolynomial<419, 1> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<417>>; }; // NOLINT
5887 template<> struct ConwayPolynomial<419, 2> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<418>, ZPZV<2>>; }; // NOLINT
5888 template<> struct ConwayPolynomial<419, 3> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<417>>; }; // NOLINT
5889 template<> struct ConwayPolynomial<419, 4> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<373>, ZPZV<2>>; }; // NOLINT
5890 template<> struct ConwayPolynomial<419, 5> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<417>>; }; // NOLINT
5891 template<> struct ConwayPolynomial<419, 6> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<411>, ZPZV<33>, ZPZV<257>, ZPZV<2>>; }; // NOLINT
5892 template<> struct ConwayPolynomial<419, 7> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<417>>; }; // NOLINT
5893 template<> struct ConwayPolynomial<419, 8> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<234>, ZPZV<388>, ZPZV<151>, ZPZV<2>>; }; // NOLINT
5894 template<> struct ConwayPolynomial<419, 9> { using ZPZ = aerobus::zpz<419>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<93>, ZPZV<386>, ZPZV<417>>; }; // NOLINT
5895 template<> struct ConwayPolynomial<421, 1> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<419>>; }; // NOLINT
5896 template<> struct ConwayPolynomial<421, 2> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<417>, ZPZV<2>>; }; // NOLINT
5897 template<> struct ConwayPolynomial<421, 3> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<419>>; }; // NOLINT
5898 template<> struct ConwayPolynomial<421, 4> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<10>, ZPZV<257>, ZPZV<2>>; }; // NOLINT
5899 template<> struct ConwayPolynomial<421, 5> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<419>>; }; // NOLINT
5900 template<> struct ConwayPolynomial<421, 6> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<111>, ZPZV<342>, ZPZV<41>, ZPZV<2>>; }; // NOLINT
5901 template<> struct ConwayPolynomial<421, 7> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<21>, ZPZV<419>>; }; // NOLINT
5902 template<> struct ConwayPolynomial<421, 8> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<389>, ZPZV<32>, ZPZV<77>, ZPZV<2>>; }; // NOLINT
5903 template<> struct ConwayPolynomial<421, 9> { using ZPZ = aerobus::zpz<421>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<394>, ZPZV<145>, ZPZV<419>>; }; // NOLINT
5904 template<> struct ConwayPolynomial<431, 1> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<424>>; }; // NOLINT
5905 template<> struct ConwayPolynomial<431, 2> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<430>, ZPZV<7>>; }; // NOLINT
5906 template<> struct ConwayPolynomial<431, 3> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<424>>; }; // NOLINT
5907 template<> struct ConwayPolynomial<431, 4> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<323>, ZPZV<7>>; }; // NOLINT
5908 template<> struct ConwayPolynomial<431, 5> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<424>>; }; // NOLINT
5909 template<> struct ConwayPolynomial<431, 6> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<161>, ZPZV<202>, ZPZV<182>, ZPZV<7>>; }; // NOLINT
5910 template<> struct ConwayPolynomial<431, 7> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<424>>; }; // NOLINT
5911 template<> struct ConwayPolynomial<431, 8> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<243>, ZPZV<286>, ZPZV<115>, ZPZV<7>>; }; // NOLINT
5912 template<> struct ConwayPolynomial<431, 9> { using ZPZ = aerobus::zpz<431>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<71>, ZPZV<329>, ZPZV<424>>; }; // NOLINT
5913 template<> struct ConwayPolynomial<433, 1> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<428>>; }; // NOLINT
5914 template<> struct ConwayPolynomial<433, 2> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<432>, ZPZV<5>>; }; // NOLINT
5915 template<> struct ConwayPolynomial<433, 3> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<428>>; }; // NOLINT
5916 template<> struct ConwayPolynomial<433, 4> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<402>, ZPZV<5>>; }; // NOLINT
5917 template<> struct ConwayPolynomial<433, 5> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<428>>; }; // NOLINT
5918 template<> struct ConwayPolynomial<433, 6> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<244>, ZPZV<353>, ZPZV<360>, ZPZV<5>>; }; // NOLINT
5919 template<> struct ConwayPolynomial<433, 7> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<428>>; }; // NOLINT
5920 template<> struct ConwayPolynomial<433, 8> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<347>, ZPZV<32>, ZPZV<39>, ZPZV<5>>; }; // NOLINT
5921 template<> struct ConwayPolynomial<433, 9> { using ZPZ = aerobus::zpz<433>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<27>, ZPZV<232>, ZPZV<45>, ZPZV<428>>; }; // NOLINT
5922 template<> struct ConwayPolynomial<439, 1> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<424>>; }; // NOLINT
5923 template<> struct ConwayPolynomial<439, 2> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<436>, ZPZV<15>>; }; // NOLINT
5924 template<> struct ConwayPolynomial<439, 3> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<424>>; }; // NOLINT
5925 template<> struct ConwayPolynomial<439, 4> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<323>, ZPZV<15>>; }; // NOLINT
5926 template<> struct ConwayPolynomial<439, 5> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<424>>; }; // NOLINT
5927 template<> struct ConwayPolynomial<439, 6> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<324>, ZPZV<190>, ZPZV<15>>; }; // NOLINT
5928 template<> struct ConwayPolynomial<439, 7> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<424>>; }; // NOLINT
5929 template<> struct ConwayPolynomial<439, 8> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<359>, ZPZV<296>, ZPZV<266>, ZPZV<15>>; }; // NOLINT
5930 template<> struct ConwayPolynomial<439, 9> { using ZPZ = aerobus::zpz<439>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<342>, ZPZV<254>, ZPZV<424>>; }; // NOLINT
5931 template<> struct ConwayPolynomial<443, 1> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<441>>; }; // NOLINT
5932 template<> struct ConwayPolynomial<443, 2> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<437>, ZPZV<2>>; }; // NOLINT
5933 template<> struct ConwayPolynomial<443, 3> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<441>>; }; // NOLINT
5934 template<> struct ConwayPolynomial<443, 4> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<383>, ZPZV<2>>; }; // NOLINT
5935 template<> struct ConwayPolynomial<443, 5> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<441>>; }; // NOLINT
5936 template<> struct ConwayPolynomial<443, 6> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<298>, ZPZV<218>, ZPZV<41>, ZPZV<2>>; }; // NOLINT
5937 template<> struct ConwayPolynomial<443, 7> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<441>>; }; // NOLINT
5938 template<> struct ConwayPolynomial<443, 8> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<437>, ZPZV<217>, ZPZV<290>, ZPZV<2>>; }; // NOLINT
5939 template<> struct ConwayPolynomial<443, 9> { using ZPZ = aerobus::zpz<443>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<125>, ZPZV<109>, ZPZV<441>>; }; // NOLINT
5940 template<> struct ConwayPolynomial<449, 1> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<446>>; }; // NOLINT
5941 template<> struct ConwayPolynomial<449, 2> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<444>, ZPZV<3>>; }; // NOLINT
5942 template<> struct ConwayPolynomial<449, 3> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<446>>; }; // NOLINT
5943 template<> struct ConwayPolynomial<449, 4> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<249>, ZPZV<3>>; }; // NOLINT
5944 template<> struct ConwayPolynomial<449, 5> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<446>>; }; // NOLINT
5945 template<> struct ConwayPolynomial<449, 6> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<437>, ZPZV<293>, ZPZV<69>, ZPZV<3>>; }; // NOLINT
5946 template<> struct ConwayPolynomial<449, 7> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<446>>; }; // NOLINT
5947 template<> struct ConwayPolynomial<449, 8> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<361>, ZPZV<348>, ZPZV<124>, ZPZV<3>>; }; // NOLINT
5948 template<> struct ConwayPolynomial<449, 9> { using ZPZ = aerobus::zpz<449>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<226>, ZPZV<9>, ZPZV<446>>; }; // NOLINT
5949 template<> struct ConwayPolynomial<457, 1> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<444>>; }; // NOLINT
5950 template<> struct ConwayPolynomial<457, 2> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<454>, ZPZV<13>>; }; // NOLINT
5951 template<> struct ConwayPolynomial<457, 3> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<444>>; }; // NOLINT
5952 template<> struct ConwayPolynomial<457, 4> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<407>, ZPZV<13>>; }; // NOLINT
5953 template<> struct ConwayPolynomial<457, 5> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<444>>; }; // NOLINT
5954 template<> struct ConwayPolynomial<457, 6> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<205>, ZPZV<389>, ZPZV<266>, ZPZV<13>>; }; // NOLINT
5955 template<> struct ConwayPolynomial<457, 7> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<444>>; }; // NOLINT
5956 template<> struct ConwayPolynomial<457, 8> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<365>, ZPZV<296>, ZPZV<412>, ZPZV<13>>; }; // NOLINT
5957 template<> struct ConwayPolynomial<457, 9> { using ZPZ = aerobus::zpz<457>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<354>, ZPZV<84>, ZPZV<444>>; }; // NOLINT
5958 template<> struct ConwayPolynomial<461, 1> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<459>>; }; // NOLINT
5959 template<> struct ConwayPolynomial<461, 2> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<460>, ZPZV<2>>; }; // NOLINT
5960 template<> struct ConwayPolynomial<461, 3> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<459>>; }; // NOLINT
5961 template<> struct ConwayPolynomial<461, 4> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<393>, ZPZV<2>>; }; // NOLINT
5962 template<> struct ConwayPolynomial<461, 5> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<459>>; }; // NOLINT
5963 template<> struct ConwayPolynomial<461, 6> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<439>, ZPZV<432>, ZPZV<329>, ZPZV<2>>; }; // NOLINT
5964 template<> struct ConwayPolynomial<461, 7> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<459>>; }; // NOLINT
5965 template<> struct ConwayPolynomial<461, 8> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<388>, ZPZV<449>, ZPZV<321>, ZPZV<2>>; }; // NOLINT
5966 template<> struct ConwayPolynomial<461, 9> { using ZPZ = aerobus::zpz<461>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<210>, ZPZV<276>, ZPZV<459>>; }; // NOLINT
5967 template<> struct ConwayPolynomial<463, 1> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<460>>; }; // NOLINT
5968 template<> struct ConwayPolynomial<463, 2> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<461>, ZPZV<3>>; }; // NOLINT
5969 template<> struct ConwayPolynomial<463, 3> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<10>, ZPZV<460>>; }; // NOLINT
5970 template<> struct ConwayPolynomial<463, 4> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<17>, ZPZV<262>, ZPZV<3>>; }; // NOLINT
5971 template<> struct ConwayPolynomial<463, 5> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<460>>; }; // NOLINT
5972 template<> struct ConwayPolynomial<463, 6> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<462>, ZPZV<51>, ZPZV<110>, ZPZV<3>>; }; // NOLINT
5973 template<> struct ConwayPolynomial<463, 7> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<460>>; }; // NOLINT
5974 template<> struct ConwayPolynomial<463, 8> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<234>, ZPZV<414>, ZPZV<396>, ZPZV<3>>; }; // NOLINT
5975 template<> struct ConwayPolynomial<463, 9> { using ZPZ = aerobus::zpz<463>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<433>, ZPZV<227>, ZPZV<460>>; }; // NOLINT
5976 template<> struct ConwayPolynomial<467, 1> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<465>>; }; // NOLINT
5977 template<> struct ConwayPolynomial<467, 2> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<463>, ZPZV<2>>; }; // NOLINT
5978 template<> struct ConwayPolynomial<467, 3> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<465>>; }; // NOLINT
5979 template<> struct ConwayPolynomial<467, 4> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<14>, ZPZV<353>, ZPZV<2>>; }; // NOLINT
5980 template<> struct ConwayPolynomial<467, 5> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<465>>; }; // NOLINT
5981 template<> struct ConwayPolynomial<467, 6> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<123>, ZPZV<62>, ZPZV<237>, ZPZV<2>>; }; // NOLINT
5982 template<> struct ConwayPolynomial<467, 7> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<465>>; }; // NOLINT
5983 template<> struct ConwayPolynomial<467, 8> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<318>, ZPZV<413>, ZPZV<289>, ZPZV<2>>; }; // NOLINT
5984 template<> struct ConwayPolynomial<467, 9> { using ZPZ = aerobus::zpz<467>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<397>, ZPZV<447>, ZPZV<465>>; }; // NOLINT
5985 template<> struct ConwayPolynomial<479, 1> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<466>>; }; // NOLINT
5986 template<> struct ConwayPolynomial<479, 2> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<474>, ZPZV<13>>; }; // NOLINT
5987 template<> struct ConwayPolynomial<479, 3> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<466>>; }; // NOLINT
5988 template<> struct ConwayPolynomial<479, 4> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<386>, ZPZV<13>>; }; // NOLINT
5989 template<> struct ConwayPolynomial<479, 5> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<466>>; }; // NOLINT
5990 template<> struct ConwayPolynomial<479, 6> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<243>, ZPZV<287>, ZPZV<334>, ZPZV<13>>; }; // NOLINT
5991 template<> struct ConwayPolynomial<479, 7> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<466>>; }; // NOLINT
5992 template<> struct ConwayPolynomial<479, 8> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<247>, ZPZV<440>, ZPZV<17>, ZPZV<13>>; }; // NOLINT
5993 template<> struct ConwayPolynomial<479, 9> { using ZPZ = aerobus::zpz<479>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<3>, ZPZV<185>, ZPZV<466>>; }; // NOLINT
5994 template<> struct ConwayPolynomial<487, 1> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<484>>; }; // NOLINT
5995 template<> struct ConwayPolynomial<487, 2> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<485>, ZPZV<3>>; }; // NOLINT
5996 template<> struct ConwayPolynomial<487, 3> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<484>>; }; // NOLINT
5997 template<> struct ConwayPolynomial<487, 4> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<483>, ZPZV<3>>; }; // NOLINT
5998 template<> struct ConwayPolynomial<487, 5> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<484>>; }; // NOLINT
5999 template<> struct ConwayPolynomial<487, 6> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<450>, ZPZV<427>, ZPZV<185>, ZPZV<3>>; }; // NOLINT
6000 template<> struct ConwayPolynomial<487, 7> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<484>>; }; // NOLINT
6001 template<> struct ConwayPolynomial<487, 8> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<283>, ZPZV<249>, ZPZV<137>, ZPZV<3>>; }; // NOLINT
6002 template<> struct ConwayPolynomial<487, 9> { using ZPZ = aerobus::zpz<487>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<271>, ZPZV<447>, ZPZV<484>>; }; // NOLINT
6003 template<> struct ConwayPolynomial<491, 1> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<489>>; }; // NOLINT
6004 template<> struct ConwayPolynomial<491, 2> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<487>, ZPZV<2>>; }; // NOLINT
6005 template<> struct ConwayPolynomial<491, 3> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<489>>; }; // NOLINT
6006 template<> struct ConwayPolynomial<491, 4> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<360>, ZPZV<2>>; }; // NOLINT
6007 template<> struct ConwayPolynomial<491, 5> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<489>>; }; // NOLINT
6008 template<> struct ConwayPolynomial<491, 6> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<369>, ZPZV<402>, ZPZV<125>, ZPZV<2>>; }; // NOLINT
6009 template<> struct ConwayPolynomial<491, 7> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<489>>; }; // NOLINT
6010 template<> struct ConwayPolynomial<491, 8> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<378>, ZPZV<372>, ZPZV<216>, ZPZV<2>>; }; // NOLINT
6011 template<> struct ConwayPolynomial<491, 9> { using ZPZ = aerobus::zpz<491>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<149>, ZPZV<453>, ZPZV<489>>; }; // NOLINT
6012 template<> struct ConwayPolynomial<499, 1> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<492>>; }; // NOLINT
6013 template<> struct ConwayPolynomial<499, 2> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<493>, ZPZV<7>>; }; // NOLINT
6014 template<> struct ConwayPolynomial<499, 3> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<492>>; }; // NOLINT
6015 template<> struct ConwayPolynomial<499, 4> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<495>, ZPZV<7>>; }; // NOLINT
6016 template<> struct ConwayPolynomial<499, 5> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<492>>; }; // NOLINT
6017 template<> struct ConwayPolynomial<499, 6> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<407>, ZPZV<191>, ZPZV<78>, ZPZV<7>>; }; // NOLINT
6018 template<> struct ConwayPolynomial<499, 7> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<492>>; }; // NOLINT
6019 template<> struct ConwayPolynomial<499, 8> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<288>, ZPZV<309>, ZPZV<200>, ZPZV<7>>; }; // NOLINT
6020 template<> struct ConwayPolynomial<499, 9> { using ZPZ = aerobus::zpz<499>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<491>, ZPZV<222>, ZPZV<492>>; }; // NOLINT
6021 template<> struct ConwayPolynomial<503, 1> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<498>>; }; // NOLINT
6022 template<> struct ConwayPolynomial<503, 2> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<498>, ZPZV<5>>; }; // NOLINT
6023 template<> struct ConwayPolynomial<503, 3> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<498>>; }; // NOLINT
6024 template<> struct ConwayPolynomial<503, 4> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<325>, ZPZV<5>>; }; // NOLINT
6025 template<> struct ConwayPolynomial<503, 5> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<498>>; }; // NOLINT
6026 template<> struct ConwayPolynomial<503, 6> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<380>, ZPZV<292>, ZPZV<255>, ZPZV<5>>; }; // NOLINT
6027 template<> struct ConwayPolynomial<503, 7> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<498>>; }; // NOLINT
6028 template<> struct ConwayPolynomial<503, 8> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<441>, ZPZV<203>, ZPZV<316>, ZPZV<5>>; }; // NOLINT
6029 template<> struct ConwayPolynomial<503, 9> { using ZPZ = aerobus::zpz<503>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<158>, ZPZV<337>, ZPZV<498>>; }; // NOLINT
6030 template<> struct ConwayPolynomial<509, 1> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<507>>; }; // NOLINT
6031 template<> struct ConwayPolynomial<509, 2> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<508>, ZPZV<2>>; }; // NOLINT
6032 template<> struct ConwayPolynomial<509, 3> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<507>>; }; // NOLINT
6033 template<> struct ConwayPolynomial<509, 4> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<408>, ZPZV<2>>; }; // NOLINT
6034 template<> struct ConwayPolynomial<509, 5> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<507>>; }; // NOLINT
6035 template<> struct ConwayPolynomial<509, 6> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<350>, ZPZV<232>, ZPZV<41>, ZPZV<2>>; }; // NOLINT
6036 template<> struct ConwayPolynomial<509, 7> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<507>>; }; // NOLINT
6037 template<> struct ConwayPolynomial<509, 8> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<420>, ZPZV<473>, ZPZV<382>, ZPZV<2>>; }; // NOLINT
6038 template<> struct ConwayPolynomial<509, 9> { using ZPZ = aerobus::zpz<509>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<314>, ZPZV<28>, ZPZV<507>>; }; // NOLINT
6039 template<> struct ConwayPolynomial<521, 1> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<518>>; }; // NOLINT
6040 template<> struct ConwayPolynomial<521, 2> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<515>, ZPZV<3>>; }; // NOLINT
6041 template<> struct ConwayPolynomial<521, 3> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<518>>; }; // NOLINT
6042 template<> struct ConwayPolynomial<521, 4> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<509>, ZPZV<3>>; }; // NOLINT
6043 template<> struct ConwayPolynomial<521, 5> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<518>>; }; // NOLINT
6044 template<> struct ConwayPolynomial<521, 6> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<315>, ZPZV<153>, ZPZV<280>, ZPZV<3>>; }; // NOLINT
6045 template<> struct ConwayPolynomial<521, 7> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<518>>; }; // NOLINT
6046 template<> struct ConwayPolynomial<521, 8> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<462>, ZPZV<407>, ZPZV<312>, ZPZV<3>>; }; // NOLINT
6047 template<> struct ConwayPolynomial<521, 9> { using ZPZ = aerobus::zpz<521>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<181>, ZPZV<483>, ZPZV<518>>; }; // NOLINT
6048 template<> struct ConwayPolynomial<523, 1> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<521>>; }; // NOLINT
6049 template<> struct ConwayPolynomial<523, 2> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<522>, ZPZV<2>>; }; // NOLINT
6050 template<> struct ConwayPolynomial<523, 3> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<521>>; }; // NOLINT
6051 template<> struct ConwayPolynomial<523, 4> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<382>, ZPZV<2>>; }; // NOLINT
6052 template<> struct ConwayPolynomial<523, 5> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<521>>; }; // NOLINT
6053 template<> struct ConwayPolynomial<523, 6> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<475>, ZPZV<475>, ZPZV<371>, ZPZV<2>>; }; // NOLINT
6054 template<> struct ConwayPolynomial<523, 7> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<521>>; }; // NOLINT
6055 template<> struct ConwayPolynomial<523, 8> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<518>, ZPZV<184>, ZPZV<380>, ZPZV<2>>; }; // NOLINT
6056 template<> struct ConwayPolynomial<523, 9> { using ZPZ = aerobus::zpz<523>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<342>, ZPZV<145>, ZPZV<521>>; }; // NOLINT
6057 template<> struct ConwayPolynomial<541, 1> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<539>>; }; // NOLINT
6058 template<> struct ConwayPolynomial<541, 2> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<537>, ZPZV<2>>; }; // NOLINT
6059 template<> struct ConwayPolynomial<541, 3> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<539>>; }; // NOLINT
6060 template<> struct ConwayPolynomial<541, 4> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<333>, ZPZV<2>>; }; // NOLINT
6061 template<> struct ConwayPolynomial<541, 5> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<539>>; }; // NOLINT
6062 template<> struct ConwayPolynomial<541, 6> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<239>, ZPZV<320>, ZPZV<69>, ZPZV<2>>; }; // NOLINT
6063 template<> struct ConwayPolynomial<541, 7> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<539>>; }; // NOLINT
6064 template<> struct ConwayPolynomial<541, 8> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<376>, ZPZV<108>, ZPZV<113>, ZPZV<2>>; }; // NOLINT
6065 template<> struct ConwayPolynomial<541, 9> { using ZPZ = aerobus::zpz<541>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<340>, ZPZV<318>, ZPZV<539>>; }; // NOLINT
6066 template<> struct ConwayPolynomial<547, 1> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<545>>; }; // NOLINT
6067 template<> struct ConwayPolynomial<547, 2> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<543>, ZPZV<2>>; }; // NOLINT
6068 template<> struct ConwayPolynomial<547, 3> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<545>>; }; // NOLINT
6069 template<> struct ConwayPolynomial<547, 4> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<334>, ZPZV<2>>; }; // NOLINT
6070 template<> struct ConwayPolynomial<547, 5> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<545>>; }; // NOLINT
6071 template<> struct ConwayPolynomial<547, 6> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<334>, ZPZV<153>, ZPZV<423>, ZPZV<2>>; }; // NOLINT
6072 template<> struct ConwayPolynomial<547, 7> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<545>>; }; // NOLINT
6073 template<> struct ConwayPolynomial<547, 8> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<368>, ZPZV<20>, ZPZV<180>, ZPZV<2>>; }; // NOLINT
6074 template<> struct ConwayPolynomial<547, 9> { using ZPZ = aerobus::zpz<547>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<238>, ZPZV<263>, ZPZV<545>>; }; // NOLINT
6075 template<> struct ConwayPolynomial<557, 1> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<555>>; }; // NOLINT
6076 template<> struct ConwayPolynomial<557, 2> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<553>, ZPZV<2>>; }; // NOLINT
6077 template<> struct ConwayPolynomial<557, 3> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<555>>; }; // NOLINT
6078 template<> struct ConwayPolynomial<557, 4> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<430>, ZPZV<2>>; }; // NOLINT
6079 template<> struct ConwayPolynomial<557, 5> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<555>>; }; // NOLINT
6080 template<> struct ConwayPolynomial<557, 6> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<202>, ZPZV<192>, ZPZV<253>, ZPZV<2>>; }; // NOLINT
6081 template<> struct ConwayPolynomial<557, 7> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<555>>; }; // NOLINT
6082 template<> struct ConwayPolynomial<557, 8> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<480>, ZPZV<384>, ZPZV<113>, ZPZV<2>>; }; // NOLINT
6083 template<> struct ConwayPolynomial<557, 9> { using ZPZ = aerobus::zpz<557>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<456>, ZPZV<434>, ZPZV<555>>; }; // NOLINT
6084 template<> struct ConwayPolynomial<563, 1> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<561>>; }; // NOLINT
6085 template<> struct ConwayPolynomial<563, 2> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<559>, ZPZV<2>>; }; // NOLINT
6086 template<> struct ConwayPolynomial<563, 3> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<561>>; }; // NOLINT
6087 template<> struct ConwayPolynomial<563, 4> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<20>, ZPZV<399>, ZPZV<2>>; }; // NOLINT
6088 template<> struct ConwayPolynomial<563, 5> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<561>>; }; // NOLINT
6089 template<> struct ConwayPolynomial<563, 6> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<122>, ZPZV<303>, ZPZV<246>, ZPZV<2>>; }; // NOLINT
6090 template<> struct ConwayPolynomial<563, 7> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<561>>; }; // NOLINT
6091 template<> struct ConwayPolynomial<563, 8> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<503>, ZPZV<176>, ZPZV<509>, ZPZV<2>>; }; // NOLINT
6092 template<> struct ConwayPolynomial<563, 9> { using ZPZ = aerobus::zpz<563>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<15>, ZPZV<19>, ZPZV<561>>; }; // NOLINT
6093 template<> struct ConwayPolynomial<569, 1> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<566>>; }; // NOLINT
6094 template<> struct ConwayPolynomial<569, 2> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<568>, ZPZV<3>>; }; // NOLINT
6095 template<> struct ConwayPolynomial<569, 3> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<566>>; }; // NOLINT
6096 template<> struct ConwayPolynomial<569, 4> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<381>, ZPZV<3>>; }; // NOLINT
6097 template<> struct ConwayPolynomial<569, 5> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<566>>; }; // NOLINT
6098 template<> struct ConwayPolynomial<569, 6> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<50>, ZPZV<263>, ZPZV<480>, ZPZV<3>>; }; // NOLINT
6099 template<> struct ConwayPolynomial<569, 7> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<566>>; }; // NOLINT
6100 template<> struct ConwayPolynomial<569, 8> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<527>, ZPZV<173>, ZPZV<241>, ZPZV<3>>; }; // NOLINT
6101 template<> struct ConwayPolynomial<569, 9> { using ZPZ = aerobus::zpz<569>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<478>, ZPZV<566>, ZPZV<566>>; }; // NOLINT
6102 template<> struct ConwayPolynomial<571, 1> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<568>>; }; // NOLINT
6103 template<> struct ConwayPolynomial<571, 2> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<570>, ZPZV<3>>; }; // NOLINT
6104 template<> struct ConwayPolynomial<571, 3> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<568>>; }; // NOLINT
6105 template<> struct ConwayPolynomial<571, 4> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<402>, ZPZV<3>>; }; // NOLINT
6106 template<> struct ConwayPolynomial<571, 5> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<568>>; }; // NOLINT
6107 template<> struct ConwayPolynomial<571, 6> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<221>, ZPZV<295>, ZPZV<33>, ZPZV<3>>; }; // NOLINT
6108 template<> struct ConwayPolynomial<571, 7> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<568>>; }; // NOLINT
6109 template<> struct ConwayPolynomial<571, 8> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<363>, ZPZV<119>, ZPZV<371>, ZPZV<3>>; }; // NOLINT
6110 template<> struct ConwayPolynomial<571, 9> { using ZPZ = aerobus::zpz<571>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<34>, ZPZV<545>, ZPZV<179>, ZPZV<568>>; }; // NOLINT
6111 template<> struct ConwayPolynomial<577, 1> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<572>>; }; // NOLINT
6112 template<> struct ConwayPolynomial<577, 2> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<572>, ZPZV<5>>; }; // NOLINT
6113 template<> struct ConwayPolynomial<577, 3> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<572>>; }; // NOLINT
6114 template<> struct ConwayPolynomial<577, 4> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<494>, ZPZV<5>>; }; // NOLINT
6115 template<> struct ConwayPolynomial<577, 5> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<572>>; }; // NOLINT
6116 template<> struct ConwayPolynomial<577, 6> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<450>, ZPZV<25>, ZPZV<283>, ZPZV<5>>; }; // NOLINT
6117 template<> struct ConwayPolynomial<577, 7> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<572>>; }; // NOLINT
6118 template<> struct ConwayPolynomial<577, 8> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<450>, ZPZV<545>, ZPZV<321>, ZPZV<5>>; }; // NOLINT
6119 template<> struct ConwayPolynomial<577, 9> { using ZPZ = aerobus::zpz<577>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<576>, ZPZV<449>, ZPZV<572>>; }; // NOLINT
6120 template<> struct ConwayPolynomial<587, 1> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<585>>; }; // NOLINT
6121 template<> struct ConwayPolynomial<587, 2> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<583>, ZPZV<2>>; }; // NOLINT
6122 template<> struct ConwayPolynomial<587, 3> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<585>>; }; // NOLINT
6123 template<> struct ConwayPolynomial<587, 4> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<16>, ZPZV<444>, ZPZV<2>>; }; // NOLINT
6124 template<> struct ConwayPolynomial<587, 5> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<585>>; }; // NOLINT
6125 template<> struct ConwayPolynomial<587, 6> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<204>, ZPZV<121>, ZPZV<226>, ZPZV<2>>; }; // NOLINT
6126 template<> struct ConwayPolynomial<587, 7> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<585>>; }; // NOLINT
6127 template<> struct ConwayPolynomial<587, 8> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<492>, ZPZV<44>, ZPZV<91>, ZPZV<2>>; }; // NOLINT
6128 template<> struct ConwayPolynomial<587, 9> { using ZPZ = aerobus::zpz<587>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<333>, ZPZV<55>, ZPZV<585>>; }; // NOLINT
6129 template<> struct ConwayPolynomial<593, 1> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<590>>; }; // NOLINT
6130 template<> struct ConwayPolynomial<593, 2> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<592>, ZPZV<3>>; }; // NOLINT
6131 template<> struct ConwayPolynomial<593, 3> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<590>>; }; // NOLINT
6132 template<> struct ConwayPolynomial<593, 4> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<419>, ZPZV<3>>; }; // NOLINT
6133 template<> struct ConwayPolynomial<593, 5> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<590>>; }; // NOLINT
6134 template<> struct ConwayPolynomial<593, 6> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<345>, ZPZV<65>, ZPZV<478>, ZPZV<3>>; }; // NOLINT
6135 template<> struct ConwayPolynomial<593, 7> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<590>>; }; // NOLINT
6136 template<> struct ConwayPolynomial<593, 8> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<350>, ZPZV<291>, ZPZV<495>, ZPZV<3>>; }; // NOLINT
6137 template<> struct ConwayPolynomial<593, 9> { using ZPZ = aerobus::zpz<593>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<223>, ZPZV<523>, ZPZV<590>>; }; // NOLINT
6138 template<> struct ConwayPolynomial<599, 1> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<592>>; }; // NOLINT
6139 template<> struct ConwayPolynomial<599, 2> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<598>, ZPZV<7>>; }; // NOLINT
6140 template<> struct ConwayPolynomial<599, 3> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<592>>; }; // NOLINT
6141 template<> struct ConwayPolynomial<599, 4> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<419>, ZPZV<7>>; }; // NOLINT
6142 template<> struct ConwayPolynomial<599, 5> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<592>>; }; // NOLINT
6143 template<> struct ConwayPolynomial<599, 6> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<515>, ZPZV<274>, ZPZV<586>, ZPZV<7>>; }; // NOLINT
6144 template<> struct ConwayPolynomial<599, 7> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<592>>; }; // NOLINT
6145 template<> struct ConwayPolynomial<599, 8> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<440>, ZPZV<37>, ZPZV<124>, ZPZV<7>>; }; // NOLINT
6146 template<> struct ConwayPolynomial<599, 9> { using ZPZ = aerobus::zpz<599>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<114>, ZPZV<98>, ZPZV<592>>; }; // NOLINT
6147 template<> struct ConwayPolynomial<601, 1> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<594>>; }; // NOLINT
6148 template<> struct ConwayPolynomial<601, 2> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<598>, ZPZV<7>>; }; // NOLINT
6149 template<> struct ConwayPolynomial<601, 3> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<594>>; }; // NOLINT
6150 template<> struct ConwayPolynomial<601, 4> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<14>, ZPZV<347>, ZPZV<7>>; }; // NOLINT
6151 template<> struct ConwayPolynomial<601, 5> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<594>>; }; // NOLINT
6152 template<> struct ConwayPolynomial<601, 6> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<128>, ZPZV<440>, ZPZV<49>, ZPZV<7>>; }; // NOLINT
6153 template<> struct ConwayPolynomial<601, 7> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<594>>; }; // NOLINT
6154 template<> struct ConwayPolynomial<601, 8> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<550>, ZPZV<241>, ZPZV<490>, ZPZV<7>>; }; // NOLINT
6155 template<> struct ConwayPolynomial<601, 9> { using ZPZ = aerobus::zpz<601>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<487>, ZPZV<590>, ZPZV<594>>; }; // NOLINT
6156 template<> struct ConwayPolynomial<607, 1> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<604>>; }; // NOLINT
6157 template<> struct ConwayPolynomial<607, 2> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<606>, ZPZV<3>>; }; // NOLINT
6158 template<> struct ConwayPolynomial<607, 3> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<604>>; }; // NOLINT
6159 template<> struct ConwayPolynomial<607, 4> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<449>, ZPZV<3>>; }; // NOLINT
6160 template<> struct ConwayPolynomial<607, 5> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<604>>; }; // NOLINT
6161 template<> struct ConwayPolynomial<607, 6> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<45>, ZPZV<478>, ZPZV<3>>; }; // NOLINT
6162 template<> struct ConwayPolynomial<607, 7> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<604>>; }; // NOLINT
6163 template<> struct ConwayPolynomial<607, 8> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<468>, ZPZV<35>, ZPZV<449>, ZPZV<3>>; }; // NOLINT
6164 template<> struct ConwayPolynomial<607, 9> { using ZPZ = aerobus::zpz<607>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<444>, ZPZV<129>, ZPZV<604>>; }; // NOLINT
6165 template<> struct ConwayPolynomial<613, 1> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<611>>; }; // NOLINT
6166 template<> struct ConwayPolynomial<613, 2> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<609>, ZPZV<2>>; }; // NOLINT
6167 template<> struct ConwayPolynomial<613, 3> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<611>>; }; // NOLINT
6168 template<> struct ConwayPolynomial<613, 4> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<333>, ZPZV<2>>; }; // NOLINT
6169 template<> struct ConwayPolynomial<613, 5> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<32>, ZPZV<611>>; }; // NOLINT
6170 template<> struct ConwayPolynomial<613, 6> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<609>, ZPZV<595>, ZPZV<601>, ZPZV<2>>; }; // NOLINT
6171 template<> struct ConwayPolynomial<613, 7> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<611>>; }; // NOLINT
6172 template<> struct ConwayPolynomial<613, 8> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<489>, ZPZV<57>, ZPZV<539>, ZPZV<2>>; }; // NOLINT
6173 template<> struct ConwayPolynomial<613, 9> { using ZPZ = aerobus::zpz<613>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<513>, ZPZV<536>, ZPZV<611>>; }; // NOLINT
6174 template<> struct ConwayPolynomial<617, 1> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<614>>; }; // NOLINT
6175 template<> struct ConwayPolynomial<617, 2> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<612>, ZPZV<3>>; }; // NOLINT
6176 template<> struct ConwayPolynomial<617, 3> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<614>>; }; // NOLINT
6177 template<> struct ConwayPolynomial<617, 4> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<503>, ZPZV<3>>; }; // NOLINT
6178 template<> struct ConwayPolynomial<617, 5> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<614>>; }; // NOLINT
6179 template<> struct ConwayPolynomial<617, 6> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<318>, ZPZV<595>, ZPZV<310>, ZPZV<3>>; }; // NOLINT
6180 template<> struct ConwayPolynomial<617, 7> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<614>>; }; // NOLINT
6181 template<> struct ConwayPolynomial<617, 8> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<519>, ZPZV<501>, ZPZV<155>, ZPZV<3>>; }; // NOLINT
6182 template<> struct ConwayPolynomial<617, 9> { using ZPZ = aerobus::zpz<617>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<388>, ZPZV<543>, ZPZV<614>>; }; // NOLINT
6183 template<> struct ConwayPolynomial<619, 1> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<617>>; }; // NOLINT
6184 template<> struct ConwayPolynomial<619, 2> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<618>, ZPZV<2>>; }; // NOLINT
6185 template<> struct ConwayPolynomial<619, 3> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<617>>; }; // NOLINT
6186 template<> struct ConwayPolynomial<619, 4> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<492>, ZPZV<2>>; }; // NOLINT
6187 template<> struct ConwayPolynomial<619, 5> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<617>>; }; // NOLINT
6188 template<> struct ConwayPolynomial<619, 6> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<238>, ZPZV<468>, ZPZV<347>, ZPZV<2>>; }; // NOLINT
6189 template<> struct ConwayPolynomial<619, 7> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<617>>; }; // NOLINT
6190 template<> struct ConwayPolynomial<619, 8> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<416>, ZPZV<383>, ZPZV<225>, ZPZV<2>>; }; // NOLINT
6191 template<> struct ConwayPolynomial<619, 9> { using ZPZ = aerobus::zpz<619>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<579>, ZPZV<310>, ZPZV<617>>; }; // NOLINT
6192 template<> struct ConwayPolynomial<631, 1> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<628>>; }; // NOLINT
6193 template<> struct ConwayPolynomial<631, 2> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<629>, ZPZV<3>>; }; // NOLINT
6194 template<> struct ConwayPolynomial<631, 3> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<628>>; }; // NOLINT
6195 template<> struct ConwayPolynomial<631, 4> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<376>, ZPZV<3>>; }; // NOLINT
6196 template<> struct ConwayPolynomial<631, 5> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<628>>; }; // NOLINT
6197 template<> struct ConwayPolynomial<631, 6> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<516>, ZPZV<541>, ZPZV<106>, ZPZV<3>>; }; // NOLINT
6198 template<> struct ConwayPolynomial<631, 7> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<628>>; }; // NOLINT
6199 template<> struct ConwayPolynomial<631, 8> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<379>, ZPZV<516>, ZPZV<187>, ZPZV<3>>; }; // NOLINT
6200 template<> struct ConwayPolynomial<631, 9> { using ZPZ = aerobus::zpz<631>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<296>, ZPZV<413>, ZPZV<628>>; }; // NOLINT
6201 template<> struct ConwayPolynomial<641, 1> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<638>>; }; // NOLINT
6202 template<> struct ConwayPolynomial<641, 2> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<635>, ZPZV<3>>; }; // NOLINT
6203 template<> struct ConwayPolynomial<641, 3> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<638>>; }; // NOLINT
6204 template<> struct ConwayPolynomial<641, 4> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<629>, ZPZV<3>>; }; // NOLINT
6205 template<> struct ConwayPolynomial<641, 5> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<638>>; }; // NOLINT
6206 template<> struct ConwayPolynomial<641, 6> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<105>, ZPZV<557>, ZPZV<294>, ZPZV<3>>; }; // NOLINT
6207 template<> struct ConwayPolynomial<641, 7> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<638>>; }; // NOLINT
6208 template<> struct ConwayPolynomial<641, 8> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<356>, ZPZV<392>, ZPZV<332>, ZPZV<3>>; }; // NOLINT
6209 template<> struct ConwayPolynomial<641, 9> { using ZPZ = aerobus::zpz<641>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<66>, ZPZV<141>, ZPZV<638>>; }; // NOLINT
6210 template<> struct ConwayPolynomial<643, 1> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<632>>; }; // NOLINT
6211 template<> struct ConwayPolynomial<643, 2> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<641>, ZPZV<11>>; }; // NOLINT
6212 template<> struct ConwayPolynomial<643, 3> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<632>>; }; // NOLINT
6213 template<> struct ConwayPolynomial<643, 4> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<600>, ZPZV<11>>; }; // NOLINT
6214 template<> struct ConwayPolynomial<643, 5> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<632>>; }; // NOLINT
6215 template<> struct ConwayPolynomial<643, 6> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<345>, ZPZV<412>, ZPZV<293>, ZPZV<11>>; }; // NOLINT
6216 template<> struct ConwayPolynomial<643, 7> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<632>>; }; // NOLINT
6217 template<> struct ConwayPolynomial<643, 8> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<631>, ZPZV<573>, ZPZV<569>, ZPZV<11>>; }; // NOLINT
6218 template<> struct ConwayPolynomial<643, 9> { using ZPZ = aerobus::zpz<643>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<591>, ZPZV<475>, ZPZV<632>>; }; // NOLINT
6219 template<> struct ConwayPolynomial<647, 1> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<642>>; }; // NOLINT
6220 template<> struct ConwayPolynomial<647, 2> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<645>, ZPZV<5>>; }; // NOLINT
6221 template<> struct ConwayPolynomial<647, 3> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<642>>; }; // NOLINT
6222 template<> struct ConwayPolynomial<647, 4> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<643>, ZPZV<5>>; }; // NOLINT
6223 template<> struct ConwayPolynomial<647, 5> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<642>>; }; // NOLINT
6224 template<> struct ConwayPolynomial<647, 6> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<308>, ZPZV<385>, ZPZV<642>, ZPZV<5>>; }; // NOLINT
6225 template<> struct ConwayPolynomial<647, 7> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<642>>; }; // NOLINT
6226 template<> struct ConwayPolynomial<647, 8> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<603>, ZPZV<259>, ZPZV<271>, ZPZV<5>>; }; // NOLINT
6227 template<> struct ConwayPolynomial<647, 9> { using ZPZ = aerobus::zpz<647>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<561>, ZPZV<123>, ZPZV<642>>; }; // NOLINT
6228 template<> struct ConwayPolynomial<653, 1> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<651>>; }; // NOLINT
6229 template<> struct ConwayPolynomial<653, 2> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<649>, ZPZV<2>>; }; // NOLINT
6230 template<> struct ConwayPolynomial<653, 3> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<651>>; }; // NOLINT
6231 template<> struct ConwayPolynomial<653, 4> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<596>, ZPZV<2>>; }; // NOLINT
6232 template<> struct ConwayPolynomial<653, 5> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<651>>; }; // NOLINT
6233 template<> struct ConwayPolynomial<653, 6> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<45>, ZPZV<220>, ZPZV<242>, ZPZV<2>>; }; // NOLINT
6234 template<> struct ConwayPolynomial<653, 7> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<651>>; }; // NOLINT
6235 template<> struct ConwayPolynomial<653, 8> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<385>, ZPZV<18>, ZPZV<296>, ZPZV<2>>; }; // NOLINT
6236 template<> struct ConwayPolynomial<653, 9> { using ZPZ = aerobus::zpz<653>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<365>, ZPZV<60>, ZPZV<651>>; }; // NOLINT
6237 template<> struct ConwayPolynomial<659, 1> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<657>>; }; // NOLINT
6238 template<> struct ConwayPolynomial<659, 2> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<655>, ZPZV<2>>; }; // NOLINT
6239 template<> struct ConwayPolynomial<659, 3> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<657>>; }; // NOLINT
6240 template<> struct ConwayPolynomial<659, 4> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<351>, ZPZV<2>>; }; // NOLINT
6241 template<> struct ConwayPolynomial<659, 5> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<657>>; }; // NOLINT
6242 template<> struct ConwayPolynomial<659, 6> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<371>, ZPZV<105>, ZPZV<223>, ZPZV<2>>; }; // NOLINT
6243 template<> struct ConwayPolynomial<659, 7> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<657>>; }; // NOLINT
6244 template<> struct ConwayPolynomial<659, 8> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<358>, ZPZV<246>, ZPZV<90>, ZPZV<2>>; }; // NOLINT
6245 template<> struct ConwayPolynomial<659, 9> { using ZPZ = aerobus::zpz<659>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<592>, ZPZV<46>, ZPZV<657>>; }; // NOLINT
6246 template<> struct ConwayPolynomial<661, 1> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<659>>; }; // NOLINT
6247 template<> struct ConwayPolynomial<661, 2> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<660>, ZPZV<2>>; }; // NOLINT
6248 template<> struct ConwayPolynomial<661, 3> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<659>>; }; // NOLINT
6249 template<> struct ConwayPolynomial<661, 4> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<616>, ZPZV<2>>; }; // NOLINT
6250 template<> struct ConwayPolynomial<661, 5> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<19>, ZPZV<659>>; }; // NOLINT
6251 template<> struct ConwayPolynomial<661, 6> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<551>, ZPZV<456>, ZPZV<382>, ZPZV<2>>; }; // NOLINT
6252 template<> struct ConwayPolynomial<661, 7> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<659>>; }; // NOLINT
6253 template<> struct ConwayPolynomial<661, 8> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<612>, ZPZV<285>, ZPZV<72>, ZPZV<2>>; }; // NOLINT
6254 template<> struct ConwayPolynomial<661, 9> { using ZPZ = aerobus::zpz<661>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<18>, ZPZV<389>, ZPZV<220>, ZPZV<659>>; }; // NOLINT
6255 template<> struct ConwayPolynomial<673, 1> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<668>>; }; // NOLINT
6256 template<> struct ConwayPolynomial<673, 2> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<672>, ZPZV<5>>; }; // NOLINT
6257 template<> struct ConwayPolynomial<673, 3> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<668>>; }; // NOLINT
6258 template<> struct ConwayPolynomial<673, 4> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<416>, ZPZV<5>>; }; // NOLINT
6259 template<> struct ConwayPolynomial<673, 5> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<668>>; }; // NOLINT
6260 template<> struct ConwayPolynomial<673, 6> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<524>, ZPZV<248>, ZPZV<35>, ZPZV<5>>; }; // NOLINT
6261 template<> struct ConwayPolynomial<673, 7> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<668>>; }; // NOLINT
6262 template<> struct ConwayPolynomial<673, 8> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<669>, ZPZV<587>, ZPZV<302>, ZPZV<5>>; }; // NOLINT
6263 template<> struct ConwayPolynomial<673, 9> { using ZPZ = aerobus::zpz<673>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<347>, ZPZV<553>, ZPZV<668>>; }; // NOLINT
6264 template<> struct ConwayPolynomial<677, 1> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<675>>; }; // NOLINT
6265 template<> struct ConwayPolynomial<677, 2> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<672>, ZPZV<2>>; }; // NOLINT
6266 template<> struct ConwayPolynomial<677, 3> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<675>>; }; // NOLINT
6267 template<> struct ConwayPolynomial<677, 4> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<631>, ZPZV<2>>; }; // NOLINT
6268 template<> struct ConwayPolynomial<677, 5> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<675>>; }; // NOLINT
6269 template<> struct ConwayPolynomial<677, 6> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<446>, ZPZV<632>, ZPZV<50>, ZPZV<2>>; }; // NOLINT
6270 template<> struct ConwayPolynomial<677, 7> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<675>>; }; // NOLINT
6271 template<> struct ConwayPolynomial<677, 8> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<363>, ZPZV<619>, ZPZV<152>, ZPZV<2>>; }; // NOLINT
6272 template<> struct ConwayPolynomial<677, 9> { using ZPZ = aerobus::zpz<677>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<504>, ZPZV<404>, ZPZV<675>>; }; // NOLINT
6273 template<> struct ConwayPolynomial<683, 1> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<678>>; }; // NOLINT
6274 template<> struct ConwayPolynomial<683, 2> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<682>, ZPZV<5>>; }; // NOLINT
6275 template<> struct ConwayPolynomial<683, 3> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<678>>; }; // NOLINT
6276 template<> struct ConwayPolynomial<683, 4> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<455>, ZPZV<5>>; }; // NOLINT
6277 template<> struct ConwayPolynomial<683, 5> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<678>>; }; // NOLINT
6278 template<> struct ConwayPolynomial<683, 6> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<644>, ZPZV<109>, ZPZV<434>, ZPZV<5>>; }; // NOLINT
6279 template<> struct ConwayPolynomial<683, 7> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<30>, ZPZV<678>>; }; // NOLINT
6280 template<> struct ConwayPolynomial<683, 8> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<383>, ZPZV<184>, ZPZV<65>, ZPZV<5>>; }; // NOLINT
6281 template<> struct ConwayPolynomial<683, 9> { using ZPZ = aerobus::zpz<683>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<85>, ZPZV<444>, ZPZV<678>>; }; // NOLINT
6282 template<> struct ConwayPolynomial<691, 1> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<688>>; }; // NOLINT
6283 template<> struct ConwayPolynomial<691, 2> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<686>, ZPZV<3>>; }; // NOLINT
6284 template<> struct ConwayPolynomial<691, 3> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<14>, ZPZV<688>>; }; // NOLINT
6285 template<> struct ConwayPolynomial<691, 4> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<632>, ZPZV<3>>; }; // NOLINT
6286 template<> struct ConwayPolynomial<691, 5> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<688>>; }; // NOLINT
6287 template<> struct ConwayPolynomial<691, 6> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<579>, ZPZV<408>, ZPZV<262>, ZPZV<3>>; }; // NOLINT
6288 template<> struct ConwayPolynomial<691, 7> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<688>>; }; // NOLINT
6289 template<> struct ConwayPolynomial<691, 8> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<356>, ZPZV<425>, ZPZV<321>, ZPZV<3>>; }; // NOLINT
6290 template<> struct ConwayPolynomial<691, 9> { using ZPZ = aerobus::zpz<691>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<556>, ZPZV<443>, ZPZV<688>>; }; // NOLINT
6291 template<> struct ConwayPolynomial<701, 1> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<699>>; }; // NOLINT
6292 template<> struct ConwayPolynomial<701, 2> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<697>, ZPZV<2>>; }; // NOLINT
6293 template<> struct ConwayPolynomial<701, 3> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<699>>; }; // NOLINT
6294 template<> struct ConwayPolynomial<701, 4> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<379>, ZPZV<2>>; }; // NOLINT
6295 template<> struct ConwayPolynomial<701, 5> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<699>>; }; // NOLINT
6296 template<> struct ConwayPolynomial<701, 6> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<571>, ZPZV<327>, ZPZV<285>, ZPZV<2>>; }; // NOLINT
6297 template<> struct ConwayPolynomial<701, 7> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<699>>; }; // NOLINT
6298 template<> struct ConwayPolynomial<701, 8> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<619>, ZPZV<206>, ZPZV<593>, ZPZV<2>>; }; // NOLINT
6299 template<> struct ConwayPolynomial<701, 9> { using ZPZ = aerobus::zpz<701>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<459>, ZPZV<373>, ZPZV<699>>; }; // NOLINT
6300 template<> struct ConwayPolynomial<709, 1> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<707>>; }; // NOLINT
6301 template<> struct ConwayPolynomial<709, 2> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<705>, ZPZV<2>>; }; // NOLINT
6302 template<> struct ConwayPolynomial<709, 3> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<707>>; }; // NOLINT
6303 template<> struct ConwayPolynomial<709, 4> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<384>, ZPZV<2>>; }; // NOLINT
6304 template<> struct ConwayPolynomial<709, 5> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<707>>; }; // NOLINT
6305 template<> struct ConwayPolynomial<709, 6> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<669>, ZPZV<514>, ZPZV<295>, ZPZV<2>>; }; // NOLINT
6306 template<> struct ConwayPolynomial<709, 7> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<707>>; }; // NOLINT
6307 template<> struct ConwayPolynomial<709, 8> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<689>, ZPZV<233>, ZPZV<79>, ZPZV<2>>; }; // NOLINT
6308 template<> struct ConwayPolynomial<709, 9> { using ZPZ = aerobus::zpz<709>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<257>, ZPZV<171>, ZPZV<707>>; }; // NOLINT
6309 template<> struct ConwayPolynomial<719, 1> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<708>>; }; // NOLINT
6310 template<> struct ConwayPolynomial<719, 2> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<715>, ZPZV<11>>; }; // NOLINT
6311 template<> struct ConwayPolynomial<719, 3> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<708>>; }; // NOLINT
6312 template<> struct ConwayPolynomial<719, 4> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<602>, ZPZV<11>>; }; // NOLINT
6313 template<> struct ConwayPolynomial<719, 5> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<708>>; }; // NOLINT
6314 template<> struct ConwayPolynomial<719, 6> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<533>, ZPZV<591>, ZPZV<182>, ZPZV<11>>; }; // NOLINT
6315 template<> struct ConwayPolynomial<719, 7> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<708>>; }; // NOLINT
6316 template<> struct ConwayPolynomial<719, 8> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<714>, ZPZV<362>, ZPZV<244>, ZPZV<11>>; }; // NOLINT
6317 template<> struct ConwayPolynomial<719, 9> { using ZPZ = aerobus::zpz<719>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<288>, ZPZV<560>, ZPZV<708>>; }; // NOLINT
6318 template<> struct ConwayPolynomial<727, 1> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<722>>; }; // NOLINT
6319 template<> struct ConwayPolynomial<727, 2> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<725>, ZPZV<5>>; }; // NOLINT
6320 template<> struct ConwayPolynomial<727, 3> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<722>>; }; // NOLINT
6321 template<> struct ConwayPolynomial<727, 4> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<723>, ZPZV<5>>; }; // NOLINT
6322 template<> struct ConwayPolynomial<727, 5> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<722>>; }; // NOLINT
6323 template<> struct ConwayPolynomial<727, 6> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<86>, ZPZV<397>, ZPZV<672>, ZPZV<5>>; }; // NOLINT
6324 template<> struct ConwayPolynomial<727, 7> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<17>, ZPZV<722>>; }; // NOLINT
6325 template<> struct ConwayPolynomial<727, 8> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<639>, ZPZV<671>, ZPZV<368>, ZPZV<5>>; }; // NOLINT
6326 template<> struct ConwayPolynomial<727, 9> { using ZPZ = aerobus::zpz<727>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<573>, ZPZV<502>, ZPZV<722>>; }; // NOLINT
6327 template<> struct ConwayPolynomial<733, 1> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<727>>; }; // NOLINT
6328 template<> struct ConwayPolynomial<733, 2> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<732>, ZPZV<6>>; }; // NOLINT
6329 template<> struct ConwayPolynomial<733, 3> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<727>>; }; // NOLINT
6330 template<> struct ConwayPolynomial<733, 4> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<539>, ZPZV<6>>; }; // NOLINT
6331 template<> struct ConwayPolynomial<733, 5> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<727>>; }; // NOLINT
6332 template<> struct ConwayPolynomial<733, 6> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<174>, ZPZV<549>, ZPZV<151>, ZPZV<6>>; }; // NOLINT
6333 template<> struct ConwayPolynomial<733, 7> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<727>>; }; // NOLINT
6334 template<> struct ConwayPolynomial<733, 8> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<532>, ZPZV<610>, ZPZV<142>, ZPZV<6>>; }; // NOLINT
6335 template<> struct ConwayPolynomial<733, 9> { using ZPZ = aerobus::zpz<733>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<337>, ZPZV<6>, ZPZV<727>>; }; // NOLINT
6336 template<> struct ConwayPolynomial<739, 1> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<736>>; }; // NOLINT
6337 template<> struct ConwayPolynomial<739, 2> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<734>, ZPZV<3>>; }; // NOLINT
6338 template<> struct ConwayPolynomial<739, 3> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<736>>; }; // NOLINT
6339 template<> struct ConwayPolynomial<739, 4> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<678>, ZPZV<3>>; }; // NOLINT
6340 template<> struct ConwayPolynomial<739, 5> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<736>>; }; // NOLINT
6341 template<> struct ConwayPolynomial<739, 6> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<422>, ZPZV<447>, ZPZV<625>, ZPZV<3>>; }; // NOLINT
6342 template<> struct ConwayPolynomial<739, 7> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<44>, ZPZV<736>>; }; // NOLINT
6343 template<> struct ConwayPolynomial<739, 8> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<401>, ZPZV<169>, ZPZV<25>, ZPZV<3>>; }; // NOLINT
6344 template<> struct ConwayPolynomial<739, 9> { using ZPZ = aerobus::zpz<739>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<616>, ZPZV<81>, ZPZV<736>>; }; // NOLINT
6345 template<> struct ConwayPolynomial<743, 1> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<738>>; }; // NOLINT
6346 template<> struct ConwayPolynomial<743, 2> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<742>, ZPZV<5>>; }; // NOLINT
6347 template<> struct ConwayPolynomial<743, 3> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<738>>; }; // NOLINT
6348 template<> struct ConwayPolynomial<743, 4> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<425>, ZPZV<5>>; }; // NOLINT
6349 template<> struct ConwayPolynomial<743, 5> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<738>>; }; // NOLINT
6350 template<> struct ConwayPolynomial<743, 6> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<236>, ZPZV<471>, ZPZV<88>, ZPZV<5>>; }; // NOLINT
6351 template<> struct ConwayPolynomial<743, 7> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<738>>; }; // NOLINT
6352 template<> struct ConwayPolynomial<743, 8> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<551>, ZPZV<279>, ZPZV<588>, ZPZV<5>>; }; // NOLINT
6353 template<> struct ConwayPolynomial<743, 9> { using ZPZ = aerobus::zpz<743>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<327>, ZPZV<676>, ZPZV<738>>; }; // NOLINT
6354 template<> struct ConwayPolynomial<751, 1> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<748>>; }; // NOLINT
6355 template<> struct ConwayPolynomial<751, 2> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<749>, ZPZV<3>>; }; // NOLINT
6356 template<> struct ConwayPolynomial<751, 3> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<748>>; }; // NOLINT
6357 template<> struct ConwayPolynomial<751, 4> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<525>, ZPZV<3>>; }; // NOLINT
6358 template<> struct ConwayPolynomial<751, 5> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<748>>; }; // NOLINT
6359 template<> struct ConwayPolynomial<751, 6> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<298>, ZPZV<633>, ZPZV<539>, ZPZV<3>>; }; // NOLINT
6360 template<> struct ConwayPolynomial<751, 7> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<748>>; }; // NOLINT
6361 template<> struct ConwayPolynomial<751, 8> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<741>, ZPZV<243>, ZPZV<672>, ZPZV<3>>; }; // NOLINT
6362 template<> struct ConwayPolynomial<751, 9> { using ZPZ = aerobus::zpz<751>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<703>, ZPZV<489>, ZPZV<748>>; }; // NOLINT
6363 template<> struct ConwayPolynomial<757, 1> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<755>>; }; // NOLINT
6364 template<> struct ConwayPolynomial<757, 2> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<753>, ZPZV<2>>; }; // NOLINT
6365 template<> struct ConwayPolynomial<757, 3> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<755>>; }; // NOLINT
6366 template<> struct ConwayPolynomial<757, 4> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<10>, ZPZV<537>, ZPZV<2>>; }; // NOLINT
6367 template<> struct ConwayPolynomial<757, 5> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<755>>; }; // NOLINT
6368 template<> struct ConwayPolynomial<757, 6> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<753>, ZPZV<739>, ZPZV<745>, ZPZV<2>>; }; // NOLINT
6369 template<> struct ConwayPolynomial<757, 7> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<755>>; }; // NOLINT
6370 template<> struct ConwayPolynomial<757, 8> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<494>, ZPZV<110>, ZPZV<509>, ZPZV<2>>; }; // NOLINT
6371 template<> struct ConwayPolynomial<757, 9> { using ZPZ = aerobus::zpz<757>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<688>, ZPZV<702>, ZPZV<755>>; }; // NOLINT
6372 template<> struct ConwayPolynomial<761, 1> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<755>>; }; // NOLINT
6373 template<> struct ConwayPolynomial<761, 2> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<758>, ZPZV<6>>; }; // NOLINT
6374 template<> struct ConwayPolynomial<761, 3> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<12>, ZPZV<755>>; }; // NOLINT
6375 template<> struct ConwayPolynomial<761, 4> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<658>, ZPZV<6>>; }; // NOLINT
6376 template<> struct ConwayPolynomial<761, 5> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<755>>; }; // NOLINT
6377 template<> struct ConwayPolynomial<761, 6> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<634>, ZPZV<597>, ZPZV<155>, ZPZV<6>>; }; // NOLINT
6378 template<> struct ConwayPolynomial<761, 7> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<755>>; }; // NOLINT
6379 template<> struct ConwayPolynomial<761, 8> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<603>, ZPZV<144>, ZPZV<540>, ZPZV<6>>; }; // NOLINT
6380 template<> struct ConwayPolynomial<761, 9> { using ZPZ = aerobus::zpz<761>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<317>, ZPZV<571>, ZPZV<755>>; }; // NOLINT
6381 template<> struct ConwayPolynomial<769, 1> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<758>>; }; // NOLINT
6382 template<> struct ConwayPolynomial<769, 2> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<765>, ZPZV<11>>; }; // NOLINT
6383 template<> struct ConwayPolynomial<769, 3> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<758>>; }; // NOLINT
6384 template<> struct ConwayPolynomial<769, 4> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<32>, ZPZV<741>, ZPZV<11>>; }; // NOLINT
6385 template<> struct ConwayPolynomial<769, 5> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<758>>; }; // NOLINT
6386 template<> struct ConwayPolynomial<769, 6> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<43>, ZPZV<326>, ZPZV<650>, ZPZV<11>>; }; // NOLINT
6387 template<> struct ConwayPolynomial<769, 7> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<758>>; }; // NOLINT
6388 template<> struct ConwayPolynomial<769, 8> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<560>, ZPZV<574>, ZPZV<632>, ZPZV<11>>; }; // NOLINT
6389 template<> struct ConwayPolynomial<769, 9> { using ZPZ = aerobus::zpz<769>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<623>, ZPZV<751>, ZPZV<758>>; }; // NOLINT
6390 template<> struct ConwayPolynomial<773, 1> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<771>>; }; // NOLINT
6391 template<> struct ConwayPolynomial<773, 2> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<772>, ZPZV<2>>; }; // NOLINT
6392 template<> struct ConwayPolynomial<773, 3> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<771>>; }; // NOLINT
6393 template<> struct ConwayPolynomial<773, 4> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<444>, ZPZV<2>>; }; // NOLINT
6394 template<> struct ConwayPolynomial<773, 5> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<771>>; }; // NOLINT
6395 template<> struct ConwayPolynomial<773, 6> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<91>, ZPZV<3>, ZPZV<581>, ZPZV<2>>; }; // NOLINT
6396 template<> struct ConwayPolynomial<773, 7> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<771>>; }; // NOLINT
6397 template<> struct ConwayPolynomial<773, 8> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<484>, ZPZV<94>, ZPZV<693>, ZPZV<2>>; }; // NOLINT
6398 template<> struct ConwayPolynomial<773, 9> { using ZPZ = aerobus::zpz<773>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<216>, ZPZV<574>, ZPZV<771>>; }; // NOLINT
6399 template<> struct ConwayPolynomial<787, 1> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<785>>; }; // NOLINT
6400 template<> struct ConwayPolynomial<787, 2> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<786>, ZPZV<2>>; }; // NOLINT
6401 template<> struct ConwayPolynomial<787, 3> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<785>>; }; // NOLINT
6402 template<> struct ConwayPolynomial<787, 4> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<605>, ZPZV<2>>; }; // NOLINT
6403 template<> struct ConwayPolynomial<787, 5> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<785>>; }; // NOLINT
6404 template<> struct ConwayPolynomial<787, 6> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<98>, ZPZV<512>, ZPZV<606>, ZPZV<2>>; }; // NOLINT
6405 template<> struct ConwayPolynomial<787, 7> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<785>>; }; // NOLINT
6406 template<> struct ConwayPolynomial<787, 8> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<612>, ZPZV<26>, ZPZV<715>, ZPZV<2>>; }; // NOLINT
6407 template<> struct ConwayPolynomial<787, 9> { using ZPZ = aerobus::zpz<787>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<480>, ZPZV<573>, ZPZV<785>>; }; // NOLINT
6408 template<> struct ConwayPolynomial<797, 1> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<795>>; }; // NOLINT
6409 template<> struct ConwayPolynomial<797, 2> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<793>, ZPZV<2>>; }; // NOLINT
6410 template<> struct ConwayPolynomial<797, 3> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<795>>; }; // NOLINT
6411 template<> struct ConwayPolynomial<797, 4> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<717>, ZPZV<2>>; }; // NOLINT
6412 template<> struct ConwayPolynomial<797, 5> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<795>>; }; // NOLINT
6413 template<> struct ConwayPolynomial<797, 6> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<657>, ZPZV<396>, ZPZV<71>, ZPZV<2>>; }; // NOLINT
6414 template<> struct ConwayPolynomial<797, 7> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<795>>; }; // NOLINT
6415 template<> struct ConwayPolynomial<797, 8> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<596>, ZPZV<747>, ZPZV<389>, ZPZV<2>>; }; // NOLINT
6416 template<> struct ConwayPolynomial<797, 9> { using ZPZ = aerobus::zpz<797>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<240>, ZPZV<599>, ZPZV<795>>; }; // NOLINT
6417 template<> struct ConwayPolynomial<809, 1> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<806>>; }; // NOLINT
6418 template<> struct ConwayPolynomial<809, 2> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<799>, ZPZV<3>>; }; // NOLINT
6419 template<> struct ConwayPolynomial<809, 3> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<806>>; }; // NOLINT
6420 template<> struct ConwayPolynomial<809, 4> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<644>, ZPZV<3>>; }; // NOLINT
6421 template<> struct ConwayPolynomial<809, 5> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<806>>; }; // NOLINT
6422 template<> struct ConwayPolynomial<809, 6> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<562>, ZPZV<75>, ZPZV<43>, ZPZV<3>>; }; // NOLINT
6423 template<> struct ConwayPolynomial<809, 7> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<806>>; }; // NOLINT
6424 template<> struct ConwayPolynomial<809, 8> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<593>, ZPZV<745>, ZPZV<673>, ZPZV<3>>; }; // NOLINT
6425 template<> struct ConwayPolynomial<809, 9> { using ZPZ = aerobus::zpz<809>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<341>, ZPZV<727>, ZPZV<806>>; }; // NOLINT
6426 template<> struct ConwayPolynomial<811, 1> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<808>>; }; // NOLINT
6427 template<> struct ConwayPolynomial<811, 2> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<806>, ZPZV<3>>; }; // NOLINT
6428 template<> struct ConwayPolynomial<811, 3> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<808>>; }; // NOLINT
6429 template<> struct ConwayPolynomial<811, 4> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<453>, ZPZV<3>>; }; // NOLINT
6430 template<> struct ConwayPolynomial<811, 5> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<808>>; }; // NOLINT
6431 template<> struct ConwayPolynomial<811, 6> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<780>, ZPZV<755>, ZPZV<307>, ZPZV<3>>; }; // NOLINT
6432 template<> struct ConwayPolynomial<811, 7> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<808>>; }; // NOLINT
6433 template<> struct ConwayPolynomial<811, 8> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<663>, ZPZV<806>, ZPZV<525>, ZPZV<3>>; }; // NOLINT
6434 template<> struct ConwayPolynomial<811, 9> { using ZPZ = aerobus::zpz<811>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<382>, ZPZV<200>, ZPZV<808>>; }; // NOLINT
6435 template<> struct ConwayPolynomial<821, 1> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<819>>; }; // NOLINT
6436 template<> struct ConwayPolynomial<821, 2> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<816>, ZPZV<2>>; }; // NOLINT
6437 template<> struct ConwayPolynomial<821, 3> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<819>>; }; // NOLINT
6438 template<> struct ConwayPolynomial<821, 4> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<15>, ZPZV<662>, ZPZV<2>>; }; // NOLINT
6439 template<> struct ConwayPolynomial<821, 5> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<819>>; }; // NOLINT
6440 template<> struct ConwayPolynomial<821, 6> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<160>, ZPZV<130>, ZPZV<803>, ZPZV<2>>; }; // NOLINT
6441 template<> struct ConwayPolynomial<821, 7> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<819>>; }; // NOLINT
6442 template<> struct ConwayPolynomial<821, 8> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<626>, ZPZV<556>, ZPZV<589>, ZPZV<2>>; }; // NOLINT
6443 template<> struct ConwayPolynomial<821, 9> { using ZPZ = aerobus::zpz<821>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<650>, ZPZV<557>, ZPZV<819>>; }; // NOLINT
6444 template<> struct ConwayPolynomial<823, 1> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<820>>; }; // NOLINT
6445 template<> struct ConwayPolynomial<823, 2> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<821>, ZPZV<3>>; }; // NOLINT
6446 template<> struct ConwayPolynomial<823, 3> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<820>>; }; // NOLINT
6447 template<> struct ConwayPolynomial<823, 4> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<819>, ZPZV<3>>; }; // NOLINT
6448 template<> struct ConwayPolynomial<823, 5> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<820>>; }; // NOLINT
6449 template<> struct ConwayPolynomial<823, 6> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<822>, ZPZV<616>, ZPZV<744>, ZPZV<3>>; }; // NOLINT
6450 template<> struct ConwayPolynomial<823, 7> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<820>>; }; // NOLINT
6451 template<> struct ConwayPolynomial<823, 8> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<451>, ZPZV<437>, ZPZV<31>, ZPZV<3>>; }; // NOLINT
6452 template<> struct ConwayPolynomial<823, 9> { using ZPZ = aerobus::zpz<823>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<740>, ZPZV<609>, ZPZV<820>>; }; // NOLINT
6453 template<> struct ConwayPolynomial<827, 1> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<825>>; }; // NOLINT
6454 template<> struct ConwayPolynomial<827, 2> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<821>, ZPZV<2>>; }; // NOLINT
6455 template<> struct ConwayPolynomial<827, 3> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<825>>; }; // NOLINT
6456 template<> struct ConwayPolynomial<827, 4> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<18>, ZPZV<605>, ZPZV<2>>; }; // NOLINT
6457 template<> struct ConwayPolynomial<827, 5> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<825>>; }; // NOLINT
6458 template<> struct ConwayPolynomial<827, 6> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<685>, ZPZV<601>, ZPZV<691>, ZPZV<2>>; }; // NOLINT
6459 template<> struct ConwayPolynomial<827, 7> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<825>>; }; // NOLINT
6460 template<> struct ConwayPolynomial<827, 8> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<812>, ZPZV<79>, ZPZV<32>, ZPZV<2>>; }; // NOLINT
6461 template<> struct ConwayPolynomial<827, 9> { using ZPZ = aerobus::zpz<827>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<177>, ZPZV<372>, ZPZV<825>>; }; // NOLINT
6462 template<> struct ConwayPolynomial<829, 1> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<827>>; }; // NOLINT
6463 template<> struct ConwayPolynomial<829, 2> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<828>, ZPZV<2>>; }; // NOLINT
6464 template<> struct ConwayPolynomial<829, 3> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<827>>; }; // NOLINT
6465 template<> struct ConwayPolynomial<829, 4> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<9>, ZPZV<604>, ZPZV<2>>; }; // NOLINT
6466 template<> struct ConwayPolynomial<829, 5> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<827>>; }; // NOLINT
6467 template<> struct ConwayPolynomial<829, 6> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<341>, ZPZV<476>, ZPZV<817>, ZPZV<2>>; }; // NOLINT
6468 template<> struct ConwayPolynomial<829, 7> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<827>>; }; // NOLINT
6469 template<> struct ConwayPolynomial<829, 8> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<468>, ZPZV<241>, ZPZV<138>, ZPZV<2>>; }; // NOLINT
6470 template<> struct ConwayPolynomial<829, 9> { using ZPZ = aerobus::zpz<829>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<621>, ZPZV<552>, ZPZV<827>>; }; // NOLINT
6471 template<> struct ConwayPolynomial<839, 1> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<828>>; }; // NOLINT
6472 template<> struct ConwayPolynomial<839, 2> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<838>, ZPZV<11>>; }; // NOLINT
6473 template<> struct ConwayPolynomial<839, 3> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<828>>; }; // NOLINT
6474 template<> struct ConwayPolynomial<839, 4> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<609>, ZPZV<11>>; }; // NOLINT
6475 template<> struct ConwayPolynomial<839, 5> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<828>>; }; // NOLINT
6476 template<> struct ConwayPolynomial<839, 6> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<370>, ZPZV<537>, ZPZV<23>, ZPZV<11>>; }; // NOLINT
6477 template<> struct ConwayPolynomial<839, 7> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<828>>; }; // NOLINT
6478 template<> struct ConwayPolynomial<839, 8> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<16>, ZPZV<553>, ZPZV<779>, ZPZV<329>, ZPZV<11>>; }; // NOLINT
6479 template<> struct ConwayPolynomial<839, 9> { using ZPZ = aerobus::zpz<839>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<349>, ZPZV<206>, ZPZV<828>>; }; // NOLINT
6480 template<> struct ConwayPolynomial<853, 1> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<851>>; }; // NOLINT
6481 template<> struct ConwayPolynomial<853, 2> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<852>, ZPZV<2>>; }; // NOLINT
6482 template<> struct ConwayPolynomial<853, 3> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<851>>; }; // NOLINT
6483 template<> struct ConwayPolynomial<853, 4> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<623>, ZPZV<2>>; }; // NOLINT
6484 template<> struct ConwayPolynomial<853, 5> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<851>>; }; // NOLINT
6485 template<> struct ConwayPolynomial<853, 6> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<276>, ZPZV<194>, ZPZV<512>, ZPZV<2>>; }; // NOLINT
6486 template<> struct ConwayPolynomial<853, 7> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<851>>; }; // NOLINT
6487 template<> struct ConwayPolynomial<853, 8> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<544>, ZPZV<846>, ZPZV<118>, ZPZV<2>>; }; // NOLINT
6488 template<> struct ConwayPolynomial<853, 9> { using ZPZ = aerobus::zpz<853>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<677>, ZPZV<821>, ZPZV<851>>; }; // NOLINT
6489 template<> struct ConwayPolynomial<857, 1> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<854>>; }; // NOLINT
6490 template<> struct ConwayPolynomial<857, 2> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<850>, ZPZV<3>>; }; // NOLINT
6491 template<> struct ConwayPolynomial<857, 3> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<854>>; }; // NOLINT
6492 template<> struct ConwayPolynomial<857, 4> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<528>, ZPZV<3>>; }; // NOLINT
6493 template<> struct ConwayPolynomial<857, 5> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<854>>; }; // NOLINT
6494 template<> struct ConwayPolynomial<857, 6> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<32>, ZPZV<824>, ZPZV<65>, ZPZV<3>>; }; // NOLINT
6495 template<> struct ConwayPolynomial<857, 7> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<854>>; }; // NOLINT
6496 template<> struct ConwayPolynomial<857, 8> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<611>, ZPZV<552>, ZPZV<494>, ZPZV<3>>; }; // NOLINT
6497 template<> struct ConwayPolynomial<857, 9> { using ZPZ = aerobus::zpz<857>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<308>, ZPZV<719>, ZPZV<854>>; }; // NOLINT
6498 template<> struct ConwayPolynomial<859, 1> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<857>>; }; // NOLINT
6499 template<> struct ConwayPolynomial<859, 2> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<858>, ZPZV<2>>; }; // NOLINT
6500 template<> struct ConwayPolynomial<859, 3> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<857>>; }; // NOLINT
6501 template<> struct ConwayPolynomial<859, 4> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<530>, ZPZV<2>>; }; // NOLINT
6502 template<> struct ConwayPolynomial<859, 5> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<12>, ZPZV<857>>; }; // NOLINT
6503 template<> struct ConwayPolynomial<859, 6> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<419>, ZPZV<646>, ZPZV<566>, ZPZV<2>>; }; // NOLINT
6504 template<> struct ConwayPolynomial<859, 7> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<857>>; }; // NOLINT
6505 template<> struct ConwayPolynomial<859, 8> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<522>, ZPZV<446>, ZPZV<672>, ZPZV<2>>; }; // NOLINT
6506 template<> struct ConwayPolynomial<859, 9> { using ZPZ = aerobus::zpz<859>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<648>, ZPZV<845>, ZPZV<857>>; }; // NOLINT
6507 template<> struct ConwayPolynomial<863, 1> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<858>>; }; // NOLINT
6508 template<> struct ConwayPolynomial<863, 2> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<862>, ZPZV<5>>; }; // NOLINT
6509 template<> struct ConwayPolynomial<863, 3> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<858>>; }; // NOLINT
6510 template<> struct ConwayPolynomial<863, 4> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<770>, ZPZV<5>>; }; // NOLINT
6511 template<> struct ConwayPolynomial<863, 5> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<858>>; }; // NOLINT
6512 template<> struct ConwayPolynomial<863, 6> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<330>, ZPZV<62>, ZPZV<300>, ZPZV<5>>; }; // NOLINT
6513 template<> struct ConwayPolynomial<863, 7> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<858>>; }; // NOLINT
6514 template<> struct ConwayPolynomial<863, 8> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<765>, ZPZV<576>, ZPZV<849>, ZPZV<5>>; }; // NOLINT
6515 template<> struct ConwayPolynomial<863, 9> { using ZPZ = aerobus::zpz<863>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<381>, ZPZV<1>, ZPZV<858>>; }; // NOLINT
6516 template<> struct ConwayPolynomial<877, 1> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<875>>; }; // NOLINT
6517 template<> struct ConwayPolynomial<877, 2> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<873>, ZPZV<2>>; }; // NOLINT
6518 template<> struct ConwayPolynomial<877, 3> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<875>>; }; // NOLINT
6519 template<> struct ConwayPolynomial<877, 4> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<604>, ZPZV<2>>; }; // NOLINT
6520 template<> struct ConwayPolynomial<877, 5> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<875>>; }; // NOLINT
6521 template<> struct ConwayPolynomial<877, 6> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<629>, ZPZV<400>, ZPZV<855>, ZPZV<2>>; }; // NOLINT
6522 template<> struct ConwayPolynomial<877, 7> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<875>>; }; // NOLINT
6523 template<> struct ConwayPolynomial<877, 8> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<767>, ZPZV<319>, ZPZV<347>, ZPZV<2>>; }; // NOLINT
6524 template<> struct ConwayPolynomial<877, 9> { using ZPZ = aerobus::zpz<877>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<770>, ZPZV<278>, ZPZV<875>>; }; // NOLINT
6525 template<> struct ConwayPolynomial<881, 1> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<878>>; }; // NOLINT
6526 template<> struct ConwayPolynomial<881, 2> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<869>, ZPZV<3>>; }; // NOLINT
6527 template<> struct ConwayPolynomial<881, 3> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<878>>; }; // NOLINT
6528 template<> struct ConwayPolynomial<881, 4> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<447>, ZPZV<3>>; }; // NOLINT
6529 template<> struct ConwayPolynomial<881, 5> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<878>>; }; // NOLINT
6530 template<> struct ConwayPolynomial<881, 6> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<218>, ZPZV<419>, ZPZV<231>, ZPZV<3>>; }; // NOLINT
6531 template<> struct ConwayPolynomial<881, 7> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<878>>; }; // NOLINT
6532 template<> struct ConwayPolynomial<881, 8> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<21>, ZPZV<635>, ZPZV<490>, ZPZV<561>, ZPZV<3>>; }; // NOLINT
6533 template<> struct ConwayPolynomial<881, 9> { using ZPZ = aerobus::zpz<881>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<587>, ZPZV<510>, ZPZV<878>>; }; // NOLINT
6534 template<> struct ConwayPolynomial<883, 1> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<881>>; }; // NOLINT
6535 template<> struct ConwayPolynomial<883, 2> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<879>, ZPZV<2>>; }; // NOLINT
6536 template<> struct ConwayPolynomial<883, 3> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<6>, ZPZV<881>>; }; // NOLINT
6537 template<> struct ConwayPolynomial<883, 4> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<715>, ZPZV<2>>; }; // NOLINT
6538 template<> struct ConwayPolynomial<883, 5> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<881>>; }; // NOLINT
6539 template<> struct ConwayPolynomial<883, 6> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<879>, ZPZV<865>, ZPZV<871>, ZPZV<2>>; }; // NOLINT
6540 template<> struct ConwayPolynomial<883, 7> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<881>>; }; // NOLINT
6541 template<> struct ConwayPolynomial<883, 8> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<740>, ZPZV<762>, ZPZV<768>, ZPZV<2>>; }; // NOLINT
6542 template<> struct ConwayPolynomial<883, 9> { using ZPZ = aerobus::zpz<883>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<360>, ZPZV<557>, ZPZV<881>>; }; // NOLINT
6543 template<> struct ConwayPolynomial<887, 1> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<882>>; }; // NOLINT
6544 template<> struct ConwayPolynomial<887, 2> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<885>, ZPZV<5>>; }; // NOLINT
6545 template<> struct ConwayPolynomial<887, 3> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<882>>; }; // NOLINT
6546 template<> struct ConwayPolynomial<887, 4> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<883>, ZPZV<5>>; }; // NOLINT
6547 template<> struct ConwayPolynomial<887, 5> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<882>>; }; // NOLINT
6548 template<> struct ConwayPolynomial<887, 6> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<775>, ZPZV<341>, ZPZV<28>, ZPZV<5>>; }; // NOLINT
6549 template<> struct ConwayPolynomial<887, 7> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<882>>; }; // NOLINT
6550 template<> struct ConwayPolynomial<887, 8> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<781>, ZPZV<381>, ZPZV<706>, ZPZV<5>>; }; // NOLINT
6551 template<> struct ConwayPolynomial<887, 9> { using ZPZ = aerobus::zpz<887>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<727>, ZPZV<345>, ZPZV<882>>; }; // NOLINT
6552 template<> struct ConwayPolynomial<907, 1> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<905>>; }; // NOLINT
6553 template<> struct ConwayPolynomial<907, 2> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<903>, ZPZV<2>>; }; // NOLINT
6554 template<> struct ConwayPolynomial<907, 3> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<905>>; }; // NOLINT
6555 template<> struct ConwayPolynomial<907, 4> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<14>, ZPZV<478>, ZPZV<2>>; }; // NOLINT
6556 template<> struct ConwayPolynomial<907, 5> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<905>>; }; // NOLINT
6557 template<> struct ConwayPolynomial<907, 6> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<626>, ZPZV<752>, ZPZV<266>, ZPZV<2>>; }; // NOLINT
6558 template<> struct ConwayPolynomial<907, 7> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<905>>; }; // NOLINT
6559 template<> struct ConwayPolynomial<907, 8> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<584>, ZPZV<518>, ZPZV<811>, ZPZV<2>>; }; // NOLINT
6560 template<> struct ConwayPolynomial<907, 9> { using ZPZ = aerobus::zpz<907>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<783>, ZPZV<57>, ZPZV<905>>; }; // NOLINT
6561 template<> struct ConwayPolynomial<911, 1> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<894>>; }; // NOLINT
6562 template<> struct ConwayPolynomial<911, 2> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<909>, ZPZV<17>>; }; // NOLINT
6563 template<> struct ConwayPolynomial<911, 3> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<894>>; }; // NOLINT
6564 template<> struct ConwayPolynomial<911, 4> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<11>, ZPZV<887>, ZPZV<17>>; }; // NOLINT
6565 template<> struct ConwayPolynomial<911, 5> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<894>>; }; // NOLINT
6566 template<> struct ConwayPolynomial<911, 6> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<172>, ZPZV<683>, ZPZV<19>, ZPZV<17>>; }; // NOLINT
6567 template<> struct ConwayPolynomial<911, 7> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<894>>; }; // NOLINT
6568 template<> struct ConwayPolynomial<911, 8> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<708>, ZPZV<590>, ZPZV<168>, ZPZV<17>>; }; // NOLINT
6569 template<> struct ConwayPolynomial<911, 9> { using ZPZ = aerobus::zpz<911>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<679>, ZPZV<116>, ZPZV<894>>; }; // NOLINT
6570 template<> struct ConwayPolynomial<919, 1> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<912>>; }; // NOLINT
6571 template<> struct ConwayPolynomial<919, 2> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<910>, ZPZV<7>>; }; // NOLINT
6572 template<> struct ConwayPolynomial<919, 3> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<912>>; }; // NOLINT
6573 template<> struct ConwayPolynomial<919, 4> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<602>, ZPZV<7>>; }; // NOLINT
6574 template<> struct ConwayPolynomial<919, 5> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<912>>; }; // NOLINT
6575 template<> struct ConwayPolynomial<919, 6> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<312>, ZPZV<817>, ZPZV<113>, ZPZV<7>>; }; // NOLINT
6576 template<> struct ConwayPolynomial<919, 7> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<912>>; }; // NOLINT
6577 template<> struct ConwayPolynomial<919, 8> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<708>, ZPZV<202>, ZPZV<504>, ZPZV<7>>; }; // NOLINT
6578 template<> struct ConwayPolynomial<919, 9> { using ZPZ = aerobus::zpz<919>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<410>, ZPZV<623>, ZPZV<912>>; }; // NOLINT
6579 template<> struct ConwayPolynomial<929, 1> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<926>>; }; // NOLINT
6580 template<> struct ConwayPolynomial<929, 2> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<917>, ZPZV<3>>; }; // NOLINT
6581 template<> struct ConwayPolynomial<929, 3> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<926>>; }; // NOLINT
6582 template<> struct ConwayPolynomial<929, 4> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<787>, ZPZV<3>>; }; // NOLINT
6583 template<> struct ConwayPolynomial<929, 5> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<926>>; }; // NOLINT
6584 template<> struct ConwayPolynomial<929, 6> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<805>, ZPZV<92>, ZPZV<86>, ZPZV<3>>; }; // NOLINT
6585 template<> struct ConwayPolynomial<929, 7> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<926>>; }; // NOLINT
6586 template<> struct ConwayPolynomial<929, 8> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<699>, ZPZV<292>, ZPZV<586>, ZPZV<3>>; }; // NOLINT
6587 template<> struct ConwayPolynomial<929, 9> { using ZPZ = aerobus::zpz<929>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<481>, ZPZV<199>, ZPZV<926>>; }; // NOLINT
6588 template<> struct ConwayPolynomial<937, 1> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<932>>; }; // NOLINT
6589 template<> struct ConwayPolynomial<937, 2> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<934>, ZPZV<5>>; }; // NOLINT
6590 template<> struct ConwayPolynomial<937, 3> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<932>>; }; // NOLINT
6591 template<> struct ConwayPolynomial<937, 4> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<23>, ZPZV<585>, ZPZV<5>>; }; // NOLINT
6592 template<> struct ConwayPolynomial<937, 5> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<932>>; }; // NOLINT
6593 template<> struct ConwayPolynomial<937, 6> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<794>, ZPZV<727>, ZPZV<934>, ZPZV<5>>; }; // NOLINT
6594 template<> struct ConwayPolynomial<937, 7> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<24>, ZPZV<932>>; }; // NOLINT
6595 template<> struct ConwayPolynomial<937, 8> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<658>, ZPZV<26>, ZPZV<53>, ZPZV<5>>; }; // NOLINT
6596 template<> struct ConwayPolynomial<937, 9> { using ZPZ = aerobus::zpz<937>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<28>, ZPZV<533>, ZPZV<483>, ZPZV<932>>; }; // NOLINT
6597 template<> struct ConwayPolynomial<941, 1> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<939>>; }; // NOLINT
6598 template<> struct ConwayPolynomial<941, 2> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<940>, ZPZV<2>>; }; // NOLINT
6599 template<> struct ConwayPolynomial<941, 3> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<939>>; }; // NOLINT
6600 template<> struct ConwayPolynomial<941, 4> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<505>, ZPZV<2>>; }; // NOLINT
6601 template<> struct ConwayPolynomial<941, 5> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<939>>; }; // NOLINT
6602 template<> struct ConwayPolynomial<941, 6> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<459>, ZPZV<694>, ZPZV<538>, ZPZV<2>>; }; // NOLINT
6603 template<> struct ConwayPolynomial<941, 7> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<4>, ZPZV<939>>; }; // NOLINT
6604 template<> struct ConwayPolynomial<941, 8> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<805>, ZPZV<675>, ZPZV<590>, ZPZV<2>>; }; // NOLINT
6605 template<> struct ConwayPolynomial<941, 9> { using ZPZ = aerobus::zpz<941>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<708>, ZPZV<197>, ZPZV<939>>; }; // NOLINT
6606 template<> struct ConwayPolynomial<947, 1> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<945>>; }; // NOLINT
6607 template<> struct ConwayPolynomial<947, 2> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<943>, ZPZV<2>>; }; // NOLINT
6608 template<> struct ConwayPolynomial<947, 3> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<945>>; }; // NOLINT
6609 template<> struct ConwayPolynomial<947, 4> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<8>, ZPZV<894>, ZPZV<2>>; }; // NOLINT
6610 template<> struct ConwayPolynomial<947, 5> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<945>>; }; // NOLINT
6611 template<> struct ConwayPolynomial<947, 6> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<880>, ZPZV<787>, ZPZV<95>, ZPZV<2>>; }; // NOLINT
6612 template<> struct ConwayPolynomial<947, 7> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<945>>; }; // NOLINT
6613 template<> struct ConwayPolynomial<947, 8> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<845>, ZPZV<597>, ZPZV<581>, ZPZV<2>>; }; // NOLINT
6614 template<> struct ConwayPolynomial<947, 9> { using ZPZ = aerobus::zpz<947>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<269>, ZPZV<808>, ZPZV<945>>; }; // NOLINT
6615 template<> struct ConwayPolynomial<953, 1> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<950>>; }; // NOLINT
6616 template<> struct ConwayPolynomial<953, 2> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<947>, ZPZV<3>>; }; // NOLINT
6617 template<> struct ConwayPolynomial<953, 3> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<7>, ZPZV<950>>; }; // NOLINT
6618 template<> struct ConwayPolynomial<953, 4> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<865>, ZPZV<3>>; }; // NOLINT
6619 template<> struct ConwayPolynomial<953, 5> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<950>>; }; // NOLINT
6620 template<> struct ConwayPolynomial<953, 6> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<507>, ZPZV<829>, ZPZV<730>, ZPZV<3>>; }; // NOLINT
6621 template<> struct ConwayPolynomial<953, 7> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<5>, ZPZV<950>>; }; // NOLINT
6622 template<> struct ConwayPolynomial<953, 8> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<6>, ZPZV<579>, ZPZV<658>, ZPZV<108>, ZPZV<3>>; }; // NOLINT
6623 template<> struct ConwayPolynomial<953, 9> { using ZPZ = aerobus::zpz<953>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<819>, ZPZV<316>, ZPZV<950>>; }; // NOLINT
6624 template<> struct ConwayPolynomial<967, 1> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<962>>; }; // NOLINT
6625 template<> struct ConwayPolynomial<967, 2> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<965>, ZPZV<5>>; }; // NOLINT
6626 template<> struct ConwayPolynomial<967, 3> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<962>>; }; // NOLINT
6627 template<> struct ConwayPolynomial<967, 4> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<963>, ZPZV<5>>; }; // NOLINT
6628 template<> struct ConwayPolynomial<967, 5> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<2>, ZPZV<962>>; }; // NOLINT
6629 template<> struct ConwayPolynomial<967, 6> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<805>, ZPZV<948>, ZPZV<831>, ZPZV<5>>; }; // NOLINT
6630 template<> struct ConwayPolynomial<967, 7> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<962>>; }; // NOLINT
6631 template<> struct ConwayPolynomial<967, 8> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<840>, ZPZV<502>, ZPZV<136>, ZPZV<5>>; }; // NOLINT
6632 template<> struct ConwayPolynomial<967, 9> { using ZPZ = aerobus::zpz<967>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<512>, ZPZV<783>, ZPZV<962>>; }; // NOLINT
6633 template<> struct ConwayPolynomial<971, 1> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<965>>; }; // NOLINT
6634 template<> struct ConwayPolynomial<971, 2> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<970>, ZPZV<6>>; }; // NOLINT
6635 template<> struct ConwayPolynomial<971, 3> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<3>, ZPZV<965>>; }; // NOLINT
6636 template<> struct ConwayPolynomial<971, 4> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<527>, ZPZV<6>>; }; // NOLINT
6637 template<> struct ConwayPolynomial<971, 5> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<14>, ZPZV<965>>; }; // NOLINT
6638 template<> struct ConwayPolynomial<971, 6> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<970>, ZPZV<729>, ZPZV<718>, ZPZV<6>>; }; // NOLINT
6639 template<> struct ConwayPolynomial<971, 7> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<13>, ZPZV<965>>; }; // NOLINT
6640 template<> struct ConwayPolynomial<971, 8> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<725>, ZPZV<281>, ZPZV<206>, ZPZV<6>>; }; // NOLINT
6641 template<> struct ConwayPolynomial<971, 9> { using ZPZ = aerobus::zpz<971>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<805>, ZPZV<473>, ZPZV<965>>; }; // NOLINT
6642 template<> struct ConwayPolynomial<977, 1> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<974>>; }; // NOLINT
6643 template<> struct ConwayPolynomial<977, 2> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<972>, ZPZV<3>>; }; // NOLINT
6644 template<> struct ConwayPolynomial<977, 3> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<974>>; }; // NOLINT
6645 template<> struct ConwayPolynomial<977, 4> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<800>, ZPZV<3>>; }; // NOLINT
6646 template<> struct ConwayPolynomial<977, 5> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<11>, ZPZV<974>>; }; // NOLINT
6647 template<> struct ConwayPolynomial<977, 6> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<729>, ZPZV<830>, ZPZV<753>, ZPZV<3>>; }; // NOLINT
6648 template<> struct ConwayPolynomial<977, 7> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<974>>; }; // NOLINT
6649 template<> struct ConwayPolynomial<977, 8> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<855>, ZPZV<807>, ZPZV<77>, ZPZV<3>>; }; // NOLINT
6650 template<> struct ConwayPolynomial<977, 9> { using ZPZ = aerobus::zpz<977>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<450>, ZPZV<740>, ZPZV<974>>; }; // NOLINT
6651 template<> struct ConwayPolynomial<983, 1> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<978>>; }; // NOLINT
6652 template<> struct ConwayPolynomial<983, 2> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<981>, ZPZV<5>>; }; // NOLINT
6653 template<> struct ConwayPolynomial<983, 3> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<1>, ZPZV<978>>; }; // NOLINT
6654 template<> struct ConwayPolynomial<983, 4> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<5>, ZPZV<567>, ZPZV<5>>; }; // NOLINT
6655 template<> struct ConwayPolynomial<983, 5> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<8>, ZPZV<978>>; }; // NOLINT
6656 template<> struct ConwayPolynomial<983, 6> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<849>, ZPZV<296>, ZPZV<228>, ZPZV<5>>; }; // NOLINT
6657 template<> struct ConwayPolynomial<983, 7> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<978>>; }; // NOLINT
6658 template<> struct ConwayPolynomial<983, 8> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<738>, ZPZV<276>, ZPZV<530>, ZPZV<5>>; }; // NOLINT
6659 template<> struct ConwayPolynomial<983, 9> { using ZPZ = aerobus::zpz<983>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<858>, ZPZV<87>, ZPZV<978>>; }; // NOLINT
6660 template<> struct ConwayPolynomial<991, 1> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<985>>; }; // NOLINT
6661 template<> struct ConwayPolynomial<991, 2> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<989>, ZPZV<6>>; }; // NOLINT
6662 template<> struct ConwayPolynomial<991, 3> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<985>>; }; // NOLINT
6663 template<> struct ConwayPolynomial<991, 4> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<10>, ZPZV<794>, ZPZV<6>>; }; // NOLINT
6664 template<> struct ConwayPolynomial<991, 5> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<3>, ZPZV<985>>; }; // NOLINT
6665 template<> struct ConwayPolynomial<991, 6> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<637>, ZPZV<855>, ZPZV<278>, ZPZV<6>>; }; // NOLINT
6666 template<> struct ConwayPolynomial<991, 7> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<7>, ZPZV<985>>; }; // NOLINT
6667 template<> struct ConwayPolynomial<991, 8> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<15>, ZPZV<941>, ZPZV<786>, ZPZV<234>, ZPZV<6>>; }; // NOLINT
6668 template<> struct ConwayPolynomial<991, 9> { using ZPZ = aerobus::zpz<991>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<9>, ZPZV<466>, ZPZV<222>, ZPZV<985>>; }; // NOLINT
6669 template<> struct ConwayPolynomial<997, 1> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<990>>; }; // NOLINT
6670 template<> struct ConwayPolynomial<997, 2> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<995>, ZPZV<7>>; }; // NOLINT
6671 template<> struct ConwayPolynomial<997, 3> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<2>, ZPZV<990>>; }; // NOLINT
6672 template<> struct ConwayPolynomial<997, 4> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<4>, ZPZV<622>, ZPZV<7>>; }; // NOLINT
6673 template<> struct ConwayPolynomial<997, 5> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<10>, ZPZV<990>>; }; // NOLINT
6674 template<> struct ConwayPolynomial<997, 6> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<981>, ZPZV<58>, ZPZV<260>, ZPZV<7>>; }; // NOLINT
6675 template<> struct ConwayPolynomial<997, 7> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<1>, ZPZV<990>>; }; // NOLINT
6676 template<> struct ConwayPolynomial<997, 8> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<934>, ZPZV<473>, ZPZV<241>, ZPZV<7>>; }; // NOLINT
6677 template<> struct ConwayPolynomial<997, 9> { using ZPZ = aerobus::zpz<997>; using type = POLYV<ZPZV<1>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<0>, ZPZV<39>, ZPZV<732>, ZPZV<616>, ZPZV<990>>; }; // NOLINT
6678#endif // DO_NOT_DOCUMENT
6679} // namespace aerobus
6680#endif // AEROBUS_CONWAY_IMPORTS
6681
6682#endif // __INC_AEROBUS__ // NOLINT
INLINED
#define INLINED
Definition aerobus.h:31
DEVICE
#define DEVICE
Definition aerobus.h:37
aerobus::IsEuclideanDomain
Concept to express R is an euclidean domain.
Definition aerobus.h:82
aerobus::IsField
Concept to express R is a field.
Definition aerobus.h:96
aerobus::IsRing
Concept to express R is a Ring.
Definition aerobus.h:72
aerobus::internal::type_at_t
typename type_at< i, Ts... >::type type_at_t
Definition aerobus.h:577
aerobus::internal::index_sequence_reverse
constexpr auto index_sequence_reverse(std::index_sequence< Is... > const &) -> decltype(std::index_sequence< sizeof...(Is) - 1U - Is... >{})
aerobus::internal::is_instantiation_of_v
constexpr bool is_instantiation_of_v
Definition aerobus.h:564
aerobus::internal::make_index_sequence_reverse
decltype(index_sequence_reverse(std::make_index_sequence< N >{})) make_index_sequence_reverse
Definition aerobus.h:682
aerobus::known_polynomials::hermite_kind
hermite_kind
Definition aerobus.h:4035
aerobus::known_polynomials::probabilist
@ probabilist
Definition aerobus.h:4037
aerobus::known_polynomials::physicist
@ physicist
Definition aerobus.h:4039
aerobus
main namespace for all publicly exposed types or functions
aerobus::mulfractions_t
typename FractionField< Ring >::template mul_t< v1, v2 > mulfractions_t
helper type : multiplies two fractions
Definition aerobus.h:3001
aerobus::atan
taylor< Integers, internal::atan_coeff, deg > atan
Definition aerobus.h:3725
aerobus::expm1
typename polynomial< FractionField< Integers > >::template sub_t< exp< Integers, deg >, typename polynomial< FractionField< Integers > >::one > expm1
Definition aerobus.h:3713
aerobus::addfractions_t
typename FractionField< Ring >::template add_t< v1, v2 > addfractions_t
helper type : adds two fractions
Definition aerobus.h:2995
aerobus::abs_t
std::conditional_t< val::enclosing_type::template pos_v< val >, val, typename val::enclosing_type::template sub_t< typename val::enclosing_type::zero, val > > abs_t
computes absolute value of 'val' val must be a 'value' in a Ring satisfying 'IsEuclideanDomain' conce...
Definition aerobus.h:786
aerobus::div_t
typename X::enclosing_type::template div_t< X, Y > div_t
generic division
Definition aerobus.h:2922
aerobus::stirling_1_unsigned_t
abs_t< typename internal::stirling_1_helper< T, n, k >::type > stirling_1_unsigned_t
Stirling number of first king (unsigned) – as types.
Definition aerobus.h:3312
aerobus::asin
taylor< Integers, internal::asin_coeff, deg > asin
arc sinus
Definition aerobus.h:3765
aerobus::q64
FractionField< i64 > q64
64 bits rationals rationals with 64 bits numerator and denominator
Definition aerobus.h:2934
aerobus::gcd_t
typename internal::gcd< T >::template type< A, B > gcd_t
computes the greatest common divisor or A and B
Definition aerobus.h:765
aerobus::tan
taylor< Integers, internal::tan_coeff, deg > tan
tangent
Definition aerobus.h:3786
aerobus::cosh
taylor< Integers, internal::cosh_coeff, deg > cosh
hyperbolic cosine
Definition aerobus.h:3744
aerobus::atanh
taylor< Integers, internal::atanh_coeff, deg > atanh
arc hyperbolic tangent
Definition aerobus.h:3779
aerobus::embed_int_poly_in_fractions_t
typename Embed< polynomial< typename v::ring_type >, polynomial< FractionField< typename v::ring_type > > >::template type< v > embed_int_poly_in_fractions_t
embed a polynomial with integers coefficients into rational coefficients polynomials
Definition aerobus.h:2962
aerobus::make_q32_t
typename q32::template simplify_t< typename q32::val< i32::inject_constant_t< p >, i32::inject_constant_t< q > > > make_q32_t
helper type : make a fraction from numerator and denominator
Definition aerobus.h:2976
aerobus::fpq64
FractionField< polynomial< q64 > > fpq64
polynomial with 64 bits rational coefficients
Definition aerobus.h:2943
aerobus::mul_t
typename X::enclosing_type::template mul_t< X, Y > mul_t
generic multiplication
Definition aerobus.h:2914
aerobus::sinh
taylor< Integers, internal::sh_coeff, deg > sinh
Definition aerobus.h:3737
aerobus::sin
taylor< Integers, internal::sin_coeff, deg > sin
Definition aerobus.h:3731
aerobus::taylor
typename internal::make_taylor_impl< T, coeff_at, internal::make_index_sequence_reverse< deg+1 > >::type taylor
Definition aerobus.h:3444
aerobus::alternate_v
constexpr T::inner_type alternate_v
(-1)^k as value from T
Definition aerobus.h:3268
aerobus::pow_t
typename internal::pow< T, p, n >::type pow_t
p^n (as 'val' type in T)
Definition aerobus.h:3414
aerobus::bernoulli_v
constexpr FloatType bernoulli_v
nth bernoulli number as value in FloatType
Definition aerobus.h:3192
aerobus::combination_t
typename internal::combination< T, k, n >::type combination_t
computes binomial coefficient (k among n) as type
Definition aerobus.h:3121
aerobus::vmul_t
typename internal::vmul< vals... >::type vmul_t
multiplies multiple values (v1 + v2 + ... + vn) vals must have same "enclosing_type" and "enclosing_t...
Definition aerobus.h:777
aerobus::bernoulli_t
typename internal::bernoulli< T, n >::type bernoulli_t
nth bernoulli number as type in T
Definition aerobus.h:3185
aerobus::vadd_t
typename internal::vadd< vals... >::type vadd_t
adds multiple values (v1 + v2 + ... + vn) vals must have same "enclosing_type" and "enclosing_type" m...
Definition aerobus.h:771
aerobus::stirling_2_t
typename internal::stirling_2_helper< T, n, k >::type stirling_2_t
Stirling number of second king – as types.
Definition aerobus.h:3363
aerobus::combination_v
constexpr T::inner_type combination_v
computes binomial coefficients (k among n) as value
Definition aerobus.h:3128
aerobus::geometric_sum
taylor< Integers, internal::geom_coeff, deg > geometric_sum
zero development of
Definition aerobus.h:3758
aerobus::make_frac_polynomial_t
typename polynomial< FractionField< Ring > >::template val< typename FractionField< Ring >::template inject_constant_t< xs >... > make_frac_polynomial_t
make a polynomial with coefficients in FractionField<Ring>
Definition aerobus.h:3050
aerobus::bell_t
typename internal::bell_helper< T, n >::type bell_t
Bell numbers.
Definition aerobus.h:3235
aerobus::lnp1
taylor< Integers, internal::lnp1_coeff, deg > lnp1
Definition aerobus.h:3719
aerobus::asinh
taylor< Integers, internal::asinh_coeff, deg > asinh
arc hyperbolic sinus
Definition aerobus.h:3772
aerobus::FractionField
typename internal::FractionFieldImpl< Ring >::type FractionField
Fraction field of an euclidean domain, such as Q for Z.
Definition aerobus.h:2876
aerobus::factorial_v
constexpr T::inner_type factorial_v
computes factorial(i) as value in T
Definition aerobus.h:3087
aerobus::q32
FractionField< i32 > q32
32 bits rationals rationals with 32 bits numerator and denominator
Definition aerobus.h:2926
aerobus::sub_t
typename X::enclosing_type::template sub_t< X, Y > sub_t
generic subtraction
Definition aerobus.h:2906
aerobus::cos
taylor< Integers, internal::cos_coeff, deg > cos
cosinus
Definition aerobus.h:3751
aerobus::aligned_malloc
T * aligned_malloc(size_t count, size_t alignment)
Definition aerobus.h:59
aerobus::exp
taylor< Integers, internal::exp_coeff, deg > exp
Definition aerobus.h:3705
aerobus::factorial_t
typename internal::factorial< T, i >::type factorial_t
computes factorial(i), as type
Definition aerobus.h:3081
aerobus::makefraction_t
typename FractionField< Ring >::template val< v1, v2 > makefraction_t
helper type : the rational V1/V2 in the field of fractions of Ring
Definition aerobus.h:2950
aerobus::alternate_t
typename internal::alternate< T, k >::type alternate_t
(-1)^k as type in T
Definition aerobus.h:3263
aerobus::make_q64_t
typename q64::template simplify_t< typename q64::val< i64::inject_constant_t< p >, i64::inject_constant_t< q > > > make_q64_t
helper type : make a fraction from numerator and denominator
Definition aerobus.h:2969
aerobus::add_t
typename X::enclosing_type::template add_t< X, Y > add_t
generic addition
Definition aerobus.h:2898
aerobus::make_int_polynomial_t
typename polynomial< Ring >::template val< typename Ring::template inject_constant_t< xs >... > make_int_polynomial_t
make a polynomial with coefficients in Ring
Definition aerobus.h:3043
aerobus::tanh
taylor< Integers, internal::tanh_coeff, deg > tanh
hyperbolic tangent
Definition aerobus.h:3793
aerobus::stirling_1_signed_t
typename internal::stirling_1_helper< T, n, k >::type stirling_1_signed_t
Stirling number of first king (signed) – as types.
Definition aerobus.h:3305
aerobus::fpq32
FractionField< polynomial< q32 > > fpq32
rational fractions with 32 bits rational coefficients rational fractions with rationals coefficients ...
Definition aerobus.h:2930
aerobus::ContinuedFraction< a0, rest... >::type
q64::template add_t< typename q64::template inject_constant_t< a0 >, typename q64::template div_t< typename q64::one, typename ContinuedFraction< rest... >::type > > type
represented value as aerobus::q64
Definition aerobus.h:3824
aerobus::ContinuedFraction< a0 >::type
typename q64::template inject_constant_t< a0 > type
represented value as aerobus::q64
Definition aerobus.h:3808
aerobus::ContinuedFraction
represents a continued fraction a0 +
Definition aerobus.h:3801
aerobus::ConwayPolynomial
Definition aerobus.h:4732
aerobus::Embed< Quotient< Ring, X >, Ring >::type
typename val::raw_t type
Ring reprensentation of val.
Definition aerobus.h:895
aerobus::Embed< Ring, FractionField< Ring > >::type
typename FractionField< Ring >::template val< v, typename Ring::one > type
FractionField<Ring> reprensentation of v.
Definition aerobus.h:2885
aerobus::Embed< polynomial< Small >, polynomial< Large > >::type
typename at_low< v, typename internal::make_index_sequence_reverse< v::degree+1 > >::type type
the polynomial<Large> reprensentation of v
Definition aerobus.h:3035
aerobus::Embed< q32, q64 >::type
make_q64_t< static_cast< int64_t >(v::x::v), static_cast< int64_t >(v::y::v)> type
q64 representation of v
Definition aerobus.h:3009
aerobus::Embed
embedding - struct forward declaration
Definition aerobus.h:796
aerobus::Quotient::val
projection values in the quotient ring
Definition aerobus.h:811
aerobus::Quotient::val::type
abs_t< typename Ring::template mod_t< V, X > > type
Definition aerobus.h:814
aerobus::Quotient::val::raw_t
V raw_t
Definition aerobus.h:813
aerobus::Quotient
Quotient ring by the principal ideal generated by 'X' With i32 as Ring and i32::val<2> as X,...
Definition aerobus.h:807
aerobus::Quotient::pos_t
std::true_type pos_t
positivity operator always true
Definition aerobus.h:863
aerobus::Quotient::is_euclidean_domain
static constexpr bool is_euclidean_domain
quotien rings are euclidean domain
Definition aerobus.h:872
aerobus::Quotient::eq_t
typename Ring::template eq_t< typename v1::type, typename v2::type > eq_t
equality operator (as type)
Definition aerobus.h:851
aerobus::Quotient::eq_v
static constexpr bool eq_v
addition operator (as boolean value)
Definition aerobus.h:857
aerobus::Quotient::pos_v
static constexpr bool pos_v
positivity operator always true
Definition aerobus.h:869
aerobus::arithmetic_helpers< double >::integers
int64_t integers
Definition aerobus.h:332
aerobus::arithmetic_helpers< double >::pi
static INLINED DEVICE consteval double pi()
Definition aerobus.h:337
aerobus::arithmetic_helpers< double >::one
static INLINED DEVICE consteval double one()
Definition aerobus.h:334
aerobus::arithmetic_helpers< double >::is_inf
static INLINED DEVICE bool is_inf(double x)
Definition aerobus.h:343
aerobus::arithmetic_helpers< double >::pi_4
static INLINED DEVICE consteval double pi_4()
Definition aerobus.h:339
aerobus::arithmetic_helpers< double >::inv_two_pi
static INLINED DEVICE consteval double inv_two_pi()
Definition aerobus.h:341
aerobus::arithmetic_helpers< double >::pi_2
static INLINED DEVICE consteval double pi_2()
Definition aerobus.h:338
aerobus::arithmetic_helpers< double >::half
static INLINED DEVICE consteval double half()
Definition aerobus.h:342
aerobus::arithmetic_helpers< double >::zero
static INLINED DEVICE consteval double zero()
Definition aerobus.h:335
aerobus::arithmetic_helpers< double >::two_pi
static INLINED DEVICE consteval double two_pi()
Definition aerobus.h:340
aerobus::arithmetic_helpers< double >::m_zero
static INLINED DEVICE consteval double m_zero()
Definition aerobus.h:336
aerobus::arithmetic_helpers< float >::two_pi
static INLINED DEVICE consteval float two_pi()
Definition aerobus.h:358
aerobus::arithmetic_helpers< float >::pi
static INLINED DEVICE consteval float pi()
Definition aerobus.h:355
aerobus::arithmetic_helpers< float >::upper_type
double upper_type
Definition aerobus.h:351
aerobus::arithmetic_helpers< float >::zero
static INLINED DEVICE consteval float zero()
Definition aerobus.h:353
aerobus::arithmetic_helpers< float >::one
static INLINED DEVICE consteval float one()
Definition aerobus.h:352
aerobus::arithmetic_helpers< float >::integers
int32_t integers
Definition aerobus.h:350
aerobus::arithmetic_helpers< float >::m_zero
static INLINED DEVICE consteval float m_zero()
Definition aerobus.h:354
aerobus::arithmetic_helpers< float >::inv_two_pi
static INLINED DEVICE consteval float inv_two_pi()
Definition aerobus.h:359
aerobus::arithmetic_helpers< float >::pi_2
static INLINED DEVICE consteval float pi_2()
Definition aerobus.h:356
aerobus::arithmetic_helpers< float >::is_inf
static INLINED DEVICE bool is_inf(float x)
Definition aerobus.h:361
aerobus::arithmetic_helpers< float >::pi_4
static INLINED DEVICE consteval float pi_4()
Definition aerobus.h:357
aerobus::arithmetic_helpers< float >::half
static INLINED DEVICE consteval float half()
Definition aerobus.h:360
aerobus::arithmetic_helpers
Definition aerobus.h:328
aerobus::double_double
Definition aerobus.h:325
aerobus::i32::val
values in i32, again represented as types
Definition aerobus.h:1227
aerobus::i32::val::is_zero_t
std::bool_constant< x==0 > is_zero_t
is value zero
Definition aerobus.h:1241
aerobus::i32::val::to_string
static std::string to_string()
string representation of value
Definition aerobus.h:1244
aerobus::i32::val::v
static constexpr int32_t v
actual value stored in val type
Definition aerobus.h:1231
aerobus::i32::val::get
static constexpr DEVICE valueType get()
cast x into valueType
Definition aerobus.h:1236
aerobus::i32
32 bits signed integers, seen as a algebraic ring with related operations
Definition aerobus.h:1222
aerobus::i32::eq_t
typename eq< v1, v2 >::type eq_t
equality operator (type) yields v1 == v2 as std::integral_constant<bool>
Definition aerobus.h:1366
aerobus::i32::inner_type
int32_t inner_type
Definition aerobus.h:1223
aerobus::i32::mod_t
typename remainder< v1, v2 >::type mod_t
modulus operator yields v1 % v2
Definition aerobus.h:1345
aerobus::i32::is_euclidean_domain
static constexpr bool is_euclidean_domain
integers are an euclidean domain
Definition aerobus.h:1256
aerobus::i32::sub_t
typename sub< v1, v2 >::type sub_t
substraction operator yields v1 - v2
Definition aerobus.h:1324
aerobus::i32::pos_v
static constexpr bool pos_v
positivity (boolean value) yields v > 0 as boolean value
Definition aerobus.h:1391
aerobus::i32::gt_t
typename gt< v1, v2 >::type gt_t
strictly greater operator (v1 > v2) yields v1 > v2
Definition aerobus.h:1352
aerobus::i32::eq_v
static constexpr bool eq_v
equality operator (boolean value)
Definition aerobus.h:1372
aerobus::i32::lt_t
typename lt< v1, v2 >::type lt_t
strict less operator (v1 < v2) yields v1 < v2
Definition aerobus.h:1359
aerobus::i32::inject_ring_t
v inject_ring_t
Definition aerobus.h:1263
aerobus::i32::is_field
static constexpr bool is_field
integers are not a field
Definition aerobus.h:1254
aerobus::i32::add_t
typename add< v1, v2 >::type add_t
addition operator yields v1 + v2
Definition aerobus.h:1317
aerobus::i32::pos_t
typename pos< v >::type pos_t
positivity operator yields v > 0 as std::true_type or std::false_type
Definition aerobus.h:1385
aerobus::i32::mul_t
typename mul< v1, v2 >::type mul_t
multiplication operator yields v1 * v2
Definition aerobus.h:1331
aerobus::i32::gcd_t
gcd_t< i32, v1, v2 > gcd_t
greatest common divisor yields GCD(v1, v2)
Definition aerobus.h:1379
aerobus::i32::div_t
typename div< v1, v2 >::type div_t
division operator yields v1 / v2
Definition aerobus.h:1338
aerobus::i64::val
values in i64
Definition aerobus.h:1404
aerobus::i64::val::is_zero_t
std::bool_constant< x==0 > is_zero_t
is value zero
Definition aerobus.h:1420
aerobus::i64::val::get
static constexpr INLINED DEVICE valueType get()
cast value in valueType
Definition aerobus.h:1415
aerobus::i64::val::inner_type
int32_t inner_type
type of represented values
Definition aerobus.h:1406
aerobus::i64::val::v
static constexpr int64_t v
actual value
Definition aerobus.h:1410
aerobus::i64::val::to_string
static std::string to_string()
string representation
Definition aerobus.h:1423
aerobus::i64
64 bits signed integers, seen as a algebraic ring with related operations
Definition aerobus.h:1398
aerobus::i64::add_t
typename add< v1, v2 >::type add_t
addition operator
Definition aerobus.h:1500
aerobus::i64::gcd_t
gcd_t< i64, v1, v2 > gcd_t
greatest common divisor yields GCD(v1, v2) as instanciation of i64::val
Definition aerobus.h:1574
aerobus::i64::gt_v
static constexpr bool gt_v
strictly greater operator yields v1 > v2 as boolean value
Definition aerobus.h:1539
aerobus::i64::is_euclidean_domain
static constexpr bool is_euclidean_domain
integers are an euclidean domain
Definition aerobus.h:1447
aerobus::i64::pos_v
static constexpr bool pos_v
positivity yields v > 0 as boolean value
Definition aerobus.h:1586
aerobus::i64::mul_t
typename mul< v1, v2 >::type mul_t
multiplication operator
Definition aerobus.h:1512
aerobus::i64::div_t
typename div< v1, v2 >::type div_t
division operator integer division
Definition aerobus.h:1519
aerobus::i64::inner_type
int64_t inner_type
type of represented values
Definition aerobus.h:1400
aerobus::i64::gt_t
typename gt< v1, v2 >::type gt_t
strictly greater operator yields v1 > v2 as std::true_type or std::false_type
Definition aerobus.h:1532
aerobus::i64::sub_t
typename sub< v1, v2 >::type sub_t
substraction operator
Definition aerobus.h:1506
aerobus::i64::eq_v
static constexpr bool eq_v
equality operator yields v1 == v2 as boolean value
Definition aerobus.h:1567
aerobus::i64::pos_t
typename pos< v >::type pos_t
is v posititive yields v > 0 as std::true_type or std::false_type
Definition aerobus.h:1580
aerobus::i64::inject_ring_t
v inject_ring_t
injects a value used for internal consistency and quotient rings implementations for example i64::inj...
Definition aerobus.h:1438
aerobus::i64::lt_v
static constexpr bool lt_v
strictly smaller operator yields v1 < v2 as boolean value
Definition aerobus.h:1553
aerobus::i64::lt_t
typename lt< v1, v2 >::type lt_t
strict less operator yields v1 < v2 as std::true_type or std::false_type
Definition aerobus.h:1546
aerobus::i64::mod_t
typename remainder< v1, v2 >::type mod_t
modulus operator
Definition aerobus.h:1525
aerobus::i64::eq_t
typename eq< v1, v2 >::type eq_t
equality operator yields v1 == v2 as std::true_type or std::false_type
Definition aerobus.h:1560
aerobus::i64::is_field
static constexpr bool is_field
integers are not a field
Definition aerobus.h:1445
aerobus::is_prime
checks if n is prime
Definition aerobus.h:663
aerobus::is_prime::value
static constexpr bool value
true iff n is prime
Definition aerobus.h:665
aerobus::libm::sin_reduction::behavior
Definition aerobus.h:4595
aerobus::libm::sin_reduction::behavior::return_fast_cos
bool return_fast_cos
Definition aerobus.h:4599
aerobus::libm::sin_reduction::behavior::return_x
bool return_x
Definition aerobus.h:4597
aerobus::libm::sin_reduction::behavior::transform
upper_type transform
Definition aerobus.h:4600
aerobus::libm::sin_reduction::behavior::return_fast_sin
bool return_fast_sin
Definition aerobus.h:4598
aerobus::libm::sin_reduction::behavior::negate
bool negate
Definition aerobus.h:4596
aerobus::libm::sin_reduction
Definition aerobus.h:4590
aerobus::libm::sin_reduction::eval
static DEVICE behavior eval(upper_type u_x, T x)
Definition aerobus.h:4608
aerobus::libm::sin_reduction::pi_4
static constexpr upper_type pi_4
Definition aerobus.h:4606
aerobus::libm::sin_reduction::pi_2
static constexpr upper_type pi_2
Definition aerobus.h:4605
aerobus::libm::sin_reduction::pi
static constexpr upper_type pi
Definition aerobus.h:4603
aerobus::libm::sin_reduction::two_pi
static constexpr upper_type two_pi
Definition aerobus.h:4604
aerobus::libm::sin_reduction::upper_type
aerobus::arithmetic_helpers< T >::upper_type upper_type
Definition aerobus.h:4591
aerobus::meta_libm
Definition aerobus.h:402
aerobus::meta_libm::floor
static INLINED DEVICE T floor(const T &f)
Definition aerobus.h:403
aerobus::meta_libm::fmod
static INLINED DEVICE T fmod(const T &x, const T &d)
Definition aerobus.h:406
aerobus::polynomial::compensated_horner::EFTHorner<-1, ghost >::func
static INLINED DEVICE void func(arithmeticType x, arithmeticType *pi, arithmeticType *sigma, arithmeticType *r)
Definition aerobus.h:2321
aerobus::polynomial::compensated_horner::EFTHorner
Definition aerobus.h:2306
aerobus::polynomial::compensated_horner::EFTHorner::func
static INLINED DEVICE void func(arithmeticType x, arithmeticType *pi, arithmeticType *sigma, arithmeticType *r)
Definition aerobus.h:2307
aerobus::polynomial::horner_reduction_t::inner< stop, stop >::type
accum type
Definition aerobus.h:1829
aerobus::polynomial::horner_reduction_t::inner
Definition aerobus.h:1816
aerobus::polynomial::horner_reduction_t::inner::type
typename horner_reduction_t< P >::template inner< index+1, stop > ::template type< typename Ring::template add_t< typename Ring::template mul_t< x, accum >, typename P::template coeff_at_t< P::degree - index > >, x > type
Definition aerobus.h:1823
aerobus::polynomial::horner_reduction_t
Used to evaluate polynomials over a value in Ring.
Definition aerobus.h:1814
aerobus::polynomial::val< coeffN >::coeff_at< index, std::enable_if_t<(index< 0||index > 0)> >::type
typename Ring::zero type
Definition aerobus.h:1949
aerobus::polynomial::val< coeffN >::coeff_at< index, std::enable_if_t<(index==0)> >::type
aN type
Definition aerobus.h:1944
aerobus::polynomial::val< coeffN >
specialization for constants
Definition aerobus.h:1926
aerobus::polynomial::val< coeffN >::ring_type
Ring ring_type
ring coefficients live in
Definition aerobus.h:1928
aerobus::polynomial::val< coeffN >::value_at_t
coeffN value_at_t
Definition aerobus.h:1970
aerobus::polynomial::val< coeffN >::aN
coeffN aN
Definition aerobus.h:1933
aerobus::polynomial::val< coeffN >::eval
static constexpr DEVICE INLINED arithmeticType eval(const arithmeticType &x)
Definition aerobus.h:1960
aerobus::polynomial::val< coeffN >::coeff_at_t
typename coeff_at< index >::type coeff_at_t
Definition aerobus.h:1953
aerobus::polynomial::val< coeffN >::to_string
static std::string to_string()
Definition aerobus.h:1955
aerobus::polynomial::val< coeffN >::compensated_eval
static DEVICE INLINED arithmeticType compensated_eval(const arithmeticType &x)
Definition aerobus.h:1965
aerobus::polynomial::val< coeffN >::is_zero_t
std::bool_constant< aN::is_zero_t::value > is_zero_t
Definition aerobus.h:1935
aerobus::polynomial::val
values (seen as types) in polynomial ring
Definition aerobus.h:1837
aerobus::polynomial::val::ring_type
Ring ring_type
ring coefficients live in
Definition aerobus.h:1839
aerobus::polynomial::val::degree
static constexpr size_t degree
degree of the polynomial
Definition aerobus.h:1843
aerobus::polynomial::val::eval
static constexpr DEVICE INLINED arithmeticType eval(const arithmeticType &x)
evaluates polynomial seen as a function operating on arithmeticType
Definition aerobus.h:1884
aerobus::polynomial::val::coeff_at_t
typename coeff_at< index >::type coeff_at_t
type of coefficient at index
Definition aerobus.h:1871
aerobus::polynomial::val::value_at_t
horner_reduction_t< val > ::template inner< 0, degree+1 > ::template type< typename Ring::zero, x > value_at_t
Definition aerobus.h:1920
aerobus::polynomial::val::aN
coeffN aN
heavy weight coefficient (non zero)
Definition aerobus.h:1845
aerobus::polynomial::val::is_zero_v
static constexpr bool is_zero_v
true if polynomial is constant zero
Definition aerobus.h:1851
aerobus::polynomial::val::to_string
static std::string to_string()
get a string representation of polynomial
Definition aerobus.h:1875
aerobus::polynomial::val::compensated_eval
static DEVICE INLINED arithmeticType compensated_eval(const arithmeticType &x)
Evaluate polynomial on x using compensated horner scheme.
Definition aerobus.h:1913
aerobus::polynomial::val::is_zero_t
std::bool_constant<(degree==0) &&(aN::is_zero_t::value)> is_zero_t
true_type if polynomial is constant zero
Definition aerobus.h:1849
aerobus::polynomial
Definition aerobus.h:1807
aerobus::polynomial::lt_t
typename lt_helper< v1, v2 >::type lt_t
strict less operator
Definition aerobus.h:2414
aerobus::polynomial::derive_t
typename derive_helper< v >::type derive_t
derivation operator
Definition aerobus.h:2443
aerobus::polynomial::mul_t
typename mul< v1, v2 >::type mul_t
multiplication of two polynomials
Definition aerobus.h:2402
aerobus::polynomial::add_t
typename add< v1, v2 >::type add_t
adds two polynomials
Definition aerobus.h:2390
aerobus::polynomial::eq_t
typename eq_helper< v1, v2 >::type eq_t
equality operator
Definition aerobus.h:2408
aerobus::polynomial::simplify_t
typename simplify< P >::type simplify_t
simplifies a polynomial (recursively deletes highest degree if zero, do nothing otherwise)
Definition aerobus.h:2384
aerobus::polynomial::is_euclidean_domain
static constexpr bool is_euclidean_domain
Definition aerobus.h:1809
aerobus::polynomial::X
val< typename Ring::one, typename Ring::zero > X
generator
Definition aerobus.h:1978
aerobus::polynomial::div_t
typename div< v1, v2 >::q_type div_t
division operator
Definition aerobus.h:2426
aerobus::polynomial::pos_v
static constexpr bool pos_v
positivity operator
Definition aerobus.h:2453
aerobus::polynomial::is_field
static constexpr bool is_field
Definition aerobus.h:1808
aerobus::polynomial::pos_t
typename Ring::template pos_t< typename v::aN > pos_t
checks for positivity (an > 0)
Definition aerobus.h:2448
aerobus::polynomial::zero
val< typename Ring::zero > zero
constant zero
Definition aerobus.h:1974
aerobus::polynomial::gcd_t
std::conditional_t< Ring::is_euclidean_domain, typename make_unit< gcd_t< polynomial< Ring >, v1, v2 > >::type, void > gcd_t
greatest common divisor of two polynomials
Definition aerobus.h:2462
aerobus::polynomial::gt_t
typename gt_helper< v1, v2 >::type gt_t
strict greater operator
Definition aerobus.h:2420
aerobus::polynomial::mod_t
typename div_helper< v1, v2, zero, v1 >::mod_type mod_t
modulo operator
Definition aerobus.h:2432
aerobus::polynomial::one
val< typename Ring::one > one
constant one
Definition aerobus.h:1976
aerobus::polynomial::sub_t
typename sub< v1, v2 >::type sub_t
substraction of two polynomials
Definition aerobus.h:2396
aerobus::polynomial::inject_constant_t
val< typename Ring::template inject_constant_t< x > > inject_constant_t
makes the constant (native type) polynomial a_0
Definition aerobus.h:2467
aerobus::polynomial::monomial_t
typename monomial< coeff, deg >::type monomial_t
monomial : coeff X^deg
Definition aerobus.h:2438
aerobus::type_list::pop_front
removes types from head of the list
Definition aerobus.h:979
aerobus::type_list::pop_front::tail
typename internal::pop_front_h< Ts... >::tail tail
remaining types in parent list when front is removed
Definition aerobus.h:983
aerobus::type_list::pop_front::type
typename internal::pop_front_h< Ts... >::head type
type that was previously head of the list
Definition aerobus.h:981
aerobus::type_list::split
splits list at index
Definition aerobus.h:999
aerobus::type_list::split::tail
typename inner::tail tail
Definition aerobus.h:1005
aerobus::type_list::split::head
typename inner::head head
Definition aerobus.h:1004
aerobus::type_list<>::concat
U concat
Definition aerobus.h:1032
aerobus::type_list
Empty pure template struct to handle type list.
Definition aerobus.h:954
aerobus::type_list::concat
typename concat_h< U >::type concat
concatenates two list into one
Definition aerobus.h:994
aerobus::type_list::insert
typename internal::insert_h< index, type_list< Ts... >, T >::type insert
inserts type at index
Definition aerobus.h:1012
aerobus::type_list::at
internal::type_at_t< index, Ts... > at
returns type at index
Definition aerobus.h:976
aerobus::type_list::length
static constexpr size_t length
length of list
Definition aerobus.h:966
aerobus::type_list::remove
typename internal::remove_h< index, type_list< Ts... > >::type remove
removes type at index
Definition aerobus.h:1017
aerobus::zpz::val
values in zpz
Definition aerobus.h:1614
aerobus::zpz::val::v
static constexpr int32_t v
actual value
Definition aerobus.h:1618
aerobus::zpz::val::is_zero_v
static constexpr bool is_zero_v
true if zero
Definition aerobus.h:1631
aerobus::zpz::val::to_string
static std::string to_string()
string representation
Definition aerobus.h:1635
aerobus::zpz::val::is_zero_t
std::bool_constant< v==0 > is_zero_t
true_type if zero
Definition aerobus.h:1628
aerobus::zpz::val::get
static constexpr INLINED DEVICE valueType get()
get value as valueType
Definition aerobus.h:1623
aerobus::zpz
congruence classes of integers modulo p (32 bits)
Definition aerobus.h:1607
aerobus::zpz::inner_type
int32_t inner_type
underlying type for values
Definition aerobus.h:1609
aerobus::zpz::is_field
static constexpr bool is_field
true iff p is prime
Definition aerobus.h:1652
aerobus::zpz::sub_t
typename sub< v1, v2 >::type sub_t
substraction operator
Definition aerobus.h:1714
aerobus::zpz::div_t
typename div< v1, v2 >::type div_t
division operator
Definition aerobus.h:1726
aerobus::zpz::is_euclidean_domain
static constexpr bool is_euclidean_domain
always true
Definition aerobus.h:1655
aerobus::zpz::gcd_t
gcd_t< i32, v1, v2 > gcd_t
greatest common divisor
Definition aerobus.h:1774
aerobus::zpz::lt_v
static constexpr bool lt_v
strictly smaller operator (booleanvalue)
Definition aerobus.h:1756
aerobus::zpz::add_t
typename add< v1, v2 >::type add_t
addition operator
Definition aerobus.h:1708
aerobus::zpz::mul_t
typename mul< v1, v2 >::type mul_t
multiplication operator
Definition aerobus.h:1720
aerobus::zpz::lt_t
typename lt< v1, v2 >::type lt_t
strictly smaller operator (type)
Definition aerobus.h:1750
aerobus::zpz::eq_v
static constexpr bool eq_v
equality operator (booleanvalue)
Definition aerobus.h:1768
aerobus::zpz::eq_t
typename eq< v1, v2 >::type eq_t
equality operator (type)
Definition aerobus.h:1762
aerobus::zpz::gt_v
static constexpr bool gt_v
strictly greater operator (booleanvalue)
Definition aerobus.h:1744
aerobus::zpz::pos_t
typename pos< v1 >::type pos_t
positivity operator (type)
Definition aerobus.h:1779
aerobus::zpz::gt_t
typename gt< v1, v2 >::type gt_t
strictly greater operator (type)
Definition aerobus.h:1738
aerobus::zpz::mod_t
typename remainder< v1, v2 >::type mod_t
modulo operator
Definition aerobus.h:1732
aerobus::zpz::pos_v
static constexpr bool pos_v
positivity operator (boolean value)
Definition aerobus.h:1784
Generated by doxygen 1.9.8