Changeset 3344 for proto


Ignore:
Timestamp:
Jun 21, 2013, 1:42:29 PM (6 years ago)
Author:
ksherdy
Message:

Valid output.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3330 r3344  
    1919// runtime libraries
    2020#include <simd-lib/bitblock.hpp>
    21 #include <simd-lib/carrySet.hpp>
     21#include <simd-lib/carryQ.hpp>
    2222#include <simd-lib/pabloSupport.hpp>
    2323
     
    191191        {
    192192        }
    193        
     193         
    194194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
    195195        {
    196                 BitBlock temp1;
    197                 temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
    198                 print_register<BitBlock>("temp1",temp1);
    199                 BitBlock temp2;
    200                 temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
    201                 print_register<BitBlock>("temp2",temp2);
    202                 BitBlock temp3;
    203                 temp3 = simd_andc(temp2,temp1);
    204                 print_register<BitBlock>("temp3",temp3);
    205                 BitBlock temp4;
    206                 temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
    207                 print_register<BitBlock>("temp4",temp4);
    208                 BitBlock temp5;
    209                 temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
    210                 print_register<BitBlock>("temp5",temp5);
    211                 BitBlock temp6;
    212                 temp6 = simd_and(temp4,temp5);
    213                 print_register<BitBlock>("temp6",temp6);
     196                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     197                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     198                BitBlock temp3 = simd_andc(temp2,temp1);
     199                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     200                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     201                BitBlock temp6 = simd_and(temp4,temp5);
    214202                lex.RefStart = simd_and(temp3,temp6);
    215                 print_register<BitBlock>("lex.RefStart",lex.RefStart);
    216                 BitBlock temp7;
    217                 temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
    218                 print_register<BitBlock>("temp7",temp7);
    219                 BitBlock temp8;
    220                 temp8 = simd_andc(temp7,temp1);
    221                 print_register<BitBlock>("temp8",temp8);
    222                 BitBlock temp9;
    223                 temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
    224                 print_register<BitBlock>("temp9",temp9);
    225                 BitBlock temp10;
    226                 temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
    227                 print_register<BitBlock>("temp10",temp10);
    228                 BitBlock temp11;
    229                 temp11 = simd_and(temp9,temp10);
    230                 print_register<BitBlock>("temp11",temp11);
     203                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     204                BitBlock temp8 = simd_andc(temp7,temp1);
     205                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     206                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     207                BitBlock temp11 = simd_and(temp9,temp10);
    231208                lex.Semicolon = simd_and(temp8,temp11);
    232                 print_register<BitBlock>("lex.Semicolon",lex.Semicolon);
    233                 BitBlock temp12;
    234                 temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
    235                 print_register<BitBlock>("temp12",temp12);
    236                 BitBlock temp13;
    237                 temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
    238                 print_register<BitBlock>("temp13",temp13);
    239                 BitBlock temp14;
    240                 temp14 = simd_andc(temp12,temp13);
    241                 print_register<BitBlock>("temp14",temp14);
     209                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     210                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     211                BitBlock temp14 = simd_andc(temp12,temp13);
    242212                lex.LAngle = simd_and(temp8,temp14);
    243                 print_register<BitBlock>("lex.LAngle",lex.LAngle);
    244                 BitBlock temp15;
    245                 temp15 = simd_and(temp12,temp5);
    246                 print_register<BitBlock>("temp15",temp15);
     213                BitBlock temp15 = simd_and(temp12,temp5);
    247214                lex.RAngle = simd_and(temp8,temp15);
    248                 print_register<BitBlock>("lex.RAngle",lex.RAngle);
    249                 BitBlock temp16;
    250                 temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
    251                 print_register<BitBlock>("temp16",temp16);
    252                 BitBlock temp17;
    253                 temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
    254                 print_register<BitBlock>("temp17",temp17);
    255                 BitBlock temp18;
    256                 temp18 = simd_and(temp16,temp17);
    257                 print_register<BitBlock>("temp18",temp18);
     215                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     216                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     217                BitBlock temp18 = simd_and(temp16,temp17);
    258218                lex.LBracket = simd_and(temp18,temp11);
    259                 print_register<BitBlock>("lex.LBracket",lex.LBracket);
    260                 BitBlock temp19;
    261                 temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
    262                 print_register<BitBlock>("temp19",temp19);
    263                 BitBlock temp20;
    264                 temp20 = simd_and(temp12,temp19);
    265                 print_register<BitBlock>("temp20",temp20);
     219                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     220                BitBlock temp20 = simd_and(temp12,temp19);
    266221                lex.RBracket = simd_and(temp18,temp20);
    267                 print_register<BitBlock>("lex.RBracket",lex.RBracket);
    268                 BitBlock temp21;
    269                 temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
    270                 print_register<BitBlock>("temp21",temp21);
    271                 BitBlock temp22;
    272                 temp22 = simd_andc(temp19,temp21);
    273                 print_register<BitBlock>("temp22",temp22);
     222                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     223                BitBlock temp22 = simd_andc(temp19,temp21);
    274224                lex.Exclam = simd_and(temp3,temp22);
    275                 print_register<BitBlock>("lex.Exclam",lex.Exclam);
    276                 BitBlock temp23;
    277                 temp23 = simd_and(temp12,temp10);
    278                 print_register<BitBlock>("temp23",temp23);
     225                BitBlock temp23 = simd_and(temp12,temp10);
    279226                lex.QMark = simd_and(temp8,temp23);
    280                 print_register<BitBlock>("lex.QMark",lex.QMark);
    281227                lex.Hyphen = simd_and(temp3,temp20);
    282                 print_register<BitBlock>("lex.Hyphen",lex.Hyphen);
    283228                lex.Equals = simd_and(temp8,temp20);
    284                 print_register<BitBlock>("lex.Equals",lex.Equals);
    285                 BitBlock temp24;
    286                 temp24 = simd_and(temp4,temp10);
    287                 print_register<BitBlock>("temp24",temp24);
     229                BitBlock temp24 = simd_and(temp4,temp10);
    288230                lex.SQuote = simd_and(temp3,temp24);
    289                 print_register<BitBlock>("lex.SQuote",lex.SQuote);
    290                 BitBlock temp25;
    291                 temp25 = simd_andc(temp5,temp21);
    292                 print_register<BitBlock>("temp25",temp25);
     231                BitBlock temp25 = simd_andc(temp5,temp21);
    293232                lex.DQuote = simd_and(temp3,temp25);
    294                 print_register<BitBlock>("lex.DQuote",lex.DQuote);
    295233                lex.Slash = simd_and(temp3,temp23);
    296                 print_register<BitBlock>("lex.Slash",lex.Slash);
    297                 BitBlock temp26;
    298                 temp26 = simd_andc(temp10,temp21);
    299                 print_register<BitBlock>("temp26",temp26);
     234                BitBlock temp26 = simd_andc(temp10,temp21);
    300235                lex.Hash = simd_and(temp3,temp26);
    301                 print_register<BitBlock>("lex.Hash",lex.Hash);
    302                 BitBlock temp27;
    303                 temp27 = simd_and(temp16,temp7);
    304                 print_register<BitBlock>("temp27",temp27);
    305                 BitBlock temp28;
    306                 temp28 = simd_andc(temp9,temp13);
    307                 print_register<BitBlock>("temp28",temp28);
     236                BitBlock temp27 = simd_and(temp16,temp7);
     237                BitBlock temp28 = simd_andc(temp9,temp13);
    308238                lex.x = simd_and(temp27,temp28);
    309                 print_register<BitBlock>("lex.x",lex.x);
    310                 BitBlock temp29;
    311                 temp29 = simd_and(temp9,temp5);
    312                 print_register<BitBlock>("temp29",temp29);
     239                BitBlock temp29 = simd_and(temp9,temp5);
    313240                lex.Colon = simd_and(temp8,temp29);
    314                 print_register<BitBlock>("lex.Colon",lex.Colon);
    315                 BitBlock temp30;
    316                 temp30 = simd_and(temp18,temp23);
    317                 print_register<BitBlock>("temp30",temp30);
    318                 BitBlock temp31;
    319                 temp31 = simd_or(temp30,lex.Colon);
    320                 print_register<BitBlock>("temp31",temp31);
    321                 BitBlock temp32;
    322                 temp32 = simd_andc(temp16,basis_bits.bit_2);
    323                 print_register<BitBlock>("temp32",temp32);
    324                 BitBlock temp33;
    325                 temp33 = simd_or(basis_bits.bit_5,temp10);
    326                 print_register<BitBlock>("temp33",temp33);
    327                 BitBlock temp34;
    328                 temp34 = simd_and(basis_bits.bit_4,temp33);
    329                 print_register<BitBlock>("temp34",temp34);
    330                 BitBlock temp35;
    331                 temp35 = simd_not(temp34);
    332                 print_register<BitBlock>("temp35",temp35);
    333                 BitBlock temp36;
    334                 temp36 = simd_or(temp21,temp13);
    335                 print_register<BitBlock>("temp36",temp36);
    336                 BitBlock temp37;
    337                 temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
    338                 print_register<BitBlock>("temp37",temp37);
    339                 BitBlock temp38;
    340                 temp38 = simd_and(temp32,temp37);
    341                 print_register<BitBlock>("temp38",temp38);
    342                 BitBlock temp39;
    343                 temp39 = simd_or(temp31,temp38);
    344                 print_register<BitBlock>("temp39",temp39);
    345                 BitBlock temp40;
    346                 temp40 = simd_and(temp16,basis_bits.bit_2);
    347                 print_register<BitBlock>("temp40",temp40);
    348                 BitBlock temp41;
    349                 temp41 = simd_and(temp40,temp37);
    350                 print_register<BitBlock>("temp41",temp41);
     241                BitBlock temp30 = simd_and(temp18,temp23);
     242                BitBlock temp31 = simd_or(temp30,lex.Colon);
     243                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     244                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     245                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     246                BitBlock temp35 = simd_not(temp34);
     247                BitBlock temp36 = simd_or(temp21,temp13);
     248                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     249                BitBlock temp38 = simd_and(temp32,temp37);
     250                BitBlock temp39 = simd_or(temp31,temp38);
     251                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     252                BitBlock temp41 = simd_and(temp40,temp37);
    351253                lex.ASCII_name_start = simd_or(temp39,temp41);
    352                 print_register<BitBlock>("lex.ASCII_name_start",lex.ASCII_name_start);
    353                 BitBlock temp42;
    354                 temp42 = simd_or(temp30,lex.Hyphen);
    355                 print_register<BitBlock>("temp42",temp42);
    356                 BitBlock temp43;
    357                 temp43 = simd_and(temp3,temp15);
    358                 print_register<BitBlock>("temp43",temp43);
    359                 BitBlock temp44;
    360                 temp44 = simd_or(temp42,temp43);
    361                 print_register<BitBlock>("temp44",temp44);
    362                 BitBlock temp45;
    363                 temp45 = simd_andc(temp8,temp34);
    364                 print_register<BitBlock>("temp45",temp45);
    365                 BitBlock temp46;
    366                 temp46 = simd_or(temp44,temp45);
    367                 print_register<BitBlock>("temp46",temp46);
    368                 BitBlock temp47;
    369                 temp47 = simd_or(temp46,temp38);
    370                 print_register<BitBlock>("temp47",temp47);
     254                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     255                BitBlock temp43 = simd_and(temp3,temp15);
     256                BitBlock temp44 = simd_or(temp42,temp43);
     257                BitBlock temp45 = simd_andc(temp8,temp34);
     258                BitBlock temp46 = simd_or(temp44,temp45);
     259                BitBlock temp47 = simd_or(temp46,temp38);
    371260                lex.ASCII_name_char = simd_or(temp47,temp41);
    372                 print_register<BitBlock>("lex.ASCII_name_char",lex.ASCII_name_char);
    373261                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
    374                 print_register<BitBlock>("lex.NameScan",lex.NameScan);
    375                 BitBlock temp48;
    376                 temp48 = simd_or(temp1,basis_bits.bit_2);
    377                 print_register<BitBlock>("temp48",temp48);
    378                 BitBlock x00_x1F;
    379                 x00_x1F = simd_not(temp48);
    380                 print_register<BitBlock>("x00_x1F",x00_x1F);
    381                 BitBlock temp49;
    382                 temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
    383                 print_register<BitBlock>("temp49",temp49);
    384                 BitBlock temp50;
    385                 temp50 = simd_or(temp1,temp49);
    386                 print_register<BitBlock>("temp50",temp50);
     262                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     263                BitBlock x00_x1F = simd_not(temp48);
     264                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     265                BitBlock temp50 = simd_or(temp1,temp49);
    387266                lex.CR = simd_andc(temp20,temp50);
    388                 print_register<BitBlock>("lex.CR",lex.CR);
    389267                lex.LF = simd_andc(temp29,temp50);
    390                 print_register<BitBlock>("lex.LF",lex.LF);
    391                 BitBlock temp51;
    392                 temp51 = simd_and(temp9,temp19);
    393                 print_register<BitBlock>("temp51",temp51);
     268                BitBlock temp51 = simd_and(temp9,temp19);
    394269                lex.HT = simd_andc(temp51,temp50);
    395                 print_register<BitBlock>("lex.HT",lex.HT);
    396270                lex.SP = simd_andc(temp3,temp36);
    397                 print_register<BitBlock>("lex.SP",lex.SP);
    398                 BitBlock temp52;
    399                 temp52 = simd_or(temp20,temp29);
    400                 print_register<BitBlock>("temp52",temp52);
    401                 BitBlock temp53;
    402                 temp53 = simd_or(temp52,temp51);
    403                 print_register<BitBlock>("temp53",temp53);
    404                 BitBlock temp54;
    405                 temp54 = simd_andc(temp53,temp50);
    406                 print_register<BitBlock>("temp54",temp54);
     271                BitBlock temp52 = simd_or(temp20,temp29);
     272                BitBlock temp53 = simd_or(temp52,temp51);
     273                BitBlock temp54 = simd_andc(temp53,temp50);
    407274                lex.WS = simd_or(temp54,lex.SP);
    408                 print_register<BitBlock>("lex.WS",lex.WS);
    409                 BitBlock temp55;
    410                 temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
    411                 print_register<BitBlock>("temp55",temp55);
    412                 BitBlock temp56;
    413                 temp56 = simd_and(basis_bits.bit_4,temp55);
    414                 print_register<BitBlock>("temp56",temp56);
     275                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     276                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
    415277                lex.Digit = simd_andc(temp8,temp56);
    416                 print_register<BitBlock>("lex.Digit",lex.Digit);
    417                 BitBlock temp57;
    418                 temp57 = simd_andc(temp16,temp49);
    419                 print_register<BitBlock>("temp57",temp57);
    420                 BitBlock temp58;
    421                 temp58 = simd_andc(temp57,basis_bits.bit_4);
    422                 print_register<BitBlock>("temp58",temp58);
    423                 BitBlock temp59;
    424                 temp59 = simd_not(temp10);
    425                 print_register<BitBlock>("temp59",temp59);
    426                 BitBlock temp60;
    427                 temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
    428                 print_register<BitBlock>("temp60",temp60);
    429                 BitBlock temp61;
    430                 temp61 = simd_and(temp58,temp60);
    431                 print_register<BitBlock>("temp61",temp61);
    432                 BitBlock temp62;
    433                 temp62 = simd_or(lex.Digit,temp61);
    434                 print_register<BitBlock>("temp62",temp62);
    435                 BitBlock temp63;
    436                 temp63 = simd_and(temp16,temp2);
    437                 print_register<BitBlock>("temp63",temp63);
    438                 BitBlock temp64;
    439                 temp64 = simd_andc(temp63,basis_bits.bit_4);
    440                 print_register<BitBlock>("temp64",temp64);
    441                 BitBlock temp65;
    442                 temp65 = simd_and(temp64,temp60);
    443                 print_register<BitBlock>("temp65",temp65);
     278                BitBlock temp57 = simd_andc(temp16,temp49);
     279                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     280                BitBlock temp59 = simd_not(temp10);
     281                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     282                BitBlock temp61 = simd_and(temp58,temp60);
     283                BitBlock temp62 = simd_or(lex.Digit,temp61);
     284                BitBlock temp63 = simd_and(temp16,temp2);
     285                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     286                BitBlock temp65 = simd_and(temp64,temp60);
    444287                lex.Hex = simd_or(temp62,temp65);
    445                 print_register<BitBlock>("lex.Hex",lex.Hex);
    446                 BitBlock lex_error;
    447                 lex_error = simd_andc(x00_x1F,lex.WS);
    448                 print_register<BitBlock>("lex_error",lex_error);
     288                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
    449289                if (bitblock::any(lex_error))
    450290                {
     
    452292                }
    453293                u8.unibyte = simd_not(basis_bits.bit_0);
    454                 print_register<BitBlock>("u8.unibyte",u8.unibyte);
    455294                u8.suffix = simd<1>::constant<0>();
    456                 print_register<BitBlock>("u8.suffix",u8.suffix);
    457                 BitBlock u8_error;
    458                 u8_error = simd<1>::constant<0>();
    459                 print_register<BitBlock>("u8_error",u8_error);
    460                 BitBlock u8_FFFE_FFFF;
    461                 u8_FFFE_FFFF = simd<1>::constant<0>();
    462                 print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    463                 BitBlock u8anyscope;
    464                 u8anyscope = simd<1>::constant<0>();
    465                 print_register<BitBlock>("u8anyscope",u8anyscope);
    466                 if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
     295                BitBlock u8_error = simd<1>::constant<0>();
     296                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     297                BitBlock u8anyscope = simd<1>::constant<0>();
     298                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
    467299                {
    468300                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
    469                         print_register<BitBlock>("u8.prefix",u8.prefix);
    470301                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
    471                         print_register<BitBlock>("u8.prefix2",u8.prefix2);
    472302                        u8.prefix3 = simd_and(u8.prefix,temp2);
    473                         print_register<BitBlock>("u8.prefix3",u8.prefix3);
    474303                        u8.prefix4 = simd_and(u8.prefix,temp7);
    475                         print_register<BitBlock>("u8.prefix4",u8.prefix4);
    476304                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
    477                         print_register<BitBlock>("u8.suffix",u8.suffix);
    478                         BitBlock temp66;
    479                         temp66 = simd_andc(u8.prefix,temp49);
    480                         print_register<BitBlock>("temp66",temp66);
    481                         BitBlock temp67;
    482                         temp67 = simd_or(temp21,basis_bits.bit_6);
    483                         print_register<BitBlock>("temp67",temp67);
    484                         BitBlock temp68;
    485                         temp68 = simd_andc(temp66,temp67);
    486                         print_register<BitBlock>("temp68",temp68);
    487                         BitBlock temp69;
    488                         temp69 = simd_and(basis_bits.bit_5,temp13);
    489                         print_register<BitBlock>("temp69",temp69);
    490                         BitBlock temp70;
    491                         temp70 = simd_or(basis_bits.bit_4,temp69);
    492                         print_register<BitBlock>("temp70",temp70);
    493                         BitBlock temp71;
    494                         temp71 = simd_and(u8.prefix4,temp70);
    495                         print_register<BitBlock>("temp71",temp71);
     305                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
     306                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     307                        BitBlock temp68 = simd_andc(temp66,temp67);
     308                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     309                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     310                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
    496311                        u8.badprefix = simd_or(temp68,temp71);
    497                         print_register<BitBlock>("u8.badprefix",u8.badprefix);
    498312                        u8_error = u8.badprefix;
    499                         print_register<BitBlock>("u8_error",u8_error);
    500                         BitBlock __temp__0;
    501                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),__temp__0));
    502                         u8.scope22 = __temp__0;
    503                         print_register<BitBlock>("u8.scope22",u8.scope22);
     313                        // u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
    504314                        u8anyscope = u8.scope22;
    505                         print_register<BitBlock>("u8anyscope",u8anyscope);
    506                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    507                         {
    508                                 BitBlock xE0;
    509                                 xE0 = simd_andc(u8.prefix3,temp36);
    510                                 print_register<BitBlock>("xE0",xE0);
    511                                 BitBlock xED;
    512                                 xED = simd_and(u8.prefix3,temp20);
    513                                 print_register<BitBlock>("xED",xED);
    514                                 BitBlock xF0;
    515                                 xF0 = simd_andc(u8.prefix4,temp36);
    516                                 print_register<BitBlock>("xF0",xF0);
    517                                 BitBlock temp72;
    518                                 temp72 = simd_andc(temp4,temp13);
    519                                 print_register<BitBlock>("temp72",temp72);
    520                                 BitBlock xF4;
    521                                 xF4 = simd_and(u8.prefix4,temp72);
    522                                 print_register<BitBlock>("xF4",xF4);
     315                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
     316                        {
     317                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     318                                BitBlock xED = simd_and(u8.prefix3,temp20);
     319                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     320                                BitBlock temp72 = simd_andc(temp4,temp13);
     321                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
    523322                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
    524                                 print_register<BitBlock>("u8.xA0_xBF",u8.xA0_xBF);
    525323                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
    526                                 print_register<BitBlock>("u8.x80_x9F",u8.x80_x9F);
    527324                                u8.x90_xBF = simd_and(u8.suffix,temp49);
    528                                 print_register<BitBlock>("u8.x90_xBF",u8.x90_xBF);
    529325                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
    530                                 print_register<BitBlock>("u8.x80_x8F",u8.x80_x8F);
    531                                 BitBlock xEF;
    532                                 xEF = simd_and(u8.prefix3,temp23);
    533                                 print_register<BitBlock>("xEF",xEF);
    534                                 BitBlock temp73;
    535                                 temp73 = simd_and(u8.suffix,temp7);
    536                                 print_register<BitBlock>("temp73",temp73);
     326                                BitBlock xEF = simd_and(u8.prefix3,temp23);
     327                                BitBlock temp73 = simd_and(u8.suffix,temp7);
    537328                                u8.xBF = simd_and(temp73,temp23);
    538                                 print_register<BitBlock>("u8.xBF",u8.xBF);
    539329                                u8.xBE = simd_and(temp73,temp15);
    540                                 print_register<BitBlock>("u8.xBE",u8.xBE);
    541                                 BitBlock __temp__1;
    542                                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),__temp__1));
    543                                 u8.scope32 = __temp__1;
    544                                 print_register<BitBlock>("u8.scope32",u8.scope32);
    545                                 BitBlock __temp__2;
    546                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),__temp__2));
    547                                 u8.scope33 = __temp__2;
    548                                 print_register<BitBlock>("u8.scope33",u8.scope33);
    549                                 BitBlock __temp__3;
    550                                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),__temp__3));
    551                                 u8.scope42 = __temp__3;
    552                                 print_register<BitBlock>("u8.scope42",u8.scope42);
    553                                 BitBlock __temp__4;
    554                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),__temp__4));
    555                                 u8.scope43 = __temp__4;
    556                                 print_register<BitBlock>("u8.scope43",u8.scope43);
    557                                 BitBlock __temp__5;
    558                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),__temp__5));
    559                                 u8.scope44 = __temp__5;
    560                                 print_register<BitBlock>("u8.scope44",u8.scope44);
    561                                 BitBlock __temp__6;
    562                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),__temp__6));
    563                                 BitBlock E0_F0_scope;
    564                                 E0_F0_scope = __temp__6;
    565                                 print_register<BitBlock>("E0_F0_scope",E0_F0_scope);
    566                                 BitBlock __temp__7;
    567                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),__temp__7));
    568                                 BitBlock ED_F4_scope;
    569                                 ED_F4_scope = __temp__7;
    570                                 print_register<BitBlock>("ED_F4_scope",ED_F4_scope);
     330                                //u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
     331                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
     332                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
     333                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
     334                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
     335                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
     336                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
    571337                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
    572                                 print_register<BitBlock>("u8.xE0_scope",u8.xE0_scope);
    573338                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
    574                                 print_register<BitBlock>("u8.xED_scope",u8.xED_scope);
    575339                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
    576                                 print_register<BitBlock>("u8.xF0_scope",u8.xF0_scope);
    577340                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    578                                 print_register<BitBlock>("u8.xF4_scope",u8.xF4_scope);
    579                                 BitBlock __temp__8;
    580                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),__temp__8));
    581                                 u8.xEF_scope = __temp__8;
    582                                 print_register<BitBlock>("u8.xEF_scope",u8.xEF_scope);
    583                                 BitBlock u8lastscope;
    584                                 u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    585                                 print_register<BitBlock>("u8lastscope",u8lastscope);
     341                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
     342                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    586343                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
    587                                 print_register<BitBlock>("u8anyscope",u8anyscope);
    588                                 BitBlock u8error1;
    589                                 u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
    590                                 print_register<BitBlock>("u8error1",u8error1);
    591                                 BitBlock u8error2;
    592                                 u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
    593                                 print_register<BitBlock>("u8error2",u8error2);
    594                                 BitBlock u8error3;
    595                                 u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
    596                                 print_register<BitBlock>("u8error3",u8error3);
    597                                 BitBlock u8error4;
    598                                 u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    599                                 print_register<BitBlock>("u8error4",u8error4);
     344                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     345                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     346                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     347                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    600348                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    601                                 print_register<BitBlock>("u8_error",u8_error);
    602                                 BitBlock __temp__9;
    603                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),__temp__9));
    604                                 BitBlock EF_BF_pending;
    605                                 EF_BF_pending = __temp__9;
    606                                 print_register<BitBlock>("EF_BF_pending",EF_BF_pending);
     349                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
    607350                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    608                                 print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    609351                        }
    610352                        else
    611353                        {
    612                                 carry_set_0.carryDequeueEnqueue(1,9);
    613                         }
    614                         BitBlock u8mismatch;
    615                         u8mismatch = simd_xor(u8anyscope,u8.suffix);
    616                         print_register<BitBlock>("u8mismatch",u8mismatch);
     354                                carry_set_0.CarryDequeueEnqueue(1,9);
     355                        }
     356                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
    617357                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    618358                        {
     
    622362                else
    623363                {
    624                         carry_set_0.carryDequeueEnqueue(0,10);
    625                 }
    626                 carry_set_0.carryAdjust(10);
     364                        carry_set_0.CarryDequeueEnqueue(0,10);
     365                }
     366                carry_set_0.CarryAdjust(10);
    627367        }
    628368       
    629369        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
    630370        {
    631                 BitBlock temp1;
    632                 temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
    633                 print_register<BitBlock>("temp1",temp1);
    634                 BitBlock temp2;
    635                 temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
    636                 print_register<BitBlock>("temp2",temp2);
    637                 BitBlock temp3;
    638                 temp3 = simd_andc(temp2,temp1);
    639                 print_register<BitBlock>("temp3",temp3);
    640                 BitBlock temp4;
    641                 temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
    642                 print_register<BitBlock>("temp4",temp4);
    643                 BitBlock temp5;
    644                 temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
    645                 print_register<BitBlock>("temp5",temp5);
    646                 BitBlock temp6;
    647                 temp6 = simd_and(temp4,temp5);
    648                 print_register<BitBlock>("temp6",temp6);
     371                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     372                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     373                BitBlock temp3 = simd_andc(temp2,temp1);
     374                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     375                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     376                BitBlock temp6 = simd_and(temp4,temp5);
    649377                lex.RefStart = simd_and(temp3,temp6);
    650                 print_register<BitBlock>("lex.RefStart",lex.RefStart);
    651                 BitBlock temp7;
    652                 temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
    653                 print_register<BitBlock>("temp7",temp7);
    654                 BitBlock temp8;
    655                 temp8 = simd_andc(temp7,temp1);
    656                 print_register<BitBlock>("temp8",temp8);
    657                 BitBlock temp9;
    658                 temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
    659                 print_register<BitBlock>("temp9",temp9);
    660                 BitBlock temp10;
    661                 temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
    662                 print_register<BitBlock>("temp10",temp10);
    663                 BitBlock temp11;
    664                 temp11 = simd_and(temp9,temp10);
    665                 print_register<BitBlock>("temp11",temp11);
     378                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     379                BitBlock temp8 = simd_andc(temp7,temp1);
     380                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     381                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     382                BitBlock temp11 = simd_and(temp9,temp10);
    666383                lex.Semicolon = simd_and(temp8,temp11);
    667                 print_register<BitBlock>("lex.Semicolon",lex.Semicolon);
    668                 BitBlock temp12;
    669                 temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
    670                 print_register<BitBlock>("temp12",temp12);
    671                 BitBlock temp13;
    672                 temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
    673                 print_register<BitBlock>("temp13",temp13);
    674                 BitBlock temp14;
    675                 temp14 = simd_andc(temp12,temp13);
    676                 print_register<BitBlock>("temp14",temp14);
     384                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     385                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     386                BitBlock temp14 = simd_andc(temp12,temp13);
    677387                lex.LAngle = simd_and(temp8,temp14);
    678                 print_register<BitBlock>("lex.LAngle",lex.LAngle);
    679                 BitBlock temp15;
    680                 temp15 = simd_and(temp12,temp5);
    681                 print_register<BitBlock>("temp15",temp15);
     388                BitBlock temp15 = simd_and(temp12,temp5);
    682389                lex.RAngle = simd_and(temp8,temp15);
    683                 print_register<BitBlock>("lex.RAngle",lex.RAngle);
    684                 BitBlock temp16;
    685                 temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
    686                 print_register<BitBlock>("temp16",temp16);
    687                 BitBlock temp17;
    688                 temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
    689                 print_register<BitBlock>("temp17",temp17);
    690                 BitBlock temp18;
    691                 temp18 = simd_and(temp16,temp17);
    692                 print_register<BitBlock>("temp18",temp18);
     390                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     391                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     392                BitBlock temp18 = simd_and(temp16,temp17);
    693393                lex.LBracket = simd_and(temp18,temp11);
    694                 print_register<BitBlock>("lex.LBracket",lex.LBracket);
    695                 BitBlock temp19;
    696                 temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
    697                 print_register<BitBlock>("temp19",temp19);
    698                 BitBlock temp20;
    699                 temp20 = simd_and(temp12,temp19);
    700                 print_register<BitBlock>("temp20",temp20);
     394                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     395                BitBlock temp20 = simd_and(temp12,temp19);
    701396                lex.RBracket = simd_and(temp18,temp20);
    702                 print_register<BitBlock>("lex.RBracket",lex.RBracket);
    703                 BitBlock temp21;
    704                 temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
    705                 print_register<BitBlock>("temp21",temp21);
    706                 BitBlock temp22;
    707                 temp22 = simd_andc(temp19,temp21);
    708                 print_register<BitBlock>("temp22",temp22);
     397                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     398                BitBlock temp22 = simd_andc(temp19,temp21);
    709399                lex.Exclam = simd_and(temp3,temp22);
    710                 print_register<BitBlock>("lex.Exclam",lex.Exclam);
    711                 BitBlock temp23;
    712                 temp23 = simd_and(temp12,temp10);
    713                 print_register<BitBlock>("temp23",temp23);
     400                BitBlock temp23 = simd_and(temp12,temp10);
    714401                lex.QMark = simd_and(temp8,temp23);
    715                 print_register<BitBlock>("lex.QMark",lex.QMark);
    716402                lex.Hyphen = simd_and(temp3,temp20);
    717                 print_register<BitBlock>("lex.Hyphen",lex.Hyphen);
    718403                lex.Equals = simd_and(temp8,temp20);
    719                 print_register<BitBlock>("lex.Equals",lex.Equals);
    720                 BitBlock temp24;
    721                 temp24 = simd_and(temp4,temp10);
    722                 print_register<BitBlock>("temp24",temp24);
     404                BitBlock temp24 = simd_and(temp4,temp10);
    723405                lex.SQuote = simd_and(temp3,temp24);
    724                 print_register<BitBlock>("lex.SQuote",lex.SQuote);
    725                 BitBlock temp25;
    726                 temp25 = simd_andc(temp5,temp21);
    727                 print_register<BitBlock>("temp25",temp25);
     406                BitBlock temp25 = simd_andc(temp5,temp21);
    728407                lex.DQuote = simd_and(temp3,temp25);
    729                 print_register<BitBlock>("lex.DQuote",lex.DQuote);
    730408                lex.Slash = simd_and(temp3,temp23);
    731                 print_register<BitBlock>("lex.Slash",lex.Slash);
    732                 BitBlock temp26;
    733                 temp26 = simd_andc(temp10,temp21);
    734                 print_register<BitBlock>("temp26",temp26);
     409                BitBlock temp26 = simd_andc(temp10,temp21);
    735410                lex.Hash = simd_and(temp3,temp26);
    736                 print_register<BitBlock>("lex.Hash",lex.Hash);
    737                 BitBlock temp27;
    738                 temp27 = simd_and(temp16,temp7);
    739                 print_register<BitBlock>("temp27",temp27);
    740                 BitBlock temp28;
    741                 temp28 = simd_andc(temp9,temp13);
    742                 print_register<BitBlock>("temp28",temp28);
     411                BitBlock temp27 = simd_and(temp16,temp7);
     412                BitBlock temp28 = simd_andc(temp9,temp13);
    743413                lex.x = simd_and(temp27,temp28);
    744                 print_register<BitBlock>("lex.x",lex.x);
    745                 BitBlock temp29;
    746                 temp29 = simd_and(temp9,temp5);
    747                 print_register<BitBlock>("temp29",temp29);
     414                BitBlock temp29 = simd_and(temp9,temp5);
    748415                lex.Colon = simd_and(temp8,temp29);
    749                 print_register<BitBlock>("lex.Colon",lex.Colon);
    750                 BitBlock temp30;
    751                 temp30 = simd_and(temp18,temp23);
    752                 print_register<BitBlock>("temp30",temp30);
    753                 BitBlock temp31;
    754                 temp31 = simd_or(temp30,lex.Colon);
    755                 print_register<BitBlock>("temp31",temp31);
    756                 BitBlock temp32;
    757                 temp32 = simd_andc(temp16,basis_bits.bit_2);
    758                 print_register<BitBlock>("temp32",temp32);
    759                 BitBlock temp33;
    760                 temp33 = simd_or(basis_bits.bit_5,temp10);
    761                 print_register<BitBlock>("temp33",temp33);
    762                 BitBlock temp34;
    763                 temp34 = simd_and(basis_bits.bit_4,temp33);
    764                 print_register<BitBlock>("temp34",temp34);
    765                 BitBlock temp35;
    766                 temp35 = simd_not(temp34);
    767                 print_register<BitBlock>("temp35",temp35);
    768                 BitBlock temp36;
    769                 temp36 = simd_or(temp21,temp13);
    770                 print_register<BitBlock>("temp36",temp36);
    771                 BitBlock temp37;
    772                 temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
    773                 print_register<BitBlock>("temp37",temp37);
    774                 BitBlock temp38;
    775                 temp38 = simd_and(temp32,temp37);
    776                 print_register<BitBlock>("temp38",temp38);
    777                 BitBlock temp39;
    778                 temp39 = simd_or(temp31,temp38);
    779                 print_register<BitBlock>("temp39",temp39);
    780                 BitBlock temp40;
    781                 temp40 = simd_and(temp16,basis_bits.bit_2);
    782                 print_register<BitBlock>("temp40",temp40);
    783                 BitBlock temp41;
    784                 temp41 = simd_and(temp40,temp37);
    785                 print_register<BitBlock>("temp41",temp41);
     416                BitBlock temp30 = simd_and(temp18,temp23);
     417                BitBlock temp31 = simd_or(temp30,lex.Colon);
     418                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     419                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     420                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     421                BitBlock temp35 = simd_not(temp34);
     422                BitBlock temp36 = simd_or(temp21,temp13);
     423                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     424                BitBlock temp38 = simd_and(temp32,temp37);
     425                BitBlock temp39 = simd_or(temp31,temp38);
     426                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     427                BitBlock temp41 = simd_and(temp40,temp37);
    786428                lex.ASCII_name_start = simd_or(temp39,temp41);
    787                 print_register<BitBlock>("lex.ASCII_name_start",lex.ASCII_name_start);
    788                 BitBlock temp42;
    789                 temp42 = simd_or(temp30,lex.Hyphen);
    790                 print_register<BitBlock>("temp42",temp42);
    791                 BitBlock temp43;
    792                 temp43 = simd_and(temp3,temp15);
    793                 print_register<BitBlock>("temp43",temp43);
    794                 BitBlock temp44;
    795                 temp44 = simd_or(temp42,temp43);
    796                 print_register<BitBlock>("temp44",temp44);
    797                 BitBlock temp45;
    798                 temp45 = simd_andc(temp8,temp34);
    799                 print_register<BitBlock>("temp45",temp45);
    800                 BitBlock temp46;
    801                 temp46 = simd_or(temp44,temp45);
    802                 print_register<BitBlock>("temp46",temp46);
    803                 BitBlock temp47;
    804                 temp47 = simd_or(temp46,temp38);
    805                 print_register<BitBlock>("temp47",temp47);
     429                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     430                BitBlock temp43 = simd_and(temp3,temp15);
     431                BitBlock temp44 = simd_or(temp42,temp43);
     432                BitBlock temp45 = simd_andc(temp8,temp34);
     433                BitBlock temp46 = simd_or(temp44,temp45);
     434                BitBlock temp47 = simd_or(temp46,temp38);
    806435                lex.ASCII_name_char = simd_or(temp47,temp41);
    807                 print_register<BitBlock>("lex.ASCII_name_char",lex.ASCII_name_char);
    808436                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
    809                 print_register<BitBlock>("lex.NameScan",lex.NameScan);
    810                 BitBlock temp48;
    811                 temp48 = simd_or(temp1,basis_bits.bit_2);
    812                 print_register<BitBlock>("temp48",temp48);
    813                 BitBlock x00_x1F;
    814                 x00_x1F = simd_not(temp48);
    815                 print_register<BitBlock>("x00_x1F",x00_x1F);
    816                 BitBlock temp49;
    817                 temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
    818                 print_register<BitBlock>("temp49",temp49);
    819                 BitBlock temp50;
    820                 temp50 = simd_or(temp1,temp49);
    821                 print_register<BitBlock>("temp50",temp50);
     437                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     438                BitBlock x00_x1F = simd_not(temp48);
     439                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     440                BitBlock temp50 = simd_or(temp1,temp49);
    822441                lex.CR = simd_andc(temp20,temp50);
    823                 print_register<BitBlock>("lex.CR",lex.CR);
    824442                lex.LF = simd_andc(temp29,temp50);
    825                 print_register<BitBlock>("lex.LF",lex.LF);
    826                 BitBlock temp51;
    827                 temp51 = simd_and(temp9,temp19);
    828                 print_register<BitBlock>("temp51",temp51);
     443                BitBlock temp51 = simd_and(temp9,temp19);
    829444                lex.HT = simd_andc(temp51,temp50);
    830                 print_register<BitBlock>("lex.HT",lex.HT);
    831445                lex.SP = simd_andc(temp3,temp36);
    832                 print_register<BitBlock>("lex.SP",lex.SP);
    833                 BitBlock temp52;
    834                 temp52 = simd_or(temp20,temp29);
    835                 print_register<BitBlock>("temp52",temp52);
    836                 BitBlock temp53;
    837                 temp53 = simd_or(temp52,temp51);
    838                 print_register<BitBlock>("temp53",temp53);
    839                 BitBlock temp54;
    840                 temp54 = simd_andc(temp53,temp50);
    841                 print_register<BitBlock>("temp54",temp54);
     446                BitBlock temp52 = simd_or(temp20,temp29);
     447                BitBlock temp53 = simd_or(temp52,temp51);
     448                BitBlock temp54 = simd_andc(temp53,temp50);
    842449                lex.WS = simd_or(temp54,lex.SP);
    843                 print_register<BitBlock>("lex.WS",lex.WS);
    844                 BitBlock temp55;
    845                 temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
    846                 print_register<BitBlock>("temp55",temp55);
    847                 BitBlock temp56;
    848                 temp56 = simd_and(basis_bits.bit_4,temp55);
    849                 print_register<BitBlock>("temp56",temp56);
     450                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     451                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
    850452                lex.Digit = simd_andc(temp8,temp56);
    851                 print_register<BitBlock>("lex.Digit",lex.Digit);
    852                 BitBlock temp57;
    853                 temp57 = simd_andc(temp16,temp49);
    854                 print_register<BitBlock>("temp57",temp57);
    855                 BitBlock temp58;
    856                 temp58 = simd_andc(temp57,basis_bits.bit_4);
    857                 print_register<BitBlock>("temp58",temp58);
    858                 BitBlock temp59;
    859                 temp59 = simd_not(temp10);
    860                 print_register<BitBlock>("temp59",temp59);
    861                 BitBlock temp60;
    862                 temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
    863                 print_register<BitBlock>("temp60",temp60);
    864                 BitBlock temp61;
    865                 temp61 = simd_and(temp58,temp60);
    866                 print_register<BitBlock>("temp61",temp61);
    867                 BitBlock temp62;
    868                 temp62 = simd_or(lex.Digit,temp61);
    869                 print_register<BitBlock>("temp62",temp62);
    870                 BitBlock temp63;
    871                 temp63 = simd_and(temp16,temp2);
    872                 print_register<BitBlock>("temp63",temp63);
    873                 BitBlock temp64;
    874                 temp64 = simd_andc(temp63,basis_bits.bit_4);
    875                 print_register<BitBlock>("temp64",temp64);
    876                 BitBlock temp65;
    877                 temp65 = simd_and(temp64,temp60);
    878                 print_register<BitBlock>("temp65",temp65);
     453                BitBlock temp57 = simd_andc(temp16,temp49);
     454                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     455                BitBlock temp59 = simd_not(temp10);
     456                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     457                BitBlock temp61 = simd_and(temp58,temp60);
     458                BitBlock temp62 = simd_or(lex.Digit,temp61);
     459                BitBlock temp63 = simd_and(temp16,temp2);
     460                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     461                BitBlock temp65 = simd_and(temp64,temp60);
    879462                lex.Hex = simd_or(temp62,temp65);
    880                 print_register<BitBlock>("lex.Hex",lex.Hex);
    881                 BitBlock lex_error;
    882                 lex_error = simd_andc(x00_x1F,lex.WS);
    883                 print_register<BitBlock>("lex_error",lex_error);
     463                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
    884464                if (bitblock::any(simd_and(lex_error,EOF_mask)))
    885465                {
     
    887467                }
    888468                u8.unibyte = simd_not(basis_bits.bit_0);
    889                 print_register<BitBlock>("u8.unibyte",u8.unibyte);
    890469                u8.suffix = simd<1>::constant<0>();
    891                 print_register<BitBlock>("u8.suffix",u8.suffix);
    892                 BitBlock u8_error;
    893                 u8_error = simd<1>::constant<0>();
    894                 print_register<BitBlock>("u8_error",u8_error);
    895                 BitBlock u8_FFFE_FFFF;
    896                 u8_FFFE_FFFF = simd<1>::constant<0>();
    897                 print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    898                 BitBlock u8anyscope;
    899                 u8anyscope = simd<1>::constant<0>();
    900                 print_register<BitBlock>("u8anyscope",u8anyscope);
    901                 if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
     470                BitBlock u8_error = simd<1>::constant<0>();
     471                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     472                BitBlock u8anyscope = simd<1>::constant<0>();
     473                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
    902474                {
    903475                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
    904                         print_register<BitBlock>("u8.prefix",u8.prefix);
    905476                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
    906                         print_register<BitBlock>("u8.prefix2",u8.prefix2);
    907477                        u8.prefix3 = simd_and(u8.prefix,temp2);
    908                         print_register<BitBlock>("u8.prefix3",u8.prefix3);
    909478                        u8.prefix4 = simd_and(u8.prefix,temp7);
    910                         print_register<BitBlock>("u8.prefix4",u8.prefix4);
    911479                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
    912                         print_register<BitBlock>("u8.suffix",u8.suffix);
    913                         BitBlock temp66;
    914                         temp66 = simd_andc(u8.prefix,temp49);
    915                         print_register<BitBlock>("temp66",temp66);
    916                         BitBlock temp67;
    917                         temp67 = simd_or(temp21,basis_bits.bit_6);
    918                         print_register<BitBlock>("temp67",temp67);
    919                         BitBlock temp68;
    920                         temp68 = simd_andc(temp66,temp67);
    921                         print_register<BitBlock>("temp68",temp68);
    922                         BitBlock temp69;
    923                         temp69 = simd_and(basis_bits.bit_5,temp13);
    924                         print_register<BitBlock>("temp69",temp69);
    925                         BitBlock temp70;
    926                         temp70 = simd_or(basis_bits.bit_4,temp69);
    927                         print_register<BitBlock>("temp70",temp70);
    928                         BitBlock temp71;
    929                         temp71 = simd_and(u8.prefix4,temp70);
    930                         print_register<BitBlock>("temp71",temp71);
     480                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
     481                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     482                        BitBlock temp68 = simd_andc(temp66,temp67);
     483                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     484                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     485                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
    931486                        u8.badprefix = simd_or(temp68,temp71);
    932                         print_register<BitBlock>("u8.badprefix",u8.badprefix);
    933487                        u8_error = u8.badprefix;
    934                         print_register<BitBlock>("u8_error",u8_error);
    935                         BitBlock __temp__0;
    936                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),__temp__0));
    937                         u8.scope22 = __temp__0;
    938                         print_register<BitBlock>("u8.scope22",u8.scope22);
     488                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
    939489                        u8anyscope = u8.scope22;
    940                         print_register<BitBlock>("u8anyscope",u8anyscope);
    941                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    942                         {
    943                                 BitBlock xE0;
    944                                 xE0 = simd_andc(u8.prefix3,temp36);
    945                                 print_register<BitBlock>("xE0",xE0);
    946                                 BitBlock xED;
    947                                 xED = simd_and(u8.prefix3,temp20);
    948                                 print_register<BitBlock>("xED",xED);
    949                                 BitBlock xF0;
    950                                 xF0 = simd_andc(u8.prefix4,temp36);
    951                                 print_register<BitBlock>("xF0",xF0);
    952                                 BitBlock temp72;
    953                                 temp72 = simd_andc(temp4,temp13);
    954                                 print_register<BitBlock>("temp72",temp72);
    955                                 BitBlock xF4;
    956                                 xF4 = simd_and(u8.prefix4,temp72);
    957                                 print_register<BitBlock>("xF4",xF4);
     490                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
     491                        {
     492                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     493                                BitBlock xED = simd_and(u8.prefix3,temp20);
     494                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     495                                BitBlock temp72 = simd_andc(temp4,temp13);
     496                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
    958497                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
    959                                 print_register<BitBlock>("u8.xA0_xBF",u8.xA0_xBF);
    960498                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
    961                                 print_register<BitBlock>("u8.x80_x9F",u8.x80_x9F);
    962499                                u8.x90_xBF = simd_and(u8.suffix,temp49);
    963                                 print_register<BitBlock>("u8.x90_xBF",u8.x90_xBF);
    964500                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
    965                                 print_register<BitBlock>("u8.x80_x8F",u8.x80_x8F);
    966                                 BitBlock xEF;
    967                                 xEF = simd_and(u8.prefix3,temp23);
    968                                 print_register<BitBlock>("xEF",xEF);
    969                                 BitBlock temp73;
    970                                 temp73 = simd_and(u8.suffix,temp7);
    971                                 print_register<BitBlock>("temp73",temp73);
     501                                BitBlock xEF = simd_and(u8.prefix3,temp23);
     502                                BitBlock temp73 = simd_and(u8.suffix,temp7);
    972503                                u8.xBF = simd_and(temp73,temp23);
    973                                 print_register<BitBlock>("u8.xBF",u8.xBF);
    974504                                u8.xBE = simd_and(temp73,temp15);
    975                                 print_register<BitBlock>("u8.xBE",u8.xBE);
    976                                 BitBlock __temp__1;
    977                                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),__temp__1));
    978                                 u8.scope32 = __temp__1;
    979                                 print_register<BitBlock>("u8.scope32",u8.scope32);
    980                                 BitBlock __temp__2;
    981                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),__temp__2));
    982                                 u8.scope33 = __temp__2;
    983                                 print_register<BitBlock>("u8.scope33",u8.scope33);
    984                                 BitBlock __temp__3;
    985                                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),__temp__3));
    986                                 u8.scope42 = __temp__3;
    987                                 print_register<BitBlock>("u8.scope42",u8.scope42);
    988                                 BitBlock __temp__4;
    989                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),__temp__4));
    990                                 u8.scope43 = __temp__4;
    991                                 print_register<BitBlock>("u8.scope43",u8.scope43);
    992                                 BitBlock __temp__5;
    993                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),__temp__5));
    994                                 u8.scope44 = __temp__5;
    995                                 print_register<BitBlock>("u8.scope44",u8.scope44);
    996                                 BitBlock __temp__6;
    997                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),__temp__6));
    998                                 BitBlock E0_F0_scope;
    999                                 E0_F0_scope = __temp__6;
    1000                                 print_register<BitBlock>("E0_F0_scope",E0_F0_scope);
    1001                                 BitBlock __temp__7;
    1002                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),__temp__7));
    1003                                 BitBlock ED_F4_scope;
    1004                                 ED_F4_scope = __temp__7;
    1005                                 print_register<BitBlock>("ED_F4_scope",ED_F4_scope);
     505                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
     506                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
     507                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
     508                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
     509                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
     510                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
     511                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
    1006512                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
    1007                                 print_register<BitBlock>("u8.xE0_scope",u8.xE0_scope);
    1008513                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
    1009                                 print_register<BitBlock>("u8.xED_scope",u8.xED_scope);
    1010514                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
    1011                                 print_register<BitBlock>("u8.xF0_scope",u8.xF0_scope);
    1012515                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    1013                                 print_register<BitBlock>("u8.xF4_scope",u8.xF4_scope);
    1014                                 BitBlock __temp__8;
    1015                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),__temp__8));
    1016                                 u8.xEF_scope = __temp__8;
    1017                                 print_register<BitBlock>("u8.xEF_scope",u8.xEF_scope);
    1018                                 BitBlock u8lastscope;
    1019                                 u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    1020                                 print_register<BitBlock>("u8lastscope",u8lastscope);
     516                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
     517                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    1021518                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
    1022                                 print_register<BitBlock>("u8anyscope",u8anyscope);
    1023                                 BitBlock u8error1;
    1024                                 u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
    1025                                 print_register<BitBlock>("u8error1",u8error1);
    1026                                 BitBlock u8error2;
    1027                                 u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
    1028                                 print_register<BitBlock>("u8error2",u8error2);
    1029                                 BitBlock u8error3;
    1030                                 u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
    1031                                 print_register<BitBlock>("u8error3",u8error3);
    1032                                 BitBlock u8error4;
    1033                                 u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    1034                                 print_register<BitBlock>("u8error4",u8error4);
     519                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     520                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     521                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     522                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    1035523                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    1036                                 print_register<BitBlock>("u8_error",u8_error);
    1037                                 BitBlock __temp__9;
    1038                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),__temp__9));
    1039                                 BitBlock EF_BF_pending;
    1040                                 EF_BF_pending = __temp__9;
    1041                                 print_register<BitBlock>("EF_BF_pending",EF_BF_pending);
     524                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
    1042525                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    1043                                 print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    1044526                        }
    1045527                        else
    1046528                        {
    1047                                 carry_set_0.carryDequeueEnqueue(1,9);
    1048                         }
    1049                         BitBlock u8mismatch;
    1050                         u8mismatch = simd_xor(u8anyscope,u8.suffix);
    1051                         print_register<BitBlock>("u8mismatch",u8mismatch);
     529                                carry_set_0.CarryDequeueEnqueue(1,9);
     530                        }
     531                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
    1052532                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    1053533                        {
     
    1057537                else
    1058538                {
    1059                         carry_set_0.carryDequeueEnqueue(0,10);
     539                        carry_set_0.CarryDequeueEnqueue(0,10);
    1060540                }
    1061541        }
     
    1068548        Parse_CtCDPI()
    1069549        {
    1070                 carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    1071         }
    1072        
    1073         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
    1074         {
    1075                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    1076                 print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
    1077                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    1078                 print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    1079                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    1080                 print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
    1081                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    1082                 print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    1083                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    1084                 print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
    1085                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    1086                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
    1087                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    1088                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
    1089                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    1090                 print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1091                 BitBlock CtCDPI_starts;
    1092                 CtCDPI_starts = simd<1>::constant<0>();
    1093                 print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1094                 BitBlock CtCDPI_ends;
    1095                 CtCDPI_ends = simd<1>::constant<0>();
    1096                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1097                 BitBlock ctCDPI_mask;
    1098                 ctCDPI_mask = simd<1>::constant<0>();
    1099                 print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1100                 BitBlock v;
    1101                 v = simd_or(lex.LAngle,lex.Hyphen);
    1102                 print_register<BitBlock>("v",v);
    1103                 BitBlock w;
    1104                 w = simd_or(lex.Hyphen,lex.QMark);
    1105                 print_register<BitBlock>("w",w);
    1106                 BitBlock __temp__0;
    1107                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),__temp__0));
    1108                 BitBlock v1;
    1109                 v1 = __temp__0;
    1110                 print_register<BitBlock>("v1",v1);
    1111                 BitBlock __temp__1;
    1112                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),__temp__1));
    1113                 BitBlock w1;
    1114                 w1 = __temp__1;
    1115                 print_register<BitBlock>("w1",w1);
    1116                 BitBlock LAngle_scope;
    1117                 LAngle_scope = simd_andc(v1,w1);
    1118                 print_register<BitBlock>("LAngle_scope",LAngle_scope);
    1119                 BitBlock PI_opener;
    1120                 PI_opener = simd_and(LAngle_scope,lex.QMark);
    1121                 print_register<BitBlock>("PI_opener",PI_opener);
    1122                 BitBlock CtCD_opener;
    1123                 CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    1124                 print_register<BitBlock>("CtCD_opener",CtCD_opener);
    1125                 BitBlock CtCDPI_opener;
    1126                 CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    1127                 print_register<BitBlock>("CtCDPI_opener",CtCDPI_opener);
    1128                 BitBlock CD_closer;
    1129                 CD_closer = simd<1>::constant<0>();
    1130                 print_register<BitBlock>("CD_closer",CD_closer);
    1131                 BitBlock DoubleHyphen;
    1132                 DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    1133                 print_register<BitBlock>("DoubleHyphen",DoubleHyphen);
    1134                 if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
    1135                 {
    1136                         BitBlock __temp__2;
    1137                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),__temp__2));
    1138                         BitBlock DoubleRBracket;
    1139                         DoubleRBracket = simd_and(__temp__2,lex.RBracket);
    1140                         print_register<BitBlock>("DoubleRBracket",DoubleRBracket);
    1141                         BitBlock __temp__3;
    1142                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),__temp__3));
    1143                         CD_closer = simd_and(__temp__3,lex.RAngle);
    1144                         print_register<BitBlock>("CD_closer",CD_closer);
    1145                 }
    1146                 else
    1147                 {
    1148                         carry_set_0.carryDequeueEnqueue(0,2);
    1149                 }
    1150                 BitBlock PI_closer;
    1151                 PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    1152                 print_register<BitBlock>("PI_closer",PI_closer);
    1153                 BitBlock __temp__4;
    1154                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),__temp__4));
    1155                 BitBlock CtCDPI_Cursor;
    1156                 CtCDPI_Cursor = __temp__4;
    1157                 print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1158                 if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
    1159                 {
    1160                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1161                         print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1162                         BitBlock PI_Cursor;
    1163                         PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1164                         print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1165                         BitBlock __temp__5;
    1166                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),__temp__5));
    1167                         BitBlock CD_Ct_Cursor;
    1168                         CD_Ct_Cursor = __temp__5;
    1169                         print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1170                         BitBlock CD_Cursor;
    1171                         CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1172                         print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1173                         BitBlock Ct_Cursor;
    1174                         Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1175                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1176                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
    1177                         {
    1178                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1179                                 print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
    1180                                 BitBlock __temp__6;
    1181                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),__temp__6));
    1182                                 PI_Cursor = __temp__6;
    1183                                 print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1184                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1185                                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
    1186                                 BitBlock __temp__7;
    1187                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),__temp__7));
    1188                                 BitBlock PI_name_end;
    1189                                 PI_name_end = __temp__7;
    1190                                 print_register<BitBlock>("PI_name_end",PI_name_end);
    1191                                 BitBlock PI_error;
    1192                                 PI_error = simd_and(PI_Cursor,PI_name_end);
    1193                                 print_register<BitBlock>("PI_error",PI_error);
    1194                                 BitBlock PI_noWS;
    1195                                 PI_noWS = simd_andc(PI_name_end,lex.WS);
    1196                                 print_register<BitBlock>("PI_noWS",PI_noWS);
    1197                                 BitBlock __temp__8;
    1198                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),__temp__8));
    1199                                 PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
    1200                                 print_register<BitBlock>("PI_error",PI_error);
    1201                                 if (bitblock::any(PI_error))
    1202                                 {
    1203                                         assert_0_error("Error in PI syntax",PI_error);
    1204                                 }
    1205                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1206                                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
    1207                                 BitBlock __temp__9;
    1208                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_0.getCarry(7),__temp__9));
    1209                                 PI_Cursor = __temp__9;
    1210                                 print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1211                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1212                                 print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1213                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1214                                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     550                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)),2);
     551                }
     552                 
     553                IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
     554                {
     555                        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     556                        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     557                        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     558                        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     559                        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     560                        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     561                        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     562                        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     563                        BitBlock CtCDPI_starts = simd<1>::constant<0>();
     564                        BitBlock CtCDPI_ends = simd<1>::constant<0>();
     565                        BitBlock ctCDPI_mask = simd<1>::constant<0>();
     566                        BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     567                        BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     568                        BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
     569                        BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
     570                        BitBlock LAngle_scope = simd_andc(v1,w1);
     571                        BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     572                        BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     573                        BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     574                        BitBlock CD_closer = simd<1>::constant<0>();
     575                        BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     576                        if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
     577                        {
     578                                BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
     579                                CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
    1215580                        }
    1216581                        else
    1217582                        {
    1218                                 carry_set_0.carryDequeueEnqueue(4,4);
    1219                         }
    1220                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
    1221                         {
    1222                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1223                                 print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
    1224                                 BitBlock __temp__10;
    1225                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),__temp__10));
    1226                                 CD_Cursor = __temp__10;
    1227                                 print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1228                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1229                                 print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    1230                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1231                                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     583                                carry_set_0.CarryDequeueEnqueue(0,2);
     584                        }
     585                        BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     586                        BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
     587                        if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.CarryRange(3,13))))
     588                        {
     589                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     590                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     591                                BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
     592                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     593                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     594                                if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
     595                                {
     596                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     597                                        PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
     598                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     599                                        BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
     600                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     601                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     602                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
     603                                        if (bitblock::any(PI_error))
     604                                        {
     605                                                assert_0_error("Error in PI syntax",PI_error);
     606                                        }
     607                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     608                                        PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),carry_set_0.GetCarry(7),7);
     609                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     610                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     611                                }
     612                                else
     613                                {
     614                                        carry_set_0.CarryDequeueEnqueue(4,4);
     615                                }
     616                                if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
     617                                {
     618                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     619                                        CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),carry_set_0.GetCarry(8),8);
     620                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     621                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     622                                }
     623                                else
     624                                {
     625                                        carry_set_0.CarryDequeueEnqueue(8,1);
     626                                }
     627                                if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
     628                                {
     629                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     630                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
     631                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     632                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(11),11);
     633                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
     634                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     635                                        {
     636                                                assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     637                                        }
     638                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     639                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     640                                }
     641                                else
     642                                {
     643                                        carry_set_0.CarryDequeueEnqueue(9,5);
     644                                }
     645                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     646                                ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
     647                                if (bitblock::any(simd<1>::constant<0>()))
     648                                {
     649                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
     650                                }
     651                                CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.GetCarry(15),15);
     652                                while (bitblock::any(CtCDPI_Cursor))
     653                                {
     654                                        CarryDeclare(carry_set_1,13,0);
     655                                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     656                                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     657                                        BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     658                                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     659                                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     660                                        if (bitblock::any(PI_Cursor))
     661                                        {
     662                                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     663                                                PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     664                                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     665                                                BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     666                                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     667                                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     668                                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
     669                                                if (bitblock::any(PI_error))
     670                                                {
     671                                                        assert_0_error("Error in PI syntax",PI_error);
     672                                                }
     673                                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     674                                                PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),simd<1>::constant<0>(),4);
     675                                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     676                                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     677                                        }
     678                                        if (bitblock::any(CD_Cursor))
     679                                        {
     680                                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     681                                                CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),simd<1>::constant<0>(),5);
     682                                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     683                                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     684                                        }
     685                                        if (bitblock::any(Ct_Cursor))
     686                                        {
     687                                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     688                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     689                                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     690                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
     691                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_not(DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
     692                                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     693                                                {
     694                                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     695                                                }
     696                                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     697                                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     698                                        }
     699                                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     700                                        ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     701                                        if (bitblock::any(simd<1>::constant<0>()))
     702                                        {
     703                                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
     704                                        }
     705                                        CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),simd<1>::constant<0>(),12);
     706                                        LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     707                                }
    1232708                        }
    1233709                        else
    1234710                        {
    1235                                 carry_set_0.carryDequeueEnqueue(8,1);
    1236                         }
    1237                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
    1238                         {
    1239                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1240                                 print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
    1241                                 BitBlock __temp__11;
    1242                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),__temp__11));
    1243                                 Ct_Cursor = __temp__11;
    1244                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1245                                 BitBlock Ct_error;
    1246                                 Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1247                                 print_register<BitBlock>("Ct_error",Ct_error);
    1248                                 BitBlock __temp__12;
    1249                                 BitBlock __temp__13;
    1250                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),__temp__12));
    1251                                 carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_0.getCarry(11),__temp__13));
    1252                                 Ct_Cursor = __temp__13;
    1253                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1254                                 BitBlock __temp__14;
    1255                                 BitBlock __temp__15;
    1256                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),__temp__14));
    1257                                 carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_0.getCarry(13),__temp__15));
    1258                                 Ct_Cursor = __temp__15;
    1259                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1260                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1261                                 {
    1262                                         assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    1263                                 }
    1264                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1265                                 print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    1266                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1267                                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     711                                carry_set_0.CarryDequeueEnqueue(3,13);
     712                        }
     713                        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
     714                        marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     715                        marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     716                        marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     717                        carry_set_0.CarryAdjust(17);
     718                }
     719               
     720                void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
     721                {
     722                        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     723                        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     724                        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     725                        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     726                        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     727                        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     728                        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     729                        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     730                        BitBlock CtCDPI_starts = simd<1>::constant<0>();
     731                        BitBlock CtCDPI_ends = simd<1>::constant<0>();
     732                        BitBlock ctCDPI_mask = simd<1>::constant<0>();
     733                        BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     734                        BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     735                        BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
     736                        BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
     737                        BitBlock LAngle_scope = simd_andc(v1,w1);
     738                        BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     739                        BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     740                        BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     741                        BitBlock CD_closer = simd<1>::constant<0>();
     742                        BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     743                        if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
     744                        {
     745                                BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
     746                                CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
    1268747                        }
    1269748                        else
    1270749                        {
    1271                                 carry_set_0.carryDequeueEnqueue(9,5);
    1272                         }
    1273                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1274                         print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1275                         BitBlock __temp__16;
    1276                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),__temp__16));
    1277                         ctCDPI_mask = __temp__16;
    1278                         print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1279                         if (bitblock::any(simd<1>::constant<0>()))
    1280                         {
    1281                                 assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
    1282                         }
    1283                         BitBlock __temp__17;
    1284                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),__temp__17));
    1285                         CtCDPI_Cursor = __temp__17;
    1286                         print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1287                         while (bitblock::any(CtCDPI_Cursor))
    1288                         {
    1289                                 CarryDeclare(carry_set_1,13,0);
     750                                carry_set_0.CarryDequeueEnqueue(0,2);
     751                        }
     752                        BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     753                        BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
     754                        if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.CarryRange(3,13))))
     755                        {
    1290756                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1291                                 print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1292                                 BitBlock PI_Cursor;
    1293                                 PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1294                                 print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1295                                 BitBlock __temp__5;
    1296                                 carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),__temp__5));
    1297                                 BitBlock CD_Ct_Cursor;
    1298                                 CD_Ct_Cursor = __temp__5;
    1299                                 print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1300                                 BitBlock CD_Cursor;
    1301                                 CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1302                                 print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1303                                 BitBlock Ct_Cursor;
    1304                                 Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1305                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1306                                 if (bitblock::any(PI_Cursor))
     757                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     758                                BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
     759                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     760                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     761                                if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
    1307762                                {
    1308763                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1309                                         print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
    1310                                         BitBlock __temp__6;
    1311                                         carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),__temp__6));
    1312                                         PI_Cursor = __temp__6;
    1313                                         print_register<BitBlock>("PI_Cursor",PI_Cursor);
     764                                        PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
    1314765                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1315                                         print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
    1316                                         BitBlock __temp__7;
    1317                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),__temp__7));
    1318                                         BitBlock PI_name_end;
    1319                                         PI_name_end = __temp__7;
    1320                                         print_register<BitBlock>("PI_name_end",PI_name_end);
    1321                                         BitBlock PI_error;
    1322                                         PI_error = simd_and(PI_Cursor,PI_name_end);
    1323                                         print_register<BitBlock>("PI_error",PI_error);
    1324                                         BitBlock PI_noWS;
    1325                                         PI_noWS = simd_andc(PI_name_end,lex.WS);
    1326                                         print_register<BitBlock>("PI_noWS",PI_noWS);
    1327                                         BitBlock __temp__8;
    1328                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),__temp__8));
    1329                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
    1330                                         print_register<BitBlock>("PI_error",PI_error);
     766                                        BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
     767                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     768                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     769                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
    1331770                                        if (bitblock::any(PI_error))
    1332771                                        {
     
    1334773                                        }
    1335774                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1336                                         print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
    1337                                         BitBlock __temp__9;
    1338                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),__temp__9));
    1339                                         PI_Cursor = __temp__9;
    1340                                         print_register<BitBlock>("PI_Cursor",PI_Cursor);
     775                                        PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.GetCarry(7),7);
    1341776                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1342                                         print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1343777                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1344                                         print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1345                                 }
    1346                                 if (bitblock::any(CD_Cursor))
     778                                }
     779                                else
     780                                {
     781                                        carry_set_0.CarryDequeueEnqueue(4,4);
     782                                }
     783                                if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
    1347784                                {
    1348785                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1349                                         print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
    1350                                         BitBlock __temp__10;
    1351                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),__temp__10));
    1352                                         CD_Cursor = __temp__10;
    1353                                         print_register<BitBlock>("CD_Cursor",CD_Cursor);
     786                                        CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.GetCarry(8),8);
    1354787                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1355                                         print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    1356788                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1357                                         print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1358                                 }
    1359                                 if (bitblock::any(Ct_Cursor))
     789                                }
     790                                else
     791                                {
     792                                        carry_set_0.CarryDequeueEnqueue(8,1);
     793                                }
     794                                if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
    1360795                                {
    1361796                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1362                                         print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
    1363                                         BitBlock __temp__11;
    1364                                         carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),__temp__11));
    1365                                         Ct_Cursor = __temp__11;
    1366                                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1367                                         BitBlock Ct_error;
    1368                                         Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1369                                         print_register<BitBlock>("Ct_error",Ct_error);
    1370                                         BitBlock __temp__12;
    1371                                         BitBlock __temp__13;
    1372                                         carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),__temp__12));
    1373                                         carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_1.getCarry(8),__temp__13));
    1374                                         Ct_Cursor = __temp__13;
    1375                                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1376                                         BitBlock __temp__14;
    1377                                         BitBlock __temp__15;
    1378                                         carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),__temp__14));
    1379                                         carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_1.getCarry(10),__temp__15));
    1380                                         Ct_Cursor = __temp__15;
    1381                                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     797                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
     798                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     799                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(11),11);
     800                                        Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.GetCarry(12),12),carry_set_0.GetCarry(13),13);
    1382801                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1383802                                        {
     
    1385804                                        }
    1386805                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1387                                         print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    1388806                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1389                                         print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     807                                }
     808                                else
     809                                {
     810                                        carry_set_0.CarryDequeueEnqueue(9,5);
    1390811                                }
    1391812                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1392                                 print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1393                                 BitBlock __temp__16;
    1394                                 carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),__temp__16));
    1395                                 ctCDPI_mask = __temp__16;
    1396                                 print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1397                                 if (bitblock::any(simd<1>::constant<0>()))
    1398                                 {
    1399                                         assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
    1400                                 }
    1401                                 BitBlock __temp__17;
    1402                                 carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),__temp__17));
    1403                                 CtCDPI_Cursor = __temp__17;
    1404                                 print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1405                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    1406                         }
    1407                 }
    1408                 else
    1409                 {
    1410                         carry_set_0.carryDequeueEnqueue(3,13);
    1411                 }
    1412                 BitBlock __temp__18;
    1413                 carry_set_0.getCarry(16) = 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),carry_set_0.getCarry(16),__temp__18));
    1414                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),__temp__18),CtCDPI_starts),EOF_mask);
    1415                 print_register<BitBlock>("check_streams.misc_mask",check_streams.misc_mask);
    1416                 marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    1417                 print_register<BitBlock>("marker.LAngle_scope",marker.LAngle_scope);
    1418                 marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    1419                 print_register<BitBlock>("marker.Ref_opener",marker.Ref_opener);
    1420                 marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    1421                 print_register<BitBlock>("marker.CD_closer",marker.CD_closer);
    1422                 carry_set_0.carryAdjust(17);
    1423         }
    1424        
    1425         void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
    1426         {
    1427                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    1428                 print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
    1429                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    1430                 print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    1431                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    1432                 print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
    1433                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    1434                 print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    1435                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    1436                 print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
    1437                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    1438                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
    1439                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    1440                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
    1441                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    1442                 print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1443                 BitBlock CtCDPI_starts;
    1444                 CtCDPI_starts = simd<1>::constant<0>();
    1445                 print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1446                 BitBlock CtCDPI_ends;
    1447                 CtCDPI_ends = simd<1>::constant<0>();
    1448                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1449                 BitBlock ctCDPI_mask;
    1450                 ctCDPI_mask = simd<1>::constant<0>();
    1451                 print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1452                 BitBlock v;
    1453                 v = simd_or(lex.LAngle,lex.Hyphen);
    1454                 print_register<BitBlock>("v",v);
    1455                 BitBlock w;
    1456                 w = simd_or(lex.Hyphen,lex.QMark);
    1457                 print_register<BitBlock>("w",w);
    1458                 BitBlock __temp__0;
    1459                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),__temp__0));
    1460                 BitBlock v1;
    1461                 v1 = __temp__0;
    1462                 print_register<BitBlock>("v1",v1);
    1463                 BitBlock __temp__1;
    1464                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),__temp__1));
    1465                 BitBlock w1;
    1466                 w1 = __temp__1;
    1467                 print_register<BitBlock>("w1",w1);
    1468                 BitBlock LAngle_scope;
    1469                 LAngle_scope = simd_andc(v1,w1);
    1470                 print_register<BitBlock>("LAngle_scope",LAngle_scope);
    1471                 BitBlock PI_opener;
    1472                 PI_opener = simd_and(LAngle_scope,lex.QMark);
    1473                 print_register<BitBlock>("PI_opener",PI_opener);
    1474                 BitBlock CtCD_opener;
    1475                 CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    1476                 print_register<BitBlock>("CtCD_opener",CtCD_opener);
    1477                 BitBlock CtCDPI_opener;
    1478                 CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    1479                 print_register<BitBlock>("CtCDPI_opener",CtCDPI_opener);
    1480                 BitBlock CD_closer;
    1481                 CD_closer = simd<1>::constant<0>();
    1482                 print_register<BitBlock>("CD_closer",CD_closer);
    1483                 BitBlock DoubleHyphen;
    1484                 DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    1485                 print_register<BitBlock>("DoubleHyphen",DoubleHyphen);
    1486                 if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
    1487                 {
    1488                         BitBlock __temp__2;
    1489                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),__temp__2));
    1490                         BitBlock DoubleRBracket;
    1491                         DoubleRBracket = simd_and(__temp__2,lex.RBracket);
    1492                         print_register<BitBlock>("DoubleRBracket",DoubleRBracket);
    1493                         BitBlock __temp__3;
    1494                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),__temp__3));
    1495                         CD_closer = simd_and(__temp__3,lex.RAngle);
    1496                         print_register<BitBlock>("CD_closer",CD_closer);
    1497                 }
    1498                 else
    1499                 {
    1500                         carry_set_0.carryDequeueEnqueue(0,2);
    1501                 }
    1502                 BitBlock PI_closer;
    1503                 PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    1504                 print_register<BitBlock>("PI_closer",PI_closer);
    1505                 BitBlock __temp__4;
    1506                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),__temp__4));
    1507                 BitBlock CtCDPI_Cursor;
    1508                 CtCDPI_Cursor = __temp__4;
    1509                 print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1510                 if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(3,13))))
    1511                 {
    1512                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1513                         print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1514                         BitBlock PI_Cursor;
    1515                         PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1516                         print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1517                         BitBlock __temp__5;
    1518                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),__temp__5));
    1519                         BitBlock CD_Ct_Cursor;
    1520                         CD_Ct_Cursor = __temp__5;
    1521                         print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1522                         BitBlock CD_Cursor;
    1523                         CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1524                         print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1525                         BitBlock Ct_Cursor;
    1526                         Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1527                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1528                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
    1529                         {
    1530                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1531                                 print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
    1532                                 BitBlock __temp__6;
    1533                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),__temp__6));
    1534                                 PI_Cursor = __temp__6;
    1535                                 print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1536                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1537                                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
    1538                                 BitBlock __temp__7;
    1539                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),__temp__7));
    1540                                 BitBlock PI_name_end;
    1541                                 PI_name_end = __temp__7;
    1542                                 print_register<BitBlock>("PI_name_end",PI_name_end);
    1543                                 BitBlock PI_error;
    1544                                 PI_error = simd_and(PI_Cursor,PI_name_end);
    1545                                 print_register<BitBlock>("PI_error",PI_error);
    1546                                 BitBlock PI_noWS;
    1547                                 PI_noWS = simd_andc(PI_name_end,lex.WS);
    1548                                 print_register<BitBlock>("PI_noWS",PI_noWS);
    1549                                 BitBlock __temp__8;
    1550                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),__temp__8));
    1551                                 PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
    1552                                 print_register<BitBlock>("PI_error",PI_error);
    1553                                 if (bitblock::any(PI_error))
    1554                                 {
    1555                                         assert_0_error("Error in PI syntax",PI_error);
    1556                                 }
    1557                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1558                                 print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
    1559                                 BitBlock __temp__9;
    1560                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),__temp__9));
    1561                                 PI_Cursor = __temp__9;
    1562                                 print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1563                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1564                                 print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1565                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1566                                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     813                                ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
     814                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     815                                {
     816                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
     817                                }
     818                                CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.GetCarry(15),15);
     819                                while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
     820                                {
     821                                        CarryDeclare(carry_set_1,13,0);
     822                                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     823                                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     824                                        BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     825                                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     826                                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     827                                        if (bitblock::any(PI_Cursor))
     828                                        {
     829                                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     830                                                PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     831                                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     832                                                BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     833                                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     834                                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     835                                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
     836                                                if (bitblock::any(PI_error))
     837                                                {
     838                                                        assert_0_error("Error in PI syntax",PI_error);
     839                                                }
     840                                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     841                                                PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),simd<1>::constant<0>(),4);
     842                                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     843                                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     844                                        }
     845                                        if (bitblock::any(CD_Cursor))
     846                                        {
     847                                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     848                                                CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),simd<1>::constant<0>(),5);
     849                                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     850                                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     851                                        }
     852                                        if (bitblock::any(Ct_Cursor))
     853                                        {
     854                                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     855                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     856                                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     857                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),7),simd<1>::constant<0>(),8);
     858                                                Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),simd<1>::constant<0>(),9),simd<1>::constant<0>(),10);
     859                                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     860                                                {
     861                                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     862                                                }
     863                                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     864                                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     865                                        }
     866                                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     867                                        ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     868                                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     869                                        {
     870                                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
     871                                        }
     872                                        CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),simd<1>::constant<0>(),12);
     873                                        LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     874                                }
    1567875                        }
    1568876                        else
    1569877                        {
    1570                                 carry_set_0.carryDequeueEnqueue(4,4);
    1571                         }
    1572                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
    1573                         {
    1574                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1575                                 print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
    1576                                 BitBlock __temp__10;
    1577                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),__temp__10));
    1578                                 CD_Cursor = __temp__10;
    1579                                 print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1580                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1581                                 print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    1582                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1583                                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1584                         }
    1585                         else
    1586                         {
    1587                                 carry_set_0.carryDequeueEnqueue(8,1);
    1588                         }
    1589                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
    1590                         {
    1591                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1592                                 print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
    1593                                 BitBlock __temp__11;
    1594                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),__temp__11));
    1595                                 Ct_Cursor = __temp__11;
    1596                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1597                                 BitBlock Ct_error;
    1598                                 Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1599                                 print_register<BitBlock>("Ct_error",Ct_error);
    1600                                 BitBlock __temp__12;
    1601                                 BitBlock __temp__13;
    1602                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),__temp__12));
    1603                                 carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_0.getCarry(11),__temp__13));
    1604                                 Ct_Cursor = __temp__13;
    1605                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1606                                 BitBlock __temp__14;
    1607                                 BitBlock __temp__15;
    1608                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),__temp__14));
    1609                                 carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_0.getCarry(13),__temp__15));
    1610                                 Ct_Cursor = __temp__15;
    1611                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1612                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1613                                 {
    1614                                         assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    1615                                 }
    1616                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1617                                 print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    1618                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1619                                 print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1620                         }
    1621                         else
    1622                         {
    1623                                 carry_set_0.carryDequeueEnqueue(9,5);
    1624                         }
    1625                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1626                         print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1627                         BitBlock __temp__16;
    1628                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),__temp__16));
    1629                         ctCDPI_mask = __temp__16;
    1630                         print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1631                         if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    1632                         {
    1633                                 assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
    1634                         }
    1635                         BitBlock __temp__17;
    1636                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),__temp__17));
    1637                         CtCDPI_Cursor = __temp__17;
    1638                         print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1639                         while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    1640                         {
    1641                                 CarryDeclare(carry_set_1,13,0);
    1642                                 CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1643                                 print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1644                                 BitBlock PI_Cursor;
    1645                                 PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1646                                 print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1647                                 BitBlock __temp__5;
    1648                                 carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),__temp__5));
    1649                                 BitBlock CD_Ct_Cursor;
    1650                                 CD_Ct_Cursor = __temp__5;
    1651                                 print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1652                                 BitBlock CD_Cursor;
    1653                                 CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1654                                 print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1655                                 BitBlock Ct_Cursor;
    1656                                 Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1657                                 print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1658                                 if (bitblock::any(PI_Cursor))
    1659                                 {
    1660                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1661                                         print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
    1662                                         BitBlock __temp__6;
    1663                                         carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),__temp__6));
    1664                                         PI_Cursor = __temp__6;
    1665                                         print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1666                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1667                                         print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
    1668                                         BitBlock __temp__7;
    1669                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),__temp__7));
    1670                                         BitBlock PI_name_end;
    1671                                         PI_name_end = __temp__7;
    1672                                         print_register<BitBlock>("PI_name_end",PI_name_end);
    1673                                         BitBlock PI_error;
    1674                                         PI_error = simd_and(PI_Cursor,PI_name_end);
    1675                                         print_register<BitBlock>("PI_error",PI_error);
    1676                                         BitBlock PI_noWS;
    1677                                         PI_noWS = simd_andc(PI_name_end,lex.WS);
    1678                                         print_register<BitBlock>("PI_noWS",PI_noWS);
    1679                                         BitBlock __temp__8;
    1680                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),__temp__8));
    1681                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
    1682                                         print_register<BitBlock>("PI_error",PI_error);
    1683                                         if (bitblock::any(PI_error))
    1684                                         {
    1685                                                 assert_0_error("Error in PI syntax",PI_error);
    1686                                         }
    1687                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1688                                         print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
    1689                                         BitBlock __temp__9;
    1690                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),__temp__9));
    1691                                         PI_Cursor = __temp__9;
    1692                                         print_register<BitBlock>("PI_Cursor",PI_Cursor);
    1693                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1694                                         print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1695                                         CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1696                                         print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1697                                 }
    1698                                 if (bitblock::any(CD_Cursor))
    1699                                 {
    1700                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1701                                         print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
    1702                                         BitBlock __temp__10;
    1703                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),__temp__10));
    1704                                         CD_Cursor = __temp__10;
    1705                                         print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1706                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1707                                         print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    1708                                         CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1709                                         print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1710                                 }
    1711                                 if (bitblock::any(Ct_Cursor))
    1712                                 {
    1713                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1714                                         print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
    1715                                         BitBlock __temp__11;
    1716                                         carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),__temp__11));
    1717                                         Ct_Cursor = __temp__11;
    1718                                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1719                                         BitBlock Ct_error;
    1720                                         Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1721                                         print_register<BitBlock>("Ct_error",Ct_error);
    1722                                         BitBlock __temp__12;
    1723                                         BitBlock __temp__13;
    1724                                         carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),__temp__12));
    1725                                         carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_1.getCarry(8),__temp__13));
    1726                                         Ct_Cursor = __temp__13;
    1727                                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1728                                         BitBlock __temp__14;
    1729                                         BitBlock __temp__15;
    1730                                         carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),__temp__14));
    1731                                         carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_1.getCarry(10),__temp__15));
    1732                                         Ct_Cursor = __temp__15;
    1733                                         print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1734                                         if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1735                                         {
    1736                                                 assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    1737                                         }
    1738                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1739                                         print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    1740                                         CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1741                                         print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1742                                 }
    1743                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1744                                 print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1745                                 BitBlock __temp__16;
    1746                                 carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),__temp__16));
    1747                                 ctCDPI_mask = __temp__16;
    1748                                 print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1749                                 if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    1750                                 {
    1751                                         assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
    1752                                 }
    1753                                 BitBlock __temp__17;
    1754                                 carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),__temp__17));
    1755                                 CtCDPI_Cursor = __temp__17;
    1756                                 print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    1757                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    1758                         }
    1759                 }
    1760                 else
    1761                 {
    1762                         carry_set_0.carryDequeueEnqueue(3,13);
    1763                 }
    1764                 BitBlock __temp__18;
    1765                 carry_set_0.getCarry(16) = 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),carry_set_0.getCarry(16),__temp__18));
    1766                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),__temp__18),CtCDPI_starts),EOF_mask);
    1767                 print_register<BitBlock>("check_streams.misc_mask",check_streams.misc_mask);
    1768                 marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    1769                 print_register<BitBlock>("marker.LAngle_scope",marker.LAngle_scope);
    1770                 marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    1771                 print_register<BitBlock>("marker.Ref_opener",marker.Ref_opener);
    1772                 marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    1773                 print_register<BitBlock>("marker.CD_closer",marker.CD_closer);
    1774         }
    1775        
    1776         CarryDeclare(carry_set_0,17,2);
    1777 };
    1778  
     878                                carry_set_0.CarryDequeueEnqueue(3,13);
     879                        }
     880                        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
     881                        marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     882                        marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     883                        marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     884                }
     885               
     886                CarryDeclare(carry_set_0,17,2);
     887        };
     888         
    1779889struct Parse_tags
    1780890{
     
    1782892        {
    1783893        }
    1784        
     894         
    1785895        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
    1786896        {
    1787                 BitBlock EqExpected;
    1788                 EqExpected = simd<1>::constant<0>();
    1789                 print_register<BitBlock>("EqExpected",EqExpected);
    1790                 BitBlock AttListEnd;
    1791                 AttListEnd = simd<1>::constant<0>();
    1792                 print_register<BitBlock>("AttListEnd",AttListEnd);
    1793                 BitBlock DQuoteDelim;
    1794                 DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
    1795                 print_register<BitBlock>("DQuoteDelim",DQuoteDelim);
    1796                 BitBlock SQuoteDelim;
    1797                 SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
    1798                 print_register<BitBlock>("SQuoteDelim",SQuoteDelim);
    1799                 BitBlock AttListDelim;
    1800                 AttListDelim = simd_or(lex.Slash,lex.RAngle);
    1801                 print_register<BitBlock>("AttListDelim",AttListDelim);
     897                BitBlock EqExpected = simd<1>::constant<0>();
     898                BitBlock AttListEnd = simd<1>::constant<0>();
     899                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     900                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     901                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
    1802902                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
    1803                 print_register<BitBlock>("tag_Callouts.ElemName_starts",tag_Callouts.ElemName_starts);
    1804903                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    1805                 print_register<BitBlock>("tag_Callouts.EndTag_marks",tag_Callouts.EndTag_marks);
    1806                 BitBlock __temp__0;
    1807                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),__temp__0));
    1808                 tag_Callouts.ElemName_ends = __temp__0;
    1809                 print_register<BitBlock>("tag_Callouts.ElemName_ends",tag_Callouts.ElemName_ends);
    1810                 BitBlock ParseError;
    1811                 ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    1812                 print_register<BitBlock>("ParseError",ParseError);
     904                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
     905                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    1813906                tag_Callouts.AttName_starts = simd<1>::constant<0>();
    1814                 print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    1815907                tag_Callouts.AttName_ends = simd<1>::constant<0>();
    1816                 print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    1817908                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    1818                 print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1819909                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1820                 print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    1821                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
    1822                 {
    1823                         BitBlock __temp__1;
    1824                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),__temp__1));
    1825                         BitBlock AfterWS;
    1826                         AfterWS = __temp__1;
    1827                         print_register<BitBlock>("AfterWS",AfterWS);
     910                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
     911                {
     912                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
    1828913                        AttListEnd = simd_and(AfterWS,AttListDelim);
    1829                         print_register<BitBlock>("AttListEnd",AttListEnd);
    1830                         BitBlock AttNameStart;
    1831                         AttNameStart = simd_andc(AfterWS,AttListDelim);
    1832                         print_register<BitBlock>("AttNameStart",AttNameStart);
    1833                         if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
     914                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
     915                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.CarryRange(2,7))))
    1834916                        {
    1835917                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1836                                 print_register<BitBlock>("ParseError",ParseError);
    1837918                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1838                                 print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    1839                                 BitBlock __temp__2;
    1840                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),__temp__2));
    1841                                 BitBlock AttNameFollow;
    1842                                 AttNameFollow = __temp__2;
    1843                                 print_register<BitBlock>("AttNameFollow",AttNameFollow);
     919                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
    1844920                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1845                                 print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    1846                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    1847                                 {
    1848                                         BitBlock __temp__3;
    1849                                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),__temp__3));
    1850                                         EqExpected = __temp__3;
    1851                                         print_register<BitBlock>("EqExpected",EqExpected);
     921                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
     922                                {
     923                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
    1852924                                }
    1853925                                else
    1854926                                {
    1855927                                        EqExpected = AttNameFollow;
    1856                                         print_register<BitBlock>("EqExpected",EqExpected);
    1857                                         carry_set_0.carryDequeueEnqueue(3,1);
     928                                        carry_set_0.CarryDequeueEnqueue(3,1);
    1858929                                }
    1859930                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1860                                 print_register<BitBlock>("ParseError",ParseError);
    1861                                 BitBlock __temp__4;
    1862                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),__temp__4));
    1863                                 BitBlock AttValPos;
    1864                                 AttValPos = __temp__4;
    1865                                 print_register<BitBlock>("AttValPos",AttValPos);
     931                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
    1866932                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1867                                 print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1868                                 BitBlock DQuoteAttVal;
    1869                                 DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1870                                 print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    1871                                 BitBlock SQuoteAttVal;
    1872                                 SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1873                                 print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    1874                                 BitBlock __temp__5;
    1875                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),__temp__5));
    1876                                 BitBlock DQuoteAttEnd;
    1877                                 DQuoteAttEnd = __temp__5;
    1878                                 print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    1879                                 BitBlock __temp__6;
    1880                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),__temp__6));
    1881                                 BitBlock SQuoteAttEnd;
    1882                                 SQuoteAttEnd = __temp__6;
    1883                                 print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    1884                                 BitBlock AttValEnd;
    1885                                 AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1886                                 print_register<BitBlock>("AttValEnd",AttValEnd);
     933                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     934                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     935                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.GetCarry(5),5);
     936                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.GetCarry(6),6);
     937                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1887938                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1888                                 print_register<BitBlock>("ParseError",ParseError);
    1889                                 BitBlock __temp__7;
    1890                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),__temp__7));
    1891                                 BitBlock AttValFollow;
    1892                                 AttValFollow = __temp__7;
    1893                                 print_register<BitBlock>("AttValFollow",AttValFollow);
     939                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
    1894940                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1895                                 print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    1896                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    1897                                 {
    1898                                         BitBlock __temp__8;
    1899                                         carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),__temp__8));
    1900                                         AfterWS = __temp__8;
    1901                                         print_register<BitBlock>("AfterWS",AfterWS);
     941                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
     942                                {
     943                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
    1902944                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1903                                         print_register<BitBlock>("AttListEnd",AttListEnd);
    1904945                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    1905                                         print_register<BitBlock>("AttNameStart",AttNameStart);
    1906946                                }
    1907947                                else
    1908948                                {
    1909949                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1910                                         print_register<BitBlock>("AttListEnd",AttListEnd);
    1911950                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1912                                         print_register<BitBlock>("AttNameStart",AttNameStart);
    1913                                         carry_set_0.carryDequeueEnqueue(8,1);
     951                                        carry_set_0.CarryDequeueEnqueue(8,1);
    1914952                                }
    1915953                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1916                                 print_register<BitBlock>("ParseError",ParseError);
    1917954                                while (bitblock::any(AttNameStart))
    1918955                                {
    1919956                                        CarryDeclare(carry_set_1,7,0);
    1920957                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1921                                         print_register<BitBlock>("ParseError",ParseError);
    1922958                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1923                                         print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    1924                                         BitBlock __temp__2;
    1925                                         carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),__temp__2));
    1926                                         BitBlock AttNameFollow;
    1927                                         AttNameFollow = __temp__2;
    1928                                         print_register<BitBlock>("AttNameFollow",AttNameFollow);
     959                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
    1929960                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1930                                         print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    1931961                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    1932962                                        {
    1933                                                 BitBlock __temp__3;
    1934                                                 carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),__temp__3));
    1935                                                 EqExpected = __temp__3;
    1936                                                 print_register<BitBlock>("EqExpected",EqExpected);
     963                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
    1937964                                        }
    1938965                                        else
    1939966                                        {
    1940967                                                EqExpected = AttNameFollow;
    1941                                                 print_register<BitBlock>("EqExpected",EqExpected);
    1942968                                        }
    1943969                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1944                                         print_register<BitBlock>("ParseError",ParseError);
    1945                                         BitBlock __temp__4;
    1946                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),__temp__4));
    1947                                         BitBlock AttValPos;
    1948                                         AttValPos = __temp__4;
    1949                                         print_register<BitBlock>("AttValPos",AttValPos);
     970                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
    1950971                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1951                                         print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1952                                         BitBlock DQuoteAttVal;
    1953                                         DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1954                                         print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    1955                                         BitBlock SQuoteAttVal;
    1956                                         SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1957                                         print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    1958                                         BitBlock __temp__5;
    1959                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),__temp__5));
    1960                                         BitBlock DQuoteAttEnd;
    1961                                         DQuoteAttEnd = __temp__5;
    1962                                         print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    1963                                         BitBlock __temp__6;
    1964                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),__temp__6));
    1965                                         BitBlock SQuoteAttEnd;
    1966                                         SQuoteAttEnd = __temp__6;
    1967                                         print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    1968                                         BitBlock AttValEnd;
    1969                                         AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1970                                         print_register<BitBlock>("AttValEnd",AttValEnd);
     972                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     973                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     974                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),simd<1>::constant<0>(),3);
     975                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),simd<1>::constant<0>(),4);
     976                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1971977                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1972                                         print_register<BitBlock>("ParseError",ParseError);
    1973                                         BitBlock __temp__7;
    1974                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),__temp__7));
    1975                                         BitBlock AttValFollow;
    1976                                         AttValFollow = __temp__7;
    1977                                         print_register<BitBlock>("AttValFollow",AttValFollow);
     978                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
    1978979                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1979                                         print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    1980980                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    1981981                                        {
    1982                                                 BitBlock __temp__8;
    1983                                                 carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),__temp__8));
    1984                                                 AfterWS = __temp__8;
    1985                                                 print_register<BitBlock>("AfterWS",AfterWS);
     982                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
    1986983                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1987                                                 print_register<BitBlock>("AttListEnd",AttListEnd);
    1988984                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
    1989                                                 print_register<BitBlock>("AttNameStart",AttNameStart);
    1990985                                        }
    1991986                                        else
    1992987                                        {
    1993988                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1994                                                 print_register<BitBlock>("AttListEnd",AttListEnd);
    1995989                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1996                                                 print_register<BitBlock>("AttNameStart",AttNameStart);
    1997990                                        }
    1998991                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1999                                         print_register<BitBlock>("ParseError",ParseError);
    2000992                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
    2001993                                }
     
    2003995                        else
    2004996                        {
    2005                                 carry_set_0.carryDequeueEnqueue(2,7);
     997                                carry_set_0.CarryDequeueEnqueue(2,7);
    2006998                        }
    2007999                }
     
    20091001                {
    20101002                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    2011                         print_register<BitBlock>("AttListEnd",AttListEnd);
    20121003                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    2013                         print_register<BitBlock>("ParseError",ParseError);
    2014                         carry_set_0.carryDequeueEnqueue(1,8);
    2015                 }
    2016                 BitBlock STagEnds;
    2017                 STagEnds = simd_and(AttListEnd,lex.RAngle);
    2018                 print_register<BitBlock>("STagEnds",STagEnds);
    2019                 BitBlock __temp__9;
    2020                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),__temp__9));
    2021                 tag_Callouts.EmptyTag_marks = __temp__9;
    2022                 print_register<BitBlock>("tag_Callouts.EmptyTag_marks",tag_Callouts.EmptyTag_marks);
     1004                        carry_set_0.CarryDequeueEnqueue(1,8);
     1005                }
     1006                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
     1007                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
    20231008                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    2024                 print_register<BitBlock>("ParseError",ParseError);
    2025                 BitBlock __temp__10;
    2026                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),__temp__10));
    2027                 BitBlock EndTagEnds;
    2028                 EndTagEnds = __temp__10;
    2029                 print_register<BitBlock>("EndTagEnds",EndTagEnds);
    2030                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
    2031                 {
    2032                         BitBlock __temp__11;
    2033                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),__temp__11));
    2034                         EndTagEnds = __temp__11;
    2035                         print_register<BitBlock>("EndTagEnds",EndTagEnds);
     1009                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
     1010                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
     1011                {
     1012                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
    20361013                }
    20371014                else
    20381015                {
    2039                         carry_set_0.carryDequeueEnqueue(11,1);
     1016                        carry_set_0.CarryDequeueEnqueue(11,1);
    20401017                }
    20411018                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
    2042                 print_register<BitBlock>("ParseError",ParseError);
    20431019                if (bitblock::any(ParseError))
    20441020                {
    20451021                        assert_0_error("Tag parsing error found",ParseError);
    20461022                }
    2047                 BitBlock __temp__12;
    2048                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),__temp__12));
    2049                 tag_Callouts.AttVal_spans = __temp__12;
    2050                 print_register<BitBlock>("tag_Callouts.AttVal_spans",tag_Callouts.AttVal_spans);
    2051                 carry_set_0.carryAdjust(13);
     1023                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
     1024                carry_set_0.CarryAdjust(13);
    20521025        }
    20531026       
    20541027        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
    20551028        {
    2056                 BitBlock EqExpected;
    2057                 EqExpected = simd<1>::constant<0>();
    2058                 print_register<BitBlock>("EqExpected",EqExpected);
    2059                 BitBlock AttListEnd;
    2060                 AttListEnd = simd<1>::constant<0>();
    2061                 print_register<BitBlock>("AttListEnd",AttListEnd);
    2062                 BitBlock DQuoteDelim;
    2063                 DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
    2064                 print_register<BitBlock>("DQuoteDelim",DQuoteDelim);
    2065                 BitBlock SQuoteDelim;
    2066                 SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
    2067                 print_register<BitBlock>("SQuoteDelim",SQuoteDelim);
    2068                 BitBlock AttListDelim;
    2069                 AttListDelim = simd_or(lex.Slash,lex.RAngle);
    2070                 print_register<BitBlock>("AttListDelim",AttListDelim);
     1029                BitBlock EqExpected = simd<1>::constant<0>();
     1030                BitBlock AttListEnd = simd<1>::constant<0>();
     1031                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     1032                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     1033                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
    20711034                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
    2072                 print_register<BitBlock>("tag_Callouts.ElemName_starts",tag_Callouts.ElemName_starts);
    20731035                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    2074                 print_register<BitBlock>("tag_Callouts.EndTag_marks",tag_Callouts.EndTag_marks);
    2075                 BitBlock __temp__0;
    2076                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),__temp__0));
    2077                 tag_Callouts.ElemName_ends = __temp__0;
    2078                 print_register<BitBlock>("tag_Callouts.ElemName_ends",tag_Callouts.ElemName_ends);
    2079                 BitBlock ParseError;
    2080                 ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    2081                 print_register<BitBlock>("ParseError",ParseError);
     1036                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
     1037                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    20821038                tag_Callouts.AttName_starts = simd<1>::constant<0>();
    2083                 print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    20841039                tag_Callouts.AttName_ends = simd<1>::constant<0>();
    2085                 print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    20861040                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    2087                 print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    20881041                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    2089                 print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    2090                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
    2091                 {
    2092                         BitBlock __temp__1;
    2093                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),__temp__1));
    2094                         BitBlock AfterWS;
    2095                         AfterWS = __temp__1;
    2096                         print_register<BitBlock>("AfterWS",AfterWS);
     1042                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
     1043                {
     1044                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
    20971045                        AttListEnd = simd_and(AfterWS,AttListDelim);
    2098                         print_register<BitBlock>("AttListEnd",AttListEnd);
    2099                         BitBlock AttNameStart;
    2100                         AttNameStart = simd_andc(AfterWS,AttListDelim);
    2101                         print_register<BitBlock>("AttNameStart",AttNameStart);
    2102                         if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(2,7))))
     1046                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
     1047                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.CarryRange(2,7))))
    21031048                        {
    21041049                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    2105                                 print_register<BitBlock>("ParseError",ParseError);
    21061050                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    2107                                 print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    2108                                 BitBlock __temp__2;
    2109                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),__temp__2));
    2110                                 BitBlock AttNameFollow;
    2111                                 AttNameFollow = __temp__2;
    2112                                 print_register<BitBlock>("AttNameFollow",AttNameFollow);
     1051                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
    21131052                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    2114                                 print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    2115                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    2116                                 {
    2117                                         BitBlock __temp__3;
    2118                                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),__temp__3));
    2119                                         EqExpected = __temp__3;
    2120                                         print_register<BitBlock>("EqExpected",EqExpected);
     1053                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
     1054                                {
     1055                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
    21211056                                }
    21221057                                else
    21231058                                {
    21241059                                        EqExpected = AttNameFollow;
    2125                                         print_register<BitBlock>("EqExpected",EqExpected);
    2126                                         carry_set_0.carryDequeueEnqueue(3,1);
     1060                                        carry_set_0.CarryDequeueEnqueue(3,1);
    21271061                                }
    21281062                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    2129                                 print_register<BitBlock>("ParseError",ParseError);
    2130                                 BitBlock __temp__4;
    2131                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),__temp__4));
    2132                                 BitBlock AttValPos;
    2133                                 AttValPos = __temp__4;
    2134                                 print_register<BitBlock>("AttValPos",AttValPos);
     1063                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
    21351064                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    2136                                 print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    2137                                 BitBlock DQuoteAttVal;
    2138                                 DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    2139                                 print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    2140                                 BitBlock SQuoteAttVal;
    2141                                 SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    2142                                 print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    2143                                 BitBlock __temp__5;
    2144                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),__temp__5));
    2145                                 BitBlock DQuoteAttEnd;
    2146                                 DQuoteAttEnd = __temp__5;
    2147                                 print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    2148                                 BitBlock __temp__6;
    2149                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),__temp__6));
    2150                                 BitBlock SQuoteAttEnd;
    2151                                 SQuoteAttEnd = __temp__6;
    2152                                 print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    2153                                 BitBlock AttValEnd;
    2154                                 AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    2155                                 print_register<BitBlock>("AttValEnd",AttValEnd);
     1065                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1066                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1067                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.GetCarry(5),5);
     1068                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.GetCarry(6),6);
     1069                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    21561070                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    2157                                 print_register<BitBlock>("ParseError",ParseError);
    2158                                 BitBlock __temp__7;
    2159                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),__temp__7));
    2160                                 BitBlock AttValFollow;
    2161                                 AttValFollow = __temp__7;
    2162                                 print_register<BitBlock>("AttValFollow",AttValFollow);
     1071                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
    21631072                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    2164                                 print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    2165                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    2166                                 {
    2167                                         BitBlock __temp__8;
    2168                                         carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),__temp__8));
    2169                                         AfterWS = __temp__8;
    2170                                         print_register<BitBlock>("AfterWS",AfterWS);
     1073                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
     1074                                {
     1075                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
    21711076                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    2172                                         print_register<BitBlock>("AttListEnd",AttListEnd);
    21731077                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    2174                                         print_register<BitBlock>("AttNameStart",AttNameStart);
    21751078                                }
    21761079                                else
    21771080                                {
    21781081                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    2179                                         print_register<BitBlock>("AttListEnd",AttListEnd);
    21801082                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    2181                                         print_register<BitBlock>("AttNameStart",AttNameStart);
    2182                                         carry_set_0.carryDequeueEnqueue(8,1);
     1083                                        carry_set_0.CarryDequeueEnqueue(8,1);
    21831084                                }
    21841085                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    2185                                 print_register<BitBlock>("ParseError",ParseError);
    21861086                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
    21871087                                {
    21881088                                        CarryDeclare(carry_set_1,7,0);
    21891089                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    2190                                         print_register<BitBlock>("ParseError",ParseError);
    21911090                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    2192                                         print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    2193                                         BitBlock __temp__2;
    2194                                         carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),__temp__2));
    2195                                         BitBlock AttNameFollow;
    2196                                         AttNameFollow = __temp__2;
    2197                                         print_register<BitBlock>("AttNameFollow",AttNameFollow);
     1091                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
    21981092                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    2199                                         print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    22001093                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    22011094                                        {
    2202                                                 BitBlock __temp__3;
    2203                                                 carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),__temp__3));
    2204                                                 EqExpected = __temp__3;
    2205                                                 print_register<BitBlock>("EqExpected",EqExpected);
     1095                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
    22061096                                        }
    22071097                                        else
    22081098                                        {
    22091099                                                EqExpected = AttNameFollow;
    2210                                                 print_register<BitBlock>("EqExpected",EqExpected);
    22111100                                        }
    22121101                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    2213                                         print_register<BitBlock>("ParseError",ParseError);
    2214                                         BitBlock __temp__4;
    2215                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),__temp__4));
    2216                                         BitBlock AttValPos;
    2217                                         AttValPos = __temp__4;
    2218                                         print_register<BitBlock>("AttValPos",AttValPos);
     1102                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
    22191103                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    2220                                         print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    2221                                         BitBlock DQuoteAttVal;
    2222                                         DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    2223                                         print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    2224                                         BitBlock SQuoteAttVal;
    2225                                         SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    2226                                         print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    2227                                         BitBlock __temp__5;
    2228                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),__temp__5));
    2229                                         BitBlock DQuoteAttEnd;
    2230                                         DQuoteAttEnd = __temp__5;
    2231                                         print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    2232                                         BitBlock __temp__6;
    2233                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),__temp__6));
    2234                                         BitBlock SQuoteAttEnd;
    2235                                         SQuoteAttEnd = __temp__6;
    2236                                         print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    2237                                         BitBlock AttValEnd;
    2238                                         AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    2239                                         print_register<BitBlock>("AttValEnd",AttValEnd);
     1104                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1105                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1106                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),simd<1>::constant<0>(),3);
     1107                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),simd<1>::constant<0>(),4);
     1108                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    22401109                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    2241                                         print_register<BitBlock>("ParseError",ParseError);
    2242                                         BitBlock __temp__7;
    2243                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),__temp__7));
    2244                                         BitBlock AttValFollow;
    2245                                         AttValFollow = __temp__7;
    2246                                         print_register<BitBlock>("AttValFollow",AttValFollow);
     1110                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
    22471111                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    2248                                         print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    22491112                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    22501113                                        {
    2251                                                 BitBlock __temp__8;
    2252                                                 carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),__temp__8));
    2253                                                 AfterWS = __temp__8;
    2254                                                 print_register<BitBlock>("AfterWS",AfterWS);
     1114                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
    22551115                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    2256                                                 print_register<BitBlock>("AttListEnd",AttListEnd);
    22571116                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
    2258                                                 print_register<BitBlock>("AttNameStart",AttNameStart);
    22591117                                        }
    22601118                                        else
    22611119                                        {
    22621120                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    2263                                                 print_register<BitBlock>("AttListEnd",AttListEnd);
    22641121                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
    2265                                                 print_register<BitBlock>("AttNameStart",AttNameStart);
    22661122                                        }
    22671123                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    2268                                         print_register<BitBlock>("ParseError",ParseError);
    22691124                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
    22701125                                }
     
    22721127                        else
    22731128                        {
    2274                                 carry_set_0.carryDequeueEnqueue(2,7);
     1129                                carry_set_0.CarryDequeueEnqueue(2,7);
    22751130                        }
    22761131                }
     
    22781133                {
    22791134                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    2280                         print_register<BitBlock>("AttListEnd",AttListEnd);
    22811135                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    2282                         print_register<BitBlock>("ParseError",ParseError);
    2283                         carry_set_0.carryDequeueEnqueue(1,8);
    2284                 }
    2285                 BitBlock STagEnds;
    2286                 STagEnds = simd_and(AttListEnd,lex.RAngle);
    2287                 print_register<BitBlock>("STagEnds",STagEnds);
    2288                 BitBlock __temp__9;
    2289                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),__temp__9));
    2290                 tag_Callouts.EmptyTag_marks = __temp__9;
    2291                 print_register<BitBlock>("tag_Callouts.EmptyTag_marks",tag_Callouts.EmptyTag_marks);
     1136                        carry_set_0.CarryDequeueEnqueue(1,8);
     1137                }
     1138                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
     1139                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
    22921140                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    2293                 print_register<BitBlock>("ParseError",ParseError);
    2294                 BitBlock __temp__10;
    2295                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),__temp__10));
    2296                 BitBlock EndTagEnds;
    2297                 EndTagEnds = __temp__10;
    2298                 print_register<BitBlock>("EndTagEnds",EndTagEnds);
    2299                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
    2300                 {
    2301                         BitBlock __temp__11;
    2302                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),__temp__11));
    2303                         EndTagEnds = __temp__11;
    2304                         print_register<BitBlock>("EndTagEnds",EndTagEnds);
     1141                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
     1142                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
     1143                {
     1144                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
    23051145                }
    23061146                else
    23071147                {
    2308                         carry_set_0.carryDequeueEnqueue(11,1);
     1148                        carry_set_0.CarryDequeueEnqueue(11,1);
    23091149                }
    23101150                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
    2311                 print_register<BitBlock>("ParseError",ParseError);
    23121151                if (bitblock::any(ParseError))
    23131152                {
    23141153                        assert_0_error("Tag parsing error found",ParseError);
    23151154                }
    2316                 BitBlock __temp__12;
    2317                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),__temp__12));
    2318                 tag_Callouts.AttVal_spans = __temp__12;
    2319                 print_register<BitBlock>("tag_Callouts.AttVal_spans",tag_Callouts.AttVal_spans);
     1155                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
    23201156        }
    23211157       
     
    23281164        {
    23291165        }
    2330        
     1166         
    23311167        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
    23321168        {
    23331169                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    2334                 print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
    23351170                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    2336                 print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
    23371171                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    2338                 print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
    23391172                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    2340                 print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
    23411173                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    2342                 print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
    23431174                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    2344                 print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2345                 BitBlock ref_error;
    2346                 ref_error = simd<1>::constant<0>();
    2347                 print_register<BitBlock>("ref_error",ref_error);
    2348                 if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
    2349                 {
    2350                         BitBlock __temp__0;
    2351                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),__temp__0));
    2352                         BitBlock Ref_scope;
    2353                         Ref_scope = __temp__0;
    2354                         print_register<BitBlock>("Ref_scope",Ref_scope);
    2355                         BitBlock NumRef2;
    2356                         NumRef2 = simd_and(Ref_scope,lex.Hash);
    2357                         print_register<BitBlock>("NumRef2",NumRef2);
     1175                BitBlock ref_error = simd<1>::constant<0>();
     1176                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
     1177                {
     1178                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
     1179                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
    23581180                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    2359                         print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
    2360                         BitBlock __temp__1;
    2361                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),__temp__1));
    2362                         BitBlock NumRef3;
    2363                         NumRef3 = __temp__1;
    2364                         print_register<BitBlock>("NumRef3",NumRef3);
    2365                         BitBlock HexRef3;
    2366                         HexRef3 = simd_and(NumRef3,lex.x);
    2367                         print_register<BitBlock>("HexRef3",HexRef3);
     1181                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
     1182                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
    23681183                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    2369                         print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
    2370                         BitBlock __temp__2;
    2371                         carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),__temp__2));
    2372                         ref_Callouts.HexRef_starts = __temp__2;
    2373                         print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
    2374                         BitBlock __temp__3;
    2375                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),__temp__3));
    2376                         ref_Callouts.GenRef_ends = __temp__3;
    2377                         print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
    2378                         BitBlock __temp__4;
    2379                         carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),__temp__4));
    2380                         ref_Callouts.DecRef_ends = __temp__4;
    2381                         print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
    2382                         BitBlock __temp__5;
    2383                         carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),__temp__5));
    2384                         ref_Callouts.HexRef_ends = __temp__5;
    2385                         print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2386                         BitBlock ref_error1;
    2387                         ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
    2388                         print_register<BitBlock>("ref_error1",ref_error1);
    2389                         BitBlock ref_error2;
    2390                         ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
    2391                         print_register<BitBlock>("ref_error2",ref_error2);
    2392                         BitBlock ref_ends;
    2393                         ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
    2394                         print_register<BitBlock>("ref_ends",ref_ends);
    2395                         BitBlock ref_error3;
    2396                         ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    2397                         print_register<BitBlock>("ref_error3",ref_error3);
     1184                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
     1185                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
     1186                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
     1187                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
     1188                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     1189                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     1190                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     1191                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    23981192                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    23991193                        {
     
    24031197                else
    24041198                {
    2405                         carry_set_0.carryDequeueEnqueue(0,6);
    2406                 }
    2407                 carry_set_0.carryAdjust(6);
     1199                        carry_set_0.CarryDequeueEnqueue(0,6);
     1200                }
     1201                carry_set_0.CarryAdjust(6);
    24081202        }
    24091203       
     
    24111205        {
    24121206                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    2413                 print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
    24141207                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    2415                 print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
    24161208                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    2417                 print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
    24181209                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    2419                 print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
    24201210                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    2421                 print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
    24221211                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    2423                 print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2424                 BitBlock ref_error;
    2425                 ref_error = simd<1>::constant<0>();
    2426                 print_register<BitBlock>("ref_error",ref_error);
    2427                 if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
    2428                 {
    2429                         BitBlock __temp__0;
    2430                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),__temp__0));
    2431                         BitBlock Ref_scope;
    2432                         Ref_scope = __temp__0;
    2433                         print_register<BitBlock>("Ref_scope",Ref_scope);
    2434                         BitBlock NumRef2;
    2435                         NumRef2 = simd_and(Ref_scope,lex.Hash);
    2436                         print_register<BitBlock>("NumRef2",NumRef2);
     1212                BitBlock ref_error = simd<1>::constant<0>();
     1213                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
     1214                {
     1215                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
     1216                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
    24371217                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    2438                         print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
    2439                         BitBlock __temp__1;
    2440                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),__temp__1));
    2441                         BitBlock NumRef3;
    2442                         NumRef3 = __temp__1;
    2443                         print_register<BitBlock>("NumRef3",NumRef3);
    2444                         BitBlock HexRef3;
    2445                         HexRef3 = simd_and(NumRef3,lex.x);
    2446                         print_register<BitBlock>("HexRef3",HexRef3);
     1218                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
     1219                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
    24471220                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    2448                         print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
    2449                         BitBlock __temp__2;
    2450                         carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),__temp__2));
    2451                         ref_Callouts.HexRef_starts = __temp__2;
    2452                         print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
    2453                         BitBlock __temp__3;
    2454                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),__temp__3));
    2455                         ref_Callouts.GenRef_ends = __temp__3;
    2456                         print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
    2457                         BitBlock __temp__4;
    2458                         carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),__temp__4));
    2459                         ref_Callouts.DecRef_ends = __temp__4;
    2460                         print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
    2461                         BitBlock __temp__5;
    2462                         carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),__temp__5));
    2463                         ref_Callouts.HexRef_ends = __temp__5;
    2464                         print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2465                         BitBlock ref_error1;
    2466                         ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
    2467                         print_register<BitBlock>("ref_error1",ref_error1);
    2468                         BitBlock ref_error2;
    2469                         ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
    2470                         print_register<BitBlock>("ref_error2",ref_error2);
    2471                         BitBlock ref_ends;
    2472                         ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
    2473                         print_register<BitBlock>("ref_ends",ref_ends);
    2474                         BitBlock ref_error3;
    2475                         ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    2476                         print_register<BitBlock>("ref_error3",ref_error3);
     1221                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
     1222                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
     1223                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
     1224                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
     1225                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     1226                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     1227                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     1228                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    24771229                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    24781230                        {
     
    24821234                else
    24831235                {
    2484                         carry_set_0.carryDequeueEnqueue(0,6);
     1236                        carry_set_0.CarryDequeueEnqueue(0,6);
    24851237                }
    24861238        }
     
    24941246        {
    24951247        }
    2496        
     1248         
    24971249        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts,struct Ref_Callouts & ref_Callouts,struct Tag_Callouts & tag_Callouts,struct Lex & lex,struct U8 & u8,struct Check_streams & check_streams)
    24981250        {
    2499                 BitBlock __temp__0;
    2500                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),__temp__0));
    2501                 BitBlock PI_names;
    2502                 PI_names = __temp__0;
    2503                 print_register<BitBlock>("PI_names",PI_names);
    2504                 BitBlock __temp__1;
    2505                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),__temp__1));
    2506                 BitBlock GenRefs;
    2507                 GenRefs = __temp__1;
    2508                 print_register<BitBlock>("GenRefs",GenRefs);
    2509                 BitBlock __temp__2;
    2510                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),__temp__2));
    2511                 BitBlock ElemNames;
    2512                 ElemNames = __temp__2;
    2513                 print_register<BitBlock>("ElemNames",ElemNames);
    2514                 BitBlock __temp__3;
    2515                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),__temp__3));
    2516                 BitBlock AttNames;
    2517                 AttNames = __temp__3;
    2518                 print_register<BitBlock>("AttNames",AttNames);
    2519                 BitBlock qname_stream;
    2520                 qname_stream = simd_or(ElemNames,AttNames);
    2521                 print_register<BitBlock>("qname_stream",qname_stream);
    2522                 BitBlock ncname_stream;
    2523                 ncname_stream = simd_or(PI_names,GenRefs);
    2524                 print_register<BitBlock>("ncname_stream",ncname_stream);
    2525                 BitBlock name_stream;
    2526                 name_stream = simd_or(qname_stream,ncname_stream);
    2527                 print_register<BitBlock>("name_stream",name_stream);
    2528                 BitBlock __temp__4;
    2529                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),__temp__4));
    2530                 BitBlock name_start;
    2531                 name_start = simd_andc(name_stream,__temp__4);
    2532                 print_register<BitBlock>("name_start",name_start);
    2533                 BitBlock __temp__5;
    2534                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),__temp__5));
    2535                 BitBlock name_cursor;
    2536                 name_cursor = simd_andc(name_stream,__temp__5);
    2537                 print_register<BitBlock>("name_cursor",name_cursor);
    2538                 BitBlock void_prefix_err;
    2539                 void_prefix_err = simd_and(name_cursor,lex.Colon);
    2540                 print_register<BitBlock>("void_prefix_err",void_prefix_err);
    2541                 BitBlock __temp__6;
    2542                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),__temp__6));
    2543                 BitBlock namespace_sep;
    2544                 namespace_sep = simd_and(__temp__6,lex.Colon);
    2545                 print_register<BitBlock>("namespace_sep",namespace_sep);
    2546                 BitBlock __temp__7;
    2547                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),__temp__7));
    2548                 BitBlock local_part_start;
    2549                 local_part_start = __temp__7;
    2550                 print_register<BitBlock>("local_part_start",local_part_start);
    2551                 BitBlock local_part_err;
    2552                 local_part_err = simd_andc(local_part_start,lex.NameScan);
    2553                 print_register<BitBlock>("local_part_err",local_part_err);
    2554                 BitBlock __temp__8;
    2555                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),__temp__8));
    2556                 BitBlock colon2_err;
    2557                 colon2_err = simd_and(__temp__8,lex.Colon);
    2558                 print_register<BitBlock>("colon2_err",colon2_err);
    2559                 BitBlock ncname_err;
    2560                 ncname_err = simd_and(ncname_stream,lex.Colon);
    2561                 print_register<BitBlock>("ncname_err",ncname_err);
     1251                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.GetCarry(0),0);
     1252                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);
     1253                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.GetCarry(2),2);
     1254                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.GetCarry(3),3);
     1255                BitBlock qname_stream = simd_or(ElemNames,AttNames);
     1256                BitBlock ncname_stream = simd_or(PI_names,GenRefs);
     1257                BitBlock name_stream = simd_or(qname_stream,ncname_stream);
     1258                BitBlock name_start = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(4),4));
     1259                BitBlock name_cursor = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(5),5));
     1260                BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
     1261                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(6),6),lex.Colon);
     1262                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep,carry_set_0.GetCarry(7),7);
     1263                BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
     1264                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(8),8),lex.Colon);
     1265                BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
    25621266                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    25631267                {
     
    25651269                }
    25661270                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
    2567                 print_register<BitBlock>("check_streams.non_ascii_name_starts",check_streams.non_ascii_name_starts);
    25681271                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
    2569                 print_register<BitBlock>("check_streams.non_ascii_names",check_streams.non_ascii_names);
    2570                 carry_set_0.carryAdjust(9);
     1272                carry_set_0.CarryAdjust(9);
    25711273        }
    25721274       
    25731275        void do_final_block(struct CtCDPI_Callouts & ctCDPI_Callouts,struct Ref_Callouts & ref_Callouts,struct Tag_Callouts & tag_Callouts,struct Lex & lex,struct U8 & u8,struct Check_streams & check_streams,BitBlock & EOF_mask)
    25741276        {
    2575                 BitBlock __temp__0;
    2576                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),__temp__0));
    2577                 BitBlock PI_names;
    2578                 PI_names = __temp__0;
    2579                 print_register<BitBlock>("PI_names",PI_names);
    2580                 BitBlock __temp__1;
    2581                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),__temp__1));
    2582                 BitBlock GenRefs;
    2583                 GenRefs = __temp__1;
    2584                 print_register<BitBlock>("GenRefs",GenRefs);
    2585                 BitBlock __temp__2;
    2586                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),__temp__2));
    2587                 BitBlock ElemNames;
    2588                 ElemNames = __temp__2;
    2589                 print_register<BitBlock>("ElemNames",ElemNames);
    2590                 BitBlock __temp__3;
    2591                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),__temp__3));
    2592                 BitBlock AttNames;
    2593                 AttNames = __temp__3;
    2594                 print_register<BitBlock>("AttNames",AttNames);
    2595                 BitBlock qname_stream;
    2596                 qname_stream = simd_or(ElemNames,AttNames);
    2597                 print_register<BitBlock>("qname_stream",qname_stream);
    2598                 BitBlock ncname_stream;
    2599                 ncname_stream = simd_or(PI_names,GenRefs);
    2600                 print_register<BitBlock>("ncname_stream",ncname_stream);
    2601                 BitBlock name_stream;
    2602                 name_stream = simd_or(qname_stream,ncname_stream);
    2603                 print_register<BitBlock>("name_stream",name_stream);
    2604                 BitBlock __temp__4;
    2605                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),__temp__4));
    2606                 BitBlock name_start;
    2607                 name_start = simd_andc(name_stream,__temp__4);
    2608                 print_register<BitBlock>("name_start",name_start);
    2609                 BitBlock __temp__5;
    2610                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),__temp__5));
    2611                 BitBlock name_cursor;
    2612                 name_cursor = simd_andc(name_stream,__temp__5);
    2613                 print_register<BitBlock>("name_cursor",name_cursor);
    2614                 BitBlock void_prefix_err;
    2615                 void_prefix_err = simd_and(name_cursor,lex.Colon);
    2616                 print_register<BitBlock>("void_prefix_err",void_prefix_err);
    2617                 BitBlock __temp__6;
    2618                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),__temp__6));
    2619                 BitBlock namespace_sep;
    2620                 namespace_sep = simd_and(__temp__6,lex.Colon);
    2621                 print_register<BitBlock>("namespace_sep",namespace_sep);
    2622                 BitBlock __temp__7;
    2623                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),__temp__7));
    2624                 BitBlock local_part_start;
    2625                 local_part_start = __temp__7;
    2626                 print_register<BitBlock>("local_part_start",local_part_start);
    2627                 BitBlock local_part_err;
    2628                 local_part_err = simd_andc(local_part_start,lex.NameScan);
    2629                 print_register<BitBlock>("local_part_err",local_part_err);
    2630                 BitBlock __temp__8;
    2631                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),__temp__8));
    2632                 BitBlock colon2_err;
    2633                 colon2_err = simd_and(__temp__8,lex.Colon);
    2634                 print_register<BitBlock>("colon2_err",colon2_err);
    2635                 BitBlock ncname_err;
    2636                 ncname_err = simd_and(ncname_stream,lex.Colon);
    2637                 print_register<BitBlock>("ncname_err",ncname_err);
     1277                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.GetCarry(0),0);
     1278                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);
     1279                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.GetCarry(2),2);
     1280                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.GetCarry(3),3);
     1281                BitBlock qname_stream = simd_or(ElemNames,AttNames);
     1282                BitBlock ncname_stream = simd_or(PI_names,GenRefs);
     1283                BitBlock name_stream = simd_or(qname_stream,ncname_stream);
     1284                BitBlock name_start = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(4),4));
     1285                BitBlock name_cursor = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(5),5));
     1286                BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
     1287                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(6),6),lex.Colon);
     1288                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep,carry_set_0.GetCarry(7),7);
     1289                BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
     1290                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(8),8),lex.Colon);
     1291                BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
    26381292                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    26391293                {
     
    26411295                }
    26421296                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
    2643                 print_register<BitBlock>("check_streams.non_ascii_name_starts",check_streams.non_ascii_name_starts);
    26441297                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
    2645                 print_register<BitBlock>("check_streams.non_ascii_names",check_streams.non_ascii_names);
    26461298        }
    26471299       
     
    26541306        {
    26551307        }
    2656        
     1308         
    26571309        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
    26581310        {
     
    26621314                }
    26631315                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks,tag_Callouts.ElemName_starts),tag_Callouts.EndTag_marks),tag_Callouts.AttName_starts);
    2664                 print_register<BitBlock>("check_streams.tag_marks",check_streams.tag_marks);
    26651316                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
    2666                 print_register<BitBlock>("check_streams.name_follows",check_streams.name_follows);
    26671317                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
    2668                 print_register<BitBlock>("check_streams.att_refs",check_streams.att_refs);
    26691318        }
    26701319       
     
    26761325                }
    26771326                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks,tag_Callouts.ElemName_starts),tag_Callouts.EndTag_marks),tag_Callouts.AttName_starts);
    2678                 print_register<BitBlock>("check_streams.tag_marks",check_streams.tag_marks);
    26791327                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
    2680                 print_register<BitBlock>("check_streams.name_follows",check_streams.name_follows);
    26811328                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
    2682                 print_register<BitBlock>("check_streams.att_refs",check_streams.att_refs);
    26831329        }
    26841330       
Note: See TracChangeset for help on using the changeset viewer.