// Modified from saffah
constexpr auto statement = "Do NOT modify this statement! "
"https://github.com/With-Sky/HintFFT "
"TSKY (WithSky)";
#include <complex>
#include <iostream>
#include <type_traits>
#include <cstdint>
#include <climits>
#include <cstring>
#include <immintrin.h>
#pragma GCC target("avx2,fma,tune=skylake,bmi,bmi2,popcnt,lzcnt")
namespace hint
{
template <typename T, size_t ALIGN = 64>
class AlignMem{
public:
using Ptr = T *;
using ConstPtr = const T *;
~AlignMem(){
if (ptr){
_mm_free(ptr);}};
AlignMem() : ptr(nullptr), len(0) {}
AlignMem(size_t n) : ptr(reinterpret_cast<Ptr>(_mm_malloc(n * sizeof(T), ALIGN))), len(n) {}
AlignMem(const AlignMem &) = delete;
AlignMem &operator=(const AlignMem &) = delete;
T &operator[](size_t i){
return ptr[i];}
const T &operator[](size_t i) const{
return ptr[i];}
Ptr begin(){
return ptr;}
Ptr end(){
return ptr + len;}
ConstPtr begin() const{
return ptr;}
ConstPtr end() const{
return ptr + len;}
size_t size() const{
return len;}
private:
T *ptr;
size_t len;};
template <typename YMM>
inline void transpose64_2X4(YMM &row0, YMM &row1){
auto t0 = _mm256_unpacklo_pd(__m256d(row0), __m256d(row1));
auto t1 = _mm256_unpackhi_pd(__m256d(row0), __m256d(row1));
row0 = YMM(_mm256_permute2f128_pd(t0, t1, 0x20));
row1 = YMM(_mm256_permute2f128_pd(t0, t1, 0x31));}
template <typename YMM>
inline void transpose64_4X2(YMM &row0, YMM &row1){
auto t0 = _mm256_permute2f128_pd(__m256d(row0), __m256d(row1), 0x20);
auto t1 = _mm256_permute2f128_pd(__m256d(row0), __m256d(row1), 0x31);
row0 = YMM(_mm256_unpacklo_pd(t0, t1));
row1 = YMM(_mm256_unpackhi_pd(t0, t1));}
template <typename YMM>
inline void transpose64_4X4(YMM &row0, YMM &row1, YMM &row2, YMM &row3){
auto t0 = _mm256_unpacklo_pd(__m256d(row0), __m256d(row1));
auto t1 = _mm256_unpackhi_pd(__m256d(row0), __m256d(row1));
auto t2 = _mm256_unpacklo_pd(__m256d(row2), __m256d(row3));
auto t3 = _mm256_unpackhi_pd(__m256d(row2), __m256d(row3));
row0 = YMM(_mm256_permute2f128_pd(t0, t2, 0x20));
row1 = YMM(_mm256_permute2f128_pd(t1, t3, 0x20));
row2 = YMM(_mm256_permute2f128_pd(t0, t2, 0x31));
row3 = YMM(_mm256_permute2f128_pd(t1, t3, 0x31));}
template <typename T>
inline void prefetch_l1(T *p)
{
_mm_prefetch(p, _MM_HINT_T0);
}
class Float64X4{
public:
using F64 = double;
using F64X4 = Float64X4;
Float64X4() : data(_mm256_setzero_pd()) {}
Float64X4(__m256d in_data) : data(in_data) {}
Float64X4(F64 in_data) : data(_mm256_set1_pd(in_data)) {}
Float64X4(const F64 *in_data) : data(_mm256_load_pd(in_data)) {}
F64X4 operator+(const F64X4 &other) const{
return _mm256_add_pd(data, other.data);}
F64X4 operator-(const F64X4 &other) const{
return _mm256_sub_pd(data, other.data);}
F64X4 operator*(const F64X4 &other) const{
return _mm256_mul_pd(data, other.data);}
F64X4 operator/(const F64X4 &other) const{
return _mm256_div_pd(data, other.data);}
static F64X4 fmadd(const F64X4 &a, const F64X4 &b, const F64X4 &c){
return _mm256_fmadd_pd(a.data, b.data, c.data);}
static F64X4 fmsub(const F64X4 &a, const F64X4 &b, const F64X4 &c){
return _mm256_fmsub_pd(a.data, b.data, c.data);}
template <int N>
F64X4 permute4x64() const{
return _mm256_permute4x64_pd(data, N);}
F64X4 reverse() const{
return permute4x64<0b00011011>();}
void load(const F64 *p){
data = _mm256_load_pd(p);}
void load1(const F64 *p){
data = _mm256_broadcast_sd(p);}
void store(F64 *p) const{
_mm256_store_pd(p, data);}
operator __m256d() const{
return data;}
__m256i toI64X4() const{
constexpr uint64_t mask = (uint64_t(1) << 52) - 1;
constexpr uint64_t offset = (uint64_t(1) << 10) - 1;
const __m256i f64bits = _mm256_castpd_si256(data);
__m256i tail = _mm256_and_si256(f64bits, _mm256_set1_epi64x(mask));
tail = _mm256_or_si256(tail, _mm256_set1_epi64x(mask + 1));
__m256i exp = _mm256_srli_epi64(f64bits, 52);
exp = _mm256_sub_epi64(_mm256_set1_epi64x(offset + 52), exp);
return _mm256_srlv_epi64(tail, exp);}
private:
__m256d data;};
struct Complex64X4{
using C64X4 = Complex64X4;
using F64X4 = Float64X4;
using F64 = double;
Complex64X4() {}
Complex64X4(F64X4 real, F64X4 imag) : real(real), imag(imag) {}
Complex64X4(const F64 *p) : real(p), imag(p + 4) {}
Complex64X4(const F64 *p_real, const F64 *p_imag) : real(p_real), imag(p_imag) {}
C64X4 operator+(const C64X4 &other) const{
return C64X4(real + other.real, imag + other.imag);}
C64X4 operator-(const C64X4 &other) const{
return C64X4(real - other.real, imag - other.imag);}
C64X4 operator*(const F64X4 &other) const{
return C64X4(real * other, imag * other);}
C64X4 mul(const C64X4 &other) const{
const F64X4 ii = imag * other.imag;
const F64X4 ri = real * other.imag;
const F64X4 r = F64X4::fmsub(real, other.real, ii);
const F64X4 i = F64X4::fmadd(imag, other.real, ri);
return C64X4(r, i);}
C64X4 mulConj(const C64X4 &other) const{
const F64X4 ii = imag * other.imag;
const F64X4 ri = real * other.imag;
const F64X4 r = F64X4::fmadd(real, other.real, ii);
const F64X4 i = F64X4::fmsub(imag, other.real, ri);
return C64X4(r, i);}
C64X4 reverse() const{
return C64X4(real.reverse(), imag.reverse());}
void set1(F64 real_in, F64 imag_in){
real = F64X4(real_in);
imag = F64X4(imag_in);}
template <typename T>
void load(const T *p, std::false_type){
this->load(p);}
template <typename T>
void load(const T *p, std::true_type){
this->load(p);
*this = this->toRRIIPermu();}
template <typename T>
void load(const T *p){
real.load(reinterpret_cast<const F64 *>(p));
imag.load(reinterpret_cast<const F64 *>(p) + 4);}
void load1(const F64 *real_p, const F64 *imag_p){
real.load1(real_p);
imag.load1(imag_p);}
template <typename T>
void store(T *p, std::false_type) const{
this->store(p);}
template <typename T>
void store(T *p, std::true_type) const{
this->toRIRIPermu().store(p);}
template <typename T>
void store(T *p) const{
real.store(reinterpret_cast<F64 *>(p));
imag.store(reinterpret_cast<F64 *>(p) + 4);}
C64X4 toRIRIPermu() const{
C64X4 res = *this;
transpose64_2X4(res.real, res.imag);
return res;}
C64X4 toRRIIPermu() const{
C64X4 res = *this;
transpose64_4X2(res.real, res.imag);
return res;}
C64X4 transToI64(std::false_type) const{
return *this;}
C64X4 transToI64(std::true_type) const{
constexpr int64_t F1_2 = 4602678819172646912;
auto F1_2X4 = F64X4(__m256d(_mm256_set1_epi64x(F1_2)));
auto real_i64 = (real + F1_2X4).toI64X4();
auto imag_i64 = (imag + F1_2X4).toI64X4();
return C64X4(__m256d(real_i64), __m256d(imag_i64));}
F64X4 real, imag;};
using Float32 = float;
using Float64 = double;
using FloatLong = long double;
constexpr FloatLong HINT_PIL = 3.141592653589793238462643383279L;
constexpr Float64 HINT_PI = HINT_PIL;
constexpr Float64 HINT_2PI = HINT_PI * 2;
constexpr Float64 COS_PI_8 = 0.707106781186547524400844;
template <typename T>
constexpr T int_floor2(T n){
constexpr int bits = sizeof(n) * 8;
for (int i = 1; i < bits; i *= 2){
n |= (n >> i);}
return (n >> 1) + 1;}
template <typename T>
constexpr T int_ceil2(T n){
constexpr int bits = sizeof(n) * 8;
n--;
for (int i = 1; i < bits; i *= 2){
n |= (n >> i);}
return n + 1;}
template <typename IntTy>
constexpr bool is_2pow(IntTy n){
return n != 0 && (n & (n - 1)) == 0;}
template <typename T>
constexpr int hint_log2(T n){
constexpr int bits = sizeof(n) * 8;
int l = -1, r = bits;
while ((l + 1) != r){
int mid = (l + r) / 2;
if ((T(1) << mid) > n){
r = mid;}
else{
l = mid;}}
return l;}
constexpr FloatLong sin_poly(FloatLong x)
{
if (x < 0)
{
return -sin_poly(-x);
}
if (x > HINT_PIL)
{
return -sin_poly(x - HINT_PIL);
}
if (x > HINT_PIL / 2)
{
return sin_poly(HINT_PIL - x);
}
const FloatLong xl = x, x2 = xl * xl, x4 = x2 * x2, x6 = x4 * x2, x8 = x4 * x4, x10 = x6 * x4, x12 = x6 * x6, x14 = x8 * x6, x16 = x8 * x8, x18 = x10 * x8, x20 = x10 * x10;
return xl * (1.0L - x2 / 6.0L + x4 / 120.0L - x6 / 5040.0L + x8 / 362880.0L - x10 / 39916800.0L + x12 / 6227020800.0L - x14 / 1307674368000.0L + x16 / 355687428096000.0L - x18 / 121645100408832000.0L + x20 / 51090942171709440000.0L);
}
constexpr FloatLong cos_poly(FloatLong x)
{
if (x < 0)
{
x = -x;
}
return sin_poly(HINT_PIL / 2.0 - x);
}
constexpr uint32_t crc32(const char *str){
uint32_t crc = 0xFFFFFFFF;
while (*str != '\0'){
crc ^= *str;
for (int i = 0; i < 8; ++i){
crc = (crc >> 1) ^ (0 - (crc & 1)) & 0xEDB88320;}
str++;}
return ~crc;}
namespace transform{
template <typename T>
inline void transform2(T &sum, T &diff){
T temp0 = sum, temp1 = diff;
sum = temp0 + temp1;
diff = temp0 - temp1;}
namespace fft{
using F64 = Float64;
using C64 = std::complex<F64>;
using F64X4 = Float64X4;
using C64X4 = Complex64X4;
template <typename Float>
constexpr void initOmega(Float *table, size_t fft_len, size_t table_len, int factor, int stride)
{
const Float theta = -HINT_2PI * factor / fft_len;
for (size_t begin = 0, index = 0; begin < table_len * 2; begin += stride * 2)
{
for (size_t j = 0; j < stride; j++, index++)
{
table[begin + j] = cos_poly(theta * index);
table[begin + j + stride] = sin_poly(theta * index);
}
}
}
template <typename Float, size_t OMEGA_LEN>
class TableFix
{
alignas(64) Float table[OMEGA_LEN * 2]{};
public:
constexpr TableFix() = default;
constexpr TableFix(size_t fft_len, size_t factor, size_t stride)
{
init(fft_len, factor, stride);
}
constexpr void init(size_t fft_len, size_t factor, size_t stride)
{
initOmega(table, fft_len, OMEGA_LEN, factor, stride);
}
constexpr const Float &operator[](size_t index) const
{
return table[index];
}
};
template <typename Float, int LOG_BEGIN, int LOG_END, int DIV>
class TableFixMulti
{
static constexpr size_t END_LEN = (size_t(1) << LOG_END) / DIV, BEGIN_LEN = (size_t(1) << LOG_BEGIN) / DIV, TABLE_CPX_LEN = END_LEN * 2 - BEGIN_LEN;
alignas(64) Float table[TABLE_CPX_LEN * 2]{};
public:
constexpr TableFixMulti() = default;
constexpr TableFixMulti(size_t factor, size_t stride = 4)
{
init(factor, stride);
}
constexpr void init(size_t factor, size_t stride)
{
for (int log_len = LOG_BEGIN; log_len <= LOG_END; log_len++)
{
size_t len = size_t(1) << log_len, cpx_len = len / DIV;
auto it = getBeginLog(log_len);
initOmega(it, len, cpx_len, factor, stride);
}
}
constexpr const Float *getBeginLog(int log_rank) const
{
return getBegin(size_t(1) << log_rank);
}
constexpr Float *getBeginLog(int log_rank)
{
return getBegin(size_t(1) << log_rank);
}
constexpr const Float *getBegin(size_t rank) const
{
return &table[rank * 2 / DIV - BEGIN_LEN * 2];
}
constexpr Float *getBegin(size_t rank)
{
return &table[rank * 2 / DIV - BEGIN_LEN * 2];
}
};
template <int LOW_LOG_LEN>
struct HighLowPtrC64XX4
{
static constexpr int CX4_LOG_LEN = LOW_LOG_LEN - 2;
static constexpr size_t LOW_LEN = size_t(1) << CX4_LOG_LEN, MASK = LOW_LEN - 1;
const C64X4 *low;
const C64 *high;
C64X4 operator[](size_t i) const
{
C64X4 hi;
auto p = reinterpret_cast<const F64 *>(&high[i >> CX4_LOG_LEN]);
hi.load1(p, p + 1);
return low[i & MASK].mul(hi);
}
};
template <int LOG_BEGIN, int LOG_END, int LOG_LOW_BYTE, int DIV>
class TableSqrtC64X4
{
public:
static constexpr int LOG_LOW_LEN = LOG_LOW_BYTE - 4; // C64 len
static constexpr size_t BEGIN_RANK = size_t(1) << LOG_BEGIN, BEGIN_LEN = BEGIN_RANK / DIV;
static constexpr size_t TABLE_COUNT = LOG_END - LOG_BEGIN + 1;
using TableLow = TableFix<Float64, size_t(1) << LOG_LOW_LEN>;
using TableHigh = TableFixMulti<Float64, LOG_BEGIN - LOG_LOW_LEN, LOG_END - LOG_LOW_LEN, DIV>;
using Ptr = HighLowPtrC64XX4<LOG_LOW_LEN>;
TableLow table_low[TABLE_COUNT]{};
TableHigh table_high;
public:
constexpr TableSqrtC64X4(int factor)
{
for (int i = 0; i < TABLE_COUNT; i++)
{
table_low[i].init(size_t(1) << (LOG_BEGIN + i), factor, 4);
}
table_high.init(factor, 1);
}
constexpr Ptr getBeginLog(int log_rank) const
{
return Ptr{reinterpret_cast<const C64X4 *>(&table_low[log_rank - LOG_BEGIN][0]),
reinterpret_cast<const C64 *>(table_high.getBeginLog(log_rank - LOG_LOW_LEN))};
}
};
template <int LOG_END, int DIV>
class TableRevC64X4
{
static constexpr size_t END_LEN = size_t(1) << LOG_END, TABLE_LEN = END_LEN * 8 / DIV;
alignas(64) F64 table[TABLE_LEN]{}; // C64X4 len
public:
constexpr TableRevC64X4()
{
table[0] = table[1] = table[2] = table[3] = 1;
for (size_t begin = 8; begin < TABLE_LEN; begin *= 2)
{
const auto theta = HINT_PIL * 8 / (begin * DIV);
auto pr = table, pi = pr + 4;
auto pr_cur = table + begin, pi_cur = pr_cur + 4;
pr_cur[0] = 1;
pi_cur[1] = 0;
pr_cur[1] = cos_poly(theta);
pi_cur[1] = -sin_poly(theta);
pr_cur[2] = cos_poly(theta * 2);
pi_cur[2] = -sin_poly(theta * 2);
pr_cur[3] = cos_poly(theta * 3);
pi_cur[3] = -sin_poly(theta * 3);
for (size_t i = 8; i < begin; i += 8)
{
pr_cur[i] = 1, pi_cur[i] = 0;
c_mul(pr[i + 1], pi[i + 1], pr_cur[1], pi_cur[1], pr_cur[i + 1], pi_cur[i + 1]);
c_mul(pr[i + 2], pi[i + 2], pr_cur[2], pi_cur[2], pr_cur[i + 2], pi_cur[i + 2]);
c_mul(pr[i + 3], pi[i + 3], pr_cur[3], pi_cur[3], pr_cur[i + 3], pi_cur[i + 3]);
}
}
}
constexpr const F64 *get(size_t i = 0) const
{
return &table[i * 8];
}
};
struct FFT{
template <typename Float>
static void trans2MulI(Float &r0, Float &i0, Float &r1, Float &i1){
auto temp = r1;
r1 = r0 + i1;
r0 = r0 - i1;
i1 = i0 - temp;
i0 = i0 + temp;}
template <typename Float>
static void trans2MulNegI(Float &r0, Float &i0, Float &r1, Float &i1){
auto temp = r1;
r1 = r0 - i1;
r0 = r0 + i1;
i1 = i0 + temp;
i0 = i0 - temp;}
template <typename Float>
static void dif4(Float &r0, Float &i0, Float &r1, Float &i1, Float &r2, Float &i2, Float &r3, Float &i3){
difSplit(r0, i0, r1, i1, r2, i2, r3, i3);
transform2(r0, r1);
transform2(i0, i1);}
template <typename Float>
static void idit4(Float &r0, Float &i0, Float &r1, Float &i1, Float &r2, Float &i2, Float &r3, Float &i3){
transform2(r0, r1);
transform2(i0, i1);
iditSplit(r0, i0, r1, i1, r2, i2, r3, i3);}
template <typename Float>
static void difSplit(Float &r0, Float &i0, Float &r1, Float &i1, Float &r2, Float &i2, Float &r3, Float &i3){
transform2(r0, r2);
transform2(i0, i2);
transform2(r1, r3);
transform2(i1, i3);
trans2MulNegI(r2, i2, r3, i3);}
template <typename Float>
static void iditSplit(Float &r0, Float &i0, Float &r1, Float &i1, Float &r2, Float &i2, Float &r3, Float &i3){
transform2(r2, r3);
transform2(i2, i3);
transform2(r0, r2);
transform2(i0, i2);
trans2MulI(r1, i1, r3, i3);}};
struct FFTAVX : public FFT{
static constexpr int LOG_SHORT = 10, LOG_MID = 25 - crc32(statement) % 15, LOG_MAX = 18, LOG_CACHE = 12;
static constexpr size_t SHORT_LEN = size_t(1) << LOG_SHORT, MID_LEN = size_t(1) << LOG_MID, MAX_LEN = size_t(1) << LOG_MAX;
using TableMulti1 = const TableFixMulti<Float64, LOG_SHORT + 2, LOG_MAX, 4>;
using TableSqrt = const TableSqrtC64X4<LOG_MID + 2, LOG_MAX, LOG_CACHE, 4>;
static constexpr TableRevC64X4<LOG_SHORT, 4> rev_table{};
static constexpr TableMulti1 multi_table_1{1, 4};
static constexpr TableSqrt sqrt_table_1{1};
static void dif4x4(F64X4 &r0, F64X4 &i0, F64X4 &r1, F64X4 &i1, F64X4 &r2, F64X4 &i2, F64X4 &r3, F64X4 &i3){
transpose64_4X4(r0, r1, r2, r3);
transpose64_4X4(i0, i1, i2, i3);
dif4(r0, i0, r1, i1, r2, i2, r3, i3);
transpose64_4X4(r0, r1, r2, r3);
transpose64_4X4(i0, i1, i2, i3);}
static void idit4x4(F64X4 &r0, F64X4 &i0, F64X4 &r1, F64X4 &i1, F64X4 &r2, F64X4 &i2, F64X4 &r3, F64X4 &i3){
transpose64_4X4(r0, r1, r2, r3);
transpose64_4X4(i0, i1, i2, i3);
idit4(r0, i0, r1, i1, r2, i2, r3, i3);
transpose64_4X4(r0, r1, r2, r3);
transpose64_4X4(i0, i1, i2, i3);}
static void difIterRev(Float64 in_out[], size_t float_len)
{
size_t fft_len = float_len / 2;
for (size_t rank = fft_len; rank >= 64; rank /= 4)
{
size_t stride = rank / 2;
auto it0 = in_out, it1 = it0 + stride, it2 = it1 + stride, it3 = it2 + stride;
for (auto end = it1; it0 < end; it0 += 8, it1 += 8, it2 += 8, it3 += 8)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3;
dif4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
auto table = rev_table.get(1);
for (auto begin = in_out + rank * 2, end = in_out + float_len; begin < end; begin += rank * 2, table += 8)
{
auto it0 = begin, it1 = it0 + stride, it2 = it1 + stride, it3 = it2 + stride;
C64X4 omega1, omega2, omega3;
omega1.load1(table + 1, table + 5), omega2.load1(table + 2, table + 6), omega3.load1(table + 3, table + 7);
for (; it0 < begin + stride; it0 += 8, it1 += 8, it2 += 8, it3 += 8)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3;
c1 = c1.mul(omega1), c2 = c2.mul(omega2), c3 = c3.mul(omega3);
dif4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
}
}
auto table = rev_table.get(0), tableX4 = table;
for (auto it = in_out; it < in_out + float_len; it += 32, table += 8, tableX4 += 32)
{
C64X4 c0 = it, c1 = it + 8, c2 = it + 16, c3 = it + 24, omega1, omega2, omega3;
omega1.load1(table + 1, table + 5), omega2.load1(table + 2, table + 6), omega3.load1(table + 3, table + 7);
c1 = c1.mul(omega1), c2 = c2.mul(omega2), c3 = c3.mul(omega3);
dif4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0 = c0.mul(C64X4(tableX4)), c1 = c1.mul(C64X4(tableX4 + 8));
c2 = c2.mul(C64X4(tableX4 + 16)), c3 = c3.mul(C64X4(tableX4 + 24));
dif4x4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0.store(it), c1.store(it + 8), c2.store(it + 16), c3.store(it + 24);
}
}
static void iditIterRev(Float64 in_out[], size_t float_len)
{
auto table = rev_table.get(0), tableX4 = table;
for (auto it = in_out; it < in_out + float_len; it += 32, table += 8, tableX4 += 32)
{
C64X4 c0 = it, c1 = it + 8, c2 = it + 16, c3 = it + 24, omega1, omega2, omega3;
idit4x4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0 = c0.mulConj(C64X4(tableX4)), c1 = c1.mulConj(C64X4(tableX4 + 8));
c2 = c2.mulConj(C64X4(tableX4 + 16)), c3 = c3.mulConj(C64X4(tableX4 + 24));
omega1.load1(table + 1, table + 5), omega2.load1(table + 2, table + 6), omega3.load1(table + 3, table + 7);
idit4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c1 = c1.mulConj(omega1), c2 = c2.mulConj(omega2), c3 = c3.mulConj(omega3);
c0.store(it), c1.store(it + 8), c2.store(it + 16), c3.store(it + 24);
}
size_t fft_len = float_len / 2;
for (size_t rank = 64; rank <= fft_len; rank *= 4)
{
size_t stride = rank / 2;
auto it0 = in_out, it1 = it0 + stride, it2 = it1 + stride, it3 = it2 + stride;
for (auto end = it1; it0 < end; it0 += 8, it1 += 8, it2 += 8, it3 += 8)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3;
idit4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
auto table = rev_table.get(1);
for (auto begin = in_out + rank * 2, end = in_out + float_len; begin < end; begin += rank * 2, table += 8)
{
auto it0 = begin, it1 = it0 + stride, it2 = it1 + stride, it3 = it2 + stride;
C64X4 omega1, omega2, omega3;
omega1.load1(table + 1, table + 5), omega2.load1(table + 2, table + 6), omega3.load1(table + 3, table + 7);
for (; it0 < begin + stride; it0 += 8, it1 += 8, it2 += 8, it3 += 8)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3;
idit4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c1 = c1.mulConj(omega1), c2 = c2.mulConj(omega2), c3 = c3.mulConj(omega3);
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
}
}
}
static void difMid(Float64 in_out[], size_t float_len)
{
size_t fft_len = float_len / 2;
if(fft_len <= SHORT_LEN)
{
difIterRev(in_out,float_len);
return;
}
size_t stride = float_len / 4;
auto table1 = multi_table_1.getBegin(fft_len);
auto it0 = in_out, it1 = it0 + stride, it2 = it1 + stride, it3 = it2 + stride;
for (; it0 < in_out + stride; it0 += 8, it1 += 8, it2 += 8, it3 += 8, table1 += 8)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3, omega1 = table1, omega2;
prefetch_l1(it0 + 8), prefetch_l1(it1 + 8), prefetch_l1(it2 + 8), prefetch_l1(it3 + 8),prefetch_l1(table1+8);
dif4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c2 = c2.mul(omega1);
omega2 = omega1.mul(omega1), c1 = c1.mul(omega2);
c3 = c3.mul(omega2.mul(omega1));
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
difMid(in_out,stride);
difMid(in_out+stride,stride);
difMid(in_out+stride*2,stride);
difMid(in_out+stride*3,stride);
}
static void iditMid(Float64 in_out[], size_t float_len)
{
size_t fft_len = float_len / 2;
if(fft_len <= SHORT_LEN)
{
iditIterRev(in_out,float_len);
return;
}
size_t stride = float_len / 4;
iditMid(in_out,stride);
iditMid(in_out+stride,stride);
iditMid(in_out+stride*2,stride);
iditMid(in_out+stride*3,stride);
auto table1 = multi_table_1.getBegin(fft_len);
auto it0 = in_out, it1 = it0 + stride, it2 = it1 + stride, it3 = it2 + stride;
for (; it0 < in_out + stride; it0 += 8, it1 += 8, it2 += 8, it3 += 8, table1 += 8)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3, omega1 = table1, omega2;
prefetch_l1(it0 + 8), prefetch_l1(it1 + 8), prefetch_l1(it2 + 8), prefetch_l1(it3 + 8),prefetch_l1(table1+8);
c2 = c2.mulConj(omega1);
omega2 = omega1.mul(omega1), c1 = c1.mulConj(omega2);
c3 = c3.mulConj(omega2.mul(omega1));
idit4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
}
template <bool FROM_RIRI_PERM = false>
static void difLong(Float64 in_out[], size_t float_len)
{
using FromRIRI = std::integral_constant<bool, FROM_RIRI_PERM>;
size_t fft_len = float_len / 2;
if (fft_len <= MID_LEN)
{
difMid(in_out, float_len);
return;
}
size_t stride = float_len / 4;
const auto table = sqrt_table_1.getBeginLog(hint_log2(fft_len));
auto it0 = in_out, it1 = in_out + stride, it2 = it1 + stride, it3 = it2 + stride;
size_t indx = 0;
C64X4 high;
for (auto end = it1; FROM_RIRI_PERM && it0 < end; it0 += 8, it1 += 8, it2 += 8, it3 += 8, indx++)
{
C64X4 c0, c1, c2, c3, omega1 = table.low[indx & table.MASK], omega2;
c0.load(it0, FromRIRI{}), c1.load(it1, FromRIRI{}), c2 = c0, c3 = c1;
prefetch_l1(it0 + 8), prefetch_l1(it1 + 8);
if((indx & table.MASK) == 0)
{
auto p = reinterpret_cast<const F64*>(&table.high[indx >> table.CX4_LOG_LEN]);
high.load1(p,p+1);
}
omega1 = omega1.mul(high);
transform2(c0, c1);
trans2MulNegI(c2.real, c2.imag, c3.real, c3.imag);
c2 = c2.mul(omega1);
omega2 = omega1.mul(omega1), c1 = c1.mul(omega2);
c3 = c3.mul(omega2.mul(omega1));
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
for (auto end = it1; (!FROM_RIRI_PERM) && it0 < end; it0 += 8, it1 += 8, it2 += 8, it3 += 8, indx++)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3, omega1 = table.low[indx & table.MASK], omega2;
prefetch_l1(it0 + 8), prefetch_l1(it1 + 8), prefetch_l1(it2 + 8), prefetch_l1(it3 + 8);
if((indx & table.MASK) == 0)
{
auto p = reinterpret_cast<const F64*>(&table.high[indx >> table.CX4_LOG_LEN]);
high.load1(p,p+1);
}
omega1 = omega1.mul(high);
dif4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c2 = c2.mul(omega1);
omega2 = omega1.mul(omega1), c1 = c1.mul(omega2);
c3 = c3.mul(omega2.mul(omega1));
c0.store(it0), c1.store(it1), c2.store(it2), c3.store(it3);
}
difLong(in_out, stride);
difLong(in_out + stride, stride);
difLong(in_out + stride * 2, stride);
difLong(in_out + stride * 3, stride);
}
template <bool TO_RIRI_PERM = false, bool TO_INT64 = false>
static void iditLong(Float64 in_out[], size_t float_len)
{
using ToRIRI = std::integral_constant<bool, TO_RIRI_PERM>;
using ToI64 = std::integral_constant<bool, TO_INT64>;
size_t fft_len = float_len / 2;
if (fft_len <= MID_LEN)
{
iditMid(in_out, float_len);
return;
}
size_t stride = float_len / 4;
iditLong(in_out, stride);
iditLong(in_out + stride, stride);
iditLong(in_out + stride * 2, stride);
iditLong(in_out + stride * 3, stride);
auto it0 = in_out, it1 = in_out + stride, it2 = it1 + stride, it3 = it2 + stride;
size_t indx = 0;
const auto table = sqrt_table_1.getBeginLog(hint_log2(fft_len));
C64X4 high;
for (auto end = it1; it0 < end; it0 += 8, it1 += 8, it2 += 8, it3 += 8, indx++)
{
C64X4 c0 = it0, c1 = it1, c2 = it2, c3 = it3, omega1 = table.low[indx & table.MASK], omega2;
prefetch_l1(it0 + 8), prefetch_l1(it1 + 8), prefetch_l1(it2 + 8), prefetch_l1(it3 + 8);
if((indx & table.MASK) == 0)
{
auto p = reinterpret_cast<const F64*>(&table.high[indx >> table.CX4_LOG_LEN]);
high.load1(p,p+1);
}
omega1 = omega1.mul(high);
c2 = c2.mulConj(omega1);
omega2 = omega1.mul(omega1), c1 = c1.mulConj(omega2);
c3 = c3.mulConj(omega2.mul(omega1));
idit4(c0.real, c0.imag, c1.real, c1.imag, c2.real, c2.imag, c3.real, c3.imag);
c0 = c0.transToI64(ToI64{}), c1 = c1.transToI64(ToI64{}), c2 = c2.transToI64(ToI64{}), c3 = c3.transToI64(ToI64{});
c0.store(it0, ToRIRI{}), c1.store(it1, ToRIRI{}), c2.store(it2, ToRIRI{}), c3.store(it3, ToRIRI{});
}
}
};
constexpr int FFTAVX::LOG_SHORT, FFTAVX::LOG_MID, FFTAVX::LOG_MAX, FFTAVX::LOG_CACHE;
constexpr size_t FFTAVX::SHORT_LEN, FFTAVX::MID_LEN, FFTAVX::MAX_LEN;
constexpr FFTAVX::TableMulti1 FFTAVX::multi_table_1;
constexpr FFTAVX::TableSqrt FFTAVX::sqrt_table_1;
constexpr uint32_t bitrev32(uint32_t n){
constexpr uint32_t mask55 = 0x55555555;
constexpr uint32_t mask33 = 0x33333333;
constexpr uint32_t mask0f = 0x0f0f0f0f;
constexpr uint32_t maskff = 0x00ff00ff;
n = ((n & mask55) << 1) | ((n >> 1) & mask55);
n = ((n & mask33) << 2) | ((n >> 2) & mask33);
n = ((n & mask0f) << 4) | ((n >> 4) & mask0f);
n = ((n & maskff) << 8) | ((n >> 8) & maskff);
return (n << 16) | (n >> 16);}
constexpr uint32_t bitrev(uint32_t n, int len){
return bitrev32(n) >> (32 - len);}
template <int MAX_LOG_LEN, int DIV>
class BinRevTableC64X4HP{
public:
static constexpr int LOG_BLOCK = 2, BLOCK = 1 << LOG_BLOCK;
static constexpr size_t MAX_LEN = size_t(1) << MAX_LOG_LEN;
struct Unit{
C64 units[MAX_LOG_LEN]{};
F64 block[BLOCK * 2]{};
// DI 入口绕过 __libc_start_main, 静态构造器不执行, 改为显式 init (run_job 调用)
void init()
{
constexpr F64 factor = F64(1) / DIV;
for (int i = 0; i < MAX_LOG_LEN; i++)
{
units[i] = getOmega(size_t(1) << (i + 1), 1, factor);}
block[0] = 1, block[BLOCK] = 0;
for (int i = 1; i < BLOCK; i++)
{
C64 omega = getOmega(BLOCK, bitrev(i, LOG_BLOCK), factor);
block[i] = omega.real(), block[i + BLOCK] = omega.imag();}}};
BinRevTableC64X4HP() : index(0), pop(0){
if (!unit_table_ready){
unit_table.init();
unit_table_ready = true;}
std::memcpy(table, unit_table.block, sizeof(unit_table.block));}
void reset(size_t i = 0){
if (i == 0){
pop = 0, index = i;
return;}
pop = 1, index = i / BLOCK;
int zero = __builtin_ctzll(index);
auto fp = reinterpret_cast<const F64 *>(&unit_table.units[zero + 2]);
table[1].load1(fp, fp + 1);
table[1] = table[1].mul(table[0]);}
C64X4 iterate(){
C64X4 res = table[pop], unit4;
index++;
int zero = __builtin_ctzll(index);
auto fp = reinterpret_cast<const F64 *>(&unit_table.units[zero + 2]);
unit4.load1(fp, fp + 1);
pop -= zero;
table[pop + 1] = table[pop].mul(unit4);
pop++;
return res;}
static C64 getOmega(size_t n, size_t index, F64 factor = 1){
F64 theta = -HINT_2PI * index / n;
return std::polar<F64>(1, theta * factor);}
private:
alignas(64) static Unit unit_table;
static bool unit_table_ready;
alignas(64) C64X4 table[MAX_LOG_LEN];
size_t index;
int pop;
int log_max_iter, log_fft_len;};
template <int MAX_LOG_LEN, int DIV>
typename BinRevTableC64X4HP<MAX_LOG_LEN, DIV>::Unit BinRevTableC64X4HP<MAX_LOG_LEN, DIV>::unit_table;
template <int MAX_LOG_LEN, int DIV>
bool BinRevTableC64X4HP<MAX_LOG_LEN, DIV>::unit_table_ready;
template <size_t RI_DIFF = 1, typename FloatTy>
inline void dot_rfft(FloatTy *inout0, FloatTy *inout1, const FloatTy *in0, const FloatTy *in1,
const std::complex<FloatTy> &omega, const FloatTy inv = 1){
using Complex = std::complex<FloatTy>;
auto addConj = [](Complex c0, Complex c1){ return Complex(c0.real() + c1.real(), c0.imag() - c1.imag()); };
Complex x0(inout0[0], inout0[RI_DIFF]), x1(inout1[0], inout1[RI_DIFF]),
y0(in0[0], in0[RI_DIFF]), y1(in1[0], in1[RI_DIFF]);
auto t0 = x0 * y0, t1 = x1 * y1, xy0 = addConj(x0, x1), xy1 = addConj(y0, y1);
auto t2 = xy0 * xy1;
y1 = addConj(t0, t1);
x1 = (y1 + y1 - t2) * omega * omega;
const auto inv2 = inv + inv;
x0 = (t2 - x1) * inv, x1 = Complex(t0.real() - t1.real(), t0.imag() + t1.imag()) * inv2;
Complex out0 = x0 + x1, out1(x0.real() - x1.real(), x1.imag() - x0.imag());
inout0[0] = out0.real(), inout0[RI_DIFF] = out0.imag();
inout1[0] = out1.real(), inout1[RI_DIFF] = out1.imag();}
inline void dot_rfftX4(F64 *inout0, F64 *inout1, const F64 *in0, const F64 *in1, const C64X4 &omega, const F64X4 &inv)
{
auto addConj = [](const C64X4 &x0, const C64X4 &x1)
{ return C64X4(x0.real + x1.real, x0.imag - x1.imag); };
C64X4 x0 = inout0, x1 = inout1, y0 = in0, y1 = in1;
prefetch_l1(inout0+8),prefetch_l1(inout1-8),prefetch_l1(in0+8),prefetch_l1(in1-8);
x1 = x1.reverse();
y1 = y1.reverse();
C64X4 t0 = x0.mul(y0), t1 = x1.mul(y1);
C64X4 xy0 = addConj(x0, x1), xy1 = addConj(y0, y1);
C64X4 t2 = xy0.mul(xy1);
y1 = addConj(t0, t1);
x1 = (y1 + y1 - t2).mul(omega);
const F64X4 inv2 = inv + inv;
x0 = (t2 - x1) * inv, x1 = C64X4(t0.real - t1.real, t0.imag + t1.imag) * inv2;
C64X4 out0 = x0 + x1, out1(x0.real - x1.real, x1.imag - x0.imag);
out0.store(inout0), out1.reverse().store(inout1);
}
inline void real_dot_binrev4(Float64 in_out[], Float64 in[], size_t float_len){
Float64 inv = 2.0 / float_len;{
auto r0 = in_out[0], i0 = in_out[4], r1 = in[0], i1 = in[4];
transform2(r0, i0);
transform2(r1, i1);
r0 *= r1, i0 *= i1;
transform2(r0, i0);
in_out[0] = r0 * 0.5 * inv, in_out[4] = i0 * 0.5 * inv;}
auto temp = C64(in_out[1], in_out[5]) * C64(in[1], in[5]) * inv;
in_out[1] = temp.real(), in_out[5] = temp.imag();
inv /= 4;
dot_rfft<4>(&in_out[2], &in_out[3], &in[2], &in[3], C64(COS_PI_8, -COS_PI_8), inv);
constexpr Float64 COS_16_1 = 0.92387953251128675612818318939;
constexpr Float64 SIN_16_1 = 0.38268343236508977172845998403;
dot_rfft<4>(&in_out[8], &in_out[11], &in[8], &in[11], C64(COS_16_1, -SIN_16_1), inv);
dot_rfft<4>(&in_out[9], &in_out[10], &in[9], &in[10], C64(-SIN_16_1, -COS_16_1), inv);
const Float64X4 inv4 = F64X4(0.5 / float_len);
BinRevTableC64X4HP<19, 1> table;
for (size_t begin = 16; begin < float_len; begin *= 2){
table.reset(begin / 2);
auto it0 = in_out + begin, it1 = it0 + begin - 8, it2 = in + begin, it3 = it2 + begin - 8;
for (; it0 < it1; it0 += 8, it1 -= 8, it2 += 8, it3 -= 8)
{
dot_rfftX4(it0, it1, it2, it3, table.iterate(), inv4);
}}}
template <bool TO_INT = false>
inline void real_conv_avx(F64 *in_out1, F64 *in2, size_t float_len){
FFTAVX::difLong<true>(in_out1, float_len);
FFTAVX::difLong<true>(in2, float_len);
real_dot_binrev4(in_out1, in2, float_len);
FFTAVX::iditLong<true, TO_INT>(in_out1, float_len);}}}}
namespace string_util
{
using namespace hint;
using namespace transform;
using namespace fft;
class ItoStrBase10000{
private:
uint32_t table[10000]{};
public:
static constexpr uint32_t itosbase10000(uint32_t num){
uint32_t res = (num / 1000 % 10) | ((num / 100 % 10) << 8) |
((num / 10 % 10) << 16) | ((num % 10) << 24);
return res + '0' * 0x1010101;}
constexpr ItoStrBase10000(){
for (size_t i = 0; i < 10000; i++){
table[i] = itosbase10000(i);}}
void tostr(char *str, uint32_t num) const{
std::memcpy(str, &table[num], sizeof(num));}
uint32_t tostr(uint32_t num) const{
return table[num];}};
constexpr ItoStrBase10000 itosbase10000{};
template <typename T>
void fill_zero(T *begin, T *end){
std::memset(begin, 0, (end - begin) * sizeof(T));}
size_t digitlen_avx2(const char *str){
auto ptr = str;
auto zero_vec = _mm256_set1_epi8('0');
for (;; ptr += 32){
auto data = _mm256_loadu_si256((const __m256i *)ptr);
auto cmp_result = _mm256_cmpgt_epi8(zero_vec, data);
int mask = _mm256_movemask_epi8(cmp_result);
if (mask != 0){
size_t offset = __builtin_ctz(mask);
return (ptr - str) + offset;}}
return 0;}
size_t parse_str4_to_f64(const char *str, size_t len, double *out){
auto zeros = _mm_set1_epi8('0');
auto mult_10_1 = _mm_setr_epi8(
10, 1, 10, 1, 10, 1, 10, 1,
10, 1, 10, 1, 10, 1, 10, 1);
auto mult_100_1 = _mm_setr_epi16(
100, 1, 100, 1, 100, 1, 100, 1);
auto str_end = str + len;
for (auto end = str_end - 15; str < end; str += 16, out += 4){
auto chars = _mm_loadu_si128((const __m128i *)str);
auto digits = _mm_sub_epi8(chars, zeros);
auto vals_16 = _mm_maddubs_epi16(digits, mult_10_1);
auto vals_32 = _mm_madd_epi16(vals_16, mult_100_1);
auto vals_double = _mm256_cvtepi32_pd(vals_32);
_mm256_store_pd(out, vals_double);}
for (auto end = str_end - 3; str < end; str += 4, out++){
out[0] = str[0] * 1000 + str[1] * 100 + str[2] * 10 + str[3] - '0' * 1111;}
size_t offset = 0,factor = 1000;
if (str < str_end){
offset = 4 - (str_end - str);
out[0] = 0;
while (str < str_end){
out[0] += (str[0] - '0')*factor;
str++;
factor /= 10;
}}
return offset;}
template <typename T>
size_t conv_to_str_base10000(const T *ary, size_t conv_len, size_t shift, char *res, size_t &res_len){
constexpr size_t BLOCK = 4;
constexpr uint64_t BASE = 10000, BASE2 = BASE * BASE;
res_len = (conv_len + 1) * BLOCK;
auto end = res + res_len;
char *p = end;
uint64_t carry = 0;
const size_t pairs = conv_len / 2;
if (conv_len % 2 != 0){
p -= BLOCK;
carry += (uint64_t)ary[conv_len - 1];
itosbase10000.tostr(p, carry % BASE);
carry /= BASE;}
for (size_t g = pairs; g > 0; g--){
uint64_t C = (uint64_t)ary[2 * g - 2] * BASE + (uint64_t)ary[2 * g - 1];
uint64_t total = C + carry;
uint64_t t4 = total / BASE;
carry = total / BASE2;
uint32_t lo = (uint32_t)(total - t4 * BASE);
uint32_t hi = (uint32_t)t4 - (uint32_t)carry * (uint32_t)BASE;
p -= 2 * BLOCK;
itosbase10000.tostr(p,hi );
itosbase10000.tostr(p + BLOCK,lo);}
p -= BLOCK;
itosbase10000.tostr(p, carry);
while (p < end && *p == '0'){
p++;}
if (p == end){
p--;
*p = '0';}
size_t offset = p - res;
res_len -= (offset + shift);
return offset;}
constexpr size_t N = size_t(1) << 19;
// DI 入口绕过 __libc_start_main, 静态构造器不执行: 用零初始化 BSS 定长数组替代 AlignMem 动态分配
template <typename T, size_t LEN, size_t ALIGN = 64>
struct StaticArr
{
alignas(ALIGN) T data[LEN];
T &operator[](size_t i){ return data[i]; }
const T &operator[](size_t i) const{ return data[i]; }
T *begin(){ return data; }
T *end(){ return data + LEN; }
const T *begin() const{ return data; }
const T *end() const{ return data + LEN; }
constexpr size_t size() const{ return LEN; }
};
// ary1/ary2 放同一对象内, 中间垫 1KB 使二者错开 1KB mod 4096, 防止 L1 set 全冲突
// (saffah 实测: 页对齐时蝶形 29.4 cyc -> 错开 1KB 后 19.4 cyc)
struct WorkBuf
{
StaticArr<Float64, N> ary1;
char pad[832];
StaticArr<Float64, N> ary2;
};
static WorkBuf work;
static auto &ary1 = work.ary1;
static auto &ary2 = work.ary2;
char *big_mul(const char *str1, size_t len1, const char *str2, size_t len2, char *res, size_t &res_len){
constexpr size_t BLOCK = 4, BASE = 10000;
size_t block_len1 = (len1 + BLOCK - 1) / BLOCK, block_len2 = (len2 + BLOCK - 1) / BLOCK;
size_t conv_len = block_len1 + block_len2 - 1, fft_len = hint::int_ceil2(conv_len);
fft_len = std::max<size_t>(fft_len, 256);
size_t shift = parse_str4_to_f64(str1, len1, &ary1[0]);
shift += parse_str4_to_f64(str2, len2, &ary2[0]);
fill_zero(ary1.begin() + block_len1, ary1.begin() + N / 2);
fill_zero(ary2.begin() + block_len2, ary2.begin() + N / 2);
real_conv_avx<true>(ary1.begin(), ary2.begin(), fft_len);
return res + conv_to_str_base10000((uint64_t *)ary1.begin(), conv_len, shift, res, res_len);
}
size_t preserve_strlen(size_t len1, size_t len2){
constexpr size_t BLOCK = 4;
size_t block_len1 = (len1 + BLOCK - 1) / BLOCK, block_len2 = (len2 + BLOCK - 1) / BLOCK;
return (block_len1 + block_len2) * BLOCK;}
}
// duck.ac 判题机 DI 描述符 (与 duck_rk1.cpp 完全一致, packed):
// s/sn=输入缓冲, o/ol/os=输出缓冲/容量/实际长度
struct DI
{
unsigned long abi;
const char *s;
unsigned long sn;
char *o;
unsigned long ol;
unsigned long os;
char *e;
unsigned long el;
unsigned long es;
const char *IB;
unsigned long IBl;
char *OB;
unsigned long OBl;
unsigned long tsc;
} __attribute__((packed));
// AVX2 扫描: want_digit=1 找下一个数字字符, =0 找下一个非数字字符 (与 duck_rk1.cpp kb_scan 一致)
static inline long kb_scan(const char *s, long i, long sn, int want_digit)
{
const __m256i lo = _mm256_set1_epi8('0' - 1), hi = _mm256_set1_epi8('9' + 1);
if (i < sn)
{
while ((((uintptr_t)(s + i)) & 31) != 0)
{
if (i >= sn)
break;
if (((s[i] >= '0' && s[i] <= '9') ? 1 : 0) == want_digit)
return i;
i++;
}
long n = sn - 32;
if (want_digit)
{
for (; i <= n; i += 32)
{
__m256i v = _mm256_load_si256((const __m256i *)(s + i));
unsigned m = (unsigned)_mm256_movemask_epi8(
_mm256_and_si256(_mm256_cmpgt_epi8(v, lo), _mm256_cmpgt_epi8(hi, v)));
if (m)
return i + __builtin_ctz(m);
}
while (i < sn && (s[i] < '0' || s[i] > '9'))
i++;
}
else
{
for (; i <= n; i += 32)
{
__m256i v = _mm256_load_si256((const __m256i *)(s + i));
unsigned m = (unsigned)_mm256_movemask_epi8(
_mm256_and_si256(_mm256_cmpgt_epi8(v, lo), _mm256_cmpgt_epi8(hi, v)));
if (~m)
return i + __builtin_ctz(~m);
}
while (i < sn && s[i] >= '0' && s[i] <= '9')
i++;
}
}
return i;
}
// duck.ac DI 作业入口 (与 duck_rk1.cpp run_job 一致):
// kb_scan 定位两个恰好 1e6 位的数字, big_mul 卷积, 结果移到 d->o 头部, 补 '\n', 置 d->os
void run_job(DI *d)
{
const char *s = d->s;
long sn = (long)d->sn;
const long first = kb_scan(s, 0, sn, 1), second = kb_scan(s, first + 1000000, sn, 1);
if (second + 1000000 > sn)
return;
size_t res_len = preserve_strlen(1000000, 1000000);
auto begin = big_mul(s + first, 1000000, s + second, 1000000, d->o, res_len);
if (begin != d->o)
memmove(d->o, begin, res_len);
d->o[res_len] = '\n';
d->os = res_len + 1;
}
#ifndef NO_LOCAL_TEST
// duck.ac 入口 (与 duck_rk1.cpp 一致): 覆盖 __libc_start_main, 从启动块扫描
// magic 0x6b637564("duck") 取 DI, 跑完 syscall exit, 不经 stdio; Windows 本地不生效
extern "C" void __libc_start_main(void *m, int argc, char **argv)
{
(void)m;
unsigned long *p = (unsigned long *)(argv + argc + 1);
while (*p)
p++;
p++;
DI *d = 0;
for (int i = 0; i < 32 && p[0]; i++, p += 2)
if (p[0] == 0x6b637564UL)
{
d = (DI *)p[1];
break;
}
if (d)
string_util::run_job(d);
__asm__ volatile("syscall" ::"a"(60), "D"(0) : "rcx", "r11", "memory");
for (;;);
}
int main() { return 0; }
#endif
| Compilation | N/A | N/A | Compile Error | Score: N/A | 显示更多 |