Ignore:
Timestamp:
Oct 29, 2013, 4:27:13 PM (6 years ago)
Author:
shiyangy
Message:

perf script added

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/xmlschema/src/xmlwf.cpp

    r3219 r3541  
    1414//#define TEMPLATED_SIMD_LIB
    1515
    16 #define DEBUG 1
    1716//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
    1817//#define SEGMENT_BLOCKS 12
     
    2221#define VECTOR_WIDTH 8
    2322#define VECTOR_TYPE (char)
     23
     24#define DEBUG 1
     25
     26//#define DATATYPE 1
     27
     28//#define CONTENT_MODEL 1
     29
     30//#define SYMBOL_TABLE 1
     31
     32int Datatype = 0;
     33int Content_model = 0;
     34int Symbol = 0;
     35int Data_gather = 0;
     36int Content_gather = 0;
     37
    2438
    2539#include <stdio.h>
     
    7690
    7791#ifdef BUFFER_PROFILING
    78         BOM_Table * parser_timer;
    79 
    80 #elif CODE_CLOCKER
    81         #define NUM_EVENTS 1
    82         int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
    83         //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
    84         //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
    85         int cal_size = 20;
    86         CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
     92    BOM_Table * parser_timer;
     93#elif PAPI
     94                #define PAPI_EVENTS_COUNT 2
     95                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
     96    CC * parser_timer;
    8797#else
    88         void * parser_timer;
     98    void * parser_timer;
    8999#endif
    90100
     
    114124LineColTracker tracker;
    115125
     126#define CONTENT_BUFFER_SIZE BLOCK_SIZE
     127char content_buffer[CONTENT_BUFFER_SIZE];
     128char content_lookahead_buffer[CONTENT_BUFFER_SIZE];
     129int content_buffer_pos = 0;
     130int content_carry = 0;
     131char gid;
     132int content_start_carry = 0;
     133
     134#define CONTENT_INDEX 13
     135
     136static inline int cfzl(long x) { if (x == 0) return sizeof(long)*8; else return __builtin_ctzl(x);}
     137/*
    116138static inline int cfzl(long x){
    117139        unsigned long ux = x;
     
    126148                if ((ux%2) == 1){
    127149                        if(n==64){
    128                                 cout << ux <<endl;
     150//                              cout << ux <<endl;
    129151                        }
    130152                        return n;               
     
    135157        }
    136158}
    137 
     159*/
    138160static inline void print_gid_vec();
    139161/*
     
    194216PBGSIdentitySymbolTable pbgs_symbol_table;
    195217
    196 vector <char> gid_vec;
     218#define MAX_COUNT 128
     219vector <char> gid_vec[MAX_COUNT];
     220int current_depth = 0;
     221vector <int> pre_index;
    197222
    198223stack <vector<char>* > elem_vec_stack;
    199224map<char, vector<char>* > elem_vec_map;
    200 
    201 static inline int ScanBackwardPos(BitBlock * block, int pos)
    202 {
    203         cout << "pos " << pos << endl;
    204     BitBlock s = block[0];
    205     if (bitblock::any(block[0])){
    206         print_register("zero",block[0]);
    207         print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
    208         }
    209     BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
    210 //      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
    211                 print_register("temp",temp);
    212     if (bitblock::any(temp))
    213     {
    214         // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
    215 //      cout << "block_size" << BLOCK_SIZE << endl;
    216         return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
    217     }
    218     else
    219     {
    220         //handle boundary case
    221         return previous_block_last_elem_start - 1;
    222     }
    223 }
    224 
    225 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
    226         int blk;
    227         int block_pos = 0;
    228         for (blk = 0; blk < blk_count; blk++) {
    229                 ScanBlock s = stream[blk];
    230                 while(s) {
    231                         int code = (ProcessPos(cfzl(s) + block_pos));
    232                         if (code) return code;
    233                         s = s & (s-1);  // clear rightmost bit.
    234                 }
    235                 block_pos += 8 * sizeof(ScanBlock);
    236         }
    237         return 0;
    238 }
    239 
    240 static inline int compute_hash_value (int lgth, int start)
    241 {
    242     unsigned int offset_bit = start + 128;
    243     uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
    244     return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
    245 }
    246 /*
    247 template <int L>
    248 static inline int ElemEnd_grouping(int pos) {
    249     int end = block_base + pos;
    250     int start = end - L;
    251     int hashvalue = compute_hash_value(L, start - block_base);
    252     int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
    253     gids.push_back(gid);
    254 #if DEBUG
    255     char* symbol = new char[L+1];
    256     strncpy ( symbol, source + start, L );
    257     symbol[L] ='\0';
    258     printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
    259     delete symbol; symbol = 0;
    260 #endif
    261     return gid;
    262 }
    263 
    264 template<>
    265 inline int ElemEnd_grouping<17>(int pos) {
    266     int end = block_base + pos;
    267     int start = ScanBackwardPos (&elem_starts, pos) + block_base;
    268     int lgth = end - start;
    269     int hashvalue = compute_hash_value(lgth, start - block_base);
    270     int gid = 0;
    271 
    272 //    if (lgth < 32)
    273 //    {
    274 //      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
    275 //    }
    276 //    else
    277     {
    278         gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
    279     }
    280     gids.push_back(gid);
    281 #if DEBUG
    282     char* symbol = new char[lgth+1];
    283     strncpy ( symbol, source + start, lgth );
    284     symbol[lgth] ='\0';
    285     printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
    286 #endif
    287     return gid;
    288 }
    289 */
    290 
    291 inline char ElemEnd_grouping(char *source,int block_base,int pos) {
    292     int end = block_base + pos;
    293     int start = ScanBackwardPos(&elem_starts, pos) + block_base;
    294     ///////////////////////
    295     //start could be negitive
    296     //the element name falls in two buffers
    297     ///////////////////////
    298     char *name = source + start;
    299     char name_buffer[50];
    300    
    301     if (start<0){
    302         memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
    303         memmove (&element_name_buffer[ELEMENT_BUFFER_SIZE+start],&source[0],50+start);
    304         name = name_buffer;
    305     }
    306 //    cout << end << "  " << start << endl;
    307     int lgth = end - start;
    308     int hashvalue = compute_hash_value(lgth, start - block_base);
    309     char gid = 0;
    310 
    311 
    312 //    if (lgth < 32)
    313 //    {
    314 //      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
    315 //    }
    316 //    else
    317 
    318         switch (lgth)
    319     {
    320     case 1:
    321         gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
    322         break;
    323     case 2:
    324         gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
    325         break;
    326     case 3:
    327         gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
    328         break;
    329     case 4:
    330         gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
    331         break;
    332     case 5:
    333         gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
    334         break;
    335     case 6:
    336         gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
    337         break;
    338     case 7:
    339         gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
    340         break;
    341     case 8:
    342         gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
    343         break;
    344     case 9:
    345         gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
    346         break;
    347     case 10:
    348         gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
    349         break;
    350     case 11:
    351         gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
    352         break;
    353     case 12:
    354         gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
    355         break;
    356     case 13:
    357         gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
    358         break;
    359     case 14:
    360         gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
    361         break;
    362     case 15:
    363         gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
    364         break;
    365     case 16:
    366         gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
    367         break;
    368     default:
    369         gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
    370         break;
    371     }
    372 /*
    373     {
    374         gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
    375     }
    376 */
    377     gids.push_back(gid);
    378 #if DEBUG
    379     char* symbol = new char[lgth+1];
    380     strncpy ( symbol, source + start, lgth );
    381     symbol[lgth] ='\0';
    382     printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
    383     fprintf (gid_writein,"%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
    384 #endif
    385     return gid;
    386 }
    387 
    388 //template <int L>
    389 static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count) {
    390     int blk;
    391     int block_pos = 0;
    392 //    cout << "cfzl():" << cfzl() << endl;
    393 //      long test = 6;
    394 //      test = (test & (test - 1));
    395 //      cout << test << endl;
    396     for (blk = 0; blk < blk_count; blk++) {
    397         cout << "blk:" << blk << endl;
    398    
    399                 ScanBlock s = stream[blk];
    400                 ScanBlock s2 = stream2[blk];
    401 //              cout << s << "  " << s2 << endl;
    402 //              print_register("s:",((BitBlock*)stream)[0]);
    403                 while(s | s2) {
    404                         cout << "cfzl(s):" << cfzl(s)<<endl;
    405                     int end_pos = cfzl(s) + block_pos;
    406 //                  cout << "s2 " << s2 << endl;
    407                     int end_tag = cfzl(s2) + block_pos;
    408 //              cout << "cfzl(s):" << cfzl(s)<<endl;
    409 //              cout << "cfzl(s2):" << cfzl(s2)<<endl;
    410 //                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
    411                         if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
    412                         cout << "here" << endl;
    413                         cout << "closing tag" << endl;
    414 //                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
    415 //                      cout << "1"<< endl;
    416 //                      cout << elem_vec_stack.size()<<endl;
    417 //                      cout << "2" << endl;
    418 //                      cout << elem_vec_stack.top()<<endl;
    419                                 if(!(gid_vec.empty())){
    420 //                                      if(gid_vec.back() != 0){
    421                                                 gid_vec.push_back(0);
    422 //                                      }
    423                                 }
    424                                 cout << "before" << s2 << endl;
    425                                 s2 = s2 & (s2 - 1);
    426                                 cout << "after" << s2 << endl;
    427 //                      cout << "s2 = " << s2 << endl;
    428                 }else{
    429                         cout << " end_pos == " << end_pos<<endl;
    430                         cout << " end_tag_pos == " << end_tag << endl;
    431                         char gid = ElemEnd_grouping(source,block_base,end_pos);
    432                         if (s!=0){
    433                                 s = s & (s-1);  // clear rightmost bit.
    434                         }
    435                         //else{
    436                         //      s2 = s2 & (s2 - 1);
    437                         //}
    438                                 if (gid != 0){
    439                                         gid_vec.push_back(gid);                 
    440                                 }
    441                                 cout << "here1" << endl;
    442                 }
    443                 }
    444                 block_pos += 8 * sizeof(ScanBlock);
    445                 print_gid_vec();
    446     }
    447     return 0;
    448 }
    449 
    450 void print_gid_vec(){
    451         for (int i = 0; i < gid_vec.size(); i++){
    452                 cout << (int)gid_vec[i] << " ";
    453         }
    454         cout << endl;
    455 /*     
    456         int i = 1;
    457         int lst[256] = {0};
    458         cout << elem_vec_map.size() << " vectors" << endl;
    459         for (int i = 0;i < gids.size(); i++){
    460                 if (lst[gids[i]] == 0){
    461                         cout << "gid: " << gids[i] << endl;
    462                         lst[gids[i]] = 1;
    463                         vector<char> *tmp = elem_vec_map[gids[i]];
    464                         cout << "vector size:"<< (*tmp).size()<<endl;
    465                         if ((*tmp).size()!=0){
    466                                 cout << "elements: ";
    467                                 for (int j = 0; j < (*tmp).size();j++){
    468                                         cout << (int)(*tmp)[j] << " ";
    469                                 }
    470                                 cout << endl;
    471                         }
    472                         cout << endl;
    473                 }
    474         }
    475 */
    476 }
    477 /*
    478 static inline int NameStrt_check(int pos) {
    479         int block_pos = block_base + pos;
    480         if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
    481               ReportError("name start error", pos);
    482               exit(-1);
    483         }
    484         return 0;
    485 }
    486 
    487 static inline int Name_check(int pos) {
    488         int block_pos = block_base + pos;
    489         if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
    490               ReportError("name error", pos);
    491               exit(-1);
    492         }
    493         return 0;
    494 }
    495 
    496 static inline int PIName_check(int pos) {
    497         int block_pos = block_base + pos;
    498         int file_pos = block_pos+buffer_base;
    499         printf ("%s:%i\n",__FUNCTION__,pos);
    500         if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
    501               // "<?xml" legal at start of file.
    502               if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
    503               ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
    504               exit(-1);
    505         }
    506         return 0;
    507 }
    508 
    509 static inline int CD_check(int pos) {
    510         int block_pos = block_base + pos;
    511         if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
    512               ReportError("CDATA error", pos);
    513               exit(-1);
    514         }
    515         return 0;
    516 }
    517 
    518 static inline int GenRef_check(int pos) {
    519         int block_pos = block_base + pos;
    520         unsigned char* s = (unsigned char*)&source[block_pos];
    521         if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
    522                         cout << pos << endl;
    523               ReportError("Undefined reference", pos);
    524               exit(-1);
    525         }
    526         return 0;
    527 }
    528 
    529 static inline int HexRef_check(int pos) {
    530         int block_pos = block_base + pos;
    531         unsigned char* s = (unsigned char*)&source[block_pos];
    532         int ch_val = 0;
    533         while(at_HexDigit<ASCII>(s)){
    534           ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    535           if (ch_val> 0x10FFFF ){
    536             ReportError("Illegal character reference", pos);
    537             exit(-1);
    538           }
    539           s++;
    540         }
    541         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    542           ReportError("Illegal character reference", pos);
    543           exit(-1);
    544         }
    545         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    546           ReportError("Illegal XML 1.0 character reference", pos);
    547           exit(-1);
    548         }
    549         return 0;
    550 }
    551 
    552 static inline int DecRef_check(int pos) {
    553         int block_pos = block_base + pos;
    554         unsigned char* s = (unsigned char*)&source[block_pos];
    555         int ch_val = 0;
    556         while(at_HexDigit<ASCII>(s)){
    557           ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    558           if (ch_val> 0x10FFFF ){
    559             ReportError("Illegal character reference", pos);
    560             exit(-1);
    561           }
    562           s++;
    563         }
    564         if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    565           ReportError("Illegal character reference", pos);
    566           exit(-1);
    567         }
    568         else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    569           ReportError("Illegal XML 1.0 character reference", pos);
    570           exit(-1);
    571         }
    572         return 0;
    573 }
    574 
    575 static inline int AttRef_check(int pos) {
    576         int block_pos = block_base + pos;
    577         unsigned char* s = (unsigned char*)&source[block_pos];
    578         int ch_val = 0;
    579         if(s[0]=='#'){
    580           s++;
    581           if(s[0]=='x' || s[0]=='X'){
    582             s++;
    583             while(at_HexDigit<ASCII>(s)){
    584               ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    585               s++;
    586             }
    587           }
    588           else{
    589             while(at_HexDigit<ASCII>(s)){
    590               ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    591               s++;
    592             }
    593           }
    594           if (ch_val==60){
    595             ReportError("Attribute values contain '<' characters after reference expansion", pos);
    596             exit(-1);
    597           }
    598         }
    599         else if(at_Ref_lt<ASCII>(s)){
    600           ReportError("Attribute values contain '<' characters after reference expansion", pos);
    601           exit(-1);
    602         }
    603         return 0;
    604 }
    605 */
    606 
    607 
    608225
    609226  struct U8 {
     
    667284  BitBlock Hex;
    668285  BitBlock WS;
     286  BitBlock tag_closing;
     287  BitBlock cc0;
     288  BitBlock Caret;
     289  BitBlock Dot;
     290  BitBlock P_H_sign;
     291  BitBlock E_and_e;
     292  BitBlock content_end;
     293  BitBlock cc1;
     294  BitBlock cc2;
     295  BitBlock cc3;
     296  BitBlock cc4;
     297  BitBlock cc5;
     298  BitBlock cc6;
     299  BitBlock cc7;
     300  BitBlock cc8;
     301  BitBlock cc9;
     302  BitBlock cc10;
     303  BitBlock cc11;
     304  BitBlock cc12;
     305  BitBlock cc13;
    669306};
    670307
     
    736373  BitBlock EmptyTag_marks;
    737374  BitBlock EndTag_marks;
     375  BitBlock Content_starts;
    738376  BitBlock Tag_closing;
    739377};
     
    781419};
    782420
     421  struct Output {
     422  BitBlock matches;
     423  BitBlock tem;
     424};
     425
    783426  struct Parse_refs {
    784427  Parse_refs() {
     
    799442        ref_error = simd<1>::constant<0>();
    800443        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
    801           carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
     444          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
    802445          NumRef2 = simd_and(Ref_scope, lex.Hash);
    803446          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    804           carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
     447          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
    805448          HexRef3 = simd_and(NumRef3, lex.x);
    806449          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    807           carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
    808           carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
    809           carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
    810           carryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
     450          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
     451          carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
     452          carryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
     453          carryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
    811454          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    812455          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
     
    822465        carryQ.CarryQ_Adjust(6);
    823466  }
     467  IDISA_INLINE void clear() {
     468 }
    824469  void do_final_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts, BitBlock EOF_mask) {
    825470                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
     
    837482        ref_error = simd<1>::constant<0>();
    838483        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
    839           carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
     484          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
    840485          NumRef2 = simd_and(Ref_scope, lex.Hash);
    841486          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    842           carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
     487          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
    843488          HexRef3 = simd_and(NumRef3, lex.x);
    844489          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    845           carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
    846           carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
    847           carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
    848           carryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
     490          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
     491          carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
     492          carryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
     493          carryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
    849494          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    850495          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
     
    862507  };
    863508
    864   struct Validate_Elem_Vec {
    865  
    866   IDISA_INLINE void do_block(Elem & elem, Basis_bits & basis_bits) {
    867                 BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
    868                 BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
    869                 BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
    870 
    871 
    872 
    873 
    874         temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    875         temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    876         temp3 = simd_or(temp1, temp2);
    877         temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    878         temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    879         temp6 = simd_andc(temp5, temp4);
    880         elem.purchaseOrder = simd_andc(temp6, temp3);
    881         temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    882         temp8 = simd_andc(temp7, temp4);
    883         elem.shipTo = simd_andc(temp8, temp3);
    884         temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    885         temp10 = simd_andc(temp9, temp4);
    886         elem.name = simd_andc(temp10, temp3);
    887         temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    888         temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    889         temp13 = simd_andc(temp11, temp12);
    890         elem.street = simd_andc(temp13, temp3);
    891         temp14 = simd_and(temp11, temp5);
    892         elem.city = simd_andc(temp14, temp3);
    893         temp15 = simd_and(temp11, temp7);
    894         elem.state = simd_andc(temp15, temp3);
    895         temp16 = simd_and(temp11, temp9);
    896         elem.zip = simd_andc(temp16, temp3);
    897         temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    898         temp18 = simd_andc(temp17, temp12);
    899         elem.billTo = simd_andc(temp18, temp3);
    900         temp19 = simd_and(temp17, temp5);
    901         elem.comment = simd_andc(temp19, temp3);
    902         temp20 = simd_and(temp17, temp7);
    903         elem.items = simd_andc(temp20, temp3);
    904         temp21 = simd_and(temp17, temp9);
    905         elem.item = simd_andc(temp21, temp3);
    906         temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    907         temp23 = simd_andc(temp22, temp12);
    908         elem.productName = simd_andc(temp23, temp3);
    909         temp24 = simd_and(temp22, temp5);
    910         elem.quantity = simd_andc(temp24, temp3);
    911         temp25 = simd_and(temp22, temp7);
    912         elem.USPrice = simd_andc(temp25, temp3);
    913         temp26 = simd_and(temp22, temp9);
    914         elem.shipDate = simd_andc(temp26, temp3);
    915   }
    916   void do_final_block(Elem & elem, Basis_bits & basis_bits, BitBlock EOF_mask) {
    917                 BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
    918                 BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
    919                 BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
    920 
    921 
    922 
    923 
    924         temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    925         temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    926         temp3 = simd_or(temp1, temp2);
    927         temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    928         temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    929         temp6 = simd_andc(temp5, temp4);
    930         elem.purchaseOrder = simd_andc(temp6, temp3);
    931         temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    932         temp8 = simd_andc(temp7, temp4);
    933         elem.shipTo = simd_andc(temp8, temp3);
    934         temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    935         temp10 = simd_andc(temp9, temp4);
    936         elem.name = simd_andc(temp10, temp3);
    937         temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    938         temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    939         temp13 = simd_andc(temp11, temp12);
    940         elem.street = simd_andc(temp13, temp3);
    941         temp14 = simd_and(temp11, temp5);
    942         elem.city = simd_andc(temp14, temp3);
    943         temp15 = simd_and(temp11, temp7);
    944         elem.state = simd_andc(temp15, temp3);
    945         temp16 = simd_and(temp11, temp9);
    946         elem.zip = simd_andc(temp16, temp3);
    947         temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    948         temp18 = simd_andc(temp17, temp12);
    949         elem.billTo = simd_andc(temp18, temp3);
    950         temp19 = simd_and(temp17, temp5);
    951         elem.comment = simd_andc(temp19, temp3);
    952         temp20 = simd_and(temp17, temp7);
    953         elem.items = simd_andc(temp20, temp3);
    954         temp21 = simd_and(temp17, temp9);
    955         elem.item = simd_andc(temp21, temp3);
    956         temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    957         temp23 = simd_andc(temp22, temp12);
    958         elem.productName = simd_andc(temp23, temp3);
    959         temp24 = simd_and(temp22, temp5);
    960         elem.quantity = simd_andc(temp24, temp3);
    961         temp25 = simd_and(temp22, temp7);
    962         elem.USPrice = simd_andc(temp25, temp3);
    963         temp26 = simd_and(temp22, temp9);
    964         elem.shipDate = simd_andc(temp26, temp3);
    965   }
    966  
    967   };
    968 
    969509  struct Parse_tags {
    970510  Parse_tags() {
     
    986526        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    987527        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    988         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
     528        carryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
    989529        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    990530        tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    993533        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    994534        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
    995           carryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
     535          carryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
    996536          AttListEnd = simd_and(AfterWS, AttListDelim);
    997537          AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    999539            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1000540            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1001             carryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
     541            carryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
    1002542            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1003543            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
    1004               carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
     544              carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
    1005545            }
    1006546            else {
     
    1009549            }
    1010550            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1011             carryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
     551            carryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
    1012552            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1013553            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1014554            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1015             carryQ.cq[5] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
    1016             carryQ.cq[6] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
     555            carryQ.cq[5] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
     556            carryQ.cq[6] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
    1017557            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1018558            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1019             carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
     559            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
    1020560            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1021561            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
    1022               carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
     562              carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
    1023563              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1024564              AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    1034574              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1035575              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1036               subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, simd<1>::constant<0>(), AttNameFollow));
     576              subcarryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carry_value_0, AttNameFollow));
    1037577              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1038578              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
    1039                 subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, simd<1>::constant<0>(), EqExpected));
     579                subcarryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carry_value_0, EqExpected));
    1040580              }
    1041581              else {
     
    1044584              }
    1045585              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1046               subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, simd<1>::constant<0>(), AttValPos));
     586              subcarryQ.cq[2] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carry_value_0, AttValPos));
    1047587              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1048588              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1049589              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1050               subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), DQuoteAttEnd));
    1051               subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), SQuoteAttEnd));
     590              subcarryQ.cq[3] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carry_value_0, DQuoteAttEnd));
     591              subcarryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carry_value_0, SQuoteAttEnd));
    1052592              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1053593              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1054               subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, simd<1>::constant<0>(), AttValFollow));
     594              subcarryQ.cq[5] = carryout2carry(pablo_blk_Advance(AttValEnd, carry_value_0, AttValFollow));
    1055595              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1056596              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
    1057                 subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, simd<1>::constant<0>(), AfterWS));
     597                subcarryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carry_value_0, AfterWS));
    1058598                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1059599                AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    1078618        }
    1079619        STagEnds = simd_and(AttListEnd, lex.RAngle);
    1080         carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
     620        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
    1081621        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1082         carryQ.cq[10] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
     622        carryQ.cq[10] = carryout2carry(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
    1083623        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
    1084           carryQ.cq[11] = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
     624          carryQ.cq[11] = carryout2carry(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
    1085625        }
    1086626        else {
     
    1091631          assert_0_error("Tag parsing error found", ParseError);
    1092632        }
    1093         carryQ.cq[12] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
     633        carryQ.cq[12] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
     634        tag_Callouts.Content_starts = STagEnds;
    1094635        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
    1095636        carryQ.CarryQ_Adjust(13);
    1096637  }
     638  IDISA_INLINE void clear() {
     639 }
    1097640  void do_final_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
    1098641                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
     
    1111654        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    1112655        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    1113         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
     656        carryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
    1114657        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    1115658        tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    1118661        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1119662        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
    1120           carryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
     663          carryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
    1121664          AttListEnd = simd_and(AfterWS, AttListDelim);
    1122665          AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    1124667            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1125668            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1126             carryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
     669            carryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
    1127670            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1128671            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
    1129               carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
     672              carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
    1130673            }
    1131674            else {
     
    1134677            }
    1135678            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1136             carryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
     679            carryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
    1137680            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1138681            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1139682            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1140             carryQ.cq[5] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
    1141             carryQ.cq[6] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
     683            carryQ.cq[5] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
     684            carryQ.cq[6] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
    1142685            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1143686            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1144             carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
     687            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
    1145688            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1146689            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
    1147               carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
     690              carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
    1148691              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1149692              AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    1159702              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1160703              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1161               subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, simd<1>::constant<0>(), AttNameFollow));
     704              subcarryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carry_value_0, AttNameFollow));
    1162705              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1163706              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
    1164                 subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, simd<1>::constant<0>(), EqExpected));
     707                subcarryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carry_value_0, EqExpected));
    1165708              }
    1166709              else {
     
    1169712              }
    1170713              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1171               subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, simd<1>::constant<0>(), AttValPos));
     714              subcarryQ.cq[2] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carry_value_0, AttValPos));
    1172715              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1173716              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1174717              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1175               subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), DQuoteAttEnd));
    1176               subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), SQuoteAttEnd));
     718              subcarryQ.cq[3] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_value_0, DQuoteAttEnd));
     719              subcarryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_value_0, SQuoteAttEnd));
    1177720              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1178721              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1179               subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, simd<1>::constant<0>(), AttValFollow));
     722              subcarryQ.cq[5] = carryout2carry(pablo_blk_Advance(AttValEnd, carry_value_0, AttValFollow));
    1180723              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1181724              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
    1182                 subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, simd<1>::constant<0>(), AfterWS));
     725                subcarryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carry_value_0, AfterWS));
    1183726                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1184727                AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    1203746        }
    1204747        STagEnds = simd_and(AttListEnd, lex.RAngle);
    1205         carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
     748        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
    1206749        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1207         carryQ.cq[10] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
     750        carryQ.cq[10] = carryout2carry(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
    1208751        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
    1209           carryQ.cq[11] = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
     752          carryQ.cq[11] = carryout2carry(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
    1210753        }
    1211754        else {
     
    1216759          assert_0_error("Tag parsing error found", ParseError);
    1217760        }
    1218         carryQ.cq[12] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
     761        carryQ.cq[12] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
     762        tag_Callouts.Content_starts = STagEnds;
    1219763        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
    1220764  }
     
    1357901          u8.badprefix = simd_or(temp68, temp71);
    1358902          u8_error = u8.badprefix;
    1359           carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
     903          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
    1360904          u8anyscope = u8.scope22;
    1361905          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
     
    1373917            u8.xBF = simd_and(temp73, temp23);
    1374918            u8.xBE = simd_and(temp73, temp15);
    1375             carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
    1376             carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
    1377             carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
    1378             carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
    1379             carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
    1380             carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
    1381             carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
    1382             carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
    1383             carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
    1384             carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
     919            carryQ.cq[1] = carryout2carry(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
     920            carryQ.cq[2] = carryout2carry(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
     921            carryQ.cq[3] = carryout2carry(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
     922            carryQ.cq[4] = carryout2carry(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
     923            carryQ.cq[5] = carryout2carry(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
     924            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
     925            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
     926            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
     927            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
     928            carryQ.cq[10] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
    1385929            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    1386930            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    1390934            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    1391935            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    1392             carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
     936            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
    1393937            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    1394938          }
     
    1405949          carryQ.CarryDequeueEnqueue(0, 12);
    1406950        }
     951        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
     952        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
     953        temp3 = simd_or(temp1, temp2);
     954        temp4 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
     955        temp5 = simd_and(basis_bits.bit_4, temp4);
     956        temp6 = simd_or(temp3, temp5);
     957        temp7 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
     958        temp8 = simd_or(basis_bits.bit_5, temp7);
     959        temp9 = simd_and(basis_bits.bit_4, temp8);
     960        temp10 = simd_or(temp2, temp9);
     961        temp11 = simd_or(basis_bits.bit_1, temp10);
     962        temp12 = simd_or(basis_bits.bit_0, temp11);
     963        temp13 = simd_andc(temp6, temp12);
     964        lex.Caret = simd_not(temp13);
     965        temp14 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
     966        temp15 = simd_andc(temp14, temp1);
     967        temp16 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
     968        temp17 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
     969        temp18 = simd_and(temp16, temp17);
     970        lex.Dot = simd_and(temp15, temp18);
     971        temp19 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
     972        temp20 = simd_andc(temp7, temp19);
     973        lex.content_end = simd_and(temp15, temp20);
     974        temp21 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
     975        temp22 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
     976        temp23 = simd_and(temp21, temp22);
     977        temp24 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
     978        temp25 = simd_andc(temp2, temp14);
     979        temp26 = simd_andc(temp24, temp25);
     980        lex.E_and_e = simd_and(temp23, temp26);
     981        temp27 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
     982        temp28 = simd_andc(temp27, temp1);
     983        lex.Digit = simd_andc(temp28, temp5);
     984        temp29 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
     985        temp30 = simd_and(temp29, temp7);
     986        temp31 = simd_and(temp16, temp22);
     987        temp32 = simd_or(temp30, temp31);
     988        lex.P_H_sign = simd_and(temp15, temp32);
    1407989        carryQ.CarryQ_Adjust(12);
    1408990  }
     991  IDISA_INLINE void clear() {
     992 }
    1409993  void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
    1410994                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
     
    15391123          u8.badprefix = simd_or(temp68, temp71);
    15401124          u8_error = u8.badprefix;
    1541           carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
     1125          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
    15421126          u8anyscope = u8.scope22;
    15431127          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
     
    15551139            u8.xBF = simd_and(temp73, temp23);
    15561140            u8.xBE = simd_and(temp73, temp15);
    1557             carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
    1558             carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
    1559             carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
    1560             carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
    1561             carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
    1562             carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
    1563             carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
    1564             carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
    1565             carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
    1566             carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
     1141            carryQ.cq[1] = carryout2carry(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
     1142            carryQ.cq[2] = carryout2carry(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
     1143            carryQ.cq[3] = carryout2carry(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
     1144            carryQ.cq[4] = carryout2carry(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
     1145            carryQ.cq[5] = carryout2carry(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
     1146            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
     1147            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
     1148            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
     1149            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
     1150            carryQ.cq[10] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
    15671151            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    15681152            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    15721156            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    15731157            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    1574             carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
     1158            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
    15751159            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    15761160          }
     
    15871171          carryQ.CarryDequeueEnqueue(0, 12);
    15881172        }
     1173        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
     1174        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
     1175        temp3 = simd_or(temp1, temp2);
     1176        temp4 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
     1177        temp5 = simd_and(basis_bits.bit_4, temp4);
     1178        temp6 = simd_or(temp3, temp5);
     1179        temp7 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
     1180        temp8 = simd_or(basis_bits.bit_5, temp7);
     1181        temp9 = simd_and(basis_bits.bit_4, temp8);
     1182        temp10 = simd_or(temp2, temp9);
     1183        temp11 = simd_or(basis_bits.bit_1, temp10);
     1184        temp12 = simd_or(basis_bits.bit_0, temp11);
     1185        temp13 = simd_andc(temp6, temp12);
     1186        lex.Caret = simd_not(temp13);
     1187        temp14 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
     1188        temp15 = simd_andc(temp14, temp1);
     1189        temp16 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
     1190        temp17 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
     1191        temp18 = simd_and(temp16, temp17);
     1192        lex.Dot = simd_and(temp15, temp18);
     1193        temp19 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
     1194        temp20 = simd_andc(temp7, temp19);
     1195        lex.content_end = simd_and(temp15, temp20);
     1196        temp21 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
     1197        temp22 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
     1198        temp23 = simd_and(temp21, temp22);
     1199        temp24 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
     1200        temp25 = simd_andc(temp2, temp14);
     1201        temp26 = simd_andc(temp24, temp25);
     1202        lex.E_and_e = simd_and(temp23, temp26);
     1203        temp27 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
     1204        temp28 = simd_andc(temp27, temp1);
     1205        lex.Digit = simd_andc(temp28, temp5);
     1206        temp29 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
     1207        temp30 = simd_and(temp29, temp7);
     1208        temp31 = simd_and(temp16, temp22);
     1209        temp32 = simd_or(temp30, temp31);
     1210        lex.P_H_sign = simd_and(temp15, temp32);
    15891211  }
    15901212  CarryArray<12, 0> carryQ;
     
    16171239        v = simd_or(lex.LAngle, lex.Hyphen);
    16181240        w = simd_or(lex.Hyphen, lex.QMark);
    1619         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
    1620         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
     1241        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
     1242        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
    16211243        LAngle_scope = simd_andc(v1, w1);
    16221244        PI_opener = simd_and(LAngle_scope, lex.QMark);
     
    16261248        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    16271249        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
    1628           carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
     1250          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
    16291251          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
    1630           carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
     1252          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
    16311253          CD_closer = simd_and(tempvar1, lex.RAngle);
    16321254        }
     
    16351257        }
    16361258        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    1637         carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
     1259        carryQ.cq[4] = carryout2carry(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
    16381260        if ((bitblock::any(CtCDPI_Cursor) || carryQ.CarryTest(5, 13))) {
    16391261          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    16401262          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    1641           carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
     1263          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
    16421264          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    16431265          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    16441266          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
    16451267            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    1646             carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
     1268            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
    16471269            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    1648             carryQ.cq[7] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
     1270            carryQ.cq[7] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
    16491271            PI_error = simd_and(PI_Cursor, PI_name_end);
    16501272            PI_noWS = simd_andc(PI_name_end, lex.WS);
    1651             carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
     1273            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
    16521274            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
    16531275            if (bitblock::any(PI_error)) {
     
    16551277            }
    16561278            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    1657             carryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(9), PI_Cursor));
     1279            carryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(9), PI_Cursor));
    16581280            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    16591281            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    16641286          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
    16651287            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    1666             carryQ.cq[10] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(10), CD_Cursor));
     1288            carryQ.cq[10] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(10), CD_Cursor));
    16671289            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    16681290            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    16731295          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
    16741296            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    1675             carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
     1297            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
    16761298            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    1677             carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
    1678             carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
    1679             carryQ.cq[14] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
    1680             carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
     1299            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
     1300            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
     1301            carryQ.cq[14] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
     1302            carryQ.cq[15] = carryout2carry(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
    16811303            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
    16821304              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
     
    16891311          }
    16901312          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    1691           carryQ.cq[16] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
     1313          carryQ.cq[16] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
    16921314          if (bitblock::any(simd<1>::constant<0>())) {
    16931315            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    16941316          }
    1695           carryQ.cq[17] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
     1317          carryQ.cq[17] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
    16961318          while (bitblock::any(CtCDPI_Cursor)) {
    16971319            LocalCarryDeclare(subcarryQ, 13);
    16981320            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    16991321            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    1700             subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), CD_Ct_Cursor));
     1322            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_value_0, CD_Ct_Cursor));
    17011323            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    17021324            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    17031325            if (bitblock::any(PI_Cursor)) {
    17041326              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    1705               subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, simd<1>::constant<0>(), PI_Cursor));
     1327              subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(PI_Cursor, carry_value_0, PI_Cursor));
    17061328              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    1707               subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), PI_name_end));
     1329              subcarryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carry_value_0, PI_name_end));
    17081330              PI_error = simd_and(PI_Cursor, PI_name_end);
    17091331              PI_noWS = simd_andc(PI_name_end, lex.WS);
    1710               subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, simd<1>::constant<0>(), tempvar2));
     1332              subcarryQ.cq[3] = carryout2carry(pablo_blk_Advance(PI_noWS, carry_value_0, tempvar2));
    17111333              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
    17121334              if (bitblock::any(PI_error)) {
     
    17141336              }
    17151337              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    1716               subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), PI_Cursor));
     1338              subcarryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carry_value_0, PI_Cursor));
    17171339              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    17181340              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    17231345            if (bitblock::any(CD_Cursor)) {
    17241346              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    1725               subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), CD_Cursor));
     1347              subcarryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carry_value_0, CD_Cursor));
    17261348              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    17271349              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    17321354            if (bitblock::any(Ct_Cursor)) {
    17331355              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    1734               subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), Ct_Cursor));
     1356              subcarryQ.cq[6] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, Ct_Cursor));
    17351357              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    1736               subcarryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), tempvar3));
    1737               subcarryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, simd<1>::constant<0>(), Ct_Cursor));
    1738               subcarryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), tempvar4));
    1739               subcarryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, simd<1>::constant<0>(), Ct_Cursor));
     1358              subcarryQ.cq[7] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, tempvar3));
     1359              subcarryQ.cq[8] = carryout2carry(pablo_blk_Advance(tempvar3, carry_value_0, Ct_Cursor));
     1360              subcarryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carry_value_0, tempvar4));
     1361              subcarryQ.cq[10] = carryout2carry(pablo_blk_Advance(tempvar4, carry_value_0, Ct_Cursor));
    17401362              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
    17411363                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
     
    17481370            }
    17491371            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    1750             subcarryQ.cq[11] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), ctCDPI_mask));
     1372            subcarryQ.cq[11] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carry_value_0, ctCDPI_mask));
    17511373            if (bitblock::any(simd<1>::constant<0>())) {
    17521374              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    17531375            }
    1754             subcarryQ.cq[12] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), CtCDPI_Cursor));
     1376            subcarryQ.cq[12] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_value_0, CtCDPI_Cursor));
    17551377            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
    17561378          }
     
    17591381          carryQ.CarryDequeueEnqueue(5, 13);
    17601382        }
    1761         carryQ.cq[18] = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
     1383        carryQ.cq[18] = carryout2carry(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
    17621384        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
    17631385        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
     
    17661388        carryQ.CarryQ_Adjust(17);
    17671389  }
     1390  IDISA_INLINE void clear() {
     1391carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
     1392 }
    17681393  void do_final_block(Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
    17691394                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
     
    17881413        v = simd_or(lex.LAngle, lex.Hyphen);
    17891414        w = simd_or(lex.Hyphen, lex.QMark);
    1790         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
    1791         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
     1415        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
     1416        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
    17921417        LAngle_scope = simd_andc(v1, w1);
    17931418        PI_opener = simd_and(LAngle_scope, lex.QMark);
     
    17971422        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    17981423        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
    1799           carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
     1424          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
    18001425          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
    1801           carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
     1426          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
    18021427          CD_closer = simd_and(tempvar1, lex.RAngle);
    18031428        }
     
    18061431        }
    18071432        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    1808         carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
     1433        carryQ.cq[4] = carryout2carry(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
    18091434        if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) || carryQ.CarryTest(5, 13))) {
    18101435          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    18111436          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    1812           carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
     1437          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
    18131438          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    18141439          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    18151440          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
    18161441            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    1817             carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
     1442            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
    18181443            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    1819             carryQ.cq[7] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
     1444            carryQ.cq[7] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
    18201445            PI_error = simd_and(PI_Cursor, PI_name_end);
    18211446            PI_noWS = simd_andc(PI_name_end, lex.WS);
    1822             carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
     1447            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
    18231448            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
    18241449            if (bitblock::any(PI_error)) {
     
    18261451            }
    18271452            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    1828             carryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(9), PI_Cursor));
     1453            carryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(9), PI_Cursor));
    18291454            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    18301455            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    18351460          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
    18361461            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    1837             carryQ.cq[10] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(10), CD_Cursor));
     1462            carryQ.cq[10] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(10), CD_Cursor));
    18381463            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    18391464            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    18441469          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
    18451470            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    1846             carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
     1471            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
    18471472            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    1848             carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
    1849             carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
    1850             carryQ.cq[14] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
    1851             carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
     1473            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
     1474            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
     1475            carryQ.cq[14] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
     1476            carryQ.cq[15] = carryout2carry(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
    18521477            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
    18531478              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
     
    18601485          }
    18611486          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    1862           carryQ.cq[16] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
    1863           if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask))) {
    1864             assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
     1487          carryQ.cq[16] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
     1488          if (bitblock::any(simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))))) {
     1489            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))));
    18651490          }
    1866           carryQ.cq[17] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
     1491          carryQ.cq[17] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
    18671492          while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
    18681493            LocalCarryDeclare(subcarryQ, 13);
    18691494            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    18701495            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    1871             subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), CD_Ct_Cursor));
     1496            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_value_0, CD_Ct_Cursor));
    18721497            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    18731498            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    18741499            if (bitblock::any(PI_Cursor)) {
    18751500              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    1876               subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, simd<1>::constant<0>(), PI_Cursor));
     1501              subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(PI_Cursor, carry_value_0, PI_Cursor));
    18771502              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    1878               subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), PI_name_end));
     1503              subcarryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carry_value_0, PI_name_end));
    18791504              PI_error = simd_and(PI_Cursor, PI_name_end);
    18801505              PI_noWS = simd_andc(PI_name_end, lex.WS);
    1881               subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, simd<1>::constant<0>(), tempvar2));
     1506              subcarryQ.cq[3] = carryout2carry(pablo_blk_Advance(PI_noWS, carry_value_0, tempvar2));
    18821507              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
    18831508              if (bitblock::any(PI_error)) {
     
    18851510              }
    18861511              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    1887               subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), PI_Cursor));
     1512              subcarryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_value_0, PI_Cursor));
    18881513              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    18891514              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    18941519            if (bitblock::any(CD_Cursor)) {
    18951520              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    1896               subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), CD_Cursor));
     1521              subcarryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_value_0, CD_Cursor));
    18971522              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    18981523              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    19031528            if (bitblock::any(Ct_Cursor)) {
    19041529              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    1905               subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), Ct_Cursor));
     1530              subcarryQ.cq[6] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, Ct_Cursor));
    19061531              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    1907               subcarryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), tempvar3));
    1908               subcarryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, simd<1>::constant<0>(), Ct_Cursor));
    1909               subcarryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), tempvar4));
    1910               subcarryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, simd<1>::constant<0>(), Ct_Cursor));
     1532              subcarryQ.cq[7] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, tempvar3));
     1533              subcarryQ.cq[8] = carryout2carry(pablo_blk_Advance(tempvar3, carry_value_0, Ct_Cursor));
     1534              subcarryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_value_0, tempvar4));
     1535              subcarryQ.cq[10] = carryout2carry(pablo_blk_Advance(tempvar4, carry_value_0, Ct_Cursor));
    19111536              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
    19121537                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
     
    19191544            }
    19201545            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    1921             subcarryQ.cq[11] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), ctCDPI_mask));
    1922             if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask))) {
    1923               assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
     1546            subcarryQ.cq[11] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carry_value_0, ctCDPI_mask));
     1547            if (bitblock::any(simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))))) {
     1548              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))));
    19241549            }
    1925             subcarryQ.cq[12] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), CtCDPI_Cursor));
     1550            subcarryQ.cq[12] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_value_0, CtCDPI_Cursor));
    19261551            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
    19271552          }
     
    19301555          carryQ.CarryDequeueEnqueue(5, 13);
    19311556        }
    1932         carryQ.cq[18] = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
     1557        carryQ.cq[18] = carryout2carry(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
    19331558        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
    19341559        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
     
    19391564  };
    19401565
     1566  struct Validation_9 {
     1567  Validation_9() {
     1568 }
     1569  IDISA_INLINE void do_block(Lex & lex, Output & output) {
     1570                BitBlock m0, m1, m2;
     1571
     1572
     1573
     1574
     1575        m0 = simd<1>::constant<0>();
     1576        m1 = simd<1>::constant<0>();
     1577        m2 = simd<1>::constant<0>();
     1578        m0 = simd_not(simd<1>::constant<0>());
     1579        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc9), carryQ.get_carry_in(0), m0));
     1580        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc10), carryQ.get_carry_in(1), m0));
     1581        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
     1582        m1 = m0;
     1583        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc11), carryQ.get_carry_in(3), m1));
     1584        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(4), m1));
     1585        m0 = simd_or(m0, m1);
     1586        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc12), carryQ.get_carry_in(5), m0));
     1587        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
     1588        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc13), carryQ.get_carry_in(7), m0));
     1589        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
     1590        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
     1591        output.matches = m0;
     1592        output.matches = simd_xor(m0, lex.cc9);
     1593        if (bitblock::any(output.matches)) {
     1594          error_tracker.NoteError("Element_9 error found", output.matches);
     1595        }
     1596        carryQ.CarryQ_Adjust(10);
     1597  }
     1598  IDISA_INLINE void clear() {
     1599 }
     1600  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
     1601                BitBlock m0, m1, m2;
     1602
     1603
     1604
     1605
     1606        m0 = simd<1>::constant<0>();
     1607        m1 = simd<1>::constant<0>();
     1608        m2 = simd<1>::constant<0>();
     1609        m0 = simd_not(simd<1>::constant<0>());
     1610        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc9), carryQ.get_carry_in(0), m0));
     1611        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc10), carryQ.get_carry_in(1), m0));
     1612        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
     1613        m1 = m0;
     1614        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc11), carryQ.get_carry_in(3), m1));
     1615        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(4), m1));
     1616        m0 = simd_or(m0, m1);
     1617        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc12), carryQ.get_carry_in(5), m0));
     1618        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
     1619        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc13), carryQ.get_carry_in(7), m0));
     1620        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
     1621        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
     1622        output.matches = m0;
     1623        output.matches = simd_xor(m0, lex.cc9);
     1624        if (bitblock::any(output.matches)) {
     1625          error_tracker.NoteError("Element_9 error found", output.matches);
     1626        }
     1627  }
     1628  CarryArray<10, 0> carryQ;
     1629  };
     1630
    19411631  struct Do_check_streams {
    19421632 
     
    19541644        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
    19551645  }
     1646  IDISA_INLINE void clear() {
     1647 }
    19561648  void do_final_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
    19571649
     
    19701662  };
    19711663
    1972   struct Form_Length_Group_Bitstreams {
    1973   Form_Length_Group_Bitstreams() {
     1664  struct Classify_bytes {
     1665 
     1666  IDISA_INLINE void do_block(Basis_bits & basis_bits, Lex & lex) {
     1667                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
     1668                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
     1669                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
     1670
     1671
     1672
     1673
     1674        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
     1675        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
     1676        temp3 = simd_or(temp1, temp2);
     1677        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
     1678        temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
     1679        temp6 = simd_andc(temp5, temp4);
     1680        lex.cc1 = simd_andc(temp6, temp3);
     1681        temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
     1682        temp8 = simd_andc(temp7, temp4);
     1683        lex.cc2 = simd_andc(temp8, temp3);
     1684        temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
     1685        temp10 = simd_andc(temp9, temp4);
     1686        lex.cc3 = simd_andc(temp10, temp3);
     1687        temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
     1688        temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
     1689        temp13 = simd_andc(temp11, temp12);
     1690        lex.cc4 = simd_andc(temp13, temp3);
     1691        temp14 = simd_and(temp11, temp5);
     1692        lex.cc5 = simd_andc(temp14, temp3);
     1693        temp15 = simd_and(temp11, temp7);
     1694        lex.cc6 = simd_andc(temp15, temp3);
     1695        temp16 = simd_and(temp11, temp9);
     1696        lex.cc7 = simd_andc(temp16, temp3);
     1697        temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
     1698        temp18 = simd_andc(temp17, temp12);
     1699        lex.cc8 = simd_andc(temp18, temp3);
     1700        temp19 = simd_and(temp17, temp5);
     1701        lex.cc9 = simd_andc(temp19, temp3);
     1702        temp20 = simd_and(temp17, temp7);
     1703        lex.cc10 = simd_andc(temp20, temp3);
     1704        temp21 = simd_and(temp17, temp9);
     1705        lex.cc11 = simd_andc(temp21, temp3);
     1706        temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
     1707        temp23 = simd_andc(temp22, temp12);
     1708        lex.cc12 = simd_andc(temp23, temp3);
     1709        temp24 = simd_and(temp22, temp5);
     1710        lex.cc13 = simd_andc(temp24, temp3);
     1711        temp25 = simd_or(temp4, temp12);
     1712        temp26 = simd_or(temp3, temp25);
     1713        lex.tag_closing = simd_not(temp26);
     1714  }
     1715  IDISA_INLINE void clear() {
    19741716 }
    1975   IDISA_INLINE void do_block(Tag_Callouts & tag_Callouts) {
    1976                 BitBlock remaining_starts, remaining_ends, temp;
    1977 
    1978 
    1979 
    1980 
    1981         remaining_starts = tag_Callouts.ElemName_starts;
    1982         remaining_ends = tag_Callouts.ElemName_ends;
    1983         temp = tag_Callouts.ElemName_starts;
    1984         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(0), temp));
    1985         tag_Callouts.ElemName_ends_1 = simd_and(temp, remaining_ends);
    1986         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_1);
    1987         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(1), temp));
    1988         tag_Callouts.ElemName_ends_2 = simd_and(temp, remaining_ends);
    1989         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_2);
    1990         carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(2), temp));
    1991         tag_Callouts.ElemName_ends_3 = simd_and(temp, remaining_ends);
    1992         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_3);
    1993         carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(3), temp));
    1994         tag_Callouts.ElemName_ends_4 = simd_and(temp, remaining_ends);
    1995         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_4);
    1996         carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(4), temp));
    1997         tag_Callouts.ElemName_ends_5 = simd_and(temp, remaining_ends);
    1998         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_5);
    1999         carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(5), temp));
    2000         tag_Callouts.ElemName_ends_6 = simd_and(temp, remaining_ends);
    2001         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_6);
    2002         carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(6), temp));
    2003         tag_Callouts.ElemName_ends_7 = simd_and(temp, remaining_ends);
    2004         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_7);
    2005         carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(7), temp));
    2006         tag_Callouts.ElemName_ends_8 = simd_and(temp, remaining_ends);
    2007         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_8);
    2008         carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(8), temp));
    2009         tag_Callouts.ElemName_ends_9 = simd_and(temp, remaining_ends);
    2010         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_9);
    2011         carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(9), temp));
    2012         tag_Callouts.ElemName_ends_10 = simd_and(temp, remaining_ends);
    2013         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_10);
    2014         carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(10), temp));
    2015         tag_Callouts.ElemName_ends_11 = simd_and(temp, remaining_ends);
    2016         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_11);
    2017         carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(11), temp));
    2018         tag_Callouts.ElemName_ends_12 = simd_and(temp, remaining_ends);
    2019         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_12);
    2020         carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(12), temp));
    2021         tag_Callouts.ElemName_ends_13 = simd_and(temp, remaining_ends);
    2022         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_13);
    2023         carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(13), temp));
    2024         tag_Callouts.ElemName_ends_14 = simd_and(temp, remaining_ends);
    2025         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_14);
    2026         carryQ.cq[14] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(14), temp));
    2027         tag_Callouts.ElemName_ends_15 = simd_and(temp, remaining_ends);
    2028         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_15);
    2029         carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(15), temp));
    2030         tag_Callouts.ElemName_ends_16 = simd_and(temp, remaining_ends);
    2031         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_16);
    2032         tag_Callouts.ElemName_ends_17_and_longer = remaining_ends;
    2033         carryQ.CarryQ_Adjust(16);
     1717  void do_final_block(Basis_bits & basis_bits, Lex & lex, BitBlock EOF_mask) {
     1718                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
     1719                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
     1720                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
     1721
     1722
     1723
     1724
     1725        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
     1726        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
     1727        temp3 = simd_or(temp1, temp2);
     1728        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
     1729        temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
     1730        temp6 = simd_andc(temp5, temp4);
     1731        lex.cc1 = simd_andc(temp6, temp3);
     1732        temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
     1733        temp8 = simd_andc(temp7, temp4);
     1734        lex.cc2 = simd_andc(temp8, temp3);
     1735        temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
     1736        temp10 = simd_andc(temp9, temp4);
     1737        lex.cc3 = simd_andc(temp10, temp3);
     1738        temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
     1739        temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
     1740        temp13 = simd_andc(temp11, temp12);
     1741        lex.cc4 = simd_andc(temp13, temp3);
     1742        temp14 = simd_and(temp11, temp5);
     1743        lex.cc5 = simd_andc(temp14, temp3);
     1744        temp15 = simd_and(temp11, temp7);
     1745        lex.cc6 = simd_andc(temp15, temp3);
     1746        temp16 = simd_and(temp11, temp9);
     1747        lex.cc7 = simd_andc(temp16, temp3);
     1748        temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
     1749        temp18 = simd_andc(temp17, temp12);
     1750        lex.cc8 = simd_andc(temp18, temp3);
     1751        temp19 = simd_and(temp17, temp5);
     1752        lex.cc9 = simd_andc(temp19, temp3);
     1753        temp20 = simd_and(temp17, temp7);
     1754        lex.cc10 = simd_andc(temp20, temp3);
     1755        temp21 = simd_and(temp17, temp9);
     1756        lex.cc11 = simd_andc(temp21, temp3);
     1757        temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
     1758        temp23 = simd_andc(temp22, temp12);
     1759        lex.cc12 = simd_andc(temp23, temp3);
     1760        temp24 = simd_and(temp22, temp5);
     1761        lex.cc13 = simd_andc(temp24, temp3);
     1762        temp25 = simd_or(temp4, temp12);
     1763        temp26 = simd_or(temp3, temp25);
     1764        lex.tag_closing = simd_not(temp26);
    20341765  }
    2035   void do_final_block(Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
    2036                 BitBlock remaining_starts, remaining_ends, temp;
    2037 
    2038 
    2039 
    2040 
    2041         remaining_starts = tag_Callouts.ElemName_starts;
    2042         remaining_ends = tag_Callouts.ElemName_ends;
    2043         temp = tag_Callouts.ElemName_starts;
    2044         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(0), temp));
    2045         tag_Callouts.ElemName_ends_1 = simd_and(temp, remaining_ends);
    2046         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_1);
    2047         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(1), temp));
    2048         tag_Callouts.ElemName_ends_2 = simd_and(temp, remaining_ends);
    2049         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_2);
    2050         carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(2), temp));
    2051         tag_Callouts.ElemName_ends_3 = simd_and(temp, remaining_ends);
    2052         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_3);
    2053         carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(3), temp));
    2054         tag_Callouts.ElemName_ends_4 = simd_and(temp, remaining_ends);
    2055         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_4);
    2056         carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(4), temp));
    2057         tag_Callouts.ElemName_ends_5 = simd_and(temp, remaining_ends);
    2058         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_5);
    2059         carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(5), temp));
    2060         tag_Callouts.ElemName_ends_6 = simd_and(temp, remaining_ends);
    2061         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_6);
    2062         carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(6), temp));
    2063         tag_Callouts.ElemName_ends_7 = simd_and(temp, remaining_ends);
    2064         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_7);
    2065         carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(7), temp));
    2066         tag_Callouts.ElemName_ends_8 = simd_and(temp, remaining_ends);
    2067         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_8);
    2068         carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(8), temp));
    2069         tag_Callouts.ElemName_ends_9 = simd_and(temp, remaining_ends);
    2070         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_9);
    2071         carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(9), temp));
    2072         tag_Callouts.ElemName_ends_10 = simd_and(temp, remaining_ends);
    2073         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_10);
    2074         carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(10), temp));
    2075         tag_Callouts.ElemName_ends_11 = simd_and(temp, remaining_ends);
    2076         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_11);
    2077         carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(11), temp));
    2078         tag_Callouts.ElemName_ends_12 = simd_and(temp, remaining_ends);
    2079         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_12);
    2080         carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(12), temp));
    2081         tag_Callouts.ElemName_ends_13 = simd_and(temp, remaining_ends);
    2082         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_13);
    2083         carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(13), temp));
    2084         tag_Callouts.ElemName_ends_14 = simd_and(temp, remaining_ends);
    2085         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_14);
    2086         carryQ.cq[14] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(14), temp));
    2087         tag_Callouts.ElemName_ends_15 = simd_and(temp, remaining_ends);
    2088         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_15);
    2089         carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(15), temp));
    2090         tag_Callouts.ElemName_ends_16 = simd_and(temp, remaining_ends);
    2091         remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_16);
    2092         tag_Callouts.ElemName_ends_17_and_longer = remaining_ends;
     1766 
     1767  };
     1768
     1769  struct Validation_2 {
     1770  Validation_2() {
     1771 }
     1772  IDISA_INLINE void do_block(Lex & lex, Output & output) {
     1773                BitBlock m0, m1, m2;
     1774
     1775
     1776
     1777
     1778        m0 = simd<1>::constant<0>();
     1779        m1 = simd<1>::constant<0>();
     1780        m2 = simd<1>::constant<0>();
     1781        m0 = simd_not(simd<1>::constant<0>());
     1782        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc2), carryQ.get_carry_in(0), m0));
     1783        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc3), carryQ.get_carry_in(1), m0));
     1784        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
     1785        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(3), m0));
     1786        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
     1787        m1 = m0;
     1788        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(5), m1));
     1789        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(6), m1));
     1790        m0 = m1;
     1791        m1 = m0;
     1792        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(7), m1));
     1793        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(8), m1));
     1794        if ((bitblock::any(simd_andc(m1, m0)) || carryQ.CarryTest(9, 2))) {
     1795          m0 = simd_or(m0, m1);
     1796          carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(9), m1));
     1797          carryQ.cq[10] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(10), m1));
     1798          while (bitblock::any(simd_andc(m1, m0))) {
     1799            LocalCarryDeclare(subcarryQ, 2);
     1800            m0 = simd_or(m0, m1);
     1801            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carry_value_0, m1));
     1802            subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carry_value_0, m1));
     1803            carryQ.CarryCombine(subcarryQ.cq, 9, 2);
     1804          }
     1805        }
     1806        else {
     1807          carryQ.CarryDequeueEnqueue(9, 2);
     1808        }
     1809        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(11), m0));
     1810        output.matches = m0;
     1811        output.matches = simd_xor(m0, lex.cc2);
     1812        if (bitblock::any(output.matches)) {
     1813          error_tracker.NoteError("Element_2 error found", output.matches);
     1814        }
     1815        carryQ.CarryQ_Adjust(12);
    20931816  }
    2094   CarryArray<16, 0> carryQ;
     1817  IDISA_INLINE void clear() {
     1818 }
     1819  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
     1820                BitBlock m0, m1, m2;
     1821
     1822
     1823
     1824
     1825        m0 = simd<1>::constant<0>();
     1826        m1 = simd<1>::constant<0>();
     1827        m2 = simd<1>::constant<0>();
     1828        m0 = simd_not(simd<1>::constant<0>());
     1829        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc2), carryQ.get_carry_in(0), m0));
     1830        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc3), carryQ.get_carry_in(1), m0));
     1831        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
     1832        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(3), m0));
     1833        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
     1834        m1 = m0;
     1835        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(5), m1));
     1836        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(6), m1));
     1837        m0 = m1;
     1838        m1 = m0;
     1839        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(7), m1));
     1840        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(8), m1));
     1841        if ((bitblock::any(simd_and(simd_andc(m1, m0), EOF_mask)) || carryQ.CarryTest(9, 2))) {
     1842          m0 = simd_or(m0, m1);
     1843          carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(9), m1));
     1844          carryQ.cq[10] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(10), m1));
     1845          while (bitblock::any(simd_and(simd_andc(m1, m0), EOF_mask))) {
     1846            LocalCarryDeclare(subcarryQ, 2);
     1847            m0 = simd_or(m0, m1);
     1848            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carry_value_0, m1));
     1849            subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carry_value_0, m1));
     1850            carryQ.CarryCombine(subcarryQ.cq, 9, 2);
     1851          }
     1852        }
     1853        else {
     1854          carryQ.CarryDequeueEnqueue(9, 2);
     1855        }
     1856        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(11), m0));
     1857        output.matches = m0;
     1858        output.matches = simd_xor(m0, lex.cc2);
     1859        if (bitblock::any(output.matches)) {
     1860          error_tracker.NoteError("Element_2 error found", output.matches);
     1861        }
     1862  }
     1863  CarryArray<12, 0> carryQ;
    20951864  };
    20961865
     
    21071876
    21081877
    2109         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
    2110         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
    2111         carryQ.cq[2] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
    2112         carryQ.cq[3] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
     1878        carryQ.cq[0] = carryout2carry(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
     1879        carryQ.cq[1] = carryout2carry(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
     1880        carryQ.cq[2] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
     1881        carryQ.cq[3] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
    21131882        qname_stream = simd_or(ElemNames, AttNames);
    21141883        ncname_stream = simd_or(PI_names, GenRefs);
    21151884        name_stream = simd_or(qname_stream, ncname_stream);
    2116         carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
     1885        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
    21171886        name_start = simd_andc(name_stream, tempvar0);
    2118         carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
     1887        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
    21191888        name_cursor = simd_andc(name_stream, tempvar1);
    21201889        void_prefix_err = simd_and(name_cursor, lex.Colon);
    2121         carryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
     1890        carryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
    21221891        namespace_sep = simd_and(tempvar2, lex.Colon);
    2123         carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
     1892        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
    21241893        local_part_err = simd_andc(local_part_start, lex.NameScan);
    2125         carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
     1894        carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
    21261895        colon2_err = simd_and(tempvar3, lex.Colon);
    21271896        ncname_err = simd_and(ncname_stream, lex.Colon);
     
    21341903        carryQ.CarryQ_Adjust(9);
    21351904  }
     1905  IDISA_INLINE void clear() {
     1906 }
    21361907  void do_final_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Check_streams & check_streams, BitBlock EOF_mask) {
    21371908                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
     
    21431914
    21441915
    2145         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
    2146         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
    2147         carryQ.cq[2] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
    2148         carryQ.cq[3] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
     1916        carryQ.cq[0] = carryout2carry(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
     1917        carryQ.cq[1] = carryout2carry(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
     1918        carryQ.cq[2] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
     1919        carryQ.cq[3] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
    21491920        qname_stream = simd_or(ElemNames, AttNames);
    21501921        ncname_stream = simd_or(PI_names, GenRefs);
    21511922        name_stream = simd_or(qname_stream, ncname_stream);
    2152         carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
     1923        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
    21531924        name_start = simd_andc(name_stream, tempvar0);
    2154         carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
     1925        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
    21551926        name_cursor = simd_andc(name_stream, tempvar1);
    21561927        void_prefix_err = simd_and(name_cursor, lex.Colon);
    2157         carryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
     1928        carryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
    21581929        namespace_sep = simd_and(tempvar2, lex.Colon);
    2159         carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
     1930        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
    21601931        local_part_err = simd_andc(local_part_start, lex.NameScan);
    2161         carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
     1932        carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
    21621933        colon2_err = simd_and(tempvar3, lex.Colon);
    21631934        ncname_err = simd_and(ncname_stream, lex.Colon);
     
    21721943  };
    21731944
    2174   struct Compute_Hash_Value_Bitstream {
    2175  
    2176   IDISA_INLINE void do_block(Hash_data & hash_data, Basis_bits & basis_bits) {
    2177 
    2178 
    2179 
    2180 
    2181 
    2182         hash_data.Hash_value = simd_xor(simd_xor(basis_bits.bit_2, basis_bits.bit_4), basis_bits.bit_6);
     1945  struct Validation_4 {
     1946  Validation_4() {
     1947 }
     1948  IDISA_INLINE void do_block(Lex & lex, Output & output) {
     1949                BitBlock m0;
     1950
     1951
     1952
     1953
     1954        m0 = simd<1>::constant<0>();
     1955        m0 = simd_not(simd<1>::constant<0>());
     1956        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(0), m0));
     1957        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc5), carryQ.get_carry_in(1), m0));
     1958        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
     1959        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc6), carryQ.get_carry_in(3), m0));
     1960        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
     1961        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc7), carryQ.get_carry_in(5), m0));
     1962        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
     1963        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc8), carryQ.get_carry_in(7), m0));
     1964        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
     1965        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
     1966        output.matches = m0;
     1967        output.matches = simd_xor(m0, lex.cc4);
     1968        if (bitblock::any(output.matches)) {
     1969          error_tracker.NoteError("Element_4 error found", output.matches);
     1970        }
     1971        carryQ.CarryQ_Adjust(10);
    21831972  }
    2184   void do_final_block(Hash_data & hash_data, Basis_bits & basis_bits, BitBlock EOF_mask) {
    2185 
    2186 
    2187 
    2188 
    2189 
    2190         hash_data.Hash_value = simd_xor(simd_xor(basis_bits.bit_2, basis_bits.bit_4), basis_bits.bit_6);
     1973  IDISA_INLINE void clear() {
     1974 }
     1975  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
     1976                BitBlock m0;
     1977
     1978
     1979
     1980
     1981        m0 = simd<1>::constant<0>();
     1982        m0 = simd_not(simd<1>::constant<0>());
     1983        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(0), m0));
     1984        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc5), carryQ.get_carry_in(1), m0));
     1985        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
     1986        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc6), carryQ.get_carry_in(3), m0));
     1987        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
     1988        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc7), carryQ.get_carry_in(5), m0));
     1989        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
     1990        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc8), carryQ.get_carry_in(7), m0));
     1991        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
     1992        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
     1993        output.matches = m0;
     1994        output.matches = simd_xor(m0, lex.cc4);
     1995        if (bitblock::any(output.matches)) {
     1996          error_tracker.NoteError("Element_4 error found", output.matches);
     1997        }
    21911998  }
    2192  
     1999  CarryArray<10, 0> carryQ;
     2000  };
     2001
     2002  struct Validate_content_5 {
     2003  Validate_content_5() {
     2004 }
     2005  IDISA_INLINE void do_block(Lex & lex, Output & output) {
     2006                BitBlock m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15;
     2007                BitBlock m16, m17, temp, all_matches;
     2008
     2009                BitBlock tempvar0;
     2010
     2011
     2012        m0 = simd<1>::constant<0>();
     2013        m1 = simd<1>::constant<0>();
     2014        m2 = simd<1>::constant<0>();
     2015        m3 = simd<1>::constant<0>();
     2016        m4 = simd<1>::constant<0>();
     2017        m5 = simd<1>::constant<0>();
     2018        m6 = simd<1>::constant<0>();
     2019        m7 = simd<1>::constant<0>();
     2020        m8 = simd<1>::constant<0>();
     2021        m9 = simd<1>::constant<0>();
     2022        m10 = simd<1>::constant<0>();
     2023        m11 = simd<1>::constant<0>();
     2024        m12 = simd<1>::constant<0>();
     2025        m13 = simd<1>::constant<0>();
     2026        m14 = simd<1>::constant<0>();
     2027        m15 = simd<1>::constant<0>();
     2028        m16 = simd<1>::constant<0>();
     2029        m17 = simd<1>::constant<0>();
     2030        m0 = simd_not(simd<1>::constant<0>());
     2031        m1 = m0;
     2032        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(lex.Caret, carryQ.get_carry_in(0), tempvar0));
     2033        m0 = simd_andc(m0, tempvar0);
     2034        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.content_end), carryQ.get_carry_in(1), m1));
     2035        m0 = simd_or(m0, m1);
     2036        m2 = m0;
     2037        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m2, lex.P_H_sign), carryQ.get_carry_in(2), m2));
     2038        m0 = simd_or(m0, m2);
     2039        carryQ.cq[3] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(3), m0));
     2040        m7 = m0;
     2041        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m7, lex.Dot), carryQ.get_carry_in(4), m7));
     2042        m0 = simd_or(m0, m7);
     2043        m9 = m0;
     2044        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m9, lex.Digit), carryQ.get_carry_in(5), m9));
     2045        m0 = m9;
     2046        carryQ.cq[6] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(6), m0));
     2047        output.tem = m9;
     2048        temp = m0;
     2049        m11 = m0;
     2050        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m11, lex.E_and_e), carryQ.get_carry_in(7), m11));
     2051        m13 = m11;
     2052        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m13, lex.P_H_sign), carryQ.get_carry_in(8), m13));
     2053        m11 = simd_or(m11, m13);
     2054        m16 = m11;
     2055        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m16, lex.Digit), carryQ.get_carry_in(9), m16));
     2056        m11 = m16;
     2057        carryQ.cq[10] = carryout2carry(pablo_blk_MatchStar(m11, lex.Digit, carryQ.get_carry_in(10), m11));
     2058        m0 = simd_or(m0, m11);
     2059        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.content_end), carryQ.get_carry_in(11), m0));
     2060        output.matches = simd<1>::constant<0>();
     2061        all_matches = m0;
     2062        output.matches = temp;
     2063        carryQ.CarryQ_Adjust(12);
     2064  }
     2065  IDISA_INLINE void clear() {
     2066 }
     2067  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
     2068                BitBlock m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15;
     2069                BitBlock m16, m17, temp, all_matches;
     2070
     2071                BitBlock tempvar0;
     2072
     2073
     2074        m0 = simd<1>::constant<0>();
     2075        m1 = simd<1>::constant<0>();
     2076        m2 = simd<1>::constant<0>();
     2077        m3 = simd<1>::constant<0>();
     2078        m4 = simd<1>::constant<0>();
     2079        m5 = simd<1>::constant<0>();
     2080        m6 = simd<1>::constant<0>();
     2081        m7 = simd<1>::constant<0>();
     2082        m8 = simd<1>::constant<0>();
     2083        m9 = simd<1>::constant<0>();
     2084        m10 = simd<1>::constant<0>();
     2085        m11 = simd<1>::constant<0>();
     2086        m12 = simd<1>::constant<0>();
     2087        m13 = simd<1>::constant<0>();
     2088        m14 = simd<1>::constant<0>();
     2089        m15 = simd<1>::constant<0>();
     2090        m16 = simd<1>::constant<0>();
     2091        m17 = simd<1>::constant<0>();
     2092        m0 = simd_not(simd<1>::constant<0>());
     2093        m1 = m0;
     2094        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(lex.Caret, carryQ.get_carry_in(0), tempvar0));
     2095        m0 = simd_andc(m0, tempvar0);
     2096        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.content_end), carryQ.get_carry_in(1), m1));
     2097        m0 = simd_or(m0, m1);
     2098        m2 = m0;
     2099        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m2, lex.P_H_sign), carryQ.get_carry_in(2), m2));
     2100        m0 = simd_or(m0, m2);
     2101        carryQ.cq[3] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(3), m0));
     2102        m7 = m0;
     2103        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m7, lex.Dot), carryQ.get_carry_in(4), m7));
     2104        m0 = simd_or(m0, m7);
     2105        m9 = m0;
     2106        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m9, lex.Digit), carryQ.get_carry_in(5), m9));
     2107        m0 = m9;
     2108        carryQ.cq[6] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(6), m0));
     2109        output.tem = m9;
     2110        temp = m0;
     2111        m11 = m0;
     2112        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m11, lex.E_and_e), carryQ.get_carry_in(7), m11));
     2113        m13 = m11;
     2114        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m13, lex.P_H_sign), carryQ.get_carry_in(8), m13));
     2115        m11 = simd_or(m11, m13);
     2116        m16 = m11;
     2117        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m16, lex.Digit), carryQ.get_carry_in(9), m16));
     2118        m11 = m16;
     2119        carryQ.cq[10] = carryout2carry(pablo_blk_MatchStar(m11, lex.Digit, carryQ.get_carry_in(10), m11));
     2120        m0 = simd_or(m0, m11);
     2121        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.content_end), carryQ.get_carry_in(11), m0));
     2122        output.matches = simd<1>::constant<0>();
     2123        all_matches = m0;
     2124        output.matches = temp;
     2125  }
     2126  CarryArray<12, 0> carryQ;
    21932127  };
    21942128
     
    22042138        v = simd_or(lex.LAngle, lex.Hyphen);
    22052139        w = simd_or(lex.Hyphen, lex.QMark);
    2206         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
    2207         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
     2140        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
     2141        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
    22082142        scope1.LAngle = simd_andc(v1, w1);
    22092143        scope1.Hyphen = simd_and(v1, w1);
     
    22122146        carryQ.CarryQ_Adjust(2);
    22132147  }
     2148  IDISA_INLINE void clear() {
     2149 }
    22142150  void do_final_block(Lex & lex, Scope1 & scope1, BitBlock EOF_mask) {
    22152151                BitBlock v, w, v1, w1;
     
    22202156        v = simd_or(lex.LAngle, lex.Hyphen);
    22212157        w = simd_or(lex.Hyphen, lex.QMark);
    2222         carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
    2223         carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
     2158        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
     2159        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
    22242160        scope1.LAngle = simd_andc(v1, w1);
    22252161        scope1.Hyphen = simd_and(v1, w1);
     
    22342170#include <simd-lib/transpose.hpp>
    22352171#include <post_process.hpp>
     2172
     2173static inline int ScanBackwardPos(BitBlock * block, int pos)
     2174{
     2175//      cout << "pos " << pos << endl;
     2176    BitBlock s = block[0];
     2177    if (bitblock::any(block[0])){
     2178//      print_register("zero",block[0]);
     2179//      print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
     2180        }
     2181    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
     2182//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
     2183//              print_register("temp",temp);
     2184    if (bitblock::any(temp))
     2185    {
     2186        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
     2187//      cout << "block_size" << BLOCK_SIZE << endl;
     2188        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
     2189    }
     2190    else
     2191    {
     2192        //handle boundary case
     2193        return previous_block_last_elem_start - 1;
     2194    }
     2195}
     2196
     2197static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
     2198        int blk;
     2199        int block_pos = 0;
     2200        for (blk = 0; blk < blk_count; blk++) {
     2201                ScanBlock s = stream[blk];
     2202                while(s) {
     2203                        int code = (ProcessPos(cfzl(s) + block_pos));
     2204                        if (code) return code;
     2205                        s = s & (s-1);  // clear rightmost bit.
     2206                }
     2207                block_pos += 8 * sizeof(ScanBlock);
     2208        }
     2209        return 0;
     2210}
     2211
     2212static inline int compute_hash_value2(char *str,int lgth){
     2213        int hash = 5381;
     2214    int c;
     2215//      while (c = *str++){
     2216        for (int i = 0;i<lgth;i++){
     2217                c=*str++;
     2218        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
     2219    }
     2220
     2221    return hash;
     2222}
     2223
     2224static inline int compute_hash_value (int lgth, int start)
     2225{
     2226    unsigned int offset_bit = start + 128;
     2227    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
     2228    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
     2229}
     2230
     2231static inline void print_basis_bits(Basis_bits & basis_bits){
     2232        print_register("bit0:",basis_bits.bit_0);
     2233        print_register("bit1:",basis_bits.bit_1);
     2234        print_register("bit2:",basis_bits.bit_2);
     2235        print_register("bit3:",basis_bits.bit_3);
     2236        print_register("bit4:",basis_bits.bit_4);
     2237        print_register("bit5:",basis_bits.bit_5);
     2238        print_register("bit6:",basis_bits.bit_6);
     2239        print_register("bit7:",basis_bits.bit_7);                                       
     2240}
     2241/*
     2242template <int L>
     2243static inline int ElemEnd_grouping(int pos) {
     2244    int end = block_base + pos;
     2245    int start = end - L;
     2246    int hashvalue = compute_hash_value(L, start - block_base);
     2247    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
     2248    gids.push_back(gid);
     2249#if DEBUG
     2250    char* symbol = new char[L+1];
     2251    strncpy ( symbol, source + start, L );
     2252    symbol[L] ='\0';
     2253    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
     2254    delete symbol; symbol = 0;
     2255#endif
     2256    return gid;
     2257}
     2258
     2259template<>
     2260inline int ElemEnd_grouping<17>(int pos) {
     2261    int end = block_base + pos;
     2262    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
     2263    int lgth = end - start;
     2264    int hashvalue = compute_hash_value(lgth, start - block_base);
     2265    int gid = 0;
     2266
     2267//    if (lgth < 32)
     2268//    {
     2269//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
     2270//    }
     2271//    else
     2272    {
     2273        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
     2274    }
     2275    gids.push_back(gid);
     2276#if DEBUG
     2277    char* symbol = new char[lgth+1];
     2278    strncpy ( symbol, source + start, lgth );
     2279    symbol[lgth] ='\0';
     2280    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
     2281#endif
     2282    return gid;
     2283}
     2284*/
     2285
     2286static inline char ElemEnd_grouping(char *source,int block_base,int pos) {
     2287    int end = block_base + pos;
     2288    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
     2289    ///////////////////////
     2290    //start could be negitive
     2291    //the element name falls in two buffers
     2292    ///////////////////////
     2293    char *name = source + start;
     2294    char name_buffer[50];
     2295   
     2296    if (start<0){
     2297#ifdef DEBUG
     2298            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
     2299#endif
     2300        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
     2301        memmove (&name_buffer[-start],&source[0],50+start);
     2302        name = name_buffer;
     2303        //fprintf (gid_writein,"name_buffer %s",name);
     2304#ifdef DEBUG
     2305        fprintf(gid_writein,"name_buffer %s\n",name);
     2306#endif
     2307    }
     2308//    cout << end << "  " << start << endl;
     2309    int lgth = end - start;
     2310//    int hashvalue = compute_hash_value(lgth,start-block_base);
     2311        int hashvalue = compute_hash_value2(name,lgth);
     2312    char gid = 0;
     2313
     2314
     2315//    if (lgth < 32)
     2316//    {
     2317//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
     2318//    }
     2319//    else
     2320
     2321        switch (lgth)
     2322    {
     2323    case 1:
     2324        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(name, hashvalue);
     2325        break;
     2326    case 2:
     2327        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(name, hashvalue);
     2328        break;
     2329    case 3:
     2330        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(name, hashvalue);
     2331        break;
     2332    case 4:
     2333        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(name, hashvalue);
     2334        break;
     2335    case 5:
     2336        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(name, hashvalue);
     2337        break;
     2338    case 6:
     2339        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(name, hashvalue);
     2340        break;
     2341    case 7:
     2342        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(name, hashvalue);
     2343        break;
     2344    case 8:
     2345        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(name, hashvalue);
     2346        break;
     2347    case 9:
     2348        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(name, hashvalue);
     2349        break;
     2350    case 10:
     2351        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(name, hashvalue);
     2352        break;
     2353    case 11:
     2354        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(name, hashvalue);
     2355        break;
     2356    case 12:
     2357        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(name, hashvalue);
     2358        break;
     2359    case 13:
     2360        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(name, hashvalue);
     2361        break;
     2362    case 14:
     2363        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(name, hashvalue);
     2364        break;
     2365    case 15:
     2366        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(name, hashvalue);
     2367        break;
     2368    case 16:
     2369        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(name, hashvalue);
     2370        break;
     2371    default:
     2372        gid = pbgs_symbol_table.Lookup_or_Insert_Name(name, hashvalue, lgth);
     2373        break;
     2374    }
     2375/*
     2376    {
     2377        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
     2378    }
     2379*/
     2380    gids.push_back(gid);
     2381#ifdef DEBUG
     2382    char* symbol = new char[lgth+1];
     2383    strncpy ( symbol, source + start, lgth );
     2384    symbol[lgth] ='\0';
     2385//    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
     2386    fprintf (gid_writein,"%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
     2387#endif
     2388    return gid;
     2389}
     2390
     2391static inline int print_source(char* source, int lgth ,int seg){
     2392        char ret[128];
     2393        int j;
     2394        for (int i=0;i<seg;i++){
     2395                for(j=0;j<lgth;j++){
     2396                        if(source[i*lgth+j]!='\n')
     2397                                ret[j] = source[i*lgth + j];
     2398                        else
     2399                                ret[j] = ' ';
     2400                }
     2401                ret[j] = '\0';
     2402//              cout << ret << endl;
     2403        }
     2404        return 0;
     2405}
     2406
     2407Validate_content_5 validate_content_5;
     2408
     2409static inline void validate_data_type(int char_aval, int gid_index){
     2410        struct Lex lex;
     2411        struct Output output;
     2412        Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
     2413        U8 u8;
     2414        Basis_bits temp_basis_bits;
     2415//      Validate_content_5 validate_content_5;
     2416       
     2417        if(char_aval == BLOCK_SIZE){
     2418                s2p_do_block((BytePack*)(&content_buffer), temp_basis_bits);
     2419#ifdef DEBUG
     2420                print_basis_bits(temp_basis_bits);
     2421#endif
     2422                classify_bytes_Validate_utf8.do_block(temp_basis_bits,lex,u8);
     2423#ifdef  DEBUG
     2424                cout << content_buffer << endl;
     2425               
     2426                print_register("digit:",lex.Digit);
     2427                print_register("dot:",lex.Dot);
     2428                print_register("namescan:",lex.NameScan);
     2429                print_register("P_N:",lex.P_H_sign);
     2430                print_register("content_end:",lex.content_end);
     2431#endif
     2432                validate_content_5.do_block(lex,output);
     2433#ifdef DEBUG
     2434                print_register("output:",output.matches);
     2435                print_register("output.tem:",output.tem);
     2436#endif
     2437        }else{
     2438                int remaining = BLOCK_SIZE -char_aval;
     2439                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     2440                s2p_do_final_block((BytePack*)(&content_buffer), temp_basis_bits,EOF_mask);
     2441                classify_bytes_Validate_utf8.do_final_block(temp_basis_bits,lex,u8,EOF_mask);
     2442                validate_content_5.do_final_block(lex,output,EOF_mask);
     2443        }
     2444}
     2445
     2446
     2447//template <int L>
     2448static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count,ScanBlock * stream3,ScanBlock * stream4) {
     2449    int blk;
     2450    int block_pos = 0;
     2451//    cout << "cfzl():" << cfzl() << endl;
     2452//      long test = 6;
     2453//      test = (test & (test - 1));
     2454//      cout << "test" << endl;
     2455    for (blk = 0; blk < blk_count; blk++) {
     2456//      cout << "blk:" << blk << endl;
     2457   
     2458                ScanBlock s = stream[blk];
     2459                ScanBlock s2 = stream2[blk];
     2460                ScanBlock s3 = stream3[blk];
     2461                ScanBlock s4 = stream4[blk];
     2462                int end_content;
     2463                int start_content;
     2464                int content_lgth;
     2465                int content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
     2466               
     2467//              cout << "block_pos " << block_pos <<endl;
     2468//#ifdef DATATYPE
     2469if(Symbol && Datatype)  {
     2470                if (content_start_carry == 1 && gid == CONTENT_INDEX){
     2471//                      cout << "****" << endl;
     2472                        start_content = cfzl(s3) + block_pos;
     2473                                        if (cfzl(s3) != 8*sizeof(ScanBlock)){
     2474                                                content_start_carry = 0;
     2475                                        }
     2476                                       
     2477                                        end_content = cfzl(s4) + block_pos;
     2478                                        while(end_content < start_content){
     2479                                                s4 = s4 & (s4-1);
     2480                                                end_content = cfzl(s4) + block_pos;
     2481                                        }
     2482        //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
     2483                                        if(cfzl(s4)==8*sizeof(ScanBlock)){
     2484                                                content_carry = 1;
     2485        //                              cout << "end_of_block" << endl;
     2486                                        }
     2487                                        content_lgth = end_content - start_content;
     2488//                                      cout << end_content << " " << start_content <<endl;
     2489//                                      cout << "lgth: " << content_lgth << endl;
     2490                                        content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
     2491                                        int full_content = 0;
     2492                                        int buffer_full = 0;
     2493                                        if(content_carry != 1 && gid == CONTENT_INDEX){
     2494                                                if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
     2495                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
     2496                                                        char temp = '#';
     2497                                                        content_buffer_pos += content_lgth-2;
     2498                                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
     2499                                                        content_buffer_pos ++;
     2500//                                                      cout << "@@" <<endl;
     2501//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
     2502                                                }else if(gid == CONTENT_INDEX){
     2503                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
     2504                                                        full_content = 1;
     2505                                               
     2506                                                        content_buffer_pos += content_aval;
     2507                                                        memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
     2508//                                                      cout << "@@@" <<endl;
     2509//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
     2510                                                        content_buffer_pos = content_lgth-2-content_aval;
     2511                                                        buffer_full = 1;
     2512                                                }
     2513                                        }else if(gid == CONTENT_INDEX){
     2514                                                if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
     2515//                                                      cout << "@" << endl;
     2516//                                              cout << content_aval << "   " << content_lgth << endl;
     2517                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
     2518//                                              printf("%.*s\n",content_lgth-1,&content_buffer[content_buffer_pos]);
     2519                                                        content_buffer_pos += content_lgth-1;
     2520//                                                      full_content = 1;       
     2521                                                }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
     2522//                                                      cout << "@@@@" << endl;
     2523//                                                      cout << content_aval << "   " << content_lgth << endl;
     2524                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
     2525                                               
     2526                                                        content_buffer_pos += content_aval;
     2527                                                        memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
     2528        //                                              full_content = 1;
     2529                                                        content_buffer_pos = content_lgth-1-content_aval;
     2530                                                        buffer_full = 1;
     2531                                                }
     2532                                        }
     2533                                        if (buffer_full == 1){
     2534        //                              cout << "buffer_full" << endl;
     2535        //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
     2536        //                              cout << content_buffer << endl << endl;
     2537if(!Data_gather)
     2538                                                validate_data_type(CONTENT_BUFFER_SIZE,5);
     2539                                                memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
     2540                                                if (full_content == 1){
     2541                                                        char temp = '#';
     2542                                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
     2543                                                        content_buffer_pos ++;
     2544                                                        full_content = 0;
     2545                                                }
     2546                                                buffer_full = 0;
     2547                                        }
     2548                }else if (content_carry == 1 && gid == CONTENT_INDEX){
     2549                end_content = cfzl(s4) + block_pos;
     2550                start_content = block_pos-1;
     2551                content_lgth = end_content-block_pos;
     2552                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
     2553                if (cfzl(s4) != 8*sizeof(ScanBlock)){
     2554                        content_carry = 0;
     2555                        s4 = s4 & (s4-1);
     2556                }
     2557                int buffer_full = 0;
     2558                if (content_carry !=1){
     2559                                if(content_aval > content_lgth-1 && content_lgth > 1){
     2560//                                      cout << "##" << endl;
     2561        //                      cout << "lgth " << content_lgth << endl;
     2562                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth-1);
     2563//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
     2564//                                      cout << "content_lgth " << content_lgth <<endl;
     2565//                                      printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
     2566                                        content_buffer_pos += content_lgth-1;
     2567                                        char temp = '#';
     2568                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
     2569                                        content_buffer_pos ++;
     2570        //                      content_buffer[content_buffer_pos] = '\0';
     2571        //                      cout << "^^^" << endl;
     2572        //                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-1 << endl;
     2573        //                      cout << content_buffer << endl;
     2574                                }else if (content_lgth == 0){
     2575                                        content_buffer[content_buffer_pos-1] = '#';
     2576                                }else if (content_aval > 0 && content_lgth == 1){
     2577//                                      cout << "###" << endl;
     2578                                        content_buffer[content_buffer_pos] = '#';
     2579                                        content_buffer_pos++;
     2580                                        if(content_buffer_pos == CONTENT_BUFFER_SIZE){
     2581if(!Data_gather)
     2582                                                validate_data_type(CONTENT_BUFFER_SIZE,5);
     2583                                                content_buffer_pos = 0;
     2584                                        }
     2585                                }else if (content_aval <= content_lgth-1){
     2586//                                      cout << "@@@@@@@@@@@@@@@@@@" << endl;
     2587                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
     2588                                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-1-content_aval);
     2589//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
     2590//                                      cout << "content_lgth " << content_lgth <<endl;
     2591//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
     2592                                        content_buffer_pos = content_lgth-1-content_aval;
     2593        //                              content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
     2594        //                              cout << content_buffer << endl << endl;
     2595if(!Data_gather)
     2596                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
     2597                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
     2598                                        if (content_lgth-1 < CONTENT_BUFFER_SIZE){
     2599                                                content_buffer[content_buffer_pos] = '#';
     2600                                                content_buffer_pos ++;
     2601                                        }
     2602                                }
     2603                }else if(gid == CONTENT_INDEX){
     2604                        if(content_aval > content_lgth){
     2605//                                      cout << "##*" << endl;
     2606//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
     2607//                                      cout << "content_lgth " << content_lgth <<endl;
     2608                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth);
     2609//                                      printf("%.*s\n",content_lgth+content_buffer_pos,content_buffer);
     2610                                        content_buffer_pos += content_lgth;
     2611                                }else if (content_aval <= content_lgth && gid == CONTENT_INDEX){
     2612//                                      cout << "@@@@@@@@@@@@@@@@@@*" << endl;
     2613                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
     2614                                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-content_aval);
     2615//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
     2616//                                      cout << "content_lgth " << content_lgth <<endl;
     2617//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
     2618                                        content_buffer_pos = content_lgth-content_aval;
     2619if(!Data_gather)
     2620                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
     2621                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
     2622                                }                       
     2623                }
     2624            }
     2625}
     2626//#endif
     2627//              print_source(&source[block_base],sizeof(ScanBlock)*8,2);
     2628//              print_register("start_content:",((BitBlock*)stream3)[0]);
     2629//              print_register("end_content:",((BitBlock*)stream4)[0]);
     2630//              cout << s << "  " << s2 << endl;
     2631//              print_register("s:",((BitBlock*)stream)[0]);
     2632                while(s | s2) {
     2633//                      cout << "cfzl(s):" << cfzl(s)<<endl;
     2634                    int end_pos = cfzl(s) + block_pos;
     2635//                  cout << "s2 " << s2 << endl;
     2636                    int end_tag = cfzl(s2) + block_pos;
     2637//              cout << "cfzl(s):" << cfzl(s)<<endl;
     2638//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
     2639//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
     2640                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
     2641//                      cout << "here" << endl;
     2642//                      cout << "closing tag" << endl;
     2643//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
     2644//                      cout << "1"<< endl;
     2645//                      cout << elem_vec_stack.size()<<endl;
     2646//                      cout << "2" << endl;
     2647//                      cout << elem_vec_stack.top()<<endl;
     2648if(Content_gather && Content_model){
     2649                                if(!(gid_vec[current_depth].empty())){
     2650//                                      if(gid_vec.back() != 0){
     2651                                                gid_vec[current_depth].push_back(0);
     2652                                                if(current_depth !=0){
     2653                                                        current_depth = pre_index.back();
     2654                                                        pre_index.pop_back();
     2655#ifdef DEBUG
     2656                                                        fprintf (gid_writein,"%d\n",current_depth);
     2657#endif
     2658                                                        gid_vec[current_depth].push_back(0);
     2659                                                }
     2660//                                      }
     2661                                }
     2662}
     2663//                              cout << "before" << s2 << endl;
     2664                                s2 = s2 & (s2 - 1);
     2665//                              cout << "after" << s2 << endl;
     2666//                              cout << "s2 = " << s2 << endl;
     2667                }else{
     2668//                      cout << " end_pos == " << end_pos<<endl;
     2669//                      cout << " end_tag_pos == " << end_tag << endl;
     2670                        gid = ElemEnd_grouping(source,block_base,end_pos);
     2671//#ifdef DATATYPE
     2672if(Symbol && Datatype){
     2673//                      printf("%d\n",int(gid));
     2674                        if (gid == CONTENT_INDEX){
     2675//                              cout << "source : ";
     2676//                              printf("%.*s\n",sizeof(ScanBlock)*8,&source[block_base]);
     2677                                        start_content = cfzl(s3) + block_pos;
     2678                                        while(start_content < end_pos){
     2679                                                s3 = s3 & (s3-1);
     2680                                                start_content = cfzl(s3) + block_pos;
     2681                                        }
     2682                                        if (cfzl(s3) == 8*sizeof(ScanBlock)){
     2683                                                content_start_carry = 1;
     2684                                        }
     2685                                        if (content_start_carry != 1){
     2686                //                      cout << "end_pos " << end_pos <<endl;
     2687                //                      char temp[20];
     2688                //                      memmove(temp,&source[end_pos+block_base],20);
     2689                //                      cout << "source: " << temp << endl;
     2690                                                //cout << "start_content " << start_content << endl;
     2691                                       
     2692                                                end_content = cfzl(s4) + block_pos;
     2693                                                while(end_content < start_content){
     2694                                                        s4 = s4 & (s4-1);
     2695                                                        end_content = cfzl(s4) + block_pos;
     2696                                                }
     2697                //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
     2698                                                if(cfzl(s4)==8*sizeof(ScanBlock)){
     2699                                                        content_carry = 1;
     2700                //                              cout << "end_of_block" << endl;
     2701                                                }
     2702                                                content_lgth = end_content - start_content;
     2703//                                              cout << end_content << " " << start_content <<endl;
     2704//                                              cout << "lgth: " << content_lgth << endl;
     2705                                                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
     2706                                                int full_content = 0;
     2707                                                int buffer_full = 0;
     2708                                                if(content_carry != 1 && gid == CONTENT_INDEX){
     2709                                                        if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
     2710                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
     2711                                                                char temp = '#';
     2712                                                                content_buffer_pos += content_lgth-2;
     2713                                                                memmove(&content_buffer[content_buffer_pos],&temp,1);
     2714                                                                content_buffer_pos ++;
     2715                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << endl;
     2716//                                                              cout << "@@" <<endl;
     2717//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
     2718                                                        }else if(gid == CONTENT_INDEX){
     2719                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
     2720                                                                full_content = 1;
     2721                                               
     2722                                                                content_buffer_pos += content_aval;
     2723                                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
     2724//                                                              cout << "@@@" <<endl;
     2725//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
     2726                                                                content_buffer_pos = content_lgth-2-content_aval;
     2727                                                                buffer_full = 1;
     2728                                                        }
     2729                                                }else if(gid == CONTENT_INDEX){
     2730                                                        if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
     2731//                                                              cout << "@" << endl;
     2732//                                                              cout << content_aval << "   " << content_lgth << endl;
     2733                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
     2734//                                                              printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
     2735                                                                content_buffer_pos += content_lgth-1;
     2736        //                                                      full_content = 1;
     2737                //                                      cout << content_carry << endl;
     2738                //                                      cout << content_buffer << endl << endl;
     2739                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE<< "            "<< content_lgth-1 << endl;             
     2740                                                        }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
     2741//                                                              cout << "@@@@" << endl;
     2742//                                                              cout << content_aval << "   " << content_lgth << endl;
     2743                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
     2744                                               
     2745                                                                content_buffer_pos += content_aval;
     2746                                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
     2747                //                                              full_content = 1;
     2748                //                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
     2749                                                                content_buffer_pos = content_lgth-1-content_aval;
     2750                                                                buffer_full = 1;
     2751                                                        }
     2752                                                }
     2753                                                if (buffer_full == 1){
     2754                //                              cout << "buffer_full" << endl;
     2755                //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
     2756                //                              cout << content_buffer << endl << endl;
     2757                                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
     2758                                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
     2759                                                        if (full_content == 1){
     2760                                                                char temp = '#';
     2761                                                                memmove(&content_buffer[content_buffer_pos],&temp,1);
     2762                                                                content_buffer_pos ++;
     2763                                                                full_content = 0;
     2764                                                        }
     2765                                                        buffer_full = 0;
     2766                                                }
     2767                                        }
     2768                        }
     2769}
     2770//#endif                       
     2771//                      content_buffer[content_buffer_pos] = '\0';
     2772//                      cout << content_buffer << endl;
     2773                        if (s!=0){
     2774                                s = s & (s-1);  // clear rightmost bit.
     2775                        }
     2776                        //else{
     2777                        //      s2 = s2 & (s2 - 1);
     2778                        //}
     2779if(Content_gather && Content_model){
     2780                                if (gid != 0){
     2781                                        gid_vec[current_depth].push_back(gid);
     2782#ifdef DEBUG
     2783                                        fprintf (gid_writein,"%d\n",current_depth);
     2784#endif
     2785                                        pre_index.push_back(current_depth);
     2786                                        current_depth = (int)gid;
     2787                                        gid_vec[current_depth].push_back(gid);
     2788#ifdef DEBUG
     2789                                        fprintf (gid_writein,"%d\n",current_depth);                     
     2790#endif
     2791                                }
     2792}
     2793                }       
     2794                }
     2795                block_pos += 8 * sizeof(ScanBlock);
     2796//              print_gid_vec();
     2797    }
     2798    return 0;
     2799}
     2800
     2801void print_gid_vec(){
     2802        for (int j = 0; j < MAX_DEPTH; j++){
     2803                if(gid_vec[j].empty()){
     2804                        return;
     2805                }
     2806                for (int i = 0; i < gid_vec[j].size(); i++){
     2807                        cout << j << ":" << endl;
     2808                        cout << (int)gid_vec[j][i] << " ";
     2809                }
     2810        }
     2811        cout << endl;
     2812/*     
     2813        int i = 1;
     2814        int lst[256] = {0};
     2815        cout << elem_vec_map.size() << " vectors" << endl;
     2816        for (int i = 0;i < gids.size(); i++){
     2817                if (lst[gids[i]] == 0){
     2818                        cout << "gid: " << gids[i] << endl;
     2819                        lst[gids[i]] = 1;
     2820                        vector<char> *tmp = elem_vec_map[gids[i]];
     2821                        cout << "vector size:"<< (*tmp).size()<<endl;
     2822                        if ((*tmp).size()!=0){
     2823                                cout << "elements: ";
     2824                                for (int j = 0; j < (*tmp).size();j++){
     2825                                        cout << (int)(*tmp)[j] << " ";
     2826                                }
     2827                                cout << endl;
     2828                        }
     2829                        cout << endl;
     2830                }
     2831        }
     2832*/
     2833}
     2834/*
     2835static inline int NameStrt_check(int pos) {
     2836        int block_pos = block_base + pos;
     2837        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
     2838              ReportError("name start error", pos);
     2839              exit(-1);
     2840        }
     2841        return 0;
     2842}
     2843
     2844static inline int Name_check(int pos) {
     2845        int block_pos = block_base + pos;
     2846        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
     2847              ReportError("name error", pos);
     2848              exit(-1);
     2849        }
     2850        return 0;
     2851}
     2852
     2853static inline int PIName_check(int pos) {
     2854        int block_pos = block_base + pos;
     2855        int file_pos = block_pos+buffer_base;
     2856        printf ("%s:%i\n",__FUNCTION__,pos);
     2857        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
     2858              // "<?xml" legal at start of file.
     2859              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
     2860              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
     2861              exit(-1);
     2862        }
     2863        return 0;
     2864}
     2865
     2866static inline int CD_check(int pos) {
     2867        int block_pos = block_base + pos;
     2868        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
     2869              ReportError("CDATA error", pos);
     2870              exit(-1);
     2871        }
     2872        return 0;
     2873}
     2874
     2875static inline int GenRef_check(int pos) {
     2876        int block_pos = block_base + pos;
     2877        unsigned char* s = (unsigned char*)&source[block_pos];
     2878        if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
     2879                        cout << pos << endl;
     2880              ReportError("Undefined reference", pos);
     2881              exit(-1);
     2882        }
     2883        return 0;
     2884}
     2885
     2886static inline int HexRef_check(int pos) {
     2887        int block_pos = block_base + pos;
     2888        unsigned char* s = (unsigned char*)&source[block_pos];
     2889        int ch_val = 0;
     2890        while(at_HexDigit<ASCII>(s)){
     2891          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
     2892          if (ch_val> 0x10FFFF ){
     2893            ReportError("Illegal character reference", pos);
     2894            exit(-1);
     2895          }
     2896          s++;
     2897        }
     2898        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
     2899          ReportError("Illegal character reference", pos);
     2900          exit(-1);
     2901        }
     2902        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
     2903          ReportError("Illegal XML 1.0 character reference", pos);
     2904          exit(-1);
     2905        }
     2906        return 0;
     2907}
     2908
     2909static inline int DecRef_check(int pos) {
     2910        int block_pos = block_base + pos;
     2911        unsigned char* s = (unsigned char*)&source[block_pos];
     2912        int ch_val = 0;
     2913        while(at_HexDigit<ASCII>(s)){
     2914          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
     2915          if (ch_val> 0x10FFFF ){
     2916            ReportError("Illegal character reference", pos);
     2917            exit(-1);
     2918          }
     2919          s++;
     2920        }
     2921        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
     2922          ReportError("Illegal character reference", pos);
     2923          exit(-1);
     2924        }
     2925        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
     2926          ReportError("Illegal XML 1.0 character reference", pos);
     2927          exit(-1);
     2928        }
     2929        return 0;
     2930}
     2931
     2932static inline int AttRef_check(int pos) {
     2933        int block_pos = block_base + pos;
     2934        unsigned char* s = (unsigned char*)&source[block_pos];
     2935        int ch_val = 0;
     2936        if(s[0]=='#'){
     2937          s++;
     2938          if(s[0]=='x' || s[0]=='X'){
     2939            s++;
     2940            while(at_HexDigit<ASCII>(s)){
     2941              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
     2942              s++;
     2943            }
     2944          }
     2945          else{
     2946            while(at_HexDigit<ASCII>(s)){
     2947              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
     2948              s++;
     2949            }
     2950          }
     2951          if (ch_val==60){
     2952            ReportError("Attribute values contain '<' characters after reference expansion", pos);
     2953            exit(-1);
     2954          }
     2955        }
     2956        else if(at_Ref_lt<ASCII>(s)){
     2957          ReportError("Attribute values contain '<' characters after reference expansion", pos);
     2958          exit(-1);
     2959        }
     2960        return 0;
     2961}
     2962*/
     2963
     2964
     2965
     2966
    22362967/*
    22372968static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
     
    22522983}
    22532984*/
    2254 static inline void print_basis_bits(Basis_bits & basis_bits){
    2255         print_register("bit0:",basis_bits.bit_0);
    2256         print_register("bit1:",basis_bits.bit_1);
    2257         print_register("bit2:",basis_bits.bit_2);
    2258         print_register("bit3:",basis_bits.bit_3);
    2259         print_register("bit4:",basis_bits.bit_4);
    2260         print_register("bit5:",basis_bits.bit_5);
    2261         print_register("bit6:",basis_bits.bit_6);
    2262         print_register("bit7:",basis_bits.bit_7);                                       
    2263 }
    2264 
    2265 static inline void print_elem_vec(vector<char>* vec, int size){
    2266         cout << "vector: ";
     2985
     2986static inline void print_elem_vec(vector<char>* vec, int size, int depth){
     2987        cout << "vector " << depth << ":";
    22672988        for (int i = 0; i<size ; i++){
    22682989                cout << (int)(*vec)[i] <<" ";
     
    22712992}
    22722993
    2273 
     2994static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner,char* str,int index){
     2995        int current_pos = 0;
     2996        int next_pos = 0;
     2997        int match_pos = 0;
     2998//      cout << str <<" = " << index <<endl;
     2999//      cout << "vec_scan" << endl;
     3000        cout << f_vec_scanner.get_final_pos() << "&&" << endl;
     3001        if(f_vec_scanner.has_next()){
     3002                current_pos = f_vec_scanner.scan_to_next();
     3003//              cout << current_pos << endl;
     3004        }else{
     3005                return;
     3006        }
     3007        if (match_scanner.has_next()){
     3008                match_pos = match_scanner.scan_to_next();
     3009        }else{
     3010                printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
     3011                while(f_vec_scanner.has_next()){
     3012                        current_pos = f_vec_scanner.scan_to_next();
     3013                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
     3014                }
     3015                return;
     3016        }
     3017        while(1){
     3018                if(f_vec_scanner.has_next()){
     3019                        next_pos = f_vec_scanner.scan_to_next();
     3020                }else{
     3021                        next_pos = -1;
     3022                }
     3023                if(next_pos > match_pos){
     3024                        cout <<"##" << next_pos << "  " << match_pos << endl;
     3025                        current_pos = next_pos;
     3026                        match_pos = match_scanner.scan_to_next();
     3027                        continue;
     3028                }else if(next_pos == -1){
     3029                        break;
     3030                }else if(next_pos < match_pos){
     3031                        cout << next_pos << "  " << match_pos << endl;
     3032                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
     3033                        current_pos = next_pos;
     3034                }
     3035        }
     3036/*     
     3037        while(1){
     3038                if(f_vec_scanner.has_next()){
     3039                        next_pos = f_vec_scanner.scan_to_next();
     3040                }else{
     3041                        next_pos = -1;
     3042                }
     3043                if (match_pos > next_pos && next_pos != -1){
     3044                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
     3045                }else if (next_pos == -1){
     3046                        break;
     3047                }else{
     3048                        if(match_scanner.has_next()){
     3049                                match_pos = match_scanner.scan_to_next();
     3050                        }else{
     3051                                printf("Mismatch found at pos of %s %d: %d.\n",str,index,next_pos);
     3052                                while(f_vec_scanner.has_next()){
     3053                                        current_pos = f_vec_scanner.scan_to_next();
     3054                                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
     3055                                }
     3056                                return;
     3057                        }
     3058                }
     3059                current_pos = next_pos;
     3060        }
     3061*/
     3062}
     3063
     3064static inline void validate_mul_block(){
     3065        struct Elem elem;
     3066        Validation_2 validation_2;
     3067        Validation_4 validation_4;
     3068        Validation_9 validation_9;
     3069//      Validation_10 validation_10;
     3070       
     3071        struct Lex lex;
     3072       
     3073        struct Output output;
     3074
     3075        Classify_bytes classify_bytes;
     3076        int j;
     3077#ifdef DEBUG
     3078        for(j=0;j<MAX_COUNT;j++){
     3079        int lgth = gid_vec[j].size();
     3080                if(!gid_vec[j].empty())
     3081                        print_elem_vec(&(gid_vec[j]),lgth,j);
     3082        }
     3083#endif
     3084        int lgth;
     3085        for(j=0;j<MAX_COUNT;j++){
     3086                lgth = gid_vec[j].size();
     3087                int remaining = 0;
     3088                Basis_bits temp_basis_bits;
     3089                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
     3090                int i = 0;
     3091                int block_base;
     3092                if(lgth != 0){ 
     3093                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
     3094                        for(i = 0;i < num_block; i++){
     3095                                block_base = i*BLOCK_SIZE;
     3096                               
     3097                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
     3098                                classify_bytes.do_block(temp_basis_bits,lex);
     3099                                switch (j){
     3100                                        case 2:
     3101                                        validation_2.do_block(lex,output);
     3102#ifdef DEBUG                           
     3103                                        print_register("cc2",lex.cc2);
     3104                                        print_register("match_2",output.matches);
     3105#endif
     3106                                        break;
     3107                                        case 4:
     3108                                        validation_4.do_block(lex,output);
     3109#ifdef DEBUG
     3110                                        print_register("cc4",lex.cc4);
     3111                                        print_register("match_4",output.matches);
     3112#endif
     3113                                        break;
     3114                                        case 9:
     3115                                        validation_9.do_block(lex,output);
     3116#ifdef DEBUG
     3117                                        print_register("cc9",lex.cc9);
     3118                                        print_register("match_9",output.matches);
     3119#endif
     3120                                        break;
     3121/*
     3122                                        case 10:
     3123                                        validation_10.do_block(lex,output);
     3124#ifdef DEBUG
     3125                                        print_register("cc10",lex.cc10);
     3126                                        print_register("match_10",output.matches);
     3127#endif
     3128                                        break;
     3129*/
     3130                                }
     3131                        }
     3132                        if (remaining !=0){
     3133                                block_base = i*BLOCK_SIZE;
     3134                                //cout << "block_base " << block_base << endl;
     3135                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     3136                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
     3137                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
     3138                                switch (j){
     3139                                        case 2:
     3140                                        validation_2.do_final_block(lex,output,EOF_mask);
     3141#ifdef DEBUG
     3142//                                      cout << remaining << endl;
     3143                                        print_register("cc2",lex.cc2);
     3144//                                      print_register("cc3",lex.cc3);
     3145//                                      print_register("cc4",lex.cc4);
     3146//                                      print_register("cc9",lex.cc9);
     3147                                        print_register("match_2",output.matches);
     3148#endif
     3149                                        break;
     3150                                        case 4:
     3151                                        validation_4.do_final_block(lex,output,EOF_mask);
     3152#ifdef DEBUG
     3153                                        print_register("cc4",lex.cc4);
     3154                                        print_register("match_4",output.matches);
     3155#endif
     3156                                        break;
     3157                                        case 9:
     3158                                        validation_9.do_final_block(lex,output,EOF_mask);
     3159#ifdef DEBUG
     3160                                        print_register("cc9",lex.cc9);
     3161                                        print_register("match_9",output.matches);
     3162#endif
     3163                                        break;
     3164/*
     3165                                        case 10:
     3166                                        validation_10.do_final_block(lex,output,EOF_mask);
     3167#ifdef DEBUG
     3168                                        print_register("cc10",lex.cc10);
     3169                                        print_register("match_10",output.matches);
     3170#endif
     3171                                        break;
     3172*/
     3173                                }
     3174                        }
     3175                }
     3176        }
     3177}
     3178
     3179
     3180
     3181/*
     3182
     3183static inline void validate_mul_block(){
     3184        struct Elem elem;
     3185        Validation_2 validation_2;
     3186//      Validation_2 validation_2;
     3187        Validation_4 validation_4;
     3188        Validation_9 validation_9;
     3189//      Validation_4 validation_4;     
     3190//      Validation_5 validation_5;
     3191//      Validation_24 validation_24;
     3192//      Validation_25 validation_25;
     3193//      Validation_27 validation_27;
     3194//      Validation_35 validation_35;
     3195//      Validation_41 validation_41;
     3196//      Validation_45 validation_45;
     3197       
     3198        struct Lex lex;
     3199       
     3200        struct Output output;
     3201
     3202        Classify_bytes classify_bytes;
     3203        int j;
     3204#ifdef DEBUG
     3205        for(j=0;j<MAX_COUNT;j++){
     3206        int lgth = gid_vec[j].size();
     3207                if(!gid_vec[j].empty())
     3208                        print_elem_vec(&(gid_vec[j]),lgth,j);
     3209        }
     3210#endif
     3211        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
     3212        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
     3213        match_scanner.init();
     3214        f_vec_scanner.init();
     3215        int lgth;
     3216        for(j=0;j<MAX_COUNT;j++){
     3217                lgth = gid_vec[j].size();
     3218                int remaining = 0;
     3219                Basis_bits temp_basis_bits;
     3220                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
     3221                int i = 0;
     3222                int block_base;
     3223               
     3224                if(lgth != 0){ 
     3225                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
     3226                        for(i = 0;i < num_block; i++){
     3227                                block_base = i*BLOCK_SIZE;
     3228                                //cout << "block_base " << block_base << endl;
     3229                       
     3230                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
     3231                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
     3232                                //print_basis_bits(temp_basis_bits);
     3233
     3234                                classify_bytes.do_block(temp_basis_bits,lex);
     3235                                switch (j){
     3236                                        case 2:
     3237                                        validation_2.do_block(lex,output);
     3238                                        f_vec_scanner.load_block(lex.cc2,i);
     3239#ifdef DEBUG                           
     3240                                        print_register("cc2",lex.cc2);
     3241                                        print_register("match_2",output.matches);
     3242#endif
     3243                                        break;
     3244                                        case 4:
     3245                                        validation_4.do_block(lex,output);
     3246                                        f_vec_scanner.load_block(lex.cc4,i);
     3247#ifdef DEBUG
     3248                                        print_register("cc4",lex.cc4);
     3249                                        print_register("match_4",output.matches);
     3250#endif
     3251                                        break;
     3252                                        case 9:
     3253                                        validation_9.do_block(lex,output);
     3254                                        f_vec_scanner.load_block(lex.cc9,i);
     3255#ifdef DEBUG
     3256                                        print_register("cc9",lex.cc9);
     3257                                        print_register("match_9",output.matches);
     3258#endif
     3259                                        break;
     3260                                }
     3261
     3262                                match_scanner.load_block(output.matches,i);
     3263
     3264                        }
     3265                        if (remaining !=0){
     3266                                block_base = i*BLOCK_SIZE;
     3267                                //cout << "block_base " << block_base << endl;
     3268                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     3269                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
     3270                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
     3271                                //print_basis_bits(temp_basis_bits);
     3272                                //print_elem_vec((vector<char>*)(gid_vec[j][block_base]),remaining,j);
     3273                       
     3274                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
     3275                                switch (j){
     3276                                        case 2:
     3277                                        validation_2.do_final_block(lex,output,EOF_mask);
     3278                                        f_vec_scanner.load_block(lex.cc2,i);
     3279#ifdef DEBUG
     3280//                                      cout << remaining << endl;
     3281                                        print_register("cc2",lex.cc2);
     3282//                                      print_register("cc3",lex.cc3);
     3283//                                      print_register("cc4",lex.cc4);
     3284//                                      print_register("cc9",lex.cc9);
     3285                                        print_register("match_2",output.matches);
     3286#endif
     3287                                        break;
     3288                                        case 4:
     3289                                        validation_4.do_final_block(lex,output,EOF_mask);
     3290                                        f_vec_scanner.load_block(lex.cc4,i);
     3291#ifdef DEBUG
     3292                                        print_register("cc4",lex.cc4);
     3293                                        print_register("match_4",output.matches);
     3294#endif
     3295                                        break;
     3296                                        case 9:
     3297                                        validation_9.do_final_block(lex,output,EOF_mask);
     3298                                        f_vec_scanner.load_block(lex.cc9,i);
     3299#ifdef DEBUG
     3300                                        print_register("cc9",lex.cc9);
     3301                                        print_register("match_9",output.matches);
     3302#endif
     3303                                        break;
     3304                                }
     3305                               
     3306                                match_scanner.load_block(output.matches,i);
     3307                        }
     3308                }
     3309        }
     3310        if(lgth != 0){
     3311                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
     3312        }
     3313       
     3314
     3315}
     3316
     3317
     3318*/
     3319
     3320/*
    22743321static inline void validate(){
    22753322        struct Elem elem;
    2276         Validate_Elem_Vec validate_Elem_Vec;
     3323        Validation_1 validation_1;
     3324        struct Lex lex;
     3325        struct Output output;
     3326        Classify_bytes classify_bytes;
    22773327        cout << "vector size " << gid_vec.size() << endl;
    22783328        int lgth = gid_vec.size();
    22793329        int remaining = 0;
     3330        int current_pos = 0;
    22803331        Basis_bits temp_basis_bits;
     3332
     3333        ForwardScanner<BitBlock, ScanWord> match_scanner;
     3334        ReverseScanner<BitBlock, ScanWord> vec_scanner;
     3335        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
     3336        int block_base = 0;
    22813337        if (lgth != 0){
    22823338                int i = 0;
     
    22883344                        print_elem_vec(&(gid_vec),lgth);
    22893345                        print_basis_bits(temp_basis_bits);
     3346                       
     3347                        classify_bytes.do_block(temp_basis_bits,lex);
     3348                        validation_1.do_block(lex,output);
     3349                       
     3350                        match_scanner.init(&output.matches);
     3351                        vec_scanner.init(&lex.cc1);
     3352                        match_scanner.scan_to_next();
     3353                        f_vec_scanner.init(&lex.cc1);
     3354                        match_scanner.scan_to_next();
     3355                        f_vec_scanner.scan_to_next();
     3356                        current_pos = f_vec_scanner.get_pos();
     3357                        vec_scanner.move_to(match_scanner.get_pos());
     3358                        vec_scanner.scan_to_next();
     3359//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3360                        if (vec_scanner.get_pos() != current_pos){
     3361                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
     3362                        }
     3363//                      out = simd_or(out,lex.cc1);
     3364//                      print_register("out",out);
     3365                       
     3366                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
     3367                                f_vec_scanner.scan_to_next();
     3368                                while(!(match_scanner.is_done())){
     3369                                        match_scanner.scan_to_next();
     3370                                        if(match_scanner.get_pos()>0){
     3371                                                vec_scanner.move_to(match_scanner.get_pos());
     3372                                                vec_scanner.scan_to_next();
     3373                                        }
     3374                                        if (vec_scanner.get_pos() != current_pos){
     3375                                                        break;
     3376                                        }
     3377                                }
     3378                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3379                                if (f_vec_scanner.get_pos()>0){
     3380                                        current_pos = f_vec_scanner.get_pos();
     3381                                }
     3382                                if (vec_scanner.get_pos() != current_pos){
     3383                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
     3384                                }
     3385//                              out = simd_or(out,lex.cc1);
     3386//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
     3387//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3388//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
     3389//                                      printf("Match found of element with id of '1'\n");                             
     3390//                              }
     3391                        }
     3392                               
     3393                       
    22903394//                      (BytePack*)(iter->second)
    2291                         validate_Elem_Vec.do_block(elem, temp_basis_bits);
     3395//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
    22923396                        cout << i ;
     3397                        block_base += BLOCK_SIZE;
    22933398                }
    2294                 cout << endl;
    22953399                if (remaining !=0){
    22963400                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     
    22983402                        print_elem_vec(&(gid_vec),lgth);
    22993403                        print_basis_bits(temp_basis_bits);
    2300                         validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
     3404                       
     3405                        classify_bytes.do_block(temp_basis_bits,lex);
     3406                        validation_1.do_block(lex,output);
     3407                        print_register("output.matches",output.matches);
     3408                        print_register("lex.cc1",lex.cc1);
     3409                        match_scanner.init(&output.matches);
     3410                        vec_scanner.init(&lex.cc1);
     3411                        f_vec_scanner.init(&lex.cc1);
     3412                        match_scanner.scan_to_next();
     3413                        f_vec_scanner.scan_to_next();
     3414                        current_pos = f_vec_scanner.get_pos();
     3415                        cout << "current_pos = " << current_pos << endl;
     3416//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
     3417//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3418                        vec_scanner.move_to(match_scanner.get_pos());
     3419                        vec_scanner.scan_to_next();
     3420                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3421                        if (vec_scanner.get_pos() != current_pos){
     3422                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
     3423                        }
     3424//                      out = simd_or(out,lex.cc1);
     3425//                      print_register("out",out);
     3426                       
     3427                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
     3428                                f_vec_scanner.scan_to_next();
     3429                                while(!(match_scanner.is_done())){
     3430                                        match_scanner.scan_to_next();
     3431                                        if(match_scanner.get_pos()>0){
     3432                                                vec_scanner.move_to(match_scanner.get_pos());
     3433                                                vec_scanner.scan_to_next();
     3434                                        }
     3435                                        if (vec_scanner.get_pos() != current_pos){
     3436                                                        break;
     3437                                        }
     3438                                }
     3439                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3440                                if (f_vec_scanner.get_pos()>0){
     3441                                        current_pos = f_vec_scanner.get_pos();
     3442                                }
     3443                                if (vec_scanner.get_pos() != current_pos){
     3444                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
     3445                                }
     3446//                              out = simd_or(out,lex.cc1);
     3447//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
     3448//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
     3449//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
     3450//                                      printf("Match found of element with id of '1'\n");                             
     3451//                              }
     3452                        }
     3453//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
    23013454                }
    23023455        }
     
    23433496        }
    23443497*/
     3498/*
    23453499}
     3500*/
    23463501
    23473502static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
     
    23503505    hashvalues[1] = hash_data.Hash_value;
    23513506   
    2352         StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
     3507//    pre_index.push(0);
     3508   
     3509        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock),(ScanBlock *) &tag_Callouts.Content_starts,(ScanBlock *) &tag_Callouts.EndTag_marks);
    23533510       
    23543511        // Store the last starting position in case we hit boundary case
     
    25503707  struct Elem elem;
    25513708
     3709  struct Output output;
     3710
    25523711
    25533712
     
    25553714                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
    25563715        #endif
     3716//#ifdef SYMBOL_TABLE
     3717        if(Symbol){
    25573718        ///////////////////////////////////////////////////
    25583719        //preload element_IDs into symbol table from schema
    25593720        ///////////////////////////////////////////////////
    25603721        FILE *element_ID_in = fopen("../test/element_ID","r");
    2561         char symble[50];
     3722        char symbol[50];
    25623723        int index;
    25633724        if(element_ID_in == NULL){
     
    25663727        }
    25673728        hashvalues[1] = hash_data.Hash_value;
    2568         while(fscanf(element_ID_in,"%s %d\n",&symble[0],&index)==2){
    2569                 int lgth = strlen(symble);
    2570                 int hashvalue = compute_hash_value(lgth,1);
    2571                 cout << symble <<" "<< lgth<<" "<<hashvalue << endl;
     3729        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
     3730                int lgth = strlen(symbol);
     3731                int hashvalue = compute_hash_value2(symbol,lgth);
     3732//              cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
    25723733                int gid = 0;
    25733734                switch (lgth)
    25743735        {
    25753736                        case 1:
    2576                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symble, hashvalue);
     3737                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
    25773738                        break;
    25783739                        case 2:
    2579                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symble, hashvalue);
     3740                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
    25803741                        break;
    25813742                        case 3:
    2582                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symble, hashvalue);
     3743                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
    25833744                        break;
    25843745                        case 4:
    2585                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symble, hashvalue);
     3746                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
    25863747                        break;
    25873748                        case 5:
    2588                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symble, hashvalue);
     3749                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
    25893750                        break;
    25903751                        case 6:
    2591                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symble, hashvalue);
     3752                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
    25923753                        break;
    25933754                        case 7:
    2594                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symble, hashvalue);
     3755                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
    25953756                        break;
    25963757                        case 8:
    2597                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symble, hashvalue);
     3758                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
    25983759                        break;
    25993760                        case 9:
    2600                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symble, hashvalue);
     3761                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
    26013762                        break;
    26023763                        case 10:
    2603                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symble, hashvalue);
     3764                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
    26043765                        break;
    26053766                        case 11:
    2606                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symble, hashvalue);
     3767                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
    26073768                        break;
    26083769                        case 12:
    2609                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symble, hashvalue);
     3770                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
    26103771                        break;
    26113772                        case 13:
    2612                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symble, hashvalue);
     3773                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
    26133774                        break;
    26143775                        case 14:
    2615                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symble, hashvalue);
     3776                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
    26163777                        break;
    26173778                        case 15:
    2618                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symble, hashvalue);
     3779                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
    26193780                        break;
    26203781                        case 16:
    2621                         gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symble, hashvalue);
     3782                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
    26223783                        break;
    26233784                        default:
    2624                         gid = pbgs_symbol_table.Lookup_or_Insert_Name(symble, hashvalue, lgth);
     3785                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
    26253786                        break;         
    26263787                }
    2627                 cout << "gid=" << gid << endl;
     3788#ifdef DEBUG
     3789                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
     3790#endif
    26283791        }       
    26293792        fclose(element_ID_in);
    2630         return;
     3793        }
     3794//#endif
     3795//      return;
    26313796
    26323797        int buffer_base = 0;
     
    26493814                        src_buffer.reserve(BUFFER_SIZE);
    26503815                #else
    2651                         uint8_t * COPYBACK;
    2652                         uint8_t * src_buffer;
     3816                        char * COPYBACK;
     3817                        char * src_buffer;
    26533818                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
    26543819                #endif
     
    27073872
    27083873  Parse_refs parse_refs;
    2709   Validate_Elem_Vec validate_Elem_Vec;
    27103874  Parse_tags parse_tags;
    27113875  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
    27123876  Parse_CtCDPI parse_CtCDPI;
     3877  Validation_9 validation_9;
    27133878  Do_check_streams do_check_streams;
    2714   Form_Length_Group_Bitstreams form_Length_Group_Bitstreams;
     3879  Classify_bytes classify_bytes;
     3880  Validation_2 validation_2;
    27153881  Validate_xml_names validate_xml_names;
    2716   Compute_Hash_Value_Bitstream compute_Hash_Value_Bitstream;
     3882  Validation_4 validation_4;
     3883  Validate_content_5 validate_content_5;
    27173884  Add_scope_streams add_scope_streams;
    27183885
     
    27273894      PERF_SEC_START(parser_timer);
    27283895      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
    2729         cout << "loops" << ends;
     3896//              cout << "loops" << ends;
    27303897                block_base = blk*BLOCK_SIZE;
    27313898        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
     
    27393906  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
    27403907  do_check_streams.do_block(marker, tag_Callouts, check_streams);
    2741   form_Length_Group_Bitstreams.do_block(tag_Callouts);
    2742   compute_Hash_Value_Bitstream.do_block(hash_data, basis_bits);
    27433908         
    27443909                tracker.StoreNewlines(lex.LF);
    2745                 cout << "post start" << endl;
     3910//              cout << "post start" << endl;
    27463911//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
    27473912                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
     3913//#ifdef SYMBOL_TABLE
     3914                if(Symbol)
    27483915                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
    2749                 cout << "post done" << endl;
     3916//#endif
     3917//              cout << "post done" << endl;
    27503918                #ifndef STL_ALIGNED_VECTOR
    27513919                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
    27523920                #endif
    27533921                tracker.AdvanceBlock();
    2754                 cout << "loop" << endl;
     3922//              cout << "loop" << endl;
    27553923      }
    27563924      #ifndef STL_ALIGNED_VECTOR
     
    27583926      matcher.Advance_buffer();
    27593927      #endif
    2760       cout << "11111" << endl;
    27613928      PERF_SEC_END(parser_timer, chars_avail);
    2762           cout << "here" << endl;
     3929//        cout << "here" << endl;
    27633930      int bytes_left = chars_read - chars_avail;
     3931     
    27643932      //////////////////
    27653933      //element name buffer, for scanning element name backwards
    27663934      /////////////////
    27673935      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
     3936//      fprintf(gid_writein,"name_buffer\n");
    27683937      cross_buffer_flag = 1;
    27693938     
     
    27713940      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
    27723941      chars_avail = chars_read;
    2773       cout << "here" << endl;
     3942//      cout << "here" << endl;
    27743943      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
    27753944      buffer_pos += chars_avail;
     
    28003969  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
    28013970  do_check_streams.do_block(marker, tag_Callouts, check_streams);
    2802   form_Length_Group_Bitstreams.do_block(tag_Callouts);
    2803   compute_Hash_Value_Bitstream.do_block(hash_data, basis_bits);
    28043971         
    28053972          tracker.StoreNewlines(lex.LF);
    2806           cout << "post start1" << endl;
     3973//        cout << "post start1" << endl;
    28073974         
    28083975//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
    28093976          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
     3977//#ifdef SYMBOL_TABLE
     3978        if(Symbol)
    28103979          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
    2811           cout << "post end2" << endl;
     3980//#endif
     3981//        cout << "post end2" << endl;
    28123982          #ifndef STL_ALIGNED_VECTOR
    28133983          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     
    28193989    block_base = block_pos;
    28203990        #ifdef USE_ANY_CARRY_TEST
    2821     if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || 0 || parse_tags.carryQ.CarryTest(0, 13) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 12) || parse_CtCDPI.carryQ.CarryTest(0, 19) || 0 || form_Length_Group_Bitstreams.carryQ.CarryTest(0, 16) || validate_xml_names.carryQ.CarryTest(0, 9) || 0 || add_scope_streams.carryQ.CarryTest(0, 2)) {
     3991    if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || parse_tags.carryQ.CarryTest(0, 13) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 12) || parse_CtCDPI.carryQ.CarryTest(0, 19) || validation_9.carryQ.CarryTest(0, 10) || 0 || 0 || validation_2.carryQ.CarryTest(0, 12) || validate_xml_names.carryQ.CarryTest(0, 9) || validation_4.carryQ.CarryTest(0, 10) || validate_content_5.carryQ.CarryTest(0, 12) || add_scope_streams.carryQ.CarryTest(0, 2)) {
    28223992        #endif
    28233993          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
     
    28314001  validate_xml_names.do_final_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams, EOF_mask);
    28324002  do_check_streams.do_final_block(marker, tag_Callouts, check_streams, EOF_mask);
    2833   form_Length_Group_Bitstreams.do_final_block(tag_Callouts, EOF_mask);
    2834   compute_Hash_Value_Bitstream.do_final_block(hash_data, basis_bits, EOF_mask);
    2835           cout << "post start3" << endl;
     4003//        cout << "post start3" << endl;
    28364004//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
    28374005          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
     4006//#ifdef SYMBOL_TABLE
     4007        if(Symbol)
    28384008          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
    2839           cout << "post end3" << endl;
     4009//#endif
     4010//        cout << "post end3" << endl;
    28404011          #ifndef STL_ALIGNED_VECTOR
    28414012      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
     
    28964067        }
    28974068
     4069        if (argc == 4){
     4070                if(strcmp(argv[3],"-s")==0){
     4071                        Symbol = 1;
     4072                        Content_model = 0;
     4073                        Datatype = 0;
     4074                        //Debug = 0;
     4075                }else if(strcmp(argv[3],"-c")==0){
     4076                        Symbol = 1;
     4077                        Content_model = 1;
     4078                        Datatype = 0;
     4079                        Content_gather = 1;
     4080                }else if(strcmp(argv[3],"-d")==0){
     4081                        Symbol = 1;
     4082                        Content_model = 0;
     4083                        Datatype = 1;
     4084                }else if(strcmp(argv[3],"-a")==0){
     4085                        Symbol = 1;
     4086                        Content_model = 1;
     4087                        Datatype = 1;
     4088                }else if(strcmp(argv[3],"-g")==0){
     4089                        Symbol = 1;
     4090                        Datatype = 1;
     4091                        Data_gather = 1;
     4092                        Content_model = 0;
     4093                }else if(strcmp(argv[3],"-v")==0){
     4094                        Symbol = 1;
     4095                        Content_model = 1;
     4096                        Datatype = 0;
     4097                        Content_gather = 1;
     4098                }
     4099        }
     4100
    28984101//      PERF_SEC_BIND(1);
    28994102
     
    29034106       
    29044107#if DEBUG
    2905 print_gid_vec();
     4108//print_gid_vec();
    29064109#endif
    29074110        //cout << "validate start" << endl;
    2908         validate();
    2909 
     4111        //validate();
     4112//#ifdef CONTENT_MODEL
     4113        if(Symbol && Content_model && !Content_gather)
     4114                validate_mul_block();
     4115//#endif
    29104116        PERF_SEC_DUMP(parser_timer);
    29114117
Note: See TracChangeset for help on using the changeset viewer.