const uint8_t *src) { // strictly speaking, static inline is a C-ism

uint32_t v1 = digit_to_val32[630 + src[0]];

uint32_t v2 = digit_to_val32[420 + src[1]];

uint32_t v3 = digit_to_val32[210 + src[2]];

uint32_t v4 = digit_to_val32[0 + src[3]];

return v1 | v2 | v3 | v4;

if (cp <= 0x7F) {

c[0] = cp;

return 1; // ascii

}

if (cp <= 0x7FF) {

c[0] = (cp >> 6) + 192;

c[1] = (cp & 63) + 128;

return 2; // universal plane

// Surrogates are treated elsewhere...

//} //else if (0xd800 <= cp && cp <= 0xdfff) {

// return 0; // surrogates // could put assert here

} else if (cp <= 0xFFFF) {

c[0] = (cp >> 12) + 224;

c[1] = ((cp >> 6) & 63) + 128;

c[2] = (cp & 63) + 128;

return 3;

} else if (cp <= 0x10FFFF) { // if you know you have a valid code point, this

// is not needed

c[0] = (cp >> 18) + 240;

c[1] = ((cp >> 12) & 63) + 128;

c[2] = ((cp >> 6) & 63) + 128;

c[3] = (cp & 63) + 128;

return 4;

}

// will return 0 when the code point was too large.

return 0; // bad r

std::FILE *fp = std::fopen(filename.c_str(), "rb");

if (fp != nullptr) {

if(std::fseek(fp, 0, SEEK_END) < 0) {

std::fclose(fp);

throw std::runtime_error("cannot seek in the file");

}

long llen = std::ftell(fp);

if((llen < 0) || (llen == LONG_MAX)) {

std::fclose(fp);

throw std::runtime_error("cannot tell where we are in the file");

}

size_t len = (size_t) llen;

padded_string s(len);

if (s.data() == nullptr) {

std::fclose(fp);

throw std::runtime_error("could not allocate memory");

}

std::rewind(fp);

size_t readb = std::fread(s.data(), 1, len, fp);

std::fclose(fp);

if (readb != len) {

throw std::runtime_error("could not read the data");

}

return s;

}

throw std::runtime_error("could not load corpus");

unsigned char *out) {

size_t i = 0, pos = 0;

uint8_t quote = 0;

uint8_t nonescape = 1;

while (i < how_many) {

unsigned char c = bytes[i];

uint8_t *meta = jump_table + 3 * c;

quote = quote ^ (meta[0] & nonescape);

out[pos] = c;

pos += meta[2] | quote;

i += 1;

nonescape = (~nonescape) | (meta[1]);

}

return pos;

__m256i mask) {

__m256i cmp_res_0 = _mm256_cmpeq_epi8(input_lo, mask);

uint64_t res_0 = static_cast<uint32_t>(_mm256_movemask_epi8(cmp_res_0));

__m256i cmp_res_1 = _mm256_cmpeq_epi8(input_hi, mask);

uint64_t res_1 = _mm256_movemask_epi8(cmp_res_1);

return res_0 | (res_1 << 32);

int mask1 = mask & 0xFF;

int mask2 = (mask >> 8) & 0xFF;

__m128i shufmask = _mm_castps_si128(

_mm_loadh_pi(_mm_castsi128_ps(_mm_loadl_epi64(

(const __m128i *)(thintable_epi8 + mask1))),

(const __m64 *)(thintable_epi8 + mask2)));

shufmask =

_mm_add_epi8(shufmask, _mm_set_epi32(0x08080808, 0x08080808, 0, 0));

__m128i pruned = _mm_shuffle_epi8(x, shufmask);

intptr_t popx2 = BitsSetTable256mul2[mask1];

__m128i compactmask =

_mm_loadu_si128((const __m128i *)(pshufb_combine_table + popx2 * 8));

return _mm_shuffle_epi8(pruned, compactmask);

// Useful constant masks

const uint64_t even_bits = 0x5555555555555555ULL;

const uint64_t odd_bits = ~even_bits;

uint8_t *initout(out);

uint64_t prev_iter_ends_odd_backslash =

0ULL; // either 0 or 1, but a 64-bit value

uint64_t prev_iter_inside_quote = 0ULL; // either all zeros or all ones

size_t idx = 0;

if (len >= 64) {

size_t avx_len = len - 63;

for (; idx < avx_len; idx += 64) {

__m256i input_lo =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buf + idx + 0));

__m256i input_hi =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buf + idx + 32));

uint64_t bs_bits = cmp_mask_against_input_mini(input_lo, input_hi,

_mm256_set1_epi8('\\'));

uint64_t start_edges = bs_bits & ~(bs_bits << 1);

uint64_t even_start_mask = even_bits ^ prev_iter_ends_odd_backslash;

uint64_t even_starts = start_edges & even_start_mask;

uint64_t odd_starts = start_edges & ~even_start_mask;

uint64_t even_carries = bs_bits + even_starts;

uint64_t odd_carries;

bool iter_ends_odd_backslash =

add_overflow(bs_bits, odd_starts, &odd_carries);

odd_carries |= prev_iter_ends_odd_backslash;

prev_iter_ends_odd_backslash = iter_ends_odd_backslash ? 0x1ULL : 0x0ULL;

uint64_t even_carry_ends = even_carries & ~bs_bits;

uint64_t odd_carry_ends = odd_carries & ~bs_bits;

uint64_t even_start_odd_end = even_carry_ends & odd_bits;

uint64_t odd_start_even_end = odd_carry_ends & even_bits;

uint64_t odd_ends = even_start_odd_end | odd_start_even_end;

uint64_t quote_bits = cmp_mask_against_input_mini(input_lo, input_hi,

_mm256_set1_epi8('"'));

quote_bits = quote_bits & ~odd_ends;

uint64_t quote_mask = _mm_cvtsi128_si64(_mm_clmulepi64_si128(

_mm_set_epi64x(0ULL, quote_bits), _mm_set1_epi8(0xFF), 0));

quote_mask ^= prev_iter_inside_quote;

prev_iter_inside_quote = static_cast<uint64_t>(

static_cast<int64_t>(quote_mask) >>

63); // might be undefined behavior, should be fully defined in C++20,

// ok according to John Regher from Utah University

const __m256i low_nibble_mask = _mm256_setr_epi8(

// 0 9 a b c d

16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 1, 2, 9, 0, 0, 16, 0, 0, 0, 0, 0,

0, 0, 0, 8, 12, 1, 2, 9, 0, 0);

const __m256i high_nibble_mask = _mm256_setr_epi8(

// 0 2 3 5 7

8, 0, 18, 4, 0, 1, 0, 1, 0, 0, 0, 3, 2, 1, 0, 0, 8, 0, 18, 4, 0, 1, 0,

1, 0, 0, 0, 3, 2, 1, 0, 0);

__m256i whitespace_shufti_mask = _mm256_set1_epi8(0x18);

__m256i v_lo = _mm256_and_si256(

_mm256_shuffle_epi8(low_nibble_mask, input_lo),

_mm256_shuffle_epi8(high_nibble_mask,

_mm256_and_si256(_mm256_srli_epi32(input_lo, 4),

_mm256_set1_epi8(0x7f))));

__m256i v_hi = _mm256_and_si256(

_mm256_shuffle_epi8(low_nibble_mask, input_hi),

_mm256_shuffle_epi8(high_nibble_mask,

_mm256_and_si256(_mm256_srli_epi32(input_hi, 4),

_mm256_set1_epi8(0x7f))));

__m256i tmp_ws_lo = _mm256_cmpeq_epi8(

_mm256_and_si256(v_lo, whitespace_shufti_mask), _mm256_set1_epi8(0));

__m256i tmp_ws_hi = _mm256_cmpeq_epi8(

_mm256_and_si256(v_hi, whitespace_shufti_mask), _mm256_set1_epi8(0));

uint64_t ws_res_0 =

static_cast<uint32_t>(_mm256_movemask_epi8(tmp_ws_lo));

uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi);

uint64_t whitespace = ~(ws_res_0 | (ws_res_1 << 32));

whitespace &= ~quote_mask;

uint64_t non_whitespace = ~whitespace;

__m128i x1 = _mm256_extracti128_si256(input_lo, 0);

__m128i x2 = _mm256_extracti128_si256(input_lo, 1);

__m128i x3 = _mm256_extracti128_si256(input_hi, 0);

__m128i x4 = _mm256_extracti128_si256(input_hi, 1);

int mask1 = non_whitespace & 0xFFFF;

int mask2 = (non_whitespace >> 16) & 0xFFFF;

int mask3 = (non_whitespace >> 32) & 0xFFFF;

int mask4 = (non_whitespace >> 48) & 0xFFFF;

x1 = skinnycleanm128(x1, mask1);

x2 = skinnycleanm128(x2, mask2);

x3 = skinnycleanm128(x3, mask3);

x4 = skinnycleanm128(x4, mask4);

int pop1 = hamming(non_whitespace & 0xFFFF);

int pop2 = hamming(non_whitespace & UINT64_C(0xFFFFFFFF));

int pop3 = hamming(non_whitespace) & UINT64_C(0xFFFFFFFFFFFF));

int pop4 = hamming(non_whitespace);

_mm_storeu_si128(reinterpret_cast<__m128i *>(out), x1);

_mm_storeu_si128(reinterpret_cast<__m128i *>(out + pop1), x2);

_mm_storeu_si128(reinterpret_cast<__m128i *>(out + pop2), x3);

_mm_storeu_si128(reinterpret_cast<__m128i *>(out + pop3), x4);

out += pop4;

}

}

// we finish off the job... copying and pasting the code is not ideal here,

// but it gets the job done.

if (idx < len) {

uint8_t buffer[64];

memset(buffer, 0, 64);

memcpy(buffer, buf + idx, len - idx);

__m256i input_lo =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buffer));

__m256i input_hi =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buffer + 32));

uint64_t bs_bits =

cmp_mask_against_input_mini(input_lo, input_hi, _mm256_set1_epi8('\\'));

uint64_t start_edges = bs_bits & ~(bs_bits << 1);

uint64_t even_start_mask = even_bits ^ prev_iter_ends_odd_backslash;

uint64_t even_starts = start_edges & even_start_mask;

uint64_t odd_starts = start_edges & ~even_start_mask;

uint64_t even_carries = bs_bits + even_starts;

uint64_t odd_carries;

// bool iter_ends_odd_backslash =

add_overflow(bs_bits, odd_starts, &odd_carries);

odd_carries |= prev_iter_ends_odd_backslash;

// prev_iter_ends_odd_backslash = iter_ends_odd_backslash ? 0x1ULL : 0x0ULL;

// // we never use it

uint64_t even_carry_ends = even_carries & ~bs_bits;

uint64_t odd_carry_ends = odd_carries & ~bs_bits;

uint64_t even_start_odd_end = even_carry_ends & odd_bits;

uint64_t odd_start_even_end = odd_carry_ends & even_bits;

uint64_t odd_ends = even_start_odd_end | odd_start_even_end;

uint64_t quote_bits =

cmp_mask_against_input_mini(input_lo, input_hi, _mm256_set1_epi8('"'));

quote_bits = quote_bits & ~odd_ends;

uint64_t quote_mask = _mm_cvtsi128_si64(_mm_clmulepi64_si128(

_mm_set_epi64x(0ULL, quote_bits), _mm_set1_epi8(0xFF), 0));

quote_mask ^= prev_iter_inside_quote;

// prev_iter_inside_quote = (uint64_t)((int64_t)quote_mask >> 63);// we

// don't need this anymore

__m256i mask_20 = _mm256_set1_epi8(0x20); // c==32