Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/bmfunc_8h_source.html below:

NCBI C++ ToolKit: include/util/bitset/bmfunc.h Source File

<

LWA=false,

RWA=false>

mem_used = (capacity *

(

));

(!safe_inc) safe_inc = 1024;

std::cout <<

[

] <<

;

std::cout << std::endl;

<

First,

Second>

<

BI_TYPE>

<

RTYPE>

<

RTYPE>

RTYPE idx = bm::get_super_block_start<RTYPE>(

);

=

- ((

>> 1) & 033333333333)

- ((

>> 2) & 011111111111);

((

+ (

>> 3)) & 030707070707) % 63;

x = x - ((x >> 1) & m1);

y = y - ((y >> 1) & m1);

u = u - ((u >> 1) & m1);

v = v - ((v >> 1) & m1);

x = (x & m2) + ((x >> 2) & m2);

y = (y & m2) + ((y >> 2) & m2);

u = (u & m2) + ((u >> 2) & m2);

v = (v & m2) + ((v >> 2) & m2);

x = (x & m3) + ((x >> 4) & m3);

u = (u & m3) + ((u >> 4) & m3);

x & 0x000001FFU;

<

T,

F>

(

sub_octet = 0; w != 0; w >>= 4, sub_octet += 4)

func(sub_octet, sub_octet + 1);

func(sub_octet, sub_octet + 2);

func(sub_octet + 1, sub_octet + 2);

func(sub_octet, sub_octet + 1, sub_octet + 2);

func(sub_octet, sub_octet + 3);

func(sub_octet + 1, sub_octet + 3);

func(sub_octet, sub_octet + 1, sub_octet + 3);

func(sub_octet + 2, sub_octet + 3);

func(sub_octet, sub_octet + 2, sub_octet + 3);

func(sub_octet + 1, sub_octet + 2, sub_octet + 3);

func(sub_octet, sub_octet + 1, sub_octet + 2, sub_octet + 3);

<

T,

F>

(

octet = 0; w != 0; w >>= 8, octet += 8)

(w & 1) func(octet + 0);

(w & 2) func(octet + 1);

(w & 4) func(octet + 2);

(w & 8) func(octet + 3);

(w & 16) func(octet + 4);

(w & 32) func(octet + 5);

(w & 64) func(octet + 6);

(w & 128) func(octet + 7);

(

sub_octet = 0; w; w >>= 4, sub_octet+=4)

bits[

++] = 0 + sub_octet;

bits[

++] = 1 + sub_octet;

bits[

] = 0 + sub_octet;

bits[

+1] = 1 + sub_octet;

bits[

++] = 2 + sub_octet;

bits[

+0] = 0 + sub_octet;

bits[

+1] = 2 + sub_octet;

bits[

+0] = 1 + sub_octet;

bits[

+1] = 2 + sub_octet;

bits[

+0] = 0 + sub_octet;

bits[

+1] = 1 + sub_octet;

bits[

+2] = 2 + sub_octet;

bits[

++] = 3 + sub_octet;

bits[

+0] = 0 + sub_octet;

bits[

+1] = 3 + sub_octet;

bits[

+0] = 1 + sub_octet;

bits[

+1] = 3 + sub_octet;

bits[

+0] = 0 + sub_octet;

bits[

+1] = 1 + sub_octet;

bits[

+2] = 3 + sub_octet;

bits[

+0] = 2 + sub_octet;

bits[

+1] = 3 + sub_octet;

bits[

+0] = 0 + sub_octet;

bits[

+1] = 2 + sub_octet;

bits[

+2] = 3 + sub_octet;

bits[

+0] = 1 + sub_octet;

bits[

+1] = 2 + sub_octet;

bits[

+2] = 3 + sub_octet;

bits[

+0] = 0 + sub_octet;

bits[

+1] = 1 + sub_octet;

bits[

+2] = 2 + sub_octet;

bits[

+3] = 3 + sub_octet;

bitscan_nibble_gcc(

w,

* bits)

* d_table[] = { &&l0,

&&l1, &&l3_1, &&l3, &&l7_1, &&l5, &&l7_0, &&l7, &&l15_1,

&&l9, &&l11_0, &&l11, &&l15_0, &&l13, &&l14, &&l15 };

(

sub_octet = 0; w; w >>= 4, sub_octet+=4)

*d_table[w & 15];

bits[

++] = sub_octet;

bits[

++] = sub_octet;

bits[

++] = 1 + sub_octet;

bits[

++] = sub_octet;

bits[

++] = sub_octet;

bits[

++] = 1 + sub_octet;

bits[

++] = 2 + sub_octet;

bits[

++] = sub_octet;

bits[

++] = sub_octet;

bits[

++] = 1 + sub_octet;

bits[

++] = 3 + sub_octet;

bits[

++] = sub_octet;

bits[

++] = 1 + sub_octet;

bits[

++] = 0 + sub_octet;

bits[

++] = 1 + sub_octet;

bits[

++] = 2 + sub_octet;

bits[

++] = 3 + sub_octet;

<

B>

[0] = (

)bit_idx0;

[1] = (

)bit_idx1;

[0] = (

)bit_idx0;

[1] = (

)bit_idx1;

[2] = (

)bit_idx2;

[0] = (

)bit_idx0;

[1] = (

)bit_idx1;

[2] = (

)bit_idx2;

[3] = (

)bit_idx3;

dest[nword] |= unsigned(1u << nbit);

dest[nword] &= ~(unsigned(1u << nbit));

(block[nword] >> nbit) & 1u;

<

T,

B>

(

)(func.

() - bits);

<

T,

B>

(

)(func.

() - bits);

<

B>

(

)pos;

<

B>

(

)pos;

<

B>

pos = 0;

<

B>

pos = 0;

<

B,

OT>

pos = 0;

<

B>

pos = 0;

<

B>

pos = 0;

<

V,

B>

constexpr (

(V) == 8)

constexpr (

(V) == 8)

(

= 0; w; w >>=1ull, ++

)

rank -= unsigned(w & 1ull);

= w & -w;

BMI2_SELECT64(w, rank);

BMI2_SELECT64(w, rank);

BMI2_SELECT64(w, rank);

BMI2_SELECT64(w, rank);

(

= from;

<= to; ++

)

m |= (1ull << (

/ 1024));

((~0ull) >> (63 - (digest_to - digest_from))) << digest_from;

bitpos_from,

bitpos_to)

!(digest &

);

curr = digest &

;

(curr && curr !=

)

(

= 0;

< 64; ++

)

block[off] = block[off+1] = block[off+2] = block[off+3] =

;

(

= 0;

< 64; ++

)

w = block[off+j+0] | block[off+j+1] |

block[off+j+2] | block[off+j+3];

digest0 |= (

<<

);

digest &= all_zero ? ~(

<< wave) : digest;

src_u->w64[j+0] | src_u->w64[j+1] | src_u->w64[j+2] | src_u->w64[j+3];

digest &= w64 ? digest : ~(

<< wave);

t_wave = 0;

(; sub_block < sub_block_end; t_sub_block+=4, sub_block+=4)

t_sub_block[0] = sub_block[0];

t_sub_block[1] = sub_block[1];

t_sub_block[2] = sub_block[2];

t_sub_block[3] = sub_block[3];

(; t_sub_block < t_sub_block_end; t_sub_block+=4)

s_wave = 0;

* sub_block = block + s_off;

(; sub_block < sub_block_end; t_sub_block+=4, sub_block+=4)

t_sub_block[0] = sub_block[0];

t_sub_block[1] = sub_block[1];

t_sub_block[2] = sub_block[2];

t_sub_block[3] = sub_block[3];

(; t_sub_block < t_sub_block_end; t_sub_block+=4)

t_sub_block[0] = 0; t_sub_block[1] = 0;

t_sub_block[2] = 0; t_sub_block[3] = 0;

(

(op) >=

(

));

::memset(_p, 0xFF,

(_p));

constexpr (

(

*) == 8)

magic_mask = 0xFFFFfffeFFFFfffe;

::memcpy(&_p_fullp, &magic_mask,

(magic_mask));

_s[

] =

*

(magic_mask);

magic_mask = 0xFFFFfffe;

::memcpy(&_p_fullp, &magic_mask,

(magic_mask));

_s[

] =

*

(magic_mask);

constexpr (

(

*) == 8)

w =

(bp);

w =

(bp);

<

N>

unroll_factor = 4;

= (

- start);

len_unr =

- (

% unroll_factor);

(k = 0; k < len_unr; k+=unroll_factor)

*pos = k + start + 1;

*pos = k + start + 2;

*pos = k + start + 3;

(; k <

; ++k)

(; start <

; ++start)

res = (w1 & 1) - (w2 & 1);

(res != 0)

res;

diff? ( (

& diff & -diff)? 1 : -1 ) : 0;

(blk[0] | blk[1] | blk[2] | blk[3])

}

(blk < blk_end);

<

T>

glevel_len[(*

>> 1) & 3];

<

T>

glevel_len[(*

>> 1) & 3]-4;

<

T>

((*

>> 1) & 3u);

<

T>

is_set = (*buf) & 1u;

end =

((*

) >> 3u);

is_set ^=

((end-1) & 1u);

<

T>

is_set = (*buf) & 1u;

<

T>

end = ((*buf) >> 3);

= end - start;

(;

>= 64;

= end - start)

mid = (start + end) >> 1;

(

[mid] < pos)

(

[mid = (start + end) >> 1] < pos)

(

[mid = (start + end) >> 1] < pos)

(

[mid = (start + end) >> 1] < pos)

(;

>= 16;

= end - start)

(

mid = (start + end) >> 1;

[mid] < pos)

(

mid = (start + end) >> 1;

[mid] < pos)

(;

; ++start)

(

[start] >= pos)

*is_set = ((*buf) & 1) ^ ((start-1) & 1);

<

T>

end = 1 + ((*buf) >> 3);

(end - start < 10)

sv = *

& 1;

sv1= sv ^ 1;

(

[1] >= pos)

sv;

(

[2] >= pos)

sv1;

(

[3] >= pos)

sv;

(

[4] >= pos)

sv1;

(

[5] >= pos)

sv;

(

[6] >= pos)

sv1;

(

[7] >= pos)

sv;

(

[8] >= pos)

sv1;

(

mid = (start + end) >> 1;

[mid] < pos)

}

(start != end);

((*

) & 1) ^ ((--start) & 1);

<

T>

<

T,

N,

F>

(nb_from > nb_to)

(i_from >= top_size)

(i_to >= top_size)

i_to = unsigned(top_size-1);

(

= i_from;

<= i_to; ++

)

** blk_blk = root[

];

j = (

== i_from) ? j_from : 0;

(!j && (

!= i_to))

((

== i_to) && (j == j_to))

j = (

== i_from) ? j_from : 0;

((

== i_to) && (j == j_to))

<

T,

F>

F::size_type size_type;

(

= 0;

< size1; ++

)

** blk_blk = root[

];

.on_empty_top(

);

.on_non_empty_top(

);

non_empty_top = 0;

* blk0 = blk_blk[j + 0];

* blk1 = blk_blk[j + 1];

* blk2 = blk_blk[j + 2];

* blk3 = blk_blk[j + 3];

size_type block_idx =

+ j + 0;

(blk0, block_idx);

.on_empty_block(block_idx);

(blk1, block_idx + 1);

.on_empty_block(block_idx + 1);

(blk2, block_idx + 2);

.on_empty_block(block_idx + 2);

(blk3, block_idx + 3);

.on_empty_block(block_idx + 3);

.on_empty_block(

+ j + 0);

.on_empty_block(

+ j + 1);

.on_empty_block(

+ j + 2);

.on_empty_block(

+ j + 3);

* blk0 = blk_blk[j + 0];

* blk1 = blk_blk[j + 1];

size_type block_idx =

+ j + 0;

(blk0, block_idx);

.on_empty_block(block_idx);

(blk1, block_idx);

.on_empty_block(block_idx);

.on_empty_block(

+ j + 0);

.on_empty_block(

+ j + 1);

(blk_blk[j],

+ j);

.on_empty_block(

+ j);

(non_empty_top == 0)

.on_empty_top(

);

<

T,

F>

(

= 0;

< size1; ++

)

((blk_blk = root[

])!=0)

* blk0 = blk_blk[j + 0];

* blk1 = blk_blk[j + 1];

* blk0 = blk_blk[j + 2];

* blk1 = blk_blk[j + 3];

(

= 0;

< size1; ++

)

((blk_blk = root[

]) != 0)

__m256i w0 = _mm256_loadu_si256((__m256i*)(blk_blk + j));

(!_mm256_testz_si256(w0, w0))

* blk0 = blk_blk[j + 0];

* blk1 = blk_blk[j + 1];

* blk2 = blk_blk[j + 2];

* blk3 = blk_blk[j + 3];

(

= 0;

< size1; ++

)

((blk_blk = root[

])!=0)

<

T,

BI,

F>

(BI

= 0;

< size1; ++

)

** blk_blk = root[

];

(

(blk_blk[j], block_idx))

<

T,

F,

BLOCK_IDX>

BLOCK_IDX block_idx = start;

(

= 0;

< size1; ++

)

** blk_blk = root[

];

(blk_blk[j], block_idx);

<

T>

<

T>

(

= 1;

< arr_len; ++

)

<

T>

(arr_len <= wlen)

min_w_prev = ~0u;

(

= 1;

< wlen; ++

)

min_w_prev =

;

min_w_prev -=

(min_w_prev);

(

= wlen;

< arr_len; ++wave,

+=wlen)

(

+ wlen > arr_len)

= arr_len % wlen;

min_w = ~0u;

(

j = 0; j < wlen; ++j)

(

<= min_w_prev)

(min_w_prev && (min_w > min0))

min_w_prev = (min_w > min0) ? min_w - 1 : min0;

<

T>

min_w_prev =

(~0u);

(

= 1;

< wlen; ++

)

min_w_prev =

;

tarr[

] =

[

] - min0 - delta_acc;

min_w_prev -=

(min_w_prev);

(

wave = 1,

=wlen;

< arr_len;

+=wlen, ++wave)

(

+ wlen > arr_len)

= arr_len % wlen;

(

j = 0; j < wlen; ++j)

tarr[

+j] =

[

+j] - min_w_prev - delta_acc;

delta_acc += min_w_prev;

tarr[

+j] =

[

+j] - min0 - delta_acc;

min_w_prev = (min_w > min0) ? min_w - 1 : min0;

<

T>

min_w_prev = ~0u;

(

= 1;

< wlen; ++

)

[

] += min0 + delta_acc;

min_w_prev =

;

min_w_prev -=

(min_w_prev);

(

= wlen;

< arr_len; ++wave,

+=wlen)

(

+ wlen > arr_len)

= arr_len % wlen;

min_w = ~0u;

(

j = 0; j < wlen; ++j)

[

+j] += (

)(min_w_prev + delta_acc);

delta_acc += (

)min_w_prev;

[

+j] += min0 + delta_acc;

min_w_prev = (min_w > min0) ? min_w - 1 : min0;

<

T>

* hist,

hist_len)

(

= 1;

< arr_len; ++

)

(

< hist_len)

<

T>

* arr_dst,

& dst_len,

*

,

arr_len,

d1_len = dst_len = 0;

arr_dst[dst_len] =

[dst_len];

(

= 1;

< arr_len; ++

)

(

<= ex_max_delta)

arr_d1[d1_len++] =

[

];

arr_dst[dst_len++] =

[

];

<

T>

tarr[0] =

[0] - delta_acc;

(

= 1;

< arr_len; ++

)

tarr[

] =

[

] - min0 - delta_acc;

<

T>

[0] =

[0] + delta_acc;

(

= 1;

< arr_len; ++

)

[

] += min0 + delta_acc;

<

T>

* pcurr =

;

dsize = (*pcurr >> 3);

* pend = pcurr + dsize;

(++pcurr; pcurr <= pend; pcurr++)

= *pcurr - *(pcurr-1);

= *pcurr - *(pcurr-1);

<

T>

* hist0,

* hist1,

hist_len

* pcurr =

;

is_set = (*pcurr & 1u);

* pend = pcurr + dsize;

(

< hist_len)

(++pcurr; pcurr <= pend; pcurr++, is_set ^= 1u)

= *pcurr - *(pcurr-1);

(

< hist_len)

++pcurr; is_set ^= 1u;

= *pcurr - *(pcurr-1);

(

< hist_len)

<

T>

<

T>

* hist0,

* hist1,

* tbuf,

* ex0_arr,

* ex1_arr,

& ex0_cnt,

& ex1_cnt)

ex0_first =

;

ex0_cnt = ex1_cnt = 0;

dsize =

;

::memcpy(tbuf,

, (1+dsize) *

(

));

(

= 1;

< h_limit; ++

)

ex0_cnt_s {ex0_cnt}, ex1_cnt_s {ex1_cnt};

h0_flag{0}, h1_flag{0};

(hist0[

] < hist1[

])

(hist0[

] == 0)

* pcurr = tbuf+1;

dsize = (*tbuf >> 3);

* pend = pcurr + dsize;

is_set = (*tbuf & 1u);

(

<

&& !is_set)

(

j = 0; j <= *pcurr; ++j)

ex0_arr[ex0_cnt++] = (

)j;

(++pcurr, is_set ^= 1u; pcurr <= pend; ++pcurr,is_set ^= 1u)

= *pcurr - *(pcurr-1);

(

<=

&& !is_set)

(

j = *(pcurr-1)+1; j <= *pcurr; ++j)

ex0_arr[ex0_cnt++] = (

)j;

++pcurr; is_set ^= 1u;

= *pcurr - *(pcurr-1);

(

<=

&& !is_set)

(

j = *(pcurr-1)+1; j <= *pcurr; ++j)

ex0_arr[ex0_cnt++] = (

)j;

new_len = dsize;

(

k = ex0_cnt_s; k < ex0_cnt; ++k)

(hist1[

] == 0)

* pcurr = tbuf+1;

* pend = pcurr + (*tbuf >> 3);

is_set = (*tbuf & 1u);

(

<

&& is_set)

(

j = 0; j <= *pcurr; ++j)

ex1_arr[ex1_cnt++] = (

)j;

(++pcurr; pcurr <= pend; ++pcurr,is_set ^= 1u)

= *pcurr - *(pcurr-1);

(

<=

&& is_set)

(

j = *(pcurr-1)+1; j <= *pcurr; ++j)

ex1_arr[ex1_cnt++] = (

)j;

++pcurr; is_set ^= 1u;

= *pcurr - *(pcurr-1);

(

<=

&& is_set)

(

j = *(pcurr-1)+1; j <= *pcurr; ++j)

ex1_arr[ex1_cnt++] = (

)j;

new_len = dsize;

(

k = ex1_cnt_s; k < ex1_cnt; ++k)

(dsize >= new_len); (void) new_len;

ex_limit,

* ex_sum)

(

= 0; (

< hist_len) && (*ex_sum < ex_limit); ++

)

*ex_sum += hist0[

] + hist1[

];

<

T>

* pcurr =

;

dsize = (*pcurr >> 3);

* pend = pcurr + dsize;

= *tcurr = (*pcurr - min0); (void)

;

(; pcurr <= pend; )

= *tcurr = *pcurr - min1 - delta_acc;

= *tcurr = *pcurr - min0 - delta_acc;

<

T>

dsize = (*pcurr >> 3);

* pend = pcurr + dsize;

*pcurr = (*pcurr + min0);

(++pcurr; pcurr <= pend; )

*pcurr = *pcurr + min1 + delta_acc;

*pcurr = *pcurr + min0 + delta_acc;

<

T>

* pcurr =

;

dsize = (*pcurr >> 3);

* pend = pcurr + dsize;

(; pcurr <= pend; pcurr++)

<

T>

* pcurr =

;

dsize = (*pcurr >> 3);

* pend = pcurr + dsize;

bits_counter = 0;

bits_counter += *pcurr + 1;

(++pcurr; pcurr <= pend; pcurr += 2)

bits_counter += *pcurr - *(pcurr-1);

bits_counter;

<

T>

* pcurr =

;

dsize = (*pcurr >> 3);

first_one = *

& 1;

unr_factor = 32;

waves = (dsize-2) / unr_factor;

unr_factor = 16;

waves = (dsize - 2) / unr_factor;

unr_factor = 8;

waves = (dsize - 2) / unr_factor;

(

= 0;

< waves;

+= unr_factor)

+= pcurr[0] - pcurr[0 - 1];

+= pcurr[2] - pcurr[2 - 1];

+= pcurr[4] - pcurr[4 - 1];

+= pcurr[6] - pcurr[6 - 1];

pcurr += unr_factor;

* pend =

+ dsize;

( ; pcurr <= pend ; pcurr+=2)

+= *pcurr - *(pcurr - 1);

<

T,

RIGHT_END = false>

is_set, bits_counter, prev_gap;

is_set = ~(is_set - 1u);

* pcurr =

+ start_pos;

(right <= *pcurr)

bits_counter = unsigned(right - left + 1u) & is_set;

bits_counter = unsigned(*pcurr - left + 1u) & is_set;

constexpr (RIGHT_END)

(prev_gap = *pcurr++ ;

; prev_gap = *pcurr++)

bits_counter += (is_set ^= ~0u) & (*pcurr - prev_gap);

(prev_gap = *pcurr++; right > *pcurr; prev_gap = *pcurr++)

bits_counter += (is_set ^= ~0u) & (*pcurr - prev_gap);

bits_counter += unsigned(right - prev_gap) & (is_set ^ ~0u);

bits_counter;

<

T>

start_pos,

is_set_c, pos;

= (pos == (start_pos) &&

(is_set) ==

(is_set_c));

(

(is_set) ==

(is_set_c));

<

T>

left,

right,

hint)

is_set, bits_counter, prev_gap;

is_set = ~(is_set - 1u);

start_pos = hint >> 1;

* pcurr =

+ start_pos;

(right <= *pcurr)

bits_counter = unsigned(right - left + 1u) & is_set;

bits_counter = unsigned(*pcurr - left + 1u) & is_set;

(prev_gap = *pcurr++; right > *pcurr; prev_gap = *pcurr++)

bits_counter += (is_set ^= ~0u) & (*pcurr - prev_gap);

bits_counter += unsigned(right - prev_gap) & (is_set ^ ~0u);

bits_counter;

<

T>

*

pcurr =

+ start_pos;

(right <= *pcurr);

<

T>

*

pcurr =

+ start_pos;

(right <= *pcurr)

<

T>

* pcurr =

+ start_pos;

(!is_set || (right != *pcurr) || (start_pos <= 1))

(*pcurr != left-1)

<

T>

*pos =

[start_pos];

<

T>

*pos =

[start_pos]+1;

<

T>

*pos =

[start_pos];

<

T,

SIZE_TYPE>

* pcurr = block;

* pend = pcurr + (*pcurr >> 3);

bits_counter = 0;

start_pos =

(block, nbit_from, &is_set);

is_set = ~(is_set - 1u);

pcurr = block + start_pos;

bits_counter += unsigned(*pcurr - nbit_from + 1u) & is_set;

(bits_counter >= rank)

nbit_pos = nbit_from + unsigned(rank) - 1u;

rank -= bits_counter;

prev_gap = *pcurr++;

(is_set ^= ~0u; pcurr <= pend; is_set ^= ~0u)

bits_counter = (*pcurr - prev_gap) & is_set;

(bits_counter >= rank)

nbit_pos = prev_gap + unsigned(rank);

rank -= bits_counter;

prev_gap = *pcurr++;

<

T,

TCORRECT=false>

bits_counter, prev_gap;

is_set = ~((unsigned(*

) & 1u) - 1u);

* pcurr =

+ 1;

(right <= *pcurr)

bits_counter = (right + 1u) & is_set;

bits_counter = (*pcurr + 1u) & is_set;

prev_gap = *pcurr++;

(is_set ^= ~0u; right > *pcurr; is_set ^= ~0u, prev_gap = *pcurr++)

bits_counter += (*pcurr - prev_gap) & is_set;

bits_counter += (right - prev_gap) & is_set;

constexpr (TCORRECT)

bits_counter -= (is_set & unsigned(TCORRECT));

bits_counter;

<

T,

Func>

* pcurr = gap_buf;

* pend = pcurr + (*pcurr >> 3);

func((

)(

+ 1));

func((

)(*pcurr -

));

}

(++pcurr < pend);

<

T>

*dgap_buf++ = *gap_buf;

for_each_dgap<T, d_copy_func<T> >(gap_buf, copy_func);

<

T>

* pcurr = dgap_buf;

*gap_buf++ = *pcurr++;

= gap_header >> 3;

*gap_buf++ = gap_header;

* pend = pcurr +

;

*gap_buf = *pcurr++;

*gap_buf =

(*gap_buf - 1);

(++gap_buf; pcurr < pend; ++pcurr)

= *(gap_buf-1);

*gap_buf++ =

(*pcurr +

);

<

T>

* pcurr1 = buf1;

* pend1 = pcurr1 + (*pcurr1 >> 3);

bitval1 = *buf1 & 1;

* pcurr2 = buf2;

bitval2 = *buf2 & 1;

(pcurr1 <= pend1)

(*pcurr1 == *pcurr2)

(bitval1 != bitval2)

(bitval1) ? 1 : -1;

(bitval1 == bitval2)

(*pcurr1 < *pcurr2) ? -1 : 1;

(*pcurr1 < *pcurr2) ? 1 : -1;

(bitval1) ? 1 : -1;

<

T>

* pcurr1 = buf1;

* pend1 = pcurr1 + (*pcurr1 >> 3);

* pcurr2 = buf2;

(++pcurr1, ++pcurr2; pcurr1 <= pend1; ++pcurr1, ++pcurr2)

(*pcurr1 != *pcurr2)

*pos = 1 + ((*pcurr1 < *pcurr2) ? *pcurr1 : *pcurr2);

<

T,

F>

vect1_mask,

vect2_mask,

* cur1 = vect1;

* cur2 = vect2;

bitval1 = (

)((*cur1++ & 1) ^ vect1_mask);

bitval2 = (

)((*cur2++ & 1) ^ vect2_mask);

bitval = (

) F::op(bitval1, bitval2);

bitval_prev = bitval;

c1 = *cur1;

c2 = *cur2;

bitval = (

) F::op(bitval1, bitval2);

res += (bitval != bitval_prev);

bitval_prev = bitval;

bitval1 ^= 1; bitval2 ^= 1;

dlen = (unsigned)(res - dest);

*dest = (

)((*dest & 7) + (dlen << 3));

<

T,

F>

vect1_mask,

* cur1 = vect1;

* cur2 = vect2;

bitval1 = (*cur1++ & 1) ^ vect1_mask;

bitval2 = (*cur2++ & 1) ^ vect2_mask;

bitval = F::op(bitval1, bitval2);

bitval_prev = bitval;

bitval = F::op(bitval1, bitval2);

(bitval != bitval_prev)

bitval_prev = bitval;

bitval1 ^= 1; bitval2 ^= 1;

<

T,

F>

* cur1 = vect1;

* cur2 = vect2;

bitval1 = (*cur1++ & 1);

bitval2 = (*cur2++ & 1);

bitval =

= F::op(bitval1, bitval2);

bitval_prev = bitval;

bitval = F::op(bitval1, bitval2);

(bitval != bitval_prev)

bitval_prev = bitval;

+= res - res_prev;

++cur1; bitval1 ^= 1;

+= res - res_prev;

bitval1 ^= 1; bitval2 ^= 1;

<

T>

end = (

)(*

>> 3);

(*is_set ==

)

* pcurr =

+ curr;

* pprev = pcurr - 1;

* pend =

+ end;

pprev =

+ 1; pcurr = pprev + 1;

(curr > 1 && ((

)(*pprev))+1 == pos)

(*pprev == *pcurr)

{ *pprev++ = *pcurr++; }

(pcurr < pend);

end += (pcurr == pend);

(pcurr+2, pcurr, (end - curr + 1)*(

(

)));

pcurr[0] = (

)(pos-1);

pcurr[1] = (

)pos;

*

= (

)((*

& 7) + (end << 3));

<

T>

<

T>

end = (

) (*

>> 3);

* pcurr =

+ curr;

* pprev = pcurr - 1;

* pend =

+ end;

pprev =

+ 1; pcurr = pprev + 1;

(curr > 1 && ((

)(*pprev))+1 == pos)

(*pprev == *pcurr)

{ *pprev++ = *pcurr++; }

(pcurr < pend);

end += (pcurr == pend);

(pcurr+2, pcurr, (end - curr + 1)*(

(

)));

pcurr[0] = (

)(pos-1);

pcurr[1] = (

)pos;

*

= (

)((*

& 7) + (end << 3));

<

T>

end = (

)(*

>> 3);

* pcurr =

+ end;

* pprev = pcurr - 1;

pprev =

+ 1; pcurr = pprev + 1;

{ *pprev++ = *pcurr++; }

(pcurr < pend);

(((

)(*pprev))+1 == pos && (curr > 1) )

(*pprev == *pcurr)

(*pcurr == pos)

end += (pcurr == pend);

pcurr[0] = (

)(pos-1);

pcurr[1] = (

)pos;

*

= (

)((*

& 7) + (end << 3));

<

T>

co, gap_set_flag;

= (*

>> 3);

bitval = *

& 1;

gap_set_flag = (bitval != co_flag);

(;

<

; ++

)

<

T>

co, gap_set_flag;

gap_set_flag = (

!= is_set);

= (*

>> 3);

(;

<

; ++

)

<

T>

bitval = *

& 1;

= (*

>> 3);

(;

<

; ++

)

<

T>

*

= (

)((*

& 6u) + (1u << 3));

* pcurr =

+ 1;

*pcurr = (

)(curr - 1);

(

= 1;

<

; ++

)

(curr ==

+ 1)

*pcurr++ = (

)(curr-1);

gap_len = unsigned(pcurr -

);

(gap_len == ((gap_len << 3) >> 3));

*

= (

)((*

& 7) + (gap_len << 3));

<

T>

gap_count = 1;

(

= 1;

<

; ++

)

(curr !=

+ 1)

<

T>

=

[gap_idx] + 1;

maskFF = ~0u;

*dest |= (1u << bitpos);

mask_r = maskFF << bitpos;

(

right_margin = bitpos + bitcount; right_margin < 32)

*dest |= (maskFF >> (32 - right_margin)) & mask_r;

bitcount -= 32 - bitpos;

( ;bitcount >= 64; bitcount-=64, dest+=2)

dest[0] = dest[1] = maskFF;

{ *dest++ = maskFF; bitcount -= 32; }

*dest |= (maskFF >> (32 - bitcount));

*dest &= ~(bitcount << bitpos);

maskFF = ~0u;

mask_r = maskFF << bitpos;

(

right_margin = bitpos + bitcount; right_margin < 32)

*dest &= ~((maskFF >> (32 - right_margin)) & mask_r);

bitcount -= 32 - bitpos;

( ;bitcount >= 64; bitcount-=64, dest+=2)

dest[0] = dest[1] = 0u;

*dest++ = 0u; bitcount -= 32;

*dest &= ~(maskFF >> (32 - bitcount));

*word ^= unsigned(1 << nbit);

right_margin = nbit + bitcount;

(right_margin < 32)

= mask_r & mask_l;

bitcount -= 32 - nbit;

( ;bitcount >= 64; bitcount-=64, word+=2)

word[0] ^= ~0u; word[1] ^= ~0u;

*word++ ^= ~0u; bitcount -= 32;

<

T>

* pend = pcurr + (*pcurr >> 3);

(pcurr += 2; pcurr <= pend; pcurr += 2)

<

T>

= (*pcurr >> 3);

found_pos =

(pbuf, start_pos, &is_set);

found_pos += !is_set;

pcurr = pbuf + found_pos;

(pcurr > pend || *pcurr >= start_pos);

(; pcurr <= pend; pcurr += 2)

(*pcurr >= start_pos)

(

; pcurr <= pend; pcurr += 2)

pos = 1u +

;

<

T>

* pend = pcurr + (*pcurr >> 3);

(pcurr += 2; pcurr <= pend; pcurr += 2)

<

T>

* pend = pcurr +

;

(; pcurr <= pend; )

pos = 1u + pcurr[-1];

bc = *pcurr - pcurr[-1];

<

T>

= (*pcurr >> 3);

<

T>

* pend = pcurr + (*pcurr >> 3);

(; pcurr <= pend; )

pos = 1u + pcurr[-1];

bc = *pcurr - pcurr[-1];

<

T>

= (*pcurr >> 3);

found_pos =

(pbuf, start_pos, &is_set);

found_pos += is_set;

pcurr = pbuf + found_pos;

(pcurr > pend || *pcurr >= start_pos);

(; pcurr <= pend; pcurr += 2)

(*pcurr >= start_pos)

(

; pcurr <= pend; pcurr += 2)

pos = 1u +

;

<

T>

* pend = pcurr + (*pcurr >> 3);

(pcurr +=2 ;pcurr <= pend; pcurr += 2)

<

T>

* pend = pcurr + (*pcurr >> 3);

(pcurr +=2 ;!

&& pcurr <= pend; pcurr += 2)

<

T>

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

(;pcurr <= pend; pcurr+=2)

<

T>

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

(; !

&& pcurr <= pend; pcurr+=2)

<

T>

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

bitval = *

& 1;

(bitval^=1, ++pcurr; pcurr <= pend; bitval^=1, ++pcurr)

= (

)(*(pcurr-1)+1);

c = (*pcurr -

+ 1) - c;

<

T>

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

bitval = *

& 1;

(bitval^=1, ++pcurr; !

&& pcurr <= pend; bitval^=1, ++pcurr)

= (

)(*(pcurr-1)+1);

c = (*pcurr -

+ 1) - c;

<

T>

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

bitval = *

& 1;

(bitval^=1, ++pcurr; pcurr <= pend; bitval^=1, ++pcurr)

= (

)(*(pcurr-1)+1);

bitval ? (*pcurr -

+ 1)

<

T>

<

T>

<

T>

(

[1] == set_max - 1)

<

T>

end = *

>> 3;

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

(pcurr <= pend)

*(++

) = (

)(set_max - 1);

(to == set_max - 1)

[2] = (

)(set_max - 1);

[0] = (

)((*

& 6u) + (gap_len << 3) +

);

(to == set_max - 1)

[1] = (

)(from - 1);

[2] = (

)(set_max - 1);

[1] = (

) (from - 1);

[3] = (

)(set_max - 1);

[0] = (

)((*

& 6u) + (gap_len << 3) +

);

<

T>

*

= (

)(((level & 3) << 1) | (*

& 1) | (*

& ~7));

<

T>

(

<=

(glevel_len[0]-4))

0;

(

<=

(glevel_len[1]-4))

1;

(

<=

(glevel_len[2]-4))

2;

(

<=

(glevel_len[3]-4))

3;

<

T>

capacity -

;

<

T>

* pend1 = buf1 +

;

(w1 & diff & -diff) ? 1 : -1;

}

(buf1 < pend1);

*pos = unsigned(idx + (

* 8u *

(

(

))));

*pos = unsigned(idx + (

* 8u *

(

)));

bitval = (*block) & 1u;

bit_idx = 0;

= *block;

(!

||

== ~0u)

(bitval !=

(

(

)))

((pcurr-1) == (dest+1) || *(pcurr-1) > *(pcurr-2));

bit_idx += unsigned(

(*block) * 8);

(++block >= block_end)

bits_consumed = 0;

(bitval != (

& 1u))

((pcurr-1) == (dest+1) || *(pcurr-1) > *(pcurr-2));

bits_consumed += tz;

(bits_consumed < 32u)

bit_idx += 32u - bits_consumed;

((pcurr-1) == (dest+1) || *(pcurr-1) > *(pcurr-2));

}

(++block < block_end);

= (unsigned)(pcurr - dest);

<

T,

F>

* pcurr =

;

* pend = pcurr + (*pcurr >> 3);

to = *pcurr;

(

= 0;

<= to; ++

)

(pcurr <= pend)

from = *(pcurr-1)+1;

to = *pcurr;

func(from -

+ first_inc);

(

= from+1;

<= to; ++

)

<

D,

T>

* pend = pcurr + (*pcurr >> 3);

bitval = (*buf) & 1;

(

(*pcurr + 1) >= dest_len)

(

= 0; ;++

)

(

== to)

;

(pcurr <= pend)

pending = *pcurr - *(pcurr-1);

(pending >= dest_len)

dest_len -= pending;

from = (

)(*(pcurr-1)+1);

(

= from; ;++

)

(

== to)

;

(

) (dest_curr - dest);

+= unsigned(__builtin_popcountll(x) + __builtin_popcountll(y)

+ __builtin_popcountll(u) + __builtin_popcountll(v));

}

(block < block_end);

}

(block < block_end);

+= unsigned(__builtin_popcountll(x) + __builtin_popcountll(y)

+ __builtin_popcountll(u) + __builtin_popcountll(v));

}

(blk < blk_end);

-= (w >> ((

(w) * 8) - 1));

gap_count = 1;

w_shift =

(

(w) * 8 - 1);

gap_count -= (w_prev = (w0 >> w_shift));

(++block; block < block_end; ++block)

gap_count -= !w_prev;

gap_count -= (w0 >> w_shift);

gap_count -= !(w_prev ^ w_l);

w_prev = (w0 >> w_shift);

gap_count = 1;

w_shift =

(

(w) * 8 - 1);

gap_count -= unsigned(w_prev = (w0 >> w_shift));

(++block; block < block_end; ++block)

gap_count -= !w_prev;

gap_count -= unsigned(w0 >> w_shift);

gap_count -= !(w_prev ^ w_l);

w_prev = (w0 >> w_shift);

nbit, bitcount, temp;

(*word >> nbit) & 1u;

right_margin = nbit + right - left;

(right_margin < 32)

= mask_r & mask_l;

temp = *word & mask_r;

bitcount = (right - left + 1u) - (32 - nbit);

bitcount = right - left + 1u;

( ;bitcount >= 128; bitcount-=128, word+=4)

((w64_0 ^ maskFF64) | (w64_1 ^ maskFF64))

( ;bitcount >= 128; bitcount-=128, word+=4)

m = (word[0] != maskFF) || (word[1] != maskFF) |

(word[2] != maskFF) || (word[3] != maskFF);

( ;bitcount >= 32; bitcount-=32, ++word)

(*word != maskFF)

temp = *word & mask_l;

<

LWA,

RWA>

nword, nbit, bitcount,

, right_margin;

(*block >> nbit) & 1u;

bitcount = 1u + (right_margin = (right - left));

right_margin += nbit;

(right_margin < 32)

bitcount -= 32 - nbit;

( ;bitcount >= 128; bitcount-=128)

( ;bitcount >= 64; bitcount-=64)

( ;bitcount >= 32; bitcount-=32)

bitcount = right + 1;

__m256i

= _mm256_setzero_si256();

( ;bitcount >= 256; bitcount -= 256)

__m256i* src = (__m256i*)block;

__m256i xmm256 = _mm256_load_si256(src);

= _mm256_add_epi64(

, bc);

+= (unsigned)(cnt64[0] + cnt64[1] + cnt64[2] + cnt64[3]);

( ;bitcount >= 64; bitcount -= 64)

block[

] = (block[

] << 1) | (block[

+ 1] >> 31);

unroll_factor = 4;

w0 = block[

+ 1] >> 31;

w1 = block[

+ 2] >> 31;

w2 = block[

+ 3] >> 31;

w3 = block[

+ 4] >> 31;

block[0 +

] = (block[0 +

] << 1) | w0;

block[1 +

] = (block[1 +

] << 1) | w1;

block[2 +

] = (block[2 +

] << 1) | w2;

block[3 +

] = (block[3 +

] << 1) | w3;

block[

] = (block[

] << 1) | (block[

+ 1] >> 31);

block[

+ 1] = (block[

+ 1] << 1) | (block[

+ 2] >> 31);

block[

+ 2] = (block[

+ 2] << 1) | (block[

+ 3] >> 31);

block[nword] = w | (unsigned(

) << nbit) | wl;

w = (w << 1u) | co_flag;

acc |= w = (w << 1u) | co_flag;

acc0 |= w = (w << 1u) | co_flag;

b_u->w64[

++] = w;

acc1 |= w = (w << 1u) | co_flag;

*empty_acc =

(acc0 | acc1);

acc |= w = (w >> 1u) | (co_flag << 31u);

w0 = block[

]; w1 = block[

-1];

acc |= w0 = (w0 >> 1u) | (co_flag << 31u);

acc |= w1 = (w1 >> 1u) | (co_flag << 31u);

w0 = block[

]; w1 = block[

-1];

acc |= w0 = (w0 >> 1u) | (co_flag << 31u);

acc |= w1 = (w1 >> 1u) | (co_flag << 31u);

w = (w >> 1u) | (co_flag << 31u);

w |= wl | (co_flag << 31u);

block[nword] = (block[nword] >> 1u) | (co_flag << 31u);

(; di < 64; ++di)

w = (w << 1u) | co_flag;

acc |= block[

] = w & mask_block[

];

block[d_base] = co_flag & mask_block[d_base];

nbit = left;

(*word >> nbit) & 1;

bitcount = right - left + 1;

right_margin = nbit + (right - left);

(right_margin < 32)

= mask_r & mask_l;

*word &

;

acc = *word & mask_r;

bitcount -= 32 - nbit;

( ;bitcount >= 128; bitcount-=128, word+=4)

acc = word[0] | word[1] | word[2] | word[3];

( ;bitcount >= 32; bitcount -= 32)

acc |= (*word) & mask_l;

<

T>

start[0] = ~start[0];

start[1] = ~start[1];

start[2] = ~start[2];

start[3] = ~start[3];

}

(start < end);

start[0] & start[1] & start[2] & start[3];

}

(start < end);

is_left, is_right, all_one;

(is_left ==

)

(is_right ==

)

w &= (1u << bit_pos);

w = (~block[nword]) >> bit_pos;

*pos = unsigned(bit_pos + (nword * 8u *

(

(

)))-1);

*pos = unsigned(bit_pos + (nword * 8u *

(

(

)))-1);

w &= (1u << bit_pos);

w = (~block[nword]) & mask_l;

*pos = unsigned(bit_pos + (nword * 8u *

(

(

)))+1);

(--nword;

; --nword)

*pos = unsigned(bit_pos + (nword * 8u *

(

(

)))+1);

w &= (1u << bit_pos);

*pos = unsigned(bit_pos + (nword * 8u *

(

(

))));

w = block[nword] & mask_l;

*pos = unsigned(bit_pos + (nword * 8u *

(

(

))));

(--nword;

; --nword)

unsigned(bit_pos + (nword * 8u *

(

(

))));

(

&& *found_nbit == 0)

(

&& *found_nbit == 0)

*found_nbit = nbit_from;

bm::gap_buff_op<bm::gap_word_t, bm::and_func>(

tmp_buf, vect1, 0, vect2, 0, dsize);

gap_buff_any_op<bm::gap_word_t, bm::and_func>(vect1, 0, vect2, 0);

bm::gap_buff_count_op<bm::gap_word_t, bm::and_func>(vect1, vect2);

bm::gap_buff_op<bm::gap_word_t, bm::xor_func>(

tmp_buf, vect1, 0, vect2, 0, dsize);

gap_buff_any_op<bm::gap_word_t, bm::xor_func>(vect1, 0, vect2, 0);

bm::gap_buff_count_op<bm::gap_word_t, bm::xor_func>(vect1, vect2);

bm::gap_buff_op<bm::gap_word_t, bm::and_func>(tmp_buf, vect1, 1, vect2, 1, dsize);

gap_buff_count_op<bm::gap_word_t, bm::or_func>(vect1, vect2);

bm::gap_buff_op<bm::gap_word_t, bm::and_func>(

tmp_buf, vect1, 0, vect2, 1, dsize);

bm::gap_buff_any_op<bm::gap_word_t, bm::and_func>(

vect1, 0, vect2, 1);

bm::gap_buff_count_op<bm::gap_word_t, bm::sub_func>(vect1, vect2);

(

= 0;

< arr_sz;

+=4)

acc |= (dst_u->w64[

] &= src_u->w64[

]) |

(dst_u->w64[

+1] &= src_u->w64[

+1]) |

(dst_u->w64[

+2] &= src_u->w64[

+2]) |

(dst_u->w64[

+3] &= src_u->w64[

+3]);

digest &= ~(

<< wave);

acc |= dst_u->w64[j+0] &= src_u->w64[j+0];

acc |= dst_u->w64[j+1] &= src_u->w64[j+1];

acc |= dst_u->w64[j+2] &= src_u->w64[j+2];

acc |= dst_u->w64[j+3] &= src_u->w64[j+3];

digest &= ~(

<< wave);

(src0 && src1 && src2 && src3);

all_zero =

(&dst[off], &src0[off], &src1[off], &src2[off], &src3[off]);

digest &= ~(

<< wave);

acc |= dst_u->w64[j + 0] &= src_u0->w64[j + 0] & src_u1->w64[j + 0] & src_u2->w64[j + 0] & src_u3->w64[j + 0];

acc |= dst_u->w64[j + 1] &= src_u0->w64[j + 1] & src_u1->w64[j + 1] & src_u2->w64[j + 1] & src_u3->w64[j + 1];

acc |= dst_u->w64[j + 2] &= src_u0->w64[j + 2] & src_u1->w64[j + 2] & src_u2->w64[j + 2] & src_u3->w64[j + 2];

acc |= dst_u->w64[j + 3] &= src_u0->w64[j + 3] & src_u1->w64[j + 3] & src_u2->w64[j + 3] & src_u3->w64[j + 3];

digest &= ~(

<< wave);

digest &= ~(

<< wave);

acc |= dst_u->w64[j] &= src_u1->w64[j] & src_u2->w64[j];

acc |= dst_u->w64[j+1] &= src_u1->w64[j+1] & src_u2->w64[j+1];

acc |= dst_u->w64[j+2] &= src_u1->w64[j+2] & src_u2->w64[j+2];

acc |= dst_u->w64[j+3] &= src_u1->w64[j+3] & src_u2->w64[j+3];

digest &= ~(

<< wave);

digest &= ~(

<< wave);

acc |= dst_u->w64[j] = src_u1->w64[j] & src_u2->w64[j];

acc |= dst_u->w64[j+1] = src_u1->w64[j+1] & src_u2->w64[j+1];

acc |= dst_u->w64[j+2] = src_u1->w64[j+2] & src_u2->w64[j+2];

acc |= dst_u->w64[j+3] = src_u1->w64[j+3] & src_u2->w64[j+3];

digest &= ~(

<< wave);

(

= 0;

< 64; ++

)

acc |= dst_u->w64[j] = src_u1->w64[j] & src_u2->w64[j];

acc |= dst_u->w64[j+1] = src_u1->w64[j+1] & src_u2->w64[j+1];

acc |= dst_u->w64[j+2] = src_u1->w64[j+2] & src_u2->w64[j+2];

acc |= dst_u->w64[j+3] = src_u1->w64[j+3] & src_u2->w64[j+3];

dst[off] = dst[off+1] = dst[off+2] = dst[off+3] = 0u;

digest &= ~(

<< wave);

acc |= dst_u->w64[j+0] |= src_u1->w64[j+0] & src_u2->w64[j+0];

acc |= dst_u->w64[j+1] |= src_u1->w64[j+1] & src_u2->w64[j+1];

acc |= dst_u->w64[j+2] |= src_u1->w64[j+2] & src_u2->w64[j+2];

acc |= dst_u->w64[j+3] |= src_u1->w64[j+3] & src_u2->w64[j+3];

digest &= ~(

<< wave);

}

(b1 < b1_end);

}

(src1 < src1_end);

= (src1[0] & src2[0]) |

(src1[1] & src2[1]) |

(src1[2] & src2[2]) |

(src1[3] & src2[3]);

}

((src1 < src1_end) && !

);

}

(b1 < b1_end);

}

(src1 < src1_end);

= (src1[0] ^ src2[0]) |

(src1[1] ^ src2[1]) |

(src1[2] ^ src2[2]) |

(src1[3] ^ src2[3]);

}

(!

&& (src1 < src1_end));

}

(b1 < b1_end);

}

(src1 < src1_end);

= (src1[0] & ~src2[0]) |

(src1[1] & ~src2[1]) |

(src1[2] & ~src2[2]) |

(src1[3] & ~src2[3]);

}

((src1 < src1_end) && (

== 0));

}

(b1 < b1_end);

}

(src1 < src1_end);

= (src1[0] | src2[0]) |

(src1[1] | src2[1]) |

(src1[2] | src2[2]) |

(src1[3] | src2[3]);

}

(!

&& (src1 < src1_end));

acc &= (dst_ptr[0] |= wrd_ptr[0]);

acc &= (dst_ptr[1] |= wrd_ptr[1]);

acc &= (dst_ptr[2] |= wrd_ptr[2]);

acc &= (dst_ptr[3] |= wrd_ptr[3]);

dst_ptr+=4;wrd_ptr+=4;

}

(wrd_ptr < wrd_end);

acc == not_acc;

acc &= (dst_ptr[0] = wrd_ptr1[0] | wrd_ptr2[0]);

acc &= (dst_ptr[1] = wrd_ptr1[1] | wrd_ptr2[1]);

acc &= (dst_ptr[2] = wrd_ptr1[2] | wrd_ptr2[2]);

acc &= (dst_ptr[3] = wrd_ptr1[3] | wrd_ptr2[3]);

dst_ptr+=4; wrd_ptr1+=4; wrd_ptr2+=4;

}

(wrd_ptr1 < wrd_end1);

acc == not_acc;

acc |= (dst_ptr[0] = wrd_ptr1[0] ^ wrd_ptr2[0]);

acc |= (dst_ptr[1] = wrd_ptr1[1] ^ wrd_ptr2[1]);

acc |= (dst_ptr[2] = wrd_ptr1[2] ^ wrd_ptr2[2]);

acc |= (dst_ptr[3] = wrd_ptr1[3] ^ wrd_ptr2[3]);

dst_ptr+=4; wrd_ptr1+=4; wrd_ptr2+=4;

}

(wrd_ptr1 < wrd_end1);

acc &= (dst_ptr[0] |= wrd_ptr1[0] | wrd_ptr2[0]);

acc &= (dst_ptr[1] |= wrd_ptr1[1] | wrd_ptr2[1]);

acc &= (dst_ptr[2] |= wrd_ptr1[2] | wrd_ptr2[2]);

acc &= (dst_ptr[3] |= wrd_ptr1[3] | wrd_ptr2[3]);

dst_ptr+=4; wrd_ptr1+=4;wrd_ptr2+=4;

}

(wrd_ptr1 < wrd_end1);

acc == not_acc;

acc &= (dst_ptr[0] |= wrd_ptr1[0] | wrd_ptr2[0] | wrd_ptr3[0] | wrd_ptr4[0]);

acc &= (dst_ptr[1] |= wrd_ptr1[1] | wrd_ptr2[1] | wrd_ptr3[1] | wrd_ptr4[1]);

acc &= (dst_ptr[2] |= wrd_ptr1[2] | wrd_ptr2[2] | wrd_ptr3[2] | wrd_ptr4[2]);

acc &= (dst_ptr[3] |= wrd_ptr1[3] | wrd_ptr2[3] | wrd_ptr3[3] | wrd_ptr4[3]);

wrd_ptr1+=4;wrd_ptr2+=4;wrd_ptr3+=4;wrd_ptr4+=4;

}

(wrd_ptr1 < wrd_end1);

acc == not_acc;

(

= 0;

< arr_sz;

+=4)

acc |= (dst_u->w64[

] &= ~src_u->w64[

]) |

(dst_u->w64[

+1] &= ~src_u->w64[

+1]) |

(dst_u->w64[

+2] &= ~src_u->w64[

+2]) |

(dst_u->w64[

+3] &= ~src_u->w64[

+3]);

digest &= ~(

<< wave);

acc |= dst_u->w64[j+0] &= ~src_u->w64[j+0];

acc |= dst_u->w64[j+1] &= ~src_u->w64[j+1];

acc |= dst_u->w64[j+2] &= ~src_u->w64[j+2];

acc |= dst_u->w64[j+3] &= ~src_u->w64[j+3];

digest &= ~(

<< wave);

digest &= ~(

<< wave);

acc |= dst_u->w64[j+0] = src_u1->w64[j+0] & ~src_u2->w64[j+0];

acc |= dst_u->w64[j+1] = src_u1->w64[j+1] & ~src_u2->w64[j+1];

acc |= dst_u->w64[j+2] = src_u1->w64[j+2] & ~src_u2->w64[j+2];

acc |= dst_u->w64[j+3] = src_u1->w64[j+3] & ~src_u2->w64[j+3];

digest &= ~(

<< wave);

(src0 && src1 && src2 && src3);

all_zero =

(&dst[off], &src0[off], &src1[off], &src2[off], &src3[off]);

digest &= ~(

<< wave);

acc |= dst_u->w64[j + 0] &= ~src_u0->w64[j + 0] & ~src_u1->w64[j + 0] & ~src_u2->w64[j + 0] & ~src_u3->w64[j + 0];

acc |= dst_u->w64[j + 1] &= ~src_u0->w64[j + 1] & ~src_u1->w64[j + 1] & ~src_u2->w64[j + 1] & ~src_u3->w64[j + 1];

acc |= dst_u->w64[j + 2] &= ~src_u0->w64[j + 2] & ~src_u1->w64[j + 2] & ~src_u2->w64[j + 2] & ~src_u3->w64[j + 2];

acc |= dst_u->w64[j + 3] &= ~src_u0->w64[j + 3] & ~src_u1->w64[j + 3] & ~src_u2->w64[j + 3] & ~src_u3->w64[j + 3];

digest &= ~(

<< wave);

digest &= ~(

<< wave);

acc |= dst_u->w64[j + 0] &= ~src_u0->w64[j + 0] & ~src_u1->w64[j + 0];

acc |= dst_u->w64[j + 1] &= ~src_u0->w64[j + 1] & ~src_u1->w64[j + 1];

acc |= dst_u->w64[j + 2] &= ~src_u0->w64[j + 2] & ~src_u1->w64[j + 2];

acc |= dst_u->w64[j + 3] &= ~src_u0->w64[j + 3] & ~src_u1->w64[j + 3];

digest &= ~(

<< wave);

(

= 0;

< arr_sz;

+=4)

acc |= dst_u->w64[

] ^= src_u->w64[

];

acc |= dst_u->w64[

+1] ^= src_u->w64[

+1];

acc |= dst_u->w64[

+2] ^= src_u->w64[

+2];

acc |= dst_u->w64[

+3] ^= src_u->w64[

+3];

dst_ptr+=4; wrd_ptr+=4;

}

(wrd_ptr < wrd_end);

(src == dst)

0;

(!src)

dst;

(!src)

dst;

* blk_end = blk + data_size - 2;

* blk_j = blk + 1;

(; blk_j < blk_end; ++blk_j)

* blk_j = blk + 1;

( ; blk_j < blk_end; ++blk_j)

(blk_j[1] | blk_j[2])

+= unsigned(blk_j - blk) * unsigned(

(

));

(blk < blk_end);

+ unsigned(2 *

(

));

w &= (1u << bit_pos);

w = block[nword] >> bit_pos;

*pos = unsigned(bit_pos + (nword * 8u *

(

(

))));

*pos = unsigned(bit_pos + (

* 8u *

(

(

))));

*

= unsigned(idx + (

* 8u *

(

(

))));

*pos = unsigned(idx + (

* 8u *

(

(

))));

base =

* 8u * unsigned(

(

));

w64 = block[

] | block[

+1];

base =

* 8u * unsigned(

(

));

=

+ 4;

(++

;

<

; ++

)

}

(++

<

);

(

w = block[

])

<

SIZE_TYPE>

pos = nbit_from;

rank -= bc; pos += unsigned(32u - nbit);

nbit_pos = pos + idx;

nbit_pos = pos + idx;

rank -= bc; pos += 32u;

nbit_pos = pos + idx;

<

SIZE_TYPE>

total_possible_bitcount,

((gap_size < block_size) && (gap_size < arr_size) && (gap_size < inv_arr_size))

(arr_size < inv_arr_size)

((arr_size < block_size) && (arr_size < gap_size))

((inv_arr_size < block_size) && (inv_arr_size < gap_size))

<

T>

imask64 = inverted ? ~0ull : 0;

src+=2, bit_idx += unsigned(

(*src) * 8 * 2))

(

)(pcurr - dest);

<

T>

(

= 1;

< sz; ++

)

d =

[

] -

[

-1];

<

T>

bitpos = 0;

w = block[nword];

= (~w) & (1 << 1);

arr_ex0[ex0_cnt] = 0; ++ex0_cnt;

(;

<= 65534; ++

)

= w & (1 << bitpos);

b_prev = w & (1 << bitpos);

b_next = w & (1 << bitpos);

w &= ~(1 << bitpos);

arr_ex0[ex0_cnt] = (

)

; ++ex0_cnt;

arr_ex0[ex0_cnt] = 0; ++ex0_cnt;

(;

<= 65534; ++

)

= w & (1 << bitpos);

b_prev = w & (1 << bitpos);

b_next = w & (1 << bitpos);

arr_ex0[ex0_cnt] = (

)

; ++ex0_cnt;

<

T>

(

k = 0; k < ex0_cnt; ++k)

<

T>

imask64 = inverted ? ~0ull : 0;

src+=2, bit_idx += unsigned(

(*src) * 8 * 2))

(idx !=

+1)

*pcurr_r++ =

(

- rl);

*pcurr_s++ =

(idx);

(!rl && (pcurr_s != dst_s))

*pcurr_r++ =

(

- rl);

s_cnt = (unsigned)(pcurr_s - dst_s);

r_cnt = (unsigned)(pcurr_r - dst_r);

<

T>

(

= 0;

< s_cnt; ++

)

(

= 0;

< r_cnt; ++

)

(!blk)

;

(blk == 0)

;

<

T>

* length_end,

(length && length_end && glevel_len);

overhead = 0;

(;length < length_end; ++length)

= *length;

capacity = glevel_len[level];

overhead += capacity -

;

<

T>

* length_end,

(length && length_end && glevel_len);

lsize = size_t(length_end - length);

(

= 0;

< lsize; ++

)

(length[

] > max_len)

max_len = length[

];

glevel_len[0] =

(max_len + 4);

min_overhead =

(length, length_end, glevel_len);

is_improved =

;

imp_flag =

;

(j = 0; j < lsize; ++j)

glevel_len[

] =

(length[j] + 4);

ov =

(length, length_end, glevel_len);

(ov <= min_overhead)

is_improved =

;

glevel_len[

] = gap_saved_value;

= *glevel_len;

* gp = glevel_len;

* res = glevel_len;

is_improved;

(!blk || !arg_blk)

(arg_gap != gap)

(cnt_ < from_ || cnt_ >

)

++

;

0;

<

It1,

It2,

BinaryOp,

Encoder>

(

= 0;

< block_size; ++

)

enc.push_back( w );

&gap_and_to_bitset<bm::gap_word_t>,

&gap_add_to_bitset<bm::gap_word_t>,

&gap_sub_to_bitset<bm::gap_word_t>,

&gap_xor_to_bitset<bm::gap_word_t>,

w0 = w_ptr[0]; w1 = w_ptr[1];

w0 = w_ptr[2]; w1 = w_ptr[3];

w0 = w_ptr[2]; w1 = w_ptr[3];

cnt0 +=

(w1, bits + cnt0, (

)(64+32));

w0 = w_ptr[2]; w1 = w_ptr[3];

(cnt0);

,

start,

TRGW;

;

constexpr (

(TRGW)==4 &&

(

)==4)

constexpr (

(TRGW)==4 &&

(

)==4)

<

TRGW,

IDX,

SZ>

SZ

= (

- start);

SZ len_unr =

- (

% 2);

(; k < len_unr; k+=2)

SZ base = start + k;

(; k <

; ++k)

(;(start <

) &&

(;(start <

) &&

block[nword] |= (1u << nbit);

= idx[start++];

block[nword] |= (1u << nbit);

}

(start < stop);

& left,

& right)

(; from <= to; ++from)

(

[from] >= target)

target,

(; from <= to; ++from)

(

[from] >= target)

linear_cutoff = 32;

= from;

= to;

dist =

-

;

(dist < linear_cutoff)

mid = (

-

)/2+

;

(

[mid] < target)

(dist < linear_cutoff)

target,

linear_cutoff = 32;

= from;

= to;

dist =

-

;

(dist < linear_cutoff)

mid = (

-

) / 2 +

;

(

[mid] < target)

(dist < linear_cutoff)

(

*

* p_arr,

arr_size,

(

= 0;

< arr_size; ++

)

(ptr == p_arr[

])

*idx =

;

;

block_idx + base_idx;

block_idx + base_idx;

md =

[1] -

[0];

(

= 1;

< arr_size; ++

)

curr =

[

];

(

= 1;

< arr_size; ++

)

<

VT,

SZ>

found =

;

(SZ

= 0;

< arr_size; ++

)

max_v = v; *found_idx =

;

<

VT,

SZ>

(SZ

= 0;

< arr_size; ++

)

<

VT,

SZ>

(SZ

= 0;

< arr_size; ++

)

bie_bits_per_int,

(bc == max_bits)

ibc = max_bits - bc;

cost_in_bits = float(gc) * bie_bits_per_int;

(cost_in_bits >=

(max_bits))

cost_in_bits = float(bc) * bie_bits_per_int;

(cost_in_bits >=

(max_bits))

*best_metric = ibc;

cost_in_bits = float(ibc) * bie_bits_per_int;

(cost_in_bits >=

(max_bits))

<

T>

& win_size,

& best_save)

use_wdr =

;

(

w_size = 20; w_size <= 78; w_size += 2)

total_windows = (sz + w_size - 1) / w_size;

bits_extra = float(total_windows + 1 + 8 + 8);

save_per_window = 0.15f * w_size;

total_save = save_per_window * wcnt;

total_save -= bits_extra;

(total_save > 0.0f)

use_wdr =

; win_size = w_size; best_save = total_save;

(total_save >= best_save)

win_size = w_size; best_save = total_save;

<

T>

temp = *

; *

= *

; *

= temp;

<

T>

(

[j] >

[pivot])

arr_idx = idx >> 1;

old_val =

[arr_idx];

[arr_idx] = (

char)(old_val | (v << 4));

old_val =

[arr_idx];

[arr_idx] = (

char)(old_val | (v & 0xF));

v =

[idx >> 1];

v >>= (idx & 1) * 4;

(ptr.i16[1] == 0);

= (ptr.i16[1] == v) | (ptr.i16[2] == v) | (ptr.i16[3] == v);

ncbi::TMaskedQueryRegions mask

#define VECT_STREAM_BLOCK_UNALIGN(dst, src)

#define VECT_COPY_BLOCK_UNALIGN(dst, src)

#define VECT_SET_BLOCK(dst, value)

#define VECT_BITCOUNT_OR(first, last, mask)

#define VECT_BIT_FIND_DIFF(src1, src2, pos)

#define VECT_AND_DIGEST_5WAY(dst, src1, src2, src3, src4)

#define VECT_OR_BLOCK_5WAY(dst, src1, src2, src3, src4)

#define VECT_BIT_FIND_FIRST(src1, off, pos)

#define VECT_COPY_BLOCK(dst, src)

#define VECT_SUB_DIGEST_5WAY(dst, src1, src2, src3, src4)

#define BM_AVX2_POPCNT_PROLOG

#define VECT_BITCOUNT_AND(first, last, mask)

#define VECT_SHIFT_R1(b, acc, co)

#define VECT_XOR_BLOCK_2WAY(dst, src1, src2)

#define VECT_IS_ONE_BLOCK(dst)

#define VECT_STREAM_BLOCK(dst, src)

#define VECT_OR_BLOCK(dst, src)

#define VECT_SHIFT_R1_AND(b, co, m, digest)

#define VECT_SUB_BLOCK(dst, src)

#define VECT_GAP_TEST(buf, pos)

#define VECT_IS_ZERO_BLOCK(dst)

#define VECT_BIT_TO_GAP(dest, src, dest_len)

#define VECT_SUB_DIGEST_2WAY(dst, src1, src2)

#define VECT_XOR_BLOCK(dst, src)

#define VECT_IS_DIGEST_ZERO(start)

#define VECT_ANDNOT_ARR_2_MASK(dst, src, src_end, mask)

#define VECT_BLOCK_CHANGE_BC(block, gc, bc)

#define VECT_BIT_COUNT_DIGEST(blk, d)

#define VECT_SHIFT_L1(b, acc, co)

#define VECT_LOWER_BOUND_SCAN_U32(arr, target, from, to)

#define VECT_SET_BLOCK_BITS(block, idx, start, stop)

#define VECT_BITCOUNT_SUB(first, last, mask)

#define VECT_BITCOUNT_XOR(first, last, mask)

#define VECT_AND_DIGEST(dst, src)

#define VECT_GAP_BFIND(buf, pos, is_set)

#define VECT_INVERT_BLOCK(first)

#define VECT_BLOCK_CHANGE(block, size)

#define VECT_SUB_DIGEST_3WAY(dst, src1, src2)

#define VECT_AND_DIGEST_2WAY(dst, src1, src2)

#define VECT_AND_OR_DIGEST_2WAY(dst, src1, src2)

#define VECT_BLOCK_SET_DIGEST(dst, val)

#define VECT_AND_DIGEST_3WAY(dst, src1, src2)

#define BM_AVX2_BIT_COUNT(ret, v)

#define VECT_ARR_BLOCK_LOOKUP(idx, size, nb, start)

#define VECT_BITCOUNT(first, last)

#define VECT_SUB_DIGEST(dst, src)

#define VECT_OR_BLOCK_3WAY(dst, src1, src2)

#define VECT_OR_BLOCK_2WAY(dst, src1, src2)

#define VECT_AND_BLOCK(dst, src)

#define IS_FULL_BLOCK(addr)

#define IS_VALID_ADDR(addr)

#define FULL_BLOCK_FAKE_ADDR

#define IS_EMPTY_BLOCK(addr)

#define BM_VECT_ALIGN_ATTR

#define FULL_BLOCK_REAL_ADDR

Bit manipulation primitives (internal)

Bit-block get adapter, takes bitblock and represents it as a get_32() accessor function.

bitblock_get_adapter(const bm::word_t *bit_block)

bm::word_t get_32() noexcept

Bit-block store adapter, takes bitblock and saves results into it.

bitblock_store_adapter(bm::word_t *bit_block)

void push_back(bm::word_t w)

Bit-block sum adapter, takes values and sums it /internal.

bm::word_t sum() const noexcept

Get accumulated sum.

void push_back(bm::word_t w) noexcept

Adaptor to copy 1 bits to array.

copy_to_array_functor(B *bits)

copy_to_array_functor(const copy_to_array_functor &)

void operator()(unsigned bit_idx0, unsigned bit_idx1) noexcept

void operator()(unsigned bit_idx0, unsigned bit_idx1, unsigned bit_idx2, unsigned bit_idx3) noexcept

void operator()(unsigned bit_idx) noexcept

void operator()(unsigned bit_idx0, unsigned bit_idx1, unsigned bit_idx2) noexcept

copy_to_array_functor & operator=(const copy_to_array_functor &)

Adapter to get words from a range stream (see range serialized bit-block)

bm::word_t get_32() noexcept

decoder_range_adapter(DEC &dec, unsigned from_idx, unsigned to_idx)

static vector< string > arr

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

bool avx2_test_all_zero_wave(const void *ptr)

check if wave of pointers is all NULL

bool sse42_test_all_zero_wave(const void *ptr) noexcept

check if wave of pointers is all NULL

NCBI_NS_STD::string::size_type SIZE_TYPE

bm::id_t bit_block_count(const bm::word_t *block) noexcept

Bitcount for bit block.

unsigned bit_find_last(const bm::word_t *block, unsigned *last) noexcept

BIT block find the last set bit (backward search)

unsigned short bitscan_bsf64(bm::id64_t w, B *bits) noexcept

Unpacks word into list of ON bits (BSF/__builtin_ctz)

bool bit_find_first(const bm::word_t *block, unsigned *pos) noexcept

BIT block find the first set bit.

void bit_block_copy_unalign(bm::word_t *dst, const bm::word_t *src) noexcept

Bitblock copy operation (unaligned src)

unsigned word_select32(unsigned w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

bm::id64_t bit_block_and_3way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, bm::id64_t digest) noexcept

digest based bit-block AND

void or_bit_block(unsigned *dest, unsigned bitpos, unsigned bitcount) noexcept

Sets bits to 1 in the bitblock.

bool bit_block_shift_r1(bm::word_t *block, bm::word_t *empty_acc, bm::word_t co_flag) noexcept

Right bit-shift bitblock by 1 bit (reference)

void bit_block_gather_scatter(TRGW *arr, const bm::word_t *blk, const IDX *idx, SZ size, SZ start, unsigned bit_idx) noexcept

bit index to word gather-scatter algorithm

int wordcmp0(T w1, T w2) noexcept

Lexicographical comparison of two words as bit strings (reference) Auxiliary implementation for testi...

void block_compact_by_digest(bm::word_t *t_block, const bm::word_t *block, bm::id64_t digest, bool zero_tail) noexcept

Compact sub-blocks by digest (rank compaction)

bm::id64_t digest_mask(unsigned from, unsigned to) noexcept

Compute digest mask for [from..to] positions.

unsigned bit_count_nonzero_size(const T *blk, unsigned data_size) noexcept

Inspects block for full zero words.

void xor_bit_block(unsigned *dest, unsigned bitpos, unsigned bitcount) noexcept

XOR bit interval to 1 in the bitblock.

bm::word_t * bit_operation_sub(bm::word_t *dst, const bm::word_t *src) noexcept

bitblock SUB operation.

unsigned word_bitcount64(bm::id64_t x) noexcept

bm::id_t bit_operation_sub_count(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock SUB operation and calculates bitcount of the result.

bm::id64_t bit_block_xor(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock XOR operation. Function does not analyse availability of source and destination blocks...

unsigned word_select64_bitscan_tz(bm::id64_t w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

bool bit_block_shift_r1_and(bm::word_t *block, bm::word_t co_flag, const bm::word_t *mask_block, bm::id64_t *digest) noexcept

Right bit-shift of bit-block by 1 bit (reference) + AND.

bool bit_find_first_diff(const bm::word_t *blk1, const bm::word_t *blk2, unsigned *pos) noexcept

Find first bit which is different between two bit-blocks.

bool bit_block_find_interval_start(const bm::word_t *block, unsigned nbit, unsigned *pos) noexcept

Searches for the first 1 bit in the 111 interval of a BIT block.

unsigned bit_block_and_any(const bm::word_t *src1, const bm::word_t *src2) noexcept

Function ANDs two bitblocks and tests for any bit. Function does not analyse availability of source b...

unsigned short bitscan_popcnt64(bm::id64_t w, B *bits) noexcept

Unpacks 64-bit word into list of ON bit indexes using popcnt method.

bm::id_t word_bitcount(bm::id_t w) noexcept

void bit_invert(T *start) noexcept

bool bit_block_or(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock OR operation. Function does not analyse availability of source and destination blocks.

unsigned short bitscan_bsf(unsigned w, B *bits) noexcept

Unpacks word into list of ON bits (BSF/__builtin_ctz)

bm::id64_t bit_block_and(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock AND operation. Function does not analyse availability of source and destination blocks...

void bit_block_stream_unalign(bm::word_t *dst, const bm::word_t *src) noexcept

Bitblock copy/stream operation (unaligned src)

unsigned bit_block_convert_to_arr(T *dest, const unsigned *src, bool inverted) noexcept

Convert bit block into an array of ints corresponding to 1 bits.

bool bit_block_shift_l1(bm::word_t *block, bm::word_t *empty_acc, bm::word_t co_flag) noexcept

Left bit-shift bitblock by 1 bit (reference)

bm::id64_t update_block_digest0(const bm::word_t *const block, bm::id64_t digest) noexcept

Compute digest for 64 non-zero areas based on existing digest (function revalidates zero areas)

void bit_andnot_arr_ffmask(bm::word_t *dst, const bm::word_t *src) noexcept

bitblock AND NOT with constant ~0 mask operation.

bool bit_block_shift_l1_unr_min(bm::word_t *block, bm::word_t *empty_acc, unsigned co_flag) noexcept

Left bit-shift bitblock by 1 bit (minimum unroll)

void bit_block_stream(bm::word_t *dst, const bm::word_t *src) noexcept

Bitblock copy/stream operation.

void bit_block_rle_split(T *dst_s, T *dst_r, T *rlen, unsigned &s_cnt, unsigned &r_cnt, const unsigned *src, bool inverted) noexcept

Convert bit block into two arrays of ints( corresponding to 1 bits)

void block_init_digest0(bm::word_t *const block, bm::id64_t digest) noexcept

Init block with 000111000 pattren based on digest.

bool bit_block_or_3way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2) noexcept

3 way (target | source1 | source2) bitblock OR operation. Function does not analyse availability of s...

bool bit_block_find_interval_end(const bm::word_t *block, unsigned nbit, unsigned *pos) noexcept

Searches for the last 1 bit in the 111 interval of a BIT block.

bool bit_block_or_2way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2) noexcept

2 way (target := source1 | source2) bitblock OR operation.

unsigned bit_block_find(const bm::word_t *block, unsigned nbit, unsigned *pos) noexcept

Searches for the next 1 bit in the BIT block.

bool is_bits_one(const bm::wordop_t *start) noexcept

Returns "true" if all bits in the block are 1.

bm::id_t bit_block_calc_count_range(const bm::word_t *block, bm::word_t left, bm::word_t right) noexcept

bool bit_block_shift_r1_unr_min(bm::word_t *block, bm::word_t *empty_acc, bm::id64_t co_flag) noexcept

Right bit-shift bitblock by 1 bit (minimum unroll)

unsigned short bitscan(V w, B *bits) noexcept

Templated Bitscan with dynamic dispatch for best type.

unsigned short bitscan_wave(const bm::word_t *w_ptr, unsigned char *bits) noexcept

Unpacks word wave (Nx 32-bit words)

bm::id_t bit_operation_xor_any(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock XOR operation test.

SIZE_TYPE bit_find_rank(const bm::word_t *const block, SIZE_TYPE rank, unsigned nbit_from, unsigned &nbit_pos) noexcept

BIT block find position for the rank.

bm::id_t bit_count_change(bm::word_t w) noexcept

unsigned bitcount64_4way(bm::id64_t x, bm::id64_t y, bm::id64_t u, bm::id64_t v) noexcept

bm::id64_t bit_block_and_or_2way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, bm::id64_t digest) noexcept

digest based bit-block AND - OR

bool bit_is_all_zero(const bm::word_t *start) noexcept

Returns "true" if all bits in the block are 0.

bool bit_block_shift_r1_unr(bm::word_t *block, bm::word_t *empty_acc, bm::word_t co_flag) noexcept

Right bit-shift of bit-block by 1 bit (loop unrolled)

void bit_for_each_4(T w, F &func)

Templated algorithm to unpacks octet based word into list of ON bit indexes.

unsigned bit_block_sub_count(const bm::word_t *src1, const bm::word_t *src2) noexcept

Function SUBs two bitblocks and computes the bitcount. Function does not analyse availability of sour...

unsigned word_select64(bm::id64_t w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

unsigned bit_block_xor_any(const bm::word_t *src1, const bm::word_t *src2) noexcept

Function XORs two bitblocks and and tests for any bit. Function does not analyse availability of sour...

void bit_block_set(bm::word_t *dst, bm::word_t value) noexcept

Bitblock memset operation.

unsigned test_bit(const unsigned *block, unsigned bitpos) noexcept

Test 1 bit in a block.

void bit_block_rotate_left_1_unr(bm::word_t *block) noexcept

Unrolled cyclic rotation of bit-block left by 1 bit.

bm::id_t bit_operation_or_any(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock OR operation test.

unsigned bit_list_4(T w, B *bits) noexcept

Unpacks word into list of ON bit indexes (quad-bit based)

bool bit_block_or_5way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, const bm::word_t *src3, const bm::word_t *src4) noexcept

5 way (target, source1, source2) bitblock OR operation. Function does not analyse availability of sou...

bm::id_t bit_block_calc_count_to(const bm::word_t *block, bm::word_t right) noexcept

void bit_for_each(T w, F &func)

Templated algorithm to unpacks word into list of ON bit indexes.

void bit_block_copy(bm::word_t *dst, const bm::word_t *src) noexcept

Bitblock copy operation.

unsigned bit_block_sub_any(const bm::word_t *src1, const bm::word_t *src2) noexcept

Function SUBs two bitblocks and and tests for any bit. Function does not analyse availability of sour...

unsigned bit_scan_reverse(T value) noexcept

bm::id_t bit_block_any_range(const bm::word_t *block, bm::word_t left, bm::word_t right) noexcept

bm::id64_t bit_block_and_2way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, bm::id64_t digest) noexcept

digest based bit-block AND

bool bit_block_shift_l1_unr(bm::word_t *block, bm::word_t *empty_acc, bm::word_t co_flag) noexcept

Left bit-shift of bit-block by 1 bit (loop unrolled)

bm::set_representation best_representation(unsigned bit_count, unsigned total_possible_bitcount, unsigned gap_count, unsigned block_size) noexcept

Choose best representation for a bit-block.

unsigned word_select64_linear(bm::id64_t w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

unsigned word_select32_bitscan_tz(unsigned w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

bm::id_t bit_operation_and_any(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock AND operation test.

bool bit_block_shift_r1_and_unr(bm::word_t *block, bm::word_t co_flag, const bm::word_t *mask_block, bm::id64_t *digest) noexcept

Right bit-shift bitblock by 1 bit (reference) + AND.

bm::id64_t bit_block_sub_3way(bm::word_t *dst, const bm::word_t *src0, const bm::word_t *src1, bm::id64_t digest) noexcept

digest based bit-block SUB 3-way

unsigned word_select32_bitscan_popcnt(unsigned w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

void sub_bit_block(unsigned *dest, unsigned bitpos, unsigned bitcount) noexcept

SUB (AND NOT) bit interval to 1 in the bitblock.

unsigned word_select64_bitscan_popcnt(bm::id64_t w, unsigned rank) noexcept

word find index of the rank-th bit set by bit-testing

bm::word_t bit_block_insert(bm::word_t *block, unsigned bitpos, bool value) noexcept

insert bit into position and shift the rest right with carryover

bm::word_t * bit_operation_xor(bm::word_t *dst, const bm::word_t *src) noexcept