Changeset 3192 for proto/pabloj/branches


Ignore:
Timestamp:
May 27, 2013, 1:54:27 PM (6 years ago)
Author:
ksherdy
Message:

Sweeping changes to sync branch with trunk.

Location:
proto/pabloj/branches/refactor-experimental
Files:
14 added
9 deleted
37 edited
8 copied
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/.project

    r3117 r3192  
    77        <buildSpec>
    88                <buildCommand>
     9                        <name>org.python.pydev.PyDevBuilder</name>
     10                        <arguments>
     11                        </arguments>
     12                </buildCommand>
     13                <buildCommand>
    914                        <name>org.eclipse.jdt.core.javabuilder</name>
    1015                        <arguments>
     
    1419        <natures>
    1520                <nature>org.eclipse.jdt.core.javanature</nature>
     21                <nature>org.python.pydev.pythonNature</nature>
    1622        </natures>
    1723</projectDescription>
  • proto/pabloj/branches/refactor-experimental/docs/Notes

    r3169 r3192  
    33================================================================================
    44This document describes the state of the PabloJ compiler at Version 0.8.0.
    5 Original implementation is modelled on the Pablo Python compiler version 2615.
     5
     6Original implementation is modelled against Pablo Python compiler version 2615.
     7parabix2_pablo.py version 2797.
    68
    79Version 0.8.0
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloB.scatter

    r3161 r3192  
    11//
    2 // Ken Herdy
     2// Tom Shermer, Ken Herdy
    33//
    44// PabloB - Block-at-a-time language
     
    88//                              06-04-2013      Updated to Scatter with types.
    99//
    10 // TODO:                Add BlockMode blocks to specify SIMD field width.
    11 //                              Add compile time integer expressions evaluation '+','-','*','/'.
    12 //                              Add Code Block.
     10// TODO:                CodeBlock, types ...
     11//
    1312
    14 types {}
     13types {
     14//      toolchain.pabloS.lang.type.Type,
     15//      toolchain.pabloS.lang.type.PrimitiveType,
     16//      toolchain.pabloS.lang.type.StreamType,
     17}
    1518
    1619context main {
     
    3134  tokens {
    3235        INIT,
    33         VAR,
    3436        KERNEL,
    3537        FUNCTION,       
    36         STREAM, // TODO - remove
    3738        STRUCT,
     39        INT,
    3840        VOID,
     41        BOOL,
    3942        BITFIELD        "BitField",     
    40         BITBLOCK        "BitBlock", // alias for architecture dependent SIMD instruction width
    41         //BLOCKMODE,
     43        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD type
     44        //CODEBLOCK,
    4245        IF,
    4346        ELSE,
     
    6063
    6164interfaces {
    62 //       escapable {boolean escaped = false;},
    63          intValued {int value = 0;},
    64          
     65         intValued {int value = 0;},     
    6566}
    6667
     
    6970        funcCall {} [funcCallRest],
    7071        idisaFuncCall {} [idisaFuncCallRest],
    71         integerConstant{intValued;} [],
    72         streamConstant{intValued;} [],
     72        integerConstant{intValued;} [fieldWidthSpecifier ], // codeBlockWidthSpecifier ],
     73        // primitiveType{} [intType voidType boolType bitBlockType],  // TODO - update S2B to handle this
     74        fieldWidthType{int fieldWidth = 1;} [],
     75        // codeBlockWidth{int codeBlockWidth = 128;} [],
    7376}
    7477
    7578grammar {
    76         program         -> (typeDecl | kernelDef) * ;
    7779       
     80        program         -> (structDecl | kernelDef) * ;
     81           
    7882        //
    79         // d e c l a r a t i o n s
     83        // s t r u c t   d e c l a r a t i o n s
    8084        //
    81         // Decls                -> typeDecl TERMINATOR ;
    82         typeDecl                ->  type TERMINATOR ;           
     85        structDecl                      ->  STRUCT structName structDeclBody TERMINATOR? ;
     86        structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
     87        structMember            ->      structMemberType structMemberName ;
     88        structMemberType        #-> structType | bitBlockType ;
     89        structMemberName        #-> identifier ;
    8390   
    8491    //
    8592        // k e r n e l   d e c l a r a t i o n s                                                       
    8693        //
    87         kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)* expr TERMINATOR? RCURLY TERMINATOR? ; // TODO - hack - stick CarryDeclare at end for now
     94        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // TODO - hack - stick CarryDeclare at end for now
    8895        kernelName                      #-> identifier ;
    8996       
     
    93100        initDef                         ->  INIT initBlock TERMINATOR? ;
    94101        initBlock                       #-> LCURLY (stateInitStmt)* RCURLY;
    95         stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
     102        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?; // TODO - array node
    96103        stateIdentifier         ->  IDENTIFIER ;
    97104        stateSize                       ->  integerConstant ;
    98         stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type
     105        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type, TODO - array init list
    99106        stateValue                      ->  integerConstant ;
    100107
     
    112119
    113120        //
    114         // c o d e   b l o c k // (32,64,128,256,...)
     121        // c o d e   b l o c k  // (32,64,128,256,...)
    115122        //
    116         // BLOCKMODE  (LANGLE fieldWidth RANGLE) blockStmt (TERMINATOR)? ;
     123        // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:value; }
     124        //                                                                                                                                      blockStmt (TERMINATOR)? ;
     125        //                             
     126        // codeBlockWidthSpecifier      #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 128;}) ;
    117127               
    118128        //
    119129        // s t a t e m e n t s
    120130        //
    121         stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    122         funcCallOrAssignStmt    #-> expr ( (idisaFuncCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
    123         funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
    124         funcCallArgList                 -> (expr (COMMA expr)*)? ;
    125         idisaFuncCallRest               -> LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
     131        stmt                                    #->     localVarDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
     132        funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call   
    126133        idisaFuncCallArgList    ->  (expr (COMMA expr)*)? ;
    127         assignOperator                  -> ASSIGN;                             
    128         assignRest                              -> assignOperator^! expr ;                             
    129         ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
    130         whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
    131         returnStmt                              -> RETURN (expr)? TERMINATOR ;
    132         localVarDecl                    -> VAR type varName (assignOperator^! expr) ? ;
    133         varName                                 #-> identifier ;
    134         blockStmt                               -> LCURLY stmt* RCURLY ;
     134        assignOperator                  ->      ASSIGN;                                 
     135        assignRest                              ->      assignOperator^! expr ;                         
     136        ifStmt                                  ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                     
     137        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
     138        returnStmt                              ->      RETURN (expr)? TERMINATOR ;
     139        localVarDecl                    ->      type varName (assignOperator^! expr) ? TERMINATOR ;
     140        varName                                 #-> compoundIdentifier ;
     141        blockStmt                               ->      LCURLY stmt* RCURLY ;
    135142       
    136143        //
     
    138145        //     
    139146        expr            #-> LROUND expr RROUND
    140                                         |integerConstant
    141                                         | stringConstant
    142                                         | compoundIdentifier (funcCallRest _promote_ | idisaFuncCallRest _promote_)?
    143                                         ;
     147                                        | constant
     148                                        | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
    144149
    145         constant                                #->  stringConstant | integerConstant ; 
    146         integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    147         stringConstant                  -> STRING | SQ_STRING ;
    148         compoundIdentifier              #-> identifier (DOT^ identifier)* ;
    149         identifier                              -> IDENTIFIER ;   
    150        
     150        constant                                #->     stringConstant | integerConstant ; 
     151        integerConstant                 ->              INTEGER_CONST {@value = @@value;} ;
     152        stringConstant                  ->              STRING | SQ_STRING ;   
     153        compoundIdentifier              #->     identifier (DOT^ identifier)* ;
     154        identifier                              ->              IDENTIFIER ;   
     155        funcCallRest                    ->              LROUND^ funcCallArgList RROUND ;
     156        funcCallArgList                 ->              (expr (COMMA expr)*) ? ;       
     157        idisaFuncCallRest               ->              LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
     158        fieldWidth                              ->              integerConstant ; // TODO - update using PabloS style
     159
    151160    //   
    152161        // t y p e s
    153162        //
    154         type                    #->     identifier      |
    155                                                         voidType        |
    156                                                         streamType      | // TODO - update in PabloS2PabloB
    157                                                         structType      |
    158                                                         bitFieldType|
    159                                                         bitBlockType; // | tupleType;
     163        type                            #-> primitiveType      |
     164                                bitFieldType       |
     165                                                        structType             
     166                                                        ;
     167       
     168        primitiveType           #->  ( intType | voidType | boolType | bitBlockType ) ;
    160169
    161         streamType              ->      STREAM (LANGLE fieldWidth RANGLE) ;     
    162         fieldWidth              ->  integerConstant ;   
    163         streamTypeName  #->     identifier ;                           
    164         bitFieldType    -> BITFIELD ; // Power-of-2 bit field
    165         bitBlockType    -> BITBLOCK ; // SIMD vector
     170        intType                         ->      INT ;           // { @type = {{PrimitiveType.INTEGER}}; } ;
     171        voidType                        ->  VOID ;              // { @type = {{PrimitiveType.VOID}}; } ;
     172        boolType                        ->  BOOL ;              // { @type = {{PrimitiveType.BOOL}}; } ;
     173        bitBlockType            ->      BITBLOCK ;  // { @type = {{PrimitiveType.BITBLOCK}}; } ;
    166174       
    167         structType                              ->      STRUCT structName (structTypeBody)? ;           
    168         structName                              #->  identifier ;                               
    169         structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
    170         structMember                    ->      type structMemberName ;
    171         structMemberName                #-> identifier ;
    172         voidType                                -> VOID ;
     175        bitFieldType            ->      BITFIELD  fieldWidthSpecifier! {        @fieldWidth = @:value;
     176                                                                                                                                // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
     177                                                                                                                } ;
     178                                                                                                                       
     179        fieldWidthSpecifier     #-> (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;       
     180       
     181        structType                      ->      STRUCT structName ;             
     182        structName                      #-> identifier ;                               
    173183       
    174184}
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter

    r3166 r3192  
     1//
     2// Tom Shermer, Ken Herdy
    13//
    24// PabloS - Parallel Stream Language 
    35//
    4 // A tiny language for the definition of stream structures, functions, and types.
     6// A tiny language for the definition of stream structures and stream functions.
    57//
    6 // Author:                      Ken Herdy <ksherdy at sfu dot ca>
    7 // Created:             2012/09/08
    8 // Last Changed:        2013/02/01
    9 //
    10 // History:                     2012/09/08 Initial definition.
     8// Modified:            2012/09/08 Original definition.
    119//                                             
    1210
     
    3432  // t o k e n s
    3533  tokens {
    36 //      VAR,
    3734        FUNCTION,       
    3835        STREAM,
    3936        STRUCT,
    40 //      TUPLE,
    4137        VOID,
    4238        INT,
    43 //      STRING,
    4439        IF,
    4540        ELSE,
     
    6661        LCURLY          "{",
    6762        RCURLY          "}",
    68 //      LSQUARE         "[",
    69 //      RSQUARE         "]",
    7063        LROUND          "(",
    7164        RROUND          ")",
     
    8780  assign {} [assignRest],
    8881  funcCall {} [funcCallRest],
    89   // streamCall {} [streamCallRest],
    9082  integerConstant{intValued;} [fieldWidthSpecifier],
    91   primitiveType{} [intType voidType],
     83  // primitiveType{} [intType voidType], // TODO - update S2B to handle this
    9284  streamType{int fieldWidth = 1;} [],
    9385}
    9486
    9587grammar {
     88
    9689        program         -> (structDecl | funcDef) *;                   
    9790
     
    9992        // s t r e a m   s t r u c t   d e c l a r a t i o n s 
    10093        //
    101         structDecl                      ->  STRUCT structName structTypeBody TERMINATOR? ;
    102         structTypeBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
     94        structDecl                      ->  STRUCT structName structDeclBody TERMINATOR? ;
     95        structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
    10396        structMember            ->      structMemberType structMemberName ;
    10497        structMemberType        #-> structType | streamType ;
     
    120113        stmt                                    #->     localVarDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
    121114        blockStmt                               ->      LCURLY stmt* RCURLY ;
    122         localVarDecl                    ->      type varName (ASSIGN^ expr) ? TERMINATOR;
     115        localVarDecl                    ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
    123116        varName                                 #-> compoundIdentifier ;
    124         funcCallOrAssignStmt    #-> expr (assignRest _promote_)? TERMINATOR ;
     117        funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call
    125118        assignRest                              ->      assignOperator^! expr ;
    126119        assignOperator                  ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
     
    128121        ifStmt                                  ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                                                 
    129122        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
    130         returnStmt                              ->      RETURN (expr)? TERMINATOR;
     123        returnStmt                              ->      RETURN (expr)? TERMINATOR ;
    131124
    132125        //
    133126        // e x p r e s s i o n s
    134127        //     
    135         expr    #->     expr1 ((OR^|XOR^) expr)?  _leftAssoc_ ;
    136         expr1   #-> expr2 ((AND^) expr1)?  _leftAssoc_ ;
     128        expr    #->     expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
     129        expr1   #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
    137130        expr2   #-> NOT^^? expr3;
    138131        expr3   #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
    139132        expr4   #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
    140133        expr5   #-> LROUND expr RROUND
    141                                         | stringConstant
    142                                         | integerConstant
    143                                         | compoundIdentifier (funcCallRest _promote_)?
     134                                        | constant
     135                                        | compoundIdentifier (funcCallRest _promote_) ?
    144136                                        ;
    145137                                                                                                                                                                                                                                                                       
    146138        constant                                #-> stringConstant | integerConstant ;
    147         integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    148         stringConstant                  -> STRING | SQ_STRING ;
     139        integerConstant                 ->      INTEGER_CONST {@value = @@value;} ;
     140        stringConstant                  ->      STRING | SQ_STRING ;   
    149141        compoundIdentifier              #-> identifier (DOT^ identifier)*;
    150         identifier                              -> IDENTIFIER ;
    151     funcCallRest                        -> LROUND^ funcCallArgList RROUND ;
    152         funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
     142        identifier                              ->      IDENTIFIER ;
     143    funcCallRest                        ->      LROUND^ funcCallArgList RROUND ;
     144        funcCallArgList                 ->      (expr (COMMA expr)*) ? ;       
    153145               
    154         // streamCallRest                       -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
    155         // streamCallArgList            -> (expr (COMMA expr)*)? ;             
    156      
    157            
    158146    //   
    159147        // t y p e s
     
    163151                                                                structType              ;
    164152
    165         primitiveType           #-> ( intType | voidType ) ;
    166         intType                         -> INT    { @type = {{PrimitiveType.INTEGER}};  } ;
    167         voidType                        -> VOID   { @type = {{PrimitiveType.VOID}}; } ;
     153        primitiveType           #->     ( intType | voidType ) ;
     154        intType                         ->              INT    { @type = {{PrimitiveType.INTEGER}};  } ;
     155        voidType                        ->              VOID   { @type = {{PrimitiveType.VOID}}; } ;
    168156
    169         streamType                      ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
    170                                                                                                                         @type = {{ new StreamType(%?) }} , @fieldWidth ;
    171                                                                                                         } ;
     157        streamType                      ->              STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
     158                                                                                                                                @type = {{ new StreamType(%?) }} , @fieldWidth ;
     159                                                                                                                } ;
    172160                                       
    173         fieldWidthSpecifier     #->  (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;       
    174         structType                      ->      STRUCT structName ;             
    175         structName                      #->  identifier ;                               
    176        
    177         //      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
    178         //      tupleTypeSpecifier              ->      TUPLE tupleName ;       
    179         //      tupleTypeBody                   ->  type (COMMA type)* ;                                 
    180         //      tupleName                               #->  identifier ;
     161        fieldWidthSpecifier     #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
     162        structType                      ->              STRUCT structName ;             
     163        structName                      #->     identifier ;                           
    181164
    182165}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloB/all/all.pablob

    r3036 r3192  
     1// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
     2               
     3kernel KernelName
     4{
     5        init
     6        {
     7                       
     8        }
     9
     10        function void do_block()
     11        {
     12       
     13                BitBlock a;
     14                BitBlock b;
     15                BitBlock c;
     16                BitBlock k;
     17                BitBlock r;
     18               
     19                /*
     20                r = simd.add(abs);
     21                r = simd.neg(a);
     22                r = simd.add_hl(a);
     23                r = simd.xor_hl(a);
     24                r = simd.slli(k);
     25                r = simd.srli(k);
     26                r = simd.srai(k);
     27                r = simd.popcount(a);
     28                r = simd.ctz(a);       
     29                */
     30               
     31                r = simd.not<1>(a);             
     32                r = simd.ifh<16>(a, b, c);
     33                               
     34                r = hsimd.add_hl<2>(a);         
     35                // r = simd.constant<2>(3);
     36               
     37                r = simd.add<1>(a,b);
     38                r = simd.sub<2>(a,b);
     39                r = simd.mul<4>(a,b);
     40                r = simd.eq<8>(a,b);
     41                r = simd.gt<16>(a,b);
     42                r = simd.ugt<32>(a,b);
     43                r = simd.lt<64>(a,b);
     44                r = simd.ult<128>(a,b);
     45                r = simd.max<256>(a,b);
     46                r = simd.umax<1>(a,b);
     47                r = simd.min<2>(a,b);
     48                r = simd.umin<4>(a,b);
     49                r = simd.sll<8>(a,b);
     50                r = simd.srl<16>(a,b);
     51                r = simd.sra<32>(a,b);
     52               
     53                //r = simd.if<128>(a,b,c);
     54               
     55        }
     56
     57        function void do_final_block()
     58        {
     59               
     60               
     61        }
     62
     63        CarryDeclare(carry_set_0, 0, 0);
     64};     
     65// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
     66               
     67kernel KernelName
     68{
     69        init
     70        {
     71                       
     72        }
     73
     74        function void do_block()
     75        {
     76       
     77                var BitBlock a;
     78                var BitBlock b;
     79                var BitBlock c;
     80                var BitBlock k;
     81                var BitBlock r;
     82                var bool t;
     83               
     84                /*
     85                r = simd.add(abs);
     86                r = simd.neg(a);
     87                r = simd.add_hl(a);
     88                r = simd.xor_hl(a);
     89                r = simd.slli(k);
     90                r = simd.srli(k);
     91                r = simd.srai(k);
     92                r = simd.popcount(a);
     93                r = simd.ctz(a);       
     94                */
     95
     96                t = bitblock.any<1>(a);
     97                r = bitblock.slli<1>(10, a);
     98                bitblock.store_unaligned<1>(a, b);
     99                r = bitblock.load_aligned<1>(b);
     100               
     101                r = simd.not<1>(a);             
     102                r = simd.nor<1>(a, b);
     103                r = simd.ifh<16>(a, b, c);                     
     104               
     105                r = simd.constant<2>(3);
     106                r = simd.slli<8>(1, a);                 
     107
     108                r = simd.add<1>(a,b);
     109                r = simd.sub<2>(a,b);
     110                r = simd.mult<4>(a,b);
     111                r = simd.eq<8>(a,b);
     112                r = simd.gt<16>(a,b);
     113                r = simd.ugt<32>(a,b);
     114                r = simd.lt<64>(a,b);
     115                r = simd.ult<128>(a,b);
     116                r = simd.max<128>(a,b);
     117                r = simd.umax<1>(a,b);
     118                r = simd.min<2>(a,b);
     119                r = simd.umin<4>(a,b);
     120                r = simd.sll<64>(a,b);
     121                r = simd.srl<64>(a,b);
     122                //r = simd.srai<32>(10,a);
     123               
     124                //r = simd.if<128>(a,b,c);
     125               
     126        }
     127
     128        function void do_final_block()
     129        {
     130               
     131               
     132        }
     133
     134        CarryDeclare(carry_set_0, 0, 0);
     135};     
    1136// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
    2137       
     
    129264};     
    130265       
     266/*     
     267       
    131268kernel Classify_bytes_Validate_utf8 
    132269{
     
    138275        function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
    139276        {
    140                 var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    141                 var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
    142                 var BitBlock temp3 = simd.andc<1>(temp2, temp1);
    143                 var BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
    144                 var BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
    145                 var BitBlock temp6 = simd.and<1>(temp4, temp5);
     277                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     278                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     279                BitBlock temp3 = simd.andc<1>(temp2, temp1);
     280                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     281                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     282                BitBlock temp6 = simd.and<1>(temp4, temp5);
    146283                lex.RefStart = simd.and<1>(temp3, temp6);
    147                 var BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
    148                 var BitBlock temp8 = simd.andc<1>(temp7, temp1);
    149                 var BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
    150                 var BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
    151                 var BitBlock temp11 = simd.and<1>(temp9, temp10);
     284                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     285                BitBlock temp8 = simd.andc<1>(temp7, temp1);
     286                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     287                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     288                BitBlock temp11 = simd.and<1>(temp9, temp10);
    152289                lex.Semicolon = simd.and<1>(temp8, temp11);
    153                 var BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
    154                 var BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
    155                 var BitBlock temp14 = simd.andc<1>(temp12, temp13);
     290                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     291                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     292                BitBlock temp14 = simd.andc<1>(temp12, temp13);
    156293                lex.LAngle = simd.and<1>(temp8, temp14);
    157                 var BitBlock temp15 = simd.and<1>(temp12, temp5);
     294                BitBlock temp15 = simd.and<1>(temp12, temp5);
    158295                lex.RAngle = simd.and<1>(temp8, temp15);
    159                 var BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
    160                 var BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
    161                 var BitBlock temp18 = simd.and<1>(temp16, temp17);
     296                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     297                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     298                BitBlock temp18 = simd.and<1>(temp16, temp17);
    162299                lex.LBracket = simd.and<1>(temp18, temp11);
    163                 var BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
    164                 var BitBlock temp20 = simd.and<1>(temp12, temp19);
     300                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     301                BitBlock temp20 = simd.and<1>(temp12, temp19);
    165302                lex.RBracket = simd.and<1>(temp18, temp20);
    166                 var BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
    167                 var BitBlock temp22 = simd.andc<1>(temp19, temp21);
     303                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     304                BitBlock temp22 = simd.andc<1>(temp19, temp21);
    168305                lex.Exclam = simd.and<1>(temp3, temp22);
    169                 var BitBlock temp23 = simd.and<1>(temp12, temp10);
     306                BitBlock temp23 = simd.and<1>(temp12, temp10);
    170307                lex.QMark = simd.and<1>(temp8, temp23);
    171308                lex.Hyphen = simd.and<1>(temp3, temp20);
    172309                lex.Equals = simd.and<1>(temp8, temp20);
    173                 var BitBlock temp24 = simd.and<1>(temp4, temp10);
     310                BitBlock temp24 = simd.and<1>(temp4, temp10);
    174311                lex.SQuote = simd.and<1>(temp3, temp24);
    175                 var BitBlock temp25 = simd.andc<1>(temp5, temp21);
     312                BitBlock temp25 = simd.andc<1>(temp5, temp21);
    176313                lex.DQuote = simd.and<1>(temp3, temp25);
    177314                lex.Slash = simd.and<1>(temp3, temp23);
    178                 var BitBlock temp26 = simd.andc<1>(temp10, temp21);
     315                BitBlock temp26 = simd.andc<1>(temp10, temp21);
    179316                lex.Hash = simd.and<1>(temp3, temp26);
    180                 var BitBlock temp27 = simd.and<1>(temp16, temp7);
    181                 var BitBlock temp28 = simd.andc<1>(temp9, temp13);
     317                BitBlock temp27 = simd.and<1>(temp16, temp7);
     318                BitBlock temp28 = simd.andc<1>(temp9, temp13);
    182319                lex.x = simd.and<1>(temp27, temp28);
    183                 var BitBlock temp29 = simd.and<1>(temp9, temp5);
     320                BitBlock temp29 = simd.and<1>(temp9, temp5);
    184321                lex.Colon = simd.and<1>(temp8, temp29);
    185                 var BitBlock temp30 = simd.and<1>(temp18, temp23);
    186                 var BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
    187                 var BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
    188                 var BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
    189                 var BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
    190                 var BitBlock temp35 = simd.not<1>(temp34);
    191                 var BitBlock temp36 = simd.or<1>(temp21, temp13);
    192                 var BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
    193                 var BitBlock temp38 = simd.and<1>(temp32, temp37);
    194                 var BitBlock temp39 = simd.or<1>(temp31, temp38);
    195                 var BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
    196                 var BitBlock temp41 = simd.and<1>(temp40, temp37);
     322                BitBlock temp30 = simd.and<1>(temp18, temp23);
     323                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     324                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     325                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     326                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     327                BitBlock temp35 = simd.not<1>(temp34);
     328                BitBlock temp36 = simd.or<1>(temp21, temp13);
     329                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     330                BitBlock temp38 = simd.and<1>(temp32, temp37);
     331                BitBlock temp39 = simd.or<1>(temp31, temp38);
     332                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     333                BitBlock temp41 = simd.and<1>(temp40, temp37);
    197334                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
    198                 var BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
    199                 var BitBlock temp43 = simd.and<1>(temp3, temp15);
    200                 var BitBlock temp44 = simd.or<1>(temp42, temp43);
    201                 var BitBlock temp45 = simd.andc<1>(temp8, temp34);
    202                 var BitBlock temp46 = simd.or<1>(temp44, temp45);
    203                 var BitBlock temp47 = simd.or<1>(temp46, temp38);
     335                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     336                BitBlock temp43 = simd.and<1>(temp3, temp15);
     337                BitBlock temp44 = simd.or<1>(temp42, temp43);
     338                BitBlock temp45 = simd.andc<1>(temp8, temp34);
     339                BitBlock temp46 = simd.or<1>(temp44, temp45);
     340                BitBlock temp47 = simd.or<1>(temp46, temp38);
    204341                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
    205342                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
    206                 var BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
    207                 var BitBlock x00_x1F = simd.not<1>(temp48);
    208                 var BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
    209                 var BitBlock temp50 = simd.or<1>(temp1, temp49);
     343                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     344                BitBlock x00_x1F = simd.not<1>(temp48);
     345                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     346                BitBlock temp50 = simd.or<1>(temp1, temp49);
    210347                lex.CR = simd.andc<1>(temp20, temp50);
    211348                lex.LF = simd.andc<1>(temp29, temp50);
    212                 var BitBlock temp51 = simd.and<1>(temp9, temp19);
     349                BitBlock temp51 = simd.and<1>(temp9, temp19);
    213350                lex.HT = simd.andc<1>(temp51, temp50);
    214351                lex.SP = simd.andc<1>(temp3, temp36);
    215                 var BitBlock temp52 = simd.or<1>(temp20, temp29);
    216                 var BitBlock temp53 = simd.or<1>(temp52, temp51);
    217                 var BitBlock temp54 = simd.andc<1>(temp53, temp50);
     352                BitBlock temp52 = simd.or<1>(temp20, temp29);
     353                BitBlock temp53 = simd.or<1>(temp52, temp51);
     354                BitBlock temp54 = simd.andc<1>(temp53, temp50);
    218355                lex.WS = simd.or<1>(temp54, lex.SP);
    219                 var BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
    220                 var BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     356                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     357                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
    221358                lex.Digit = simd.andc<1>(temp8, temp56);
    222                 var BitBlock temp57 = simd.andc<1>(temp16, temp49);
    223                 var BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
    224                 var BitBlock temp59 = simd.not<1>(temp10);
    225                 var BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
    226                 var BitBlock temp61 = simd.and<1>(temp58, temp60);
    227                 var BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
    228                 var BitBlock temp63 = simd.and<1>(temp16, temp2);
    229                 var BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
    230                 var BitBlock temp65 = simd.and<1>(temp64, temp60);
     359                BitBlock temp57 = simd.andc<1>(temp16, temp49);
     360                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     361                BitBlock temp59 = simd.not<1>(temp10);
     362                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     363                BitBlock temp61 = simd.and<1>(temp58, temp60);
     364                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     365                BitBlock temp63 = simd.and<1>(temp16, temp2);
     366                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     367                BitBlock temp65 = simd.and<1>(temp64, temp60);
    231368                lex.Hex = simd.or<1>(temp62, temp65);
    232                 var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     369                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    233370
    234371                if (bitblock.any<1>((lex_error)))
     
    238375                u8.unibyte = simd.not<1>(basis_bits.bit_0);
    239376                u8.suffix = simd.constant<1>(0);
    240                 var BitBlock u8_error = simd.constant<1>(0);
    241                 var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    242                 var BitBlock u8anyscope = simd.constant<1>(0);
     377                BitBlock u8_error = simd.constant<1>(0);
     378                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     379                BitBlock u8anyscope = simd.constant<1>(0);
    243380                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    244381                {
     
    248385                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
    249386                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
    250                         var BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
    251                         var BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
    252                         var BitBlock temp68 = simd.andc<1>(temp66, temp67);
    253                         var BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
    254                         var BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
    255                         var BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     387                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     388                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     389                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
     390                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     391                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     392                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
    256393                        u8.badprefix = simd.or<1>(temp68, temp71);
    257394                        u8_error = u8.badprefix;
     
    260397                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    261398                        {
    262                                 var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
    263                                 var BitBlock xED = simd.and<1>(u8.prefix3, temp20);
    264                                 var BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
    265                                 var BitBlock temp72 = simd.andc<1>(temp4, temp13);
    266                                 var BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     399                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     400                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     401                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     402                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
     403                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
    267404                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
    268405                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
    269406                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
    270407                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
    271                                 var BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
    272                                 var BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     408                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     409                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
    273410                                u8.xBF = simd.and<1>(temp73, temp23);
    274411                                u8.xBE = simd.and<1>(temp73, temp15);
     
    278415                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    279416                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    280                                 var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
    281                                 var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
     417                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     418                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    282419                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    283420                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     
    285422                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    286423                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    287                                 var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     424                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    288425                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    289                                 var BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
    290                                 var BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
    291                                 var BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
    292                                 var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     426                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     427                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     428                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     429                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    293430                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    294                                 var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     431                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
    295432                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    296433                        }
     
    299436                                carry_set_0.CarryDequeueEnqueue(1, 9);
    300437                        }
    301                         var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     438                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    302439                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    303440                        {
     
    314451
    315452        function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask) {
    316                 var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    317                 var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
    318                 var BitBlock temp3 = simd.andc<1>(temp2, temp1);
    319                 var BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
    320                 var BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
    321                 var BitBlock temp6 = simd.and<1>(temp4, temp5);
     453                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     454                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     455                BitBlock temp3 = simd.andc<1>(temp2, temp1);
     456                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     457                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     458                BitBlock temp6 = simd.and<1>(temp4, temp5);
    322459                lex.RefStart = simd.and<1>(temp3, temp6);
    323                 var BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
    324                 var BitBlock temp8 = simd.andc<1>(temp7, temp1);
    325                 var BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
    326                 var BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
    327                 var BitBlock temp11 = simd.and<1>(temp9, temp10);
     460                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     461                BitBlock temp8 = simd.andc<1>(temp7, temp1);
     462                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     463                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     464                BitBlock temp11 = simd.and<1>(temp9, temp10);
    328465                lex.Semicolon = simd.and<1>(temp8, temp11);
    329                 var BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
    330                 var BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
    331                 var BitBlock temp14 = simd.andc<1>(temp12, temp13);
     466                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     467                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     468                BitBlock temp14 = simd.andc<1>(temp12, temp13);
    332469                lex.LAngle = simd.and<1>(temp8, temp14);
    333                 var BitBlock temp15 = simd.and<1>(temp12, temp5);
     470                BitBlock temp15 = simd.and<1>(temp12, temp5);
    334471                lex.RAngle = simd.and<1>(temp8, temp15);
    335                 var BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
    336                 var BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
    337                 var BitBlock temp18 = simd.and<1>(temp16, temp17);
     472                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     473                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     474                BitBlock temp18 = simd.and<1>(temp16, temp17);
    338475                lex.LBracket = simd.and<1>(temp18, temp11);
    339                 var BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
    340                 var BitBlock temp20 = simd.and<1>(temp12, temp19);
     476                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     477                BitBlock temp20 = simd.and<1>(temp12, temp19);
    341478                lex.RBracket = simd.and<1>(temp18, temp20);
    342                 var BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
    343                 var BitBlock temp22 = simd.andc<1>(temp19, temp21);
     479                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     480                BitBlock temp22 = simd.andc<1>(temp19, temp21);
    344481                lex.Exclam = simd.and<1>(temp3, temp22);
    345                 var BitBlock temp23 = simd.and<1>(temp12, temp10);
     482                BitBlock temp23 = simd.and<1>(temp12, temp10);
    346483                lex.QMark = simd.and<1>(temp8, temp23);
    347484                lex.Hyphen = simd.and<1>(temp3, temp20);
    348485                lex.Equals = simd.and<1>(temp8, temp20);
    349                 var BitBlock temp24 = simd.and<1>(temp4, temp10);
     486                BitBlock temp24 = simd.and<1>(temp4, temp10);
    350487                lex.SQuote = simd.and<1>(temp3, temp24);
    351                 var BitBlock temp25 = simd.andc<1>(temp5, temp21);
     488                BitBlock temp25 = simd.andc<1>(temp5, temp21);
    352489                lex.DQuote = simd.and<1>(temp3, temp25);
    353490                lex.Slash = simd.and<1>(temp3, temp23);
    354                 var BitBlock temp26 = simd.andc<1>(temp10, temp21);
     491                BitBlock temp26 = simd.andc<1>(temp10, temp21);
    355492                lex.Hash = simd.and<1>(temp3, temp26);
    356                 var BitBlock temp27 = simd.and<1>(temp16, temp7);
    357                 var BitBlock temp28 = simd.andc<1>(temp9, temp13);
     493                BitBlock temp27 = simd.and<1>(temp16, temp7);
     494                BitBlock temp28 = simd.andc<1>(temp9, temp13);
    358495                lex.x = simd.and<1>(temp27, temp28);
    359                 var BitBlock temp29 = simd.and<1>(temp9, temp5);
     496                BitBlock temp29 = simd.and<1>(temp9, temp5);
    360497                lex.Colon = simd.and<1>(temp8, temp29);
    361                 var BitBlock temp30 = simd.and<1>(temp18, temp23);
    362                 var BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
    363                 var BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
    364                 var BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
    365                 var BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
    366                 var BitBlock temp35 = simd.not<1>(temp34);
    367                 var BitBlock temp36 = simd.or<1>(temp21, temp13);
    368                 var BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
    369                 var BitBlock temp38 = simd.and<1>(temp32, temp37);
    370                 var BitBlock temp39 = simd.or<1>(temp31, temp38);
    371                 var BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
    372                 var BitBlock temp41 = simd.and<1>(temp40, temp37);
     498                BitBlock temp30 = simd.and<1>(temp18, temp23);
     499                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     500                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     501                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     502                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     503                BitBlock temp35 = simd.not<1>(temp34);
     504                BitBlock temp36 = simd.or<1>(temp21, temp13);
     505                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     506                BitBlock temp38 = simd.and<1>(temp32, temp37);
     507                BitBlock temp39 = simd.or<1>(temp31, temp38);
     508                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     509                BitBlock temp41 = simd.and<1>(temp40, temp37);
    373510                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
    374                 var BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
    375                 var BitBlock temp43 = simd.and<1>(temp3, temp15);
    376                 var BitBlock temp44 = simd.or<1>(temp42, temp43);
    377                 var BitBlock temp45 = simd.andc<1>(temp8, temp34);
    378                 var BitBlock temp46 = simd.or<1>(temp44, temp45);
    379                 var BitBlock temp47 = simd.or<1>(temp46, temp38);
     511                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     512                BitBlock temp43 = simd.and<1>(temp3, temp15);
     513                BitBlock temp44 = simd.or<1>(temp42, temp43);
     514                BitBlock temp45 = simd.andc<1>(temp8, temp34);
     515                BitBlock temp46 = simd.or<1>(temp44, temp45);
     516                BitBlock temp47 = simd.or<1>(temp46, temp38);
    380517                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
    381518                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
    382                 var BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
    383                 var BitBlock x00_x1F = simd.not<1>(temp48);
    384                 var BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
    385                 var BitBlock temp50 = simd.or<1>(temp1, temp49);
     519                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     520                BitBlock x00_x1F = simd.not<1>(temp48);
     521                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     522                BitBlock temp50 = simd.or<1>(temp1, temp49);
    386523                lex.CR = simd.andc<1>(temp20, temp50);
    387524                lex.LF = simd.andc<1>(temp29, temp50);
    388                 var BitBlock temp51 = simd.and<1>(temp9, temp19);
     525                BitBlock temp51 = simd.and<1>(temp9, temp19);
    389526                lex.HT = simd.andc<1>(temp51, temp50);
    390527                lex.SP = simd.andc<1>(temp3, temp36);
    391                 var BitBlock temp52 = simd.or<1>(temp20, temp29);
    392                 var BitBlock temp53 = simd.or<1>(temp52, temp51);
    393                 var BitBlock temp54 = simd.andc<1>(temp53, temp50);
     528                BitBlock temp52 = simd.or<1>(temp20, temp29);
     529                BitBlock temp53 = simd.or<1>(temp52, temp51);
     530                BitBlock temp54 = simd.andc<1>(temp53, temp50);
    394531                lex.WS = simd.or<1>(temp54, lex.SP);
    395                 var BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
    396                 var BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     532                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     533                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
    397534                lex.Digit = simd.andc<1>(temp8, temp56);
    398                 var BitBlock temp57 = simd.andc<1>(temp16, temp49);
    399                 var BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
    400                 var BitBlock temp59 = simd.not<1>(temp10);
    401                 var BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
    402                 var BitBlock temp61 = simd.and<1>(temp58, temp60);
    403                 var BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
    404                 var BitBlock temp63 = simd.and<1>(temp16, temp2);
    405                 var BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
    406                 var BitBlock temp65 = simd.and<1>(temp64, temp60);
     535                BitBlock temp57 = simd.andc<1>(temp16, temp49);
     536                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     537                BitBlock temp59 = simd.not<1>(temp10);
     538                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     539                BitBlock temp61 = simd.and<1>(temp58, temp60);
     540                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     541                BitBlock temp63 = simd.and<1>(temp16, temp2);
     542                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     543                BitBlock temp65 = simd.and<1>(temp64, temp60);
    407544                lex.Hex = simd.or<1>(temp62, temp65);
    408                 var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     545                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    409546                if (bitblock.any<1>((simd.and<1>(lex_error, EOF_mask))))
    410547                {
     
    413550                u8.unibyte = simd.not<1>(basis_bits.bit_0);
    414551                u8.suffix = simd.constant<1>(0);
    415                 var BitBlock u8_error = simd.constant<1>(0);
    416                 var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    417                 var BitBlock u8anyscope = simd.constant<1>(0);
     552                BitBlock u8_error = simd.constant<1>(0);
     553                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     554                BitBlock u8anyscope = simd.constant<1>(0);
    418555                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    419556                {
     
    423560                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
    424561                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
    425                         var BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
    426                         var BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
    427                         var BitBlock temp68 = simd.andc<1>(temp66, temp67);
    428                         var BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
    429                         var BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
    430                         var BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     562                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     563                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     564                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
     565                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     566                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     567                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
    431568                        u8.badprefix = simd.or<1>(temp68, temp71);
    432569                        u8_error = u8.badprefix;
     
    435572                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    436573                        {
    437                                 var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
    438                                 var BitBlock xED = simd.and<1>(u8.prefix3, temp20);
    439                                 var BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
    440                                 var BitBlock temp72 = simd.andc<1>(temp4, temp13);
    441                                 var BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     574                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     575                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     576                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     577                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
     578                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
    442579                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
    443580                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
    444581                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
    445582                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
    446                                 var BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
    447                                 var BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     583                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     584                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
    448585                                u8.xBF = simd.and<1>(temp73, temp23);
    449586                                u8.xBE = simd.and<1>(temp73, temp15);
     
    453590                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    454591                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    455                                 var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
    456                                 var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
     592                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     593                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    457594                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    458595                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     
    460597                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    461598                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    462                                 var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     599                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    463600                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    464                                 var BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
    465                                 var BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
    466                                 var BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
    467                                 var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     601                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     602                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     603                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     604                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    468605                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    469                                 var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     606                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
    470607                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    471608                        }
     
    474611                                carry_set_0.CarryDequeueEnqueue(1, 9);
    475612                        }
    476                         var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     613                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    477614                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    478615                        {
     
    503640                ref_Callouts.HexRef_starts = simd.constant<1>(0);
    504641                ref_Callouts.HexRef_ends = simd.constant<1>(0);
    505                 var BitBlock ref_error = simd.constant<1>(0);
     642                BitBlock ref_error = simd.constant<1>(0);
    506643                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
    507644                {
    508                         var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    509                         var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     645                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     646                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    510647                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    511                         var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    512                         var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     648                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     649                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    513650                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    514651                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     
    516653                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    517654                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    518                         var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    519                         var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    520                         var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    521                         var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     655                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     656                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     657                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     658                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    522659                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    523660                        {
     
    540677                ref_Callouts.HexRef_starts = simd.constant<1>(0);
    541678                ref_Callouts.HexRef_ends = simd.constant<1>(0);
    542                 var BitBlock ref_error = simd.constant<1>(0);
     679                BitBlock ref_error = simd.constant<1>(0);
    543680                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
    544681                {
    545                         var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    546                         var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     682                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     683                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    547684                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    548                         var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    549                         var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     685                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     686                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    550687                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    551688                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     
    553690                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    554691                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    555                         var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    556                         var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    557                         var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    558                         var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     692                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     693                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     694                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     695                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    559696                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    560697                        {
     
    580717        function 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)
    581718        {
    582                 var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
    583                 var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    584                 var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    585                 var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    586                 var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    587                 var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    588                 var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    589                 var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    590                 var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    591                 var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    592                 var BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
    593                 var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    594                 var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    595                 var BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
    596                 var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     719                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     720                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     721                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     722                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     723                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     724                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     725                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     726                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     727                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     728                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     729                BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     730                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     731                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     732                BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     733                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    597734                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    598735                {
     
    606743        function 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)
    607744        {
    608                 var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
    609                 var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    610                 var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    611                 var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    612                 var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    613                 var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    614                 var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    615                 var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    616                 var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    617                 var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    618                 var BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
    619                 var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    620                 var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    621                 var BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
    622                 var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     745                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     746                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     747                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     748                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     749                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     750                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     751                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     752                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     753                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     754                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     755                BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     756                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     757                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     758                BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     759                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    623760                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    624761                {
     
    664801};
    665802
     803*/// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
     804       
     805struct Basis_bits
     806{
     807        BitBlock bit_0;
     808        BitBlock bit_1;
     809        BitBlock bit_2;
     810        BitBlock bit_3;
     811        BitBlock bit_4;
     812        BitBlock bit_5;
     813        BitBlock bit_6;
     814        BitBlock bit_7;
     815};
     816 
     817struct U8
     818{
     819        BitBlock unibyte;
     820        BitBlock prefix;
     821        BitBlock prefix2;
     822        BitBlock prefix3;
     823        BitBlock prefix4;
     824        BitBlock suffix;
     825        BitBlock badprefix;
     826        BitBlock xE0;
     827        BitBlock xED;
     828        BitBlock xF0;
     829        BitBlock xF4;
     830        BitBlock xA0_xBF;
     831        BitBlock x80_x9F;
     832        BitBlock x90_xBF;
     833        BitBlock x80_x8F;
     834        BitBlock xEF;
     835        BitBlock xBF;
     836        BitBlock xBE;
     837        BitBlock scope22;
     838        BitBlock scope32;
     839        BitBlock scope33;
     840        BitBlock scope42;
     841        BitBlock scope43;
     842        BitBlock scope44;
     843        BitBlock xE0_scope;
     844        BitBlock xED_scope;
     845        BitBlock xF0_scope;
     846        BitBlock xF4_scope;
     847        BitBlock xEF_scope;
     848};
     849 
     850struct Lex
     851{
     852        BitBlock CR;
     853        BitBlock LF;
     854        BitBlock HT;
     855        BitBlock SP;
     856        BitBlock CRLF;
     857        BitBlock RefStart;
     858        BitBlock Semicolon;
     859        BitBlock Colon;
     860        BitBlock LAngle;
     861        BitBlock RAngle;
     862        BitBlock LBracket;
     863        BitBlock RBracket;
     864        BitBlock Exclam;
     865        BitBlock QMark;
     866        BitBlock Hyphen;
     867        BitBlock Equals;
     868        BitBlock SQuote;
     869        BitBlock DQuote;
     870        BitBlock Slash;
     871        BitBlock Hash;
     872        BitBlock x;
     873        BitBlock ASCII_name_start;
     874        BitBlock ASCII_name_char;
     875        BitBlock NameScan;
     876        BitBlock Digit;
     877        BitBlock Hex;
     878        BitBlock WS;
     879};
     880 
     881struct Marker
     882{
     883        BitBlock LAngle_scope;
     884        BitBlock Ref_opener;
     885        BitBlock CD_closer;
     886};
     887 
     888struct CtCDPI_Callouts
     889{
     890        BitBlock Ct_starts;
     891        BitBlock Ct_ends;
     892        BitBlock CD_starts;
     893        BitBlock CD_ends;
     894        BitBlock PI_starts;
     895        BitBlock PI_name_starts;
     896        BitBlock PI_name_ends;
     897        BitBlock PI_ends;
     898};
     899 
     900struct Ref_Callouts
     901{
     902        BitBlock GenRef_starts;
     903        BitBlock GenRef_ends;
     904        BitBlock DecRef_starts;
     905        BitBlock DecRef_ends;
     906        BitBlock HexRef_starts;
     907        BitBlock HexRef_ends;
     908};
     909 
     910struct Tag_Callouts
     911{
     912        BitBlock ElemName_starts;
     913        BitBlock ElemName_ends;
     914        BitBlock AttName_starts;
     915        BitBlock AttName_ends;
     916        BitBlock AttVal_starts;
     917        BitBlock AttVal_ends;
     918        BitBlock AttVal_spans;
     919        BitBlock EmptyTag_marks;
     920        BitBlock EndTag_marks;
     921};
     922 
     923struct Check_streams
     924{
     925        BitBlock misc_mask;
     926        BitBlock non_ascii_name_starts;
     927        BitBlock non_ascii_names;
     928        BitBlock tag_marks;
     929        BitBlock name_follows;
     930        BitBlock att_refs;
     931};     
     932               
     933kernel Classify_bytes_Validate_utf8 
     934{
     935        init
     936        {
     937         
     938        }
     939
     940        function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
     941        {
     942                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     943                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     944                BitBlock temp3 = simd.andc<1>(temp2, temp1);
     945                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     946                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     947                BitBlock temp6 = simd.and<1>(temp4, temp5);
     948                lex.RefStart = simd.and<1>(temp3, temp6);
     949                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     950                BitBlock temp8 = simd.andc<1>(temp7, temp1);
     951                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     952                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     953                BitBlock temp11 = simd.and<1>(temp9, temp10);
     954                lex.Semicolon = simd.and<1>(temp8, temp11);
     955                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     956                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     957                BitBlock temp14 = simd.andc<1>(temp12, temp13);
     958                lex.LAngle = simd.and<1>(temp8, temp14);
     959                BitBlock temp15 = simd.and<1>(temp12, temp5);
     960                lex.RAngle = simd.and<1>(temp8, temp15);
     961                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     962                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     963                BitBlock temp18 = simd.and<1>(temp16, temp17);
     964                lex.LBracket = simd.and<1>(temp18, temp11);
     965                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     966                BitBlock temp20 = simd.and<1>(temp12, temp19);
     967                lex.RBracket = simd.and<1>(temp18, temp20);
     968                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     969                BitBlock temp22 = simd.andc<1>(temp19, temp21);
     970                lex.Exclam = simd.and<1>(temp3, temp22);
     971                BitBlock temp23 = simd.and<1>(temp12, temp10);
     972                lex.QMark = simd.and<1>(temp8, temp23);
     973                lex.Hyphen = simd.and<1>(temp3, temp20);
     974                lex.Equals = simd.and<1>(temp8, temp20);
     975                BitBlock temp24 = simd.and<1>(temp4, temp10);
     976                lex.SQuote = simd.and<1>(temp3, temp24);
     977                BitBlock temp25 = simd.andc<1>(temp5, temp21);
     978                lex.DQuote = simd.and<1>(temp3, temp25);
     979                lex.Slash = simd.and<1>(temp3, temp23);
     980                BitBlock temp26 = simd.andc<1>(temp10, temp21);
     981                lex.Hash = simd.and<1>(temp3, temp26);
     982                BitBlock temp27 = simd.and<1>(temp16, temp7);
     983                BitBlock temp28 = simd.andc<1>(temp9, temp13);
     984                lex.x = simd.and<1>(temp27, temp28);
     985                BitBlock temp29 = simd.and<1>(temp9, temp5);
     986                lex.Colon = simd.and<1>(temp8, temp29);
     987                BitBlock temp30 = simd.and<1>(temp18, temp23);
     988                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     989                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     990                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     991                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     992                BitBlock temp35 = simd.not<1>(temp34);
     993                BitBlock temp36 = simd.or<1>(temp21, temp13);
     994                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     995                BitBlock temp38 = simd.and<1>(temp32, temp37);
     996                BitBlock temp39 = simd.or<1>(temp31, temp38);
     997                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     998                BitBlock temp41 = simd.and<1>(temp40, temp37);
     999                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
     1000                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     1001                BitBlock temp43 = simd.and<1>(temp3, temp15);
     1002                BitBlock temp44 = simd.or<1>(temp42, temp43);
     1003                BitBlock temp45 = simd.andc<1>(temp8, temp34);
     1004                BitBlock temp46 = simd.or<1>(temp44, temp45);
     1005                BitBlock temp47 = simd.or<1>(temp46, temp38);
     1006                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
     1007                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
     1008                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     1009                BitBlock x00_x1F = simd.not<1>(temp48);
     1010                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     1011                BitBlock temp50 = simd.or<1>(temp1, temp49);
     1012                lex.CR = simd.andc<1>(temp20, temp50);
     1013                lex.LF = simd.andc<1>(temp29, temp50);
     1014                BitBlock temp51 = simd.and<1>(temp9, temp19);
     1015                lex.HT = simd.andc<1>(temp51, temp50);
     1016                lex.SP = simd.andc<1>(temp3, temp36);
     1017                BitBlock temp52 = simd.or<1>(temp20, temp29);
     1018                BitBlock temp53 = simd.or<1>(temp52, temp51);
     1019                BitBlock temp54 = simd.andc<1>(temp53, temp50);
     1020                lex.WS = simd.or<1>(temp54, lex.SP);
     1021                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     1022                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     1023                lex.Digit = simd.andc<1>(temp8, temp56);
     1024                BitBlock temp57 = simd.andc<1>(temp16, temp49);
     1025                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     1026                BitBlock temp59 = simd.not<1>(temp10);
     1027                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     1028                BitBlock temp61 = simd.and<1>(temp58, temp60);
     1029                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     1030                BitBlock temp63 = simd.and<1>(temp16, temp2);
     1031                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     1032                BitBlock temp65 = simd.and<1>(temp64, temp60);
     1033                lex.Hex = simd.or<1>(temp62, temp65);
     1034                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     1035
     1036                if (bitblock.any<1>((lex_error)))
     1037                {
     1038                        assert_0_error("Error: illegal character", lex_error);
     1039                }
     1040                u8.unibyte = simd.not<1>(basis_bits.bit_0);
     1041                u8.suffix = simd.constant<1>(0);
     1042                BitBlock u8_error = simd.constant<1>(0);
     1043                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     1044                BitBlock u8anyscope = simd.constant<1>(0);
     1045                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
     1046                {
     1047                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
     1048                        u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
     1049                        u8.prefix3 = simd.and<1>(u8.prefix, temp2);
     1050                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
     1051                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
     1052                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     1053                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     1054                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
     1055                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     1056                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     1057                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     1058                        u8.badprefix = simd.or<1>(temp68, temp71);
     1059                        u8_error = u8.badprefix;
     1060                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
     1061                        u8anyscope = u8.scope22;
     1062                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
     1063                        {
     1064                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     1065                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     1066                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     1067                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
     1068                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     1069                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
     1070                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
     1071                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
     1072                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
     1073                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     1074                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     1075                                u8.xBF = simd.and<1>(temp73, temp23);
     1076                                u8.xBE = simd.and<1>(temp73, temp15);
     1077                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
     1078                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
     1079                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
     1080                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
     1081                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
     1082                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     1083                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
     1084                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
     1085                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     1086                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
     1087                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
     1088                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
     1089                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     1090                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     1091                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     1092                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     1093                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     1094                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     1095                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
     1096                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     1097                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
     1098                        }
     1099                        else
     1100                        {
     1101                                carry_set_0.CarryDequeueEnqueue(1, 9);
     1102                        }
     1103                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     1104                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
     1105                        {
     1106                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
     1107                        }
     1108                }
     1109                else
     1110                {
     1111                        carry_set_0.CarryDequeueEnqueue(0, 10);
     1112                }
     1113                carry_set_0.CarryAdjust(10);
     1114
     1115        }
     1116
     1117        function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask) {
     1118                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     1119                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     1120                BitBlock temp3 = simd.andc<1>(temp2, temp1);
     1121                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     1122                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     1123                BitBlock temp6 = simd.and<1>(temp4, temp5);
     1124                lex.RefStart = simd.and<1>(temp3, temp6);
     1125                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     1126                BitBlock temp8 = simd.andc<1>(temp7, temp1);
     1127                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     1128                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     1129                BitBlock temp11 = simd.and<1>(temp9, temp10);
     1130                lex.Semicolon = simd.and<1>(temp8, temp11);
     1131                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     1132                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     1133                BitBlock temp14 = simd.andc<1>(temp12, temp13);
     1134                lex.LAngle = simd.and<1>(temp8, temp14);
     1135                BitBlock temp15 = simd.and<1>(temp12, temp5);
     1136                lex.RAngle = simd.and<1>(temp8, temp15);
     1137                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     1138                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     1139                BitBlock temp18 = simd.and<1>(temp16, temp17);
     1140                lex.LBracket = simd.and<1>(temp18, temp11);
     1141                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     1142                BitBlock temp20 = simd.and<1>(temp12, temp19);
     1143                lex.RBracket = simd.and<1>(temp18, temp20);
     1144                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     1145                BitBlock temp22 = simd.andc<1>(temp19, temp21);
     1146                lex.Exclam = simd.and<1>(temp3, temp22);
     1147                BitBlock temp23 = simd.and<1>(temp12, temp10);
     1148                lex.QMark = simd.and<1>(temp8, temp23);
     1149                lex.Hyphen = simd.and<1>(temp3, temp20);
     1150                lex.Equals = simd.and<1>(temp8, temp20);
     1151                BitBlock temp24 = simd.and<1>(temp4, temp10);
     1152                lex.SQuote = simd.and<1>(temp3, temp24);
     1153                BitBlock temp25 = simd.andc<1>(temp5, temp21);
     1154                lex.DQuote = simd.and<1>(temp3, temp25);
     1155                lex.Slash = simd.and<1>(temp3, temp23);
     1156                BitBlock temp26 = simd.andc<1>(temp10, temp21);
     1157                lex.Hash = simd.and<1>(temp3, temp26);
     1158                BitBlock temp27 = simd.and<1>(temp16, temp7);
     1159                BitBlock temp28 = simd.andc<1>(temp9, temp13);
     1160                lex.x = simd.and<1>(temp27, temp28);
     1161                BitBlock temp29 = simd.and<1>(temp9, temp5);
     1162                lex.Colon = simd.and<1>(temp8, temp29);
     1163                BitBlock temp30 = simd.and<1>(temp18, temp23);
     1164                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     1165                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     1166                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     1167                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     1168                BitBlock temp35 = simd.not<1>(temp34);
     1169                BitBlock temp36 = simd.or<1>(temp21, temp13);
     1170                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     1171                BitBlock temp38 = simd.and<1>(temp32, temp37);
     1172                BitBlock temp39 = simd.or<1>(temp31, temp38);
     1173                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     1174                BitBlock temp41 = simd.and<1>(temp40, temp37);
     1175                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
     1176                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     1177                BitBlock temp43 = simd.and<1>(temp3, temp15);
     1178                BitBlock temp44 = simd.or<1>(temp42, temp43);
     1179                BitBlock temp45 = simd.andc<1>(temp8, temp34);
     1180                BitBlock temp46 = simd.or<1>(temp44, temp45);
     1181                BitBlock temp47 = simd.or<1>(temp46, temp38);
     1182                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
     1183                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
     1184                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     1185                BitBlock x00_x1F = simd.not<1>(temp48);
     1186                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     1187                BitBlock temp50 = simd.or<1>(temp1, temp49);
     1188                lex.CR = simd.andc<1>(temp20, temp50);
     1189                lex.LF = simd.andc<1>(temp29, temp50);
     1190                BitBlock temp51 = simd.and<1>(temp9, temp19);
     1191                lex.HT = simd.andc<1>(temp51, temp50);
     1192                lex.SP = simd.andc<1>(temp3, temp36);
     1193                BitBlock temp52 = simd.or<1>(temp20, temp29);
     1194                BitBlock temp53 = simd.or<1>(temp52, temp51);
     1195                BitBlock temp54 = simd.andc<1>(temp53, temp50);
     1196                lex.WS = simd.or<1>(temp54, lex.SP);
     1197                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     1198                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     1199                lex.Digit = simd.andc<1>(temp8, temp56);
     1200                BitBlock temp57 = simd.andc<1>(temp16, temp49);
     1201                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     1202                BitBlock temp59 = simd.not<1>(temp10);
     1203                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     1204                BitBlock temp61 = simd.and<1>(temp58, temp60);
     1205                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     1206                BitBlock temp63 = simd.and<1>(temp16, temp2);
     1207                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     1208                BitBlock temp65 = simd.and<1>(temp64, temp60);
     1209                lex.Hex = simd.or<1>(temp62, temp65);
     1210                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     1211                if (bitblock.any<1>((simd.and<1>(lex_error, EOF_mask))))
     1212                {
     1213                        assert_0_error("Error: illegal character", simd.and<1>(lex_error, EOF_mask));
     1214                }
     1215                u8.unibyte = simd.not<1>(basis_bits.bit_0);
     1216                u8.suffix = simd.constant<1>(0);
     1217                BitBlock u8_error = simd.constant<1>(0);
     1218                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     1219                BitBlock u8anyscope = simd.constant<1>(0);
     1220                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
     1221                {
     1222                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
     1223                        u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
     1224                        u8.prefix3 = simd.and<1>(u8.prefix, temp2);
     1225                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
     1226                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
     1227                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     1228                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     1229                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
     1230                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     1231                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     1232                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     1233                        u8.badprefix = simd.or<1>(temp68, temp71);
     1234                        u8_error = u8.badprefix;
     1235                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
     1236                        u8anyscope = u8.scope22;
     1237                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
     1238                        {
     1239                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     1240                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     1241                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     1242                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
     1243                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     1244                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
     1245                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
     1246                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
     1247                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
     1248                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     1249                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     1250                                u8.xBF = simd.and<1>(temp73, temp23);
     1251                                u8.xBE = simd.and<1>(temp73, temp15);
     1252                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
     1253                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
     1254                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
     1255                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
     1256                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
     1257                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     1258                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
     1259                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
     1260                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     1261                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
     1262                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
     1263                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
     1264                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     1265                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     1266                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     1267                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     1268                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     1269                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     1270                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
     1271                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     1272                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
     1273                        }
     1274                        else
     1275                        {
     1276                                carry_set_0.CarryDequeueEnqueue(1, 9);
     1277                        }
     1278                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     1279                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
     1280                        {
     1281                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
     1282                        }
     1283                }
     1284                else
     1285                {
     1286                        carry_set_0.CarryDequeueEnqueue(0, 10);
     1287                }       
     1288        }
     1289        CarryDeclare(carry_set_0, 10, 0);       
     1290};     
     1291
     1292kernel Parse_refs
     1293{
     1294        init
     1295        {
     1296               
     1297        }
     1298         
     1299        function void do_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts)
     1300        {
     1301                ref_Callouts.GenRef_starts = simd.constant<1>(0);
     1302                ref_Callouts.GenRef_ends = simd.constant<1>(0);
     1303                ref_Callouts.DecRef_starts = simd.constant<1>(0);
     1304                ref_Callouts.DecRef_ends = simd.constant<1>(0);
     1305                ref_Callouts.HexRef_starts = simd.constant<1>(0);
     1306                ref_Callouts.HexRef_ends = simd.constant<1>(0);
     1307                BitBlock ref_error = simd.constant<1>(0);
     1308                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
     1309                {
     1310                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     1311                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     1312                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
     1313                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     1314                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     1315                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
     1316                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     1317                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
     1318                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
     1319                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
     1320                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     1321                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     1322                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     1323                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     1324                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
     1325                        {
     1326                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
     1327                        }
     1328                }
     1329                else
     1330                {
     1331                        carry_set_0.CarryDequeueEnqueue(0, 6);
     1332                }
     1333                carry_set_0.CarryAdjust(6);
     1334        }
     1335       
     1336        function void do_final_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts, BitBlock EOF_mask)
     1337        {
     1338                ref_Callouts.GenRef_starts = simd.constant<1>(0);
     1339                ref_Callouts.GenRef_ends = simd.constant<1>(0);
     1340                ref_Callouts.DecRef_starts = simd.constant<1>(0);
     1341                ref_Callouts.DecRef_ends = simd.constant<1>(0);
     1342                ref_Callouts.HexRef_starts = simd.constant<1>(0);
     1343                ref_Callouts.HexRef_ends = simd.constant<1>(0);
     1344                BitBlock ref_error = simd.constant<1>(0);
     1345                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
     1346                {
     1347                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     1348                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     1349                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
     1350                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     1351                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     1352                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
     1353                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     1354                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
     1355                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
     1356                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
     1357                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     1358                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     1359                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     1360                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     1361                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
     1362                        {
     1363                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
     1364                        }
     1365                }
     1366                else
     1367                {
     1368                        carry_set_0.CarryDequeueEnqueue(0, 6);
     1369                }
     1370        }
     1371       
     1372        CarryDeclare(carry_set_0, 6, 0);
     1373};
     1374
     1375kernel Validate_xml_names
     1376{
     1377        init
     1378        {
     1379               
     1380        }
     1381         
     1382        function 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)
     1383        {
     1384                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     1385                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     1386                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     1387                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     1388                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     1389                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     1390                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     1391                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     1392                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     1393                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     1394                BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     1395                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     1396                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     1397                BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     1398                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     1399                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
     1400                {
     1401                        assert_0_error("name syntax error", simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err));
     1402                }
     1403                check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
     1404                check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
     1405                carry_set_0.CarryAdjust(9);
     1406        }
     1407       
     1408        function 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)
     1409        {
     1410                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     1411                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     1412                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     1413                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     1414                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     1415                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     1416                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     1417                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     1418                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     1419                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     1420                BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     1421                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     1422                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     1423                BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     1424                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     1425                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
     1426                {
     1427                        assert_0_error("name syntax error", simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err));
     1428                }
     1429                check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
     1430                check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
     1431        }
     1432       
     1433        CarryDeclare(carry_set_0, 9, 0);
     1434};
     1435 
     1436kernel Do_check_streams
     1437{
     1438        init
     1439        {
     1440               
     1441        }
     1442         
     1443        function  void do_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams)
     1444        {
     1445                if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
     1446                {
     1447                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
     1448                }
     1449                check_streams.tag_marks = simd.or<1>(simd.or<1>(simd.or<1>(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
     1450                check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
     1451                check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
     1452        }
     1453       
     1454        function void do_final_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
     1455        {
     1456                if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
     1457                {
     1458                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
     1459                }
     1460                check_streams.tag_marks = simd.or<1>(simd.or<1>(simd.or<1>(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
     1461                check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
     1462                check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
     1463        }
     1464       
     1465        CarryDeclare(carry_set_0, 0, 0);
     1466};
  • proto/pabloj/branches/refactor-experimental/input/test/pabloB/proto/parabix2_pablo.pablob

    r3036 r3192  
    128128        BitBlock att_refs;
    129129};     
    130        
     130               
    131131kernel Classify_bytes_Validate_utf8 
    132132{
     
    138138        function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
    139139        {
    140                 var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    141                 var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
    142                 var BitBlock temp3 = simd.andc<1>(temp2, temp1);
    143                 var BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
    144                 var BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
    145                 var BitBlock temp6 = simd.and<1>(temp4, temp5);
     140                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     141                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     142                BitBlock temp3 = simd.andc<1>(temp2, temp1);
     143                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     144                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     145                BitBlock temp6 = simd.and<1>(temp4, temp5);
    146146                lex.RefStart = simd.and<1>(temp3, temp6);
    147                 var BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
    148                 var BitBlock temp8 = simd.andc<1>(temp7, temp1);
    149                 var BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
    150                 var BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
    151                 var BitBlock temp11 = simd.and<1>(temp9, temp10);
     147                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     148                BitBlock temp8 = simd.andc<1>(temp7, temp1);
     149                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     150                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     151                BitBlock temp11 = simd.and<1>(temp9, temp10);
    152152                lex.Semicolon = simd.and<1>(temp8, temp11);
    153                 var BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
    154                 var BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
    155                 var BitBlock temp14 = simd.andc<1>(temp12, temp13);
     153                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     154                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     155                BitBlock temp14 = simd.andc<1>(temp12, temp13);
    156156                lex.LAngle = simd.and<1>(temp8, temp14);
    157                 var BitBlock temp15 = simd.and<1>(temp12, temp5);
     157                BitBlock temp15 = simd.and<1>(temp12, temp5);
    158158                lex.RAngle = simd.and<1>(temp8, temp15);
    159                 var BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
    160                 var BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
    161                 var BitBlock temp18 = simd.and<1>(temp16, temp17);
     159                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     160                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     161                BitBlock temp18 = simd.and<1>(temp16, temp17);
    162162                lex.LBracket = simd.and<1>(temp18, temp11);
    163                 var BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
    164                 var BitBlock temp20 = simd.and<1>(temp12, temp19);
     163                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     164                BitBlock temp20 = simd.and<1>(temp12, temp19);
    165165                lex.RBracket = simd.and<1>(temp18, temp20);
    166                 var BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
    167                 var BitBlock temp22 = simd.andc<1>(temp19, temp21);
     166                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     167                BitBlock temp22 = simd.andc<1>(temp19, temp21);
    168168                lex.Exclam = simd.and<1>(temp3, temp22);
    169                 var BitBlock temp23 = simd.and<1>(temp12, temp10);
     169                BitBlock temp23 = simd.and<1>(temp12, temp10);
    170170                lex.QMark = simd.and<1>(temp8, temp23);
    171171                lex.Hyphen = simd.and<1>(temp3, temp20);
    172172                lex.Equals = simd.and<1>(temp8, temp20);
    173                 var BitBlock temp24 = simd.and<1>(temp4, temp10);
     173                BitBlock temp24 = simd.and<1>(temp4, temp10);
    174174                lex.SQuote = simd.and<1>(temp3, temp24);
    175                 var BitBlock temp25 = simd.andc<1>(temp5, temp21);
     175                BitBlock temp25 = simd.andc<1>(temp5, temp21);
    176176                lex.DQuote = simd.and<1>(temp3, temp25);
    177177                lex.Slash = simd.and<1>(temp3, temp23);
    178                 var BitBlock temp26 = simd.andc<1>(temp10, temp21);
     178                BitBlock temp26 = simd.andc<1>(temp10, temp21);
    179179                lex.Hash = simd.and<1>(temp3, temp26);
    180                 var BitBlock temp27 = simd.and<1>(temp16, temp7);
    181                 var BitBlock temp28 = simd.andc<1>(temp9, temp13);
     180                BitBlock temp27 = simd.and<1>(temp16, temp7);
     181                BitBlock temp28 = simd.andc<1>(temp9, temp13);
    182182                lex.x = simd.and<1>(temp27, temp28);
    183                 var BitBlock temp29 = simd.and<1>(temp9, temp5);
     183                BitBlock temp29 = simd.and<1>(temp9, temp5);
    184184                lex.Colon = simd.and<1>(temp8, temp29);
    185                 var BitBlock temp30 = simd.and<1>(temp18, temp23);
    186                 var BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
    187                 var BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
    188                 var BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
    189                 var BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
    190                 var BitBlock temp35 = simd.not<1>(temp34);
    191                 var BitBlock temp36 = simd.or<1>(temp21, temp13);
    192                 var BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
    193                 var BitBlock temp38 = simd.and<1>(temp32, temp37);
    194                 var BitBlock temp39 = simd.or<1>(temp31, temp38);
    195                 var BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
    196                 var BitBlock temp41 = simd.and<1>(temp40, temp37);
     185                BitBlock temp30 = simd.and<1>(temp18, temp23);
     186                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     187                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     188                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     189                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     190                BitBlock temp35 = simd.not<1>(temp34);
     191                BitBlock temp36 = simd.or<1>(temp21, temp13);
     192                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     193                BitBlock temp38 = simd.and<1>(temp32, temp37);
     194                BitBlock temp39 = simd.or<1>(temp31, temp38);
     195                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     196                BitBlock temp41 = simd.and<1>(temp40, temp37);
    197197                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
    198                 var BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
    199                 var BitBlock temp43 = simd.and<1>(temp3, temp15);
    200                 var BitBlock temp44 = simd.or<1>(temp42, temp43);
    201                 var BitBlock temp45 = simd.andc<1>(temp8, temp34);
    202                 var BitBlock temp46 = simd.or<1>(temp44, temp45);
    203                 var BitBlock temp47 = simd.or<1>(temp46, temp38);
     198                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     199                BitBlock temp43 = simd.and<1>(temp3, temp15);
     200                BitBlock temp44 = simd.or<1>(temp42, temp43);
     201                BitBlock temp45 = simd.andc<1>(temp8, temp34);
     202                BitBlock temp46 = simd.or<1>(temp44, temp45);
     203                BitBlock temp47 = simd.or<1>(temp46, temp38);
    204204                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
    205205                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
    206                 var BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
    207                 var BitBlock x00_x1F = simd.not<1>(temp48);
    208                 var BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
    209                 var BitBlock temp50 = simd.or<1>(temp1, temp49);
     206                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     207                BitBlock x00_x1F = simd.not<1>(temp48);
     208                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     209                BitBlock temp50 = simd.or<1>(temp1, temp49);
    210210                lex.CR = simd.andc<1>(temp20, temp50);
    211211                lex.LF = simd.andc<1>(temp29, temp50);
    212                 var BitBlock temp51 = simd.and<1>(temp9, temp19);
     212                BitBlock temp51 = simd.and<1>(temp9, temp19);
    213213                lex.HT = simd.andc<1>(temp51, temp50);
    214214                lex.SP = simd.andc<1>(temp3, temp36);
    215                 var BitBlock temp52 = simd.or<1>(temp20, temp29);
    216                 var BitBlock temp53 = simd.or<1>(temp52, temp51);
    217                 var BitBlock temp54 = simd.andc<1>(temp53, temp50);
     215                BitBlock temp52 = simd.or<1>(temp20, temp29);
     216                BitBlock temp53 = simd.or<1>(temp52, temp51);
     217                BitBlock temp54 = simd.andc<1>(temp53, temp50);
    218218                lex.WS = simd.or<1>(temp54, lex.SP);
    219                 var BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
    220                 var BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     219                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     220                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
    221221                lex.Digit = simd.andc<1>(temp8, temp56);
    222                 var BitBlock temp57 = simd.andc<1>(temp16, temp49);
    223                 var BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
    224                 var BitBlock temp59 = simd.not<1>(temp10);
    225                 var BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
    226                 var BitBlock temp61 = simd.and<1>(temp58, temp60);
    227                 var BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
    228                 var BitBlock temp63 = simd.and<1>(temp16, temp2);
    229                 var BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
    230                 var BitBlock temp65 = simd.and<1>(temp64, temp60);
     222                BitBlock temp57 = simd.andc<1>(temp16, temp49);
     223                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     224                BitBlock temp59 = simd.not<1>(temp10);
     225                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     226                BitBlock temp61 = simd.and<1>(temp58, temp60);
     227                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     228                BitBlock temp63 = simd.and<1>(temp16, temp2);
     229                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     230                BitBlock temp65 = simd.and<1>(temp64, temp60);
    231231                lex.Hex = simd.or<1>(temp62, temp65);
    232                 var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     232                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    233233
    234234                if (bitblock.any<1>((lex_error)))
     
    238238                u8.unibyte = simd.not<1>(basis_bits.bit_0);
    239239                u8.suffix = simd.constant<1>(0);
    240                 var BitBlock u8_error = simd.constant<1>(0);
    241                 var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    242                 var BitBlock u8anyscope = simd.constant<1>(0);
     240                BitBlock u8_error = simd.constant<1>(0);
     241                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     242                BitBlock u8anyscope = simd.constant<1>(0);
    243243                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    244244                {
     
    248248                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
    249249                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
    250                         var BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
    251                         var BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
    252                         var BitBlock temp68 = simd.andc<1>(temp66, temp67);
    253                         var BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
    254                         var BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
    255                         var BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     250                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     251                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     252                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
     253                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     254                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     255                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
    256256                        u8.badprefix = simd.or<1>(temp68, temp71);
    257257                        u8_error = u8.badprefix;
     
    260260                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    261261                        {
    262                                 var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
    263                                 var BitBlock xED = simd.and<1>(u8.prefix3, temp20);
    264                                 var BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
    265                                 var BitBlock temp72 = simd.andc<1>(temp4, temp13);
    266                                 var BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     262                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     263                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     264                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     265                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
     266                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
    267267                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
    268268                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
    269269                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
    270270                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
    271                                 var BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
    272                                 var BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     271                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     272                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
    273273                                u8.xBF = simd.and<1>(temp73, temp23);
    274274                                u8.xBE = simd.and<1>(temp73, temp15);
     
    278278                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    279279                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    280                                 var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
    281                                 var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
     280                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     281                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    282282                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    283283                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     
    285285                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    286286                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    287                                 var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     287                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    288288                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    289                                 var BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
    290                                 var BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
    291                                 var BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
    292                                 var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     289                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     290                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     291                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     292                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    293293                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    294                                 var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     294                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
    295295                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    296296                        }
     
    299299                                carry_set_0.CarryDequeueEnqueue(1, 9);
    300300                        }
    301                         var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     301                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    302302                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    303303                        {
     
    314314
    315315        function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask) {
    316                 var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    317                 var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
    318                 var BitBlock temp3 = simd.andc<1>(temp2, temp1);
    319                 var BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
    320                 var BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
    321                 var BitBlock temp6 = simd.and<1>(temp4, temp5);
     316                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     317                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     318                BitBlock temp3 = simd.andc<1>(temp2, temp1);
     319                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     320                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     321                BitBlock temp6 = simd.and<1>(temp4, temp5);
    322322                lex.RefStart = simd.and<1>(temp3, temp6);
    323                 var BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
    324                 var BitBlock temp8 = simd.andc<1>(temp7, temp1);
    325                 var BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
    326                 var BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
    327                 var BitBlock temp11 = simd.and<1>(temp9, temp10);
     323                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     324                BitBlock temp8 = simd.andc<1>(temp7, temp1);
     325                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     326                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     327                BitBlock temp11 = simd.and<1>(temp9, temp10);
    328328                lex.Semicolon = simd.and<1>(temp8, temp11);
    329                 var BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
    330                 var BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
    331                 var BitBlock temp14 = simd.andc<1>(temp12, temp13);
     329                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     330                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     331                BitBlock temp14 = simd.andc<1>(temp12, temp13);
    332332                lex.LAngle = simd.and<1>(temp8, temp14);
    333                 var BitBlock temp15 = simd.and<1>(temp12, temp5);
     333                BitBlock temp15 = simd.and<1>(temp12, temp5);
    334334                lex.RAngle = simd.and<1>(temp8, temp15);
    335                 var BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
    336                 var BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
    337                 var BitBlock temp18 = simd.and<1>(temp16, temp17);
     335                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     336                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     337                BitBlock temp18 = simd.and<1>(temp16, temp17);
    338338                lex.LBracket = simd.and<1>(temp18, temp11);
    339                 var BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
    340                 var BitBlock temp20 = simd.and<1>(temp12, temp19);
     339                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     340                BitBlock temp20 = simd.and<1>(temp12, temp19);
    341341                lex.RBracket = simd.and<1>(temp18, temp20);
    342                 var BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
    343                 var BitBlock temp22 = simd.andc<1>(temp19, temp21);
     342                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     343                BitBlock temp22 = simd.andc<1>(temp19, temp21);
    344344                lex.Exclam = simd.and<1>(temp3, temp22);
    345                 var BitBlock temp23 = simd.and<1>(temp12, temp10);
     345                BitBlock temp23 = simd.and<1>(temp12, temp10);
    346346                lex.QMark = simd.and<1>(temp8, temp23);
    347347                lex.Hyphen = simd.and<1>(temp3, temp20);
    348348                lex.Equals = simd.and<1>(temp8, temp20);
    349                 var BitBlock temp24 = simd.and<1>(temp4, temp10);
     349                BitBlock temp24 = simd.and<1>(temp4, temp10);
    350350                lex.SQuote = simd.and<1>(temp3, temp24);
    351                 var BitBlock temp25 = simd.andc<1>(temp5, temp21);
     351                BitBlock temp25 = simd.andc<1>(temp5, temp21);
    352352                lex.DQuote = simd.and<1>(temp3, temp25);
    353353                lex.Slash = simd.and<1>(temp3, temp23);
    354                 var BitBlock temp26 = simd.andc<1>(temp10, temp21);
     354                BitBlock temp26 = simd.andc<1>(temp10, temp21);
    355355                lex.Hash = simd.and<1>(temp3, temp26);
    356                 var BitBlock temp27 = simd.and<1>(temp16, temp7);
    357                 var BitBlock temp28 = simd.andc<1>(temp9, temp13);
     356                BitBlock temp27 = simd.and<1>(temp16, temp7);
     357                BitBlock temp28 = simd.andc<1>(temp9, temp13);
    358358                lex.x = simd.and<1>(temp27, temp28);
    359                 var BitBlock temp29 = simd.and<1>(temp9, temp5);
     359                BitBlock temp29 = simd.and<1>(temp9, temp5);
    360360                lex.Colon = simd.and<1>(temp8, temp29);
    361                 var BitBlock temp30 = simd.and<1>(temp18, temp23);
    362                 var BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
    363                 var BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
    364                 var BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
    365                 var BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
    366                 var BitBlock temp35 = simd.not<1>(temp34);
    367                 var BitBlock temp36 = simd.or<1>(temp21, temp13);
    368                 var BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
    369                 var BitBlock temp38 = simd.and<1>(temp32, temp37);
    370                 var BitBlock temp39 = simd.or<1>(temp31, temp38);
    371                 var BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
    372                 var BitBlock temp41 = simd.and<1>(temp40, temp37);
     361                BitBlock temp30 = simd.and<1>(temp18, temp23);
     362                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     363                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     364                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     365                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     366                BitBlock temp35 = simd.not<1>(temp34);
     367                BitBlock temp36 = simd.or<1>(temp21, temp13);
     368                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     369                BitBlock temp38 = simd.and<1>(temp32, temp37);
     370                BitBlock temp39 = simd.or<1>(temp31, temp38);
     371                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     372                BitBlock temp41 = simd.and<1>(temp40, temp37);
    373373                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
    374                 var BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
    375                 var BitBlock temp43 = simd.and<1>(temp3, temp15);
    376                 var BitBlock temp44 = simd.or<1>(temp42, temp43);
    377                 var BitBlock temp45 = simd.andc<1>(temp8, temp34);
    378                 var BitBlock temp46 = simd.or<1>(temp44, temp45);
    379                 var BitBlock temp47 = simd.or<1>(temp46, temp38);
     374                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     375                BitBlock temp43 = simd.and<1>(temp3, temp15);
     376                BitBlock temp44 = simd.or<1>(temp42, temp43);
     377                BitBlock temp45 = simd.andc<1>(temp8, temp34);
     378                BitBlock temp46 = simd.or<1>(temp44, temp45);
     379                BitBlock temp47 = simd.or<1>(temp46, temp38);
    380380                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
    381381                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
    382                 var BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
    383                 var BitBlock x00_x1F = simd.not<1>(temp48);
    384                 var BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
    385                 var BitBlock temp50 = simd.or<1>(temp1, temp49);
     382                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     383                BitBlock x00_x1F = simd.not<1>(temp48);
     384                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     385                BitBlock temp50 = simd.or<1>(temp1, temp49);
    386386                lex.CR = simd.andc<1>(temp20, temp50);
    387387                lex.LF = simd.andc<1>(temp29, temp50);
    388                 var BitBlock temp51 = simd.and<1>(temp9, temp19);
     388                BitBlock temp51 = simd.and<1>(temp9, temp19);
    389389                lex.HT = simd.andc<1>(temp51, temp50);
    390390                lex.SP = simd.andc<1>(temp3, temp36);
    391                 var BitBlock temp52 = simd.or<1>(temp20, temp29);
    392                 var BitBlock temp53 = simd.or<1>(temp52, temp51);
    393                 var BitBlock temp54 = simd.andc<1>(temp53, temp50);
     391                BitBlock temp52 = simd.or<1>(temp20, temp29);
     392                BitBlock temp53 = simd.or<1>(temp52, temp51);
     393                BitBlock temp54 = simd.andc<1>(temp53, temp50);
    394394                lex.WS = simd.or<1>(temp54, lex.SP);
    395                 var BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
    396                 var BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     395                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     396                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
    397397                lex.Digit = simd.andc<1>(temp8, temp56);
    398                 var BitBlock temp57 = simd.andc<1>(temp16, temp49);
    399                 var BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
    400                 var BitBlock temp59 = simd.not<1>(temp10);
    401                 var BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
    402                 var BitBlock temp61 = simd.and<1>(temp58, temp60);
    403                 var BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
    404                 var BitBlock temp63 = simd.and<1>(temp16, temp2);
    405                 var BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
    406                 var BitBlock temp65 = simd.and<1>(temp64, temp60);
     398                BitBlock temp57 = simd.andc<1>(temp16, temp49);
     399                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     400                BitBlock temp59 = simd.not<1>(temp10);
     401                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     402                BitBlock temp61 = simd.and<1>(temp58, temp60);
     403                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     404                BitBlock temp63 = simd.and<1>(temp16, temp2);
     405                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     406                BitBlock temp65 = simd.and<1>(temp64, temp60);
    407407                lex.Hex = simd.or<1>(temp62, temp65);
    408                 var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     408                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    409409                if (bitblock.any<1>((simd.and<1>(lex_error, EOF_mask))))
    410410                {
     
    413413                u8.unibyte = simd.not<1>(basis_bits.bit_0);
    414414                u8.suffix = simd.constant<1>(0);
    415                 var BitBlock u8_error = simd.constant<1>(0);
    416                 var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    417                 var BitBlock u8anyscope = simd.constant<1>(0);
     415                BitBlock u8_error = simd.constant<1>(0);
     416                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     417                BitBlock u8anyscope = simd.constant<1>(0);
    418418                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    419419                {
     
    423423                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
    424424                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
    425                         var BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
    426                         var BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
    427                         var BitBlock temp68 = simd.andc<1>(temp66, temp67);
    428                         var BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
    429                         var BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
    430                         var BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     425                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     426                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     427                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
     428                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     429                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     430                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
    431431                        u8.badprefix = simd.or<1>(temp68, temp71);
    432432                        u8_error = u8.badprefix;
     
    435435                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    436436                        {
    437                                 var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
    438                                 var BitBlock xED = simd.and<1>(u8.prefix3, temp20);
    439                                 var BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
    440                                 var BitBlock temp72 = simd.andc<1>(temp4, temp13);
    441                                 var BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     437                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     438                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     439                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     440                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
     441                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
    442442                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
    443443                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
    444444                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
    445445                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
    446                                 var BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
    447                                 var BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     446                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     447                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
    448448                                u8.xBF = simd.and<1>(temp73, temp23);
    449449                                u8.xBE = simd.and<1>(temp73, temp15);
     
    453453                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    454454                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    455                                 var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
    456                                 var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
     455                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
     456                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    457457                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    458458                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     
    460460                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    461461                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    462                                 var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     462                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    463463                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    464                                 var BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
    465                                 var BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
    466                                 var BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
    467                                 var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     464                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     465                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     466                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     467                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    468468                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    469                                 var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     469                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
    470470                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    471471                        }
     
    474474                                carry_set_0.CarryDequeueEnqueue(1, 9);
    475475                        }
    476                         var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     476                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    477477                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    478478                        {
     
    503503                ref_Callouts.HexRef_starts = simd.constant<1>(0);
    504504                ref_Callouts.HexRef_ends = simd.constant<1>(0);
    505                 var BitBlock ref_error = simd.constant<1>(0);
     505                BitBlock ref_error = simd.constant<1>(0);
    506506                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
    507507                {
    508                         var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    509                         var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     508                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     509                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    510510                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    511                         var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    512                         var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     511                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     512                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    513513                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    514514                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     
    516516                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    517517                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    518                         var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    519                         var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    520                         var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    521                         var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     518                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     519                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     520                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     521                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    522522                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    523523                        {
     
    540540                ref_Callouts.HexRef_starts = simd.constant<1>(0);
    541541                ref_Callouts.HexRef_ends = simd.constant<1>(0);
    542                 var BitBlock ref_error = simd.constant<1>(0);
     542                BitBlock ref_error = simd.constant<1>(0);
    543543                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
    544544                {
    545                         var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    546                         var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     545                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     546                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    547547                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    548                         var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    549                         var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     548                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     549                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    550550                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    551551                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     
    553553                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    554554                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    555                         var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    556                         var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    557                         var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    558                         var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     555                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     556                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     557                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     558                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    559559                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    560560                        {
     
    580580        function 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)
    581581        {
    582                 var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
    583                 var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    584                 var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    585                 var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    586                 var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    587                 var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    588                 var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    589                 var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    590                 var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    591                 var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    592                 var BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
    593                 var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    594                 var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    595                 var BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
    596                 var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     582                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     583                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     584                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     585                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     586                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     587                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     588                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     589                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     590                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     591                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     592                BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     593                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     594                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     595                BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     596                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    597597                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    598598                {
     
    606606        function 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)
    607607        {
    608                 var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
    609                 var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    610                 var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    611                 var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    612                 var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    613                 var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    614                 var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    615                 var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    616                 var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    617                 var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    618                 var BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
    619                 var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    620                 var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    621                 var BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
    622                 var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     608                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     609                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     610                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     611                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     612                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     613                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     614                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     615                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     616                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     617                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     618                BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     619                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     620                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     621                BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     622                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    623623                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    624624                {
     
    663663        CarryDeclare(carry_set_0, 0, 0);
    664664};
    665 
  • proto/pabloj/branches/refactor-experimental/input/test/pabloB/statements/idisaFuncCall/idisa1.pablob

    r3026 r3192  
    1111        {
    1212       
    13                 var BitBlock a;
    14                 var BitBlock b;
    15                 var BitBlock c;
    16                 var BitBlock k;
    17                 var BitBlock r;
     13                BitBlock a;
     14                BitBlock b;
     15                BitBlock c;
     16                BitBlock k;
     17                BitBlock r;
    1818               
    1919                /*
  • proto/pabloj/branches/refactor-experimental/input/test/pabloB/test.pablob

    r3033 r3192  
    11// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
    2                
     2       
    33kernel KernelName
    44{
    5         init
    6         {
    7                        
    8         }
     5    init
     6    {
     7           
     8    }
    99
    10         function void do_block()
    11         {
    12        
    13                 var BitBlock a;
    14                 var BitBlock b;
    15                 var BitBlock c;
    16                 var BitBlock k;
    17                 var BitBlock r;
    18                 var bool t;
    19                
    20                 /*
    21                 r = simd.add(abs);
    22                 r = simd.neg(a);
    23                 r = simd.add_hl(a);
    24                 r = simd.xor_hl(a);
    25                 r = simd.slli(k);
    26                 r = simd.srli(k);
    27                 r = simd.srai(k);
    28                 r = simd.popcount(a);
    29                 r = simd.ctz(a);       
    30                 */
     10    function void do_block()
     11    {
     12   
     13        BitBlock a;
     14        BitBlock b;
     15        BitBlock c;
     16        BitBlock k;
     17        BitBlock r;
     18        bool t;
     19       
     20        /*
     21        r = simd.add(abs);
     22        r = simd.neg(a);
     23        r = simd.add_hl(a);
     24        r = simd.xor_hl(a);
     25        r = simd.slli(k);
     26        r = simd.srli(k);
     27        r = simd.srai(k);
     28        r = simd.popcount(a);
     29        r = simd.ctz(a);   
     30        */
    3131
    32                 t = bitblock.any<1>(a);
    33                 r = bitblock.slli<1>(10, a);
    34                 bitblock.store_unaligned<1>(a, b);
    35                 r = bitblock.load_aligned<1>(b);
    36                
    37                 r = simd.not<1>(a);             
    38                 r = simd.nor<1>(a, b);
    39                 r = simd.ifh<16>(a, b, c);                     
    40                
    41                 r = simd.constant<2>(3);
    42                 r = simd.slli<8>(1, a);                 
     32        t = bitblock.any<1>(a);
     33        r = bitblock.slli<1>(10, a);
     34        bitblock.store_unaligned<1>(a, b);
     35        r = bitblock.load_aligned<1>(b);
     36       
     37        r = simd.not<1>(a);     
     38        r = simd.nor<1>(a, b);
     39        r = simd.ifh<16>(a, b, c);         
     40       
     41        r = simd.constant<2>(3);
     42        r = simd.slli<8>(1, a);         
    4343
    44                 r = simd.add<1>(a,b);
    45                 r = simd.sub<2>(a,b);
    46                 r = simd.mult<4>(a,b);
    47                 r = simd.eq<8>(a,b);
    48                 r = simd.gt<16>(a,b);
    49                 r = simd.ugt<32>(a,b);
    50                 r = simd.lt<64>(a,b);
    51                 r = simd.ult<128>(a,b);
    52                 r = simd.max<128>(a,b);
    53                 r = simd.umax<1>(a,b);
    54                 r = simd.min<2>(a,b);
    55                 r = simd.umin<4>(a,b);
    56                 r = simd.sll<64>(a,b);
    57                 r = simd.srl<64>(a,b);
    58                 //r = simd.srai<32>(10,a);
    59                
    60                 //r = simd.if<128>(a,b,c);
    61                
    62         }
     44        r = simd.add<1>(a,b);
     45        r = simd.sub<2>(a,b);
     46        r = simd.mult<4>(a,b);
     47        r = simd.eq<8>(a,b);
     48        r = simd.gt<16>(a,b);
     49        r = simd.ugt<32>(a,b);
     50        r = simd.lt<64>(a,b);
     51        r = simd.ult<128>(a,b);
     52        r = simd.max<128>(a,b);
     53        r = simd.umax<1>(a,b);
     54        r = simd.min<2>(a,b);
     55        r = simd.umin<4>(a,b);
     56        r = simd.sll<64>(a,b);
     57        r = simd.srl<64>(a,b);
     58        //r = simd.srai<32>(10,a);
     59       
     60        //r = simd.if<128>(a,b,c);
     61       
     62    }
    6363
    64         function void do_final_block()
    65         {
    66                
    67                
    68         }
     64    function void do_final_block()
     65    {
     66       
     67       
     68    }
    6969
    70         CarryDeclare(carry_set_0, 0, 0);
    71 };     
     70    CarryDeclare(carry_set_0, 0, 0);
     71}; 
  • proto/pabloj/branches/refactor-experimental/input/test/pabloB/test_meng.pablob

    r3033 r3192  
    1111        {
    1212       
    13                 var BitBlock a;
    14                 var BitBlock b;
    15                 var BitBlock c;
    16                 var BitBlock k;
    17                 var BitBlock r;
    18                 var bool t;
     13                BitBlock a;
     14                BitBlock b;
     15                BitBlock c;
     16                BitBlock k;
     17                BitBlock r;
     18                bool t;
    1919               
    2020                /*
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/test.pablos

    r3175 r3192  
    1 struct BasisBits {
    2         stream<1> b1;
    3         stream<1> b2;
    4         stream<1> b3;
    5         stream<1> b4;
    6 };
    7 struct BasisBits {
    8         stream<1> b1;
    9         stream<1> b2;
    10         stream<1> b3;
    11         stream<1> b4;
    12 };
    13 
    14 function void Foo() {
    15 
    16 }struct B
    17 {
    18         stream<1> a;
    19         stream<1> a;
    20         stream<1> a;
    21         stream<1> a;
    22 };
    23 
    24 function struct B Foo() { }
    25 struct bb {
    26         stream<1> a;
    27 
    28 };
    29 
    30 /*
    31 function stream<1> Function(stream<1> a, stream<1> b, stream<1> c) {
    32 
    33 
    34 };
    35 */
    36 function struct Lex ClassifyBytes(struct BasisBit basis) {};
    371// PabloS version of parabix2_pablo.py generated with py2pabloS.py
    382
     
    511475    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    512476}
    513 function void While() {
    514                        
    515         stream<1> cursor = 1;
    516        
    517         while (cursor) {
    518           cursor = pablo.Advance(cursor);
    519         }
    520 }
    521 function void Function() {     
    522         stream<1> cursor1;
    523        
    524         while (cursor1) {
    525                 stream<1> cursor2;
    526                 while(cursor2) {
    527                         cursor = pablo.Advance(cursor);
    528                         // cursor = cursor &~ terminator;
    529                 }
    530         }
    531 }
    532 function void While() {
    533        
    534         stream<1> cursor;
    535        
    536         while (cursor) {
    537                 cursor = pablo.Advance(cursor);
    538                 cursor = cursor &~ terminator;
    539         }
    540 }
    541 function void Function(struct TagCallouts tagCallouts, struct Lex lex) {       
    542 
    543         stream<1> starts_accum = 0;
    544         stream<1> ends_accum = 0;       
    545         stream<1> cursor = pablo.ScanToFirst(lex.opener);
    546        
    547         while (cursor) {
    548                 starts_accum |= cursor;
    549                 cursor = pablo.ScanTo(cursor, lex.marker &~ cursor);
    550                 ends_accum |= cursor;
    551                 cursor = pablo.ScanTo(cursor, (lex.marker | lex.terminator) &~ cursor);
    552                 cursor = cursor & lex.marker;
    553         }
    554 };
    555 function void Function() {     
    556        
    557         stream cursor;
    558        
    559         if(cursor & a) {
    560 
    561         } else {
    562 
    563         }
    564        
    565 }
    566 function void Function() {     
    567        
    568         stream cursor;
    569        
    570         if(cursor & a) {
    571                 if(cursor & b) {
    572                
    573                 } else {
    574                
    575                 }
    576 
    577         } else {
    578 
    579         }
    580        
    581 }
    582 function void Function() {     
    583        
    584         stream cursor;
    585        
    586         if(cursor & a) {
    587                 if(cursor & b) {
    588                
    589                 }
    590         }
    591        
    592 }
    593 function void Function() {             
    594         stream cursor;
    595         if(cursor) {
    596 
    597         }
    598 }
    599 function void Assignments() {
    600         stream<1> s;
    601         s = 0;
    602 };function void Assignments() {
    603         stream<1> s;
    604         stream<1> a;
    605         stream<1> b;
    606         stream<1> c;
    607         //s |= 0;
    608         //s = a | b | c;
    609         s |= a;
    610         s |= a | b;
    611         s |= a | b | c;
    612         s |= a | b | c | d;
    613         // s = s | a | b | c;
    614 };function void StreamStructs() {
    615 
    616         // records
    617         temp4 = temp1.temp2;
    618         temp4 = temp1.temp2.temp3;
    619        
    620         temp1.temp2 = temp4;
    621         temp1.temp2.temp3 = temp4;
    622                
    623 };function void AssignmentExpressions() {       
    624         temp4 = temp;
    625         temp4 &= temp1 | temp2;
    626         temp4 |= temp1 ^ temp2;
    627         temp4 ^= temp1 & temp2;
    628 };function void BasicExpressions() {
    629 
    630         temp4 = temp;
    631         temp4 = temp1 | temp2;
    632         temp4 = temp1 ^ temp2;
    633         temp4 = temp1 & temp2;
    634         temp4 = temp1 ^ temp2 | temp3;
    635         temp4 = temp1 | temp2 ^ temp3;
    636         temp4 = temp1 & temp2 | temp3;
    637         temp4 = temp1 | temp2 & temp3;
    638         temp4 = temp1 & (temp2 | temp3);
    639         temp4 = (temp1 | temp2) & temp3;
    640 //      temp4 = ~temp;
    641        
    642 };
    643 
    644 function struct A FunctionExpressions() {
    645          stream<1> a = b.Advance();
    646 };
    647 function void localDecl() {
    648 
    649         struct BasisBits A;
    650 
    651 } function void localDecl() {
    652 
    653         struct BasisBits A;
    654         struct BasisBits A;
    655         struct BasisBits A;
    656        
    657 
    658 };function void localDecl() {
    659         stream<1> A;
    660         stream B;
    661 }function void Assignments2() {
    662         stream a;
    663         stream<1> s = a;
    664 }
  • proto/pabloj/branches/refactor-experimental/input/test/visitors/CarryIntroXFormerFinalBlock/atEOF.pablos

    r3169 r3192  
    11function void Test() {
    2         var stream<1> X;
    3         var stream<1> R;
     2        stream<1> X;
     3        stream<1> R;
    44                       
    5         // Translate atEOF(X) calls in non-final blocks to andc(X, EOF_mask)
    6         R = simd_andc(X, EOF_mask);
    7         R = atEOF(X);
     5        R = simd_andc(X, EOF_mask);    // Expected
     6        R = atEOF(X);                  // Translated
    87}
  • proto/pabloj/branches/refactor-experimental/input/test/visitors/CarryIntroXFormerFinalBlock/inFile.pablos

    r3169 r3192  
    11function void Test() {
    2         var stream<1> X;
    3         var stream<1> R;
     2        stream<1> X;
     3        stream<1> R;
    44                       
    5         R = simd_and(X, EOF_mask);
    6         R = inFile(X);
     5        R = simd_and(X, EOF_mask); // Expected
     6        R = inFile(X);             // Translated
    77}
  • proto/pabloj/branches/refactor-experimental/input/test/visitors/CarryIntroXFormerFinalBlock/pablo2CarryQ.pablos

    r3169 r3192  
    11function void Test() {
    2         var stream<1> temp;
    3         var stream<1> C;        // Cursor stream<1>
    4         var stream<1> M;        // Marker stream<1>
    5         var stream<1> R;        // Result stream<1>
    6        
    7         // TODO - UPDATE EXPECTED RESULTS
     2        stream<1> temp;
     3        stream<1> C;    // cursor stream
     4        stream<1> M;    // marker stream
     5        stream<1> R;    // result stream
    86       
    97        R = carry_set_0.BitBlock_advance_ci_co(C,carry_set_0.GetCarry(0),0);    // Expected
    10         R = Advance(C);                                                                                                 // Translated
    11                
     8        R = Advance(C);                                                                                                         // Translated
     9       
     10/*             
    1211        R = carry_set_0.BitBlock_advance_ci_co(C,carry_set_0.GetCarry(1),1);
    1312        R = pablo.Advance(C);
     
    6059        R = carry_set_0.BitBlock_exclusive_span(C,X,carry_set_0.GetCarry(17),17);               
    6160        R = pablo.ExclusiveSpan(C,X);                   
    62                
     61*/             
    6362}
  • proto/pabloj/branches/refactor-experimental/input/test/visitors/CarryIntroXFormerNotFinalBlock/pablo2CarryQ.pablos

    r3169 r3192  
    11function void Test() {
    2         var stream<1> temp;
    3         var stream<1> C;        // Cursor stream<1>
    4         var stream<1> M;        // Marker stream<1>
    5         var stream<1> R;        // Result stream<1>
     2        stream<1> temp;
     3        stream<1> C;    // Cursor stream<1>
     4        stream<1> M;    // Marker stream<1>
     5        stream<1> R;    // Result stream<1>
    66       
    77        // TODO - UPDATE EXPECTED RESULTS
    88       
    9         R = carry_set_0.BitBlock_advance_ci_co(C,carry_set_0.GetCarry(0),0);    // Expected
    10         R = Advance(C);                                                                                                 // Translated
     9        R = carry_set_0.BitBlock_advance_ci_co(C,carry_set_0.GetCarry(0),0);       // Expected
     10        R = Advance(C);                                                                                                            // Translated
    1111               
    1212        R = carry_set_0.BitBlock_advance_ci_co(C,carry_set_0.GetCarry(1),1);
  • proto/pabloj/branches/refactor-experimental/input/test/visitors/ExpandAugmentedAssignments/expandAugmentedAssignments.pablos

    r3175 r3192  
    1616    x |= y | z;
    1717       
    18 //      x = x & y & z;
    19 //      x &= y & z;
     18        x = x & (y & z);
     19        x &= y & z;
    2020       
    21 //      x =  x ^ y ^ z;
    22 //      x ^=  y ^ z;
     21        x =  x ^ (y ^ z);
     22        x ^=  y ^ z;
    2323
    2424}
  • proto/pabloj/branches/refactor-experimental/output/clang/idisa_definitions.h

    r3134 r3192  
    5151        }
    5252       
    53         void do_final_block()
     53        IDISA_INLINE void do_final_block()
    5454        {
    5555               
  • proto/pabloj/branches/refactor-experimental/output/cpplang/pablo_definitions.hpp

    r3166 r3192  
    5858// namespace pablo
    5959// {
    60 struct Test
     60struct Basis_bits
    6161{
    62         Test()
     62        BitBlock bit_0;
     63        BitBlock bit_1;
     64        BitBlock bit_2;
     65        BitBlock bit_3;
     66        BitBlock bit_4;
     67        BitBlock bit_5;
     68        BitBlock bit_6;
     69        BitBlock bit_7;
     70};
     71 
     72struct U8
     73{
     74        BitBlock unibyte;
     75        BitBlock prefix;
     76        BitBlock prefix2;
     77        BitBlock prefix3;
     78        BitBlock prefix4;
     79        BitBlock suffix;
     80        BitBlock badprefix;
     81        BitBlock xE0;
     82        BitBlock xED;
     83        BitBlock xF0;
     84        BitBlock xF4;
     85        BitBlock xA0_xBF;
     86        BitBlock x80_x9F;
     87        BitBlock x90_xBF;
     88        BitBlock x80_x8F;
     89        BitBlock xEF;
     90        BitBlock xBF;
     91        BitBlock xBE;
     92        BitBlock scope22;
     93        BitBlock scope32;
     94        BitBlock scope33;
     95        BitBlock scope42;
     96        BitBlock scope43;
     97        BitBlock scope44;
     98        BitBlock xE0_scope;
     99        BitBlock xED_scope;
     100        BitBlock xF0_scope;
     101        BitBlock xF4_scope;
     102        BitBlock xEF_scope;
     103};
     104 
     105struct Lex
     106{
     107        BitBlock CR;
     108        BitBlock LF;
     109        BitBlock HT;
     110        BitBlock SP;
     111        BitBlock CRLF;
     112        BitBlock RefStart;
     113        BitBlock Semicolon;
     114        BitBlock Colon;
     115        BitBlock LAngle;
     116        BitBlock RAngle;
     117        BitBlock LBracket;
     118        BitBlock RBracket;
     119        BitBlock Exclam;
     120        BitBlock QMark;
     121        BitBlock Hyphen;
     122        BitBlock Equals;
     123        BitBlock SQuote;
     124        BitBlock DQuote;
     125        BitBlock Slash;
     126        BitBlock Hash;
     127        BitBlock x;
     128        BitBlock ASCII_name_start;
     129        BitBlock ASCII_name_char;
     130        BitBlock NameScan;
     131        BitBlock Digit;
     132        BitBlock Hex;
     133        BitBlock WS;
     134};
     135 
     136struct Marker
     137{
     138        BitBlock LAngle_scope;
     139        BitBlock Ref_opener;
     140        BitBlock CD_closer;
     141};
     142 
     143struct CtCDPI_Callouts
     144{
     145        BitBlock Ct_starts;
     146        BitBlock Ct_ends;
     147        BitBlock CD_starts;
     148        BitBlock CD_ends;
     149        BitBlock PI_starts;
     150        BitBlock PI_name_starts;
     151        BitBlock PI_name_ends;
     152        BitBlock PI_ends;
     153};
     154 
     155struct Ref_Callouts
     156{
     157        BitBlock GenRef_starts;
     158        BitBlock GenRef_ends;
     159        BitBlock DecRef_starts;
     160        BitBlock DecRef_ends;
     161        BitBlock HexRef_starts;
     162        BitBlock HexRef_ends;
     163};
     164 
     165struct Tag_Callouts
     166{
     167        BitBlock ElemName_starts;
     168        BitBlock ElemName_ends;
     169        BitBlock AttName_starts;
     170        BitBlock AttName_ends;
     171        BitBlock AttVal_starts;
     172        BitBlock AttVal_ends;
     173        BitBlock AttVal_spans;
     174        BitBlock EmptyTag_marks;
     175        BitBlock EndTag_marks;
     176};
     177 
     178struct Check_streams
     179{
     180        BitBlock misc_mask;
     181        BitBlock non_ascii_name_starts;
     182        BitBlock non_ascii_names;
     183        BitBlock tag_marks;
     184        BitBlock name_follows;
     185        BitBlock att_refs;
     186};
     187 
     188struct Classify_bytes_Validate_utf8
     189{
     190        Classify_bytes_Validate_utf8()
    63191        {
    64192               
    65193        }
    66194         
    67         IDISA_INLINE void do_block()
    68         {
    69                 a.b();
     195        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
     196        {
     197                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     198                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     199                BitBlock temp3 = simd_andc(temp2,temp1);
     200                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     201                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     202                BitBlock temp6 = simd_and(temp4,temp5);
     203                lex.RefStart = simd_and(temp3,temp6);
     204                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     205                BitBlock temp8 = simd_andc(temp7,temp1);
     206                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     207                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     208                BitBlock temp11 = simd_and(temp9,temp10);
     209                lex.Semicolon = simd_and(temp8,temp11);
     210                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     211                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     212                BitBlock temp14 = simd_andc(temp12,temp13);
     213                lex.LAngle = simd_and(temp8,temp14);
     214                BitBlock temp15 = simd_and(temp12,temp5);
     215                lex.RAngle = simd_and(temp8,temp15);
     216                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     217                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     218                BitBlock temp18 = simd_and(temp16,temp17);
     219                lex.LBracket = simd_and(temp18,temp11);
     220                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     221                BitBlock temp20 = simd_and(temp12,temp19);
     222                lex.RBracket = simd_and(temp18,temp20);
     223                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     224                BitBlock temp22 = simd_andc(temp19,temp21);
     225                lex.Exclam = simd_and(temp3,temp22);
     226                BitBlock temp23 = simd_and(temp12,temp10);
     227                lex.QMark = simd_and(temp8,temp23);
     228                lex.Hyphen = simd_and(temp3,temp20);
     229                lex.Equals = simd_and(temp8,temp20);
     230                BitBlock temp24 = simd_and(temp4,temp10);
     231                lex.SQuote = simd_and(temp3,temp24);
     232                BitBlock temp25 = simd_andc(temp5,temp21);
     233                lex.DQuote = simd_and(temp3,temp25);
     234                lex.Slash = simd_and(temp3,temp23);
     235                BitBlock temp26 = simd_andc(temp10,temp21);
     236                lex.Hash = simd_and(temp3,temp26);
     237                BitBlock temp27 = simd_and(temp16,temp7);
     238                BitBlock temp28 = simd_andc(temp9,temp13);
     239                lex.x = simd_and(temp27,temp28);
     240                BitBlock temp29 = simd_and(temp9,temp5);
     241                lex.Colon = simd_and(temp8,temp29);
     242                BitBlock temp30 = simd_and(temp18,temp23);
     243                BitBlock temp31 = simd_or(temp30,lex.Colon);
     244                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     245                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     246                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     247                BitBlock temp35 = simd_not(temp34);
     248                BitBlock temp36 = simd_or(temp21,temp13);
     249                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     250                BitBlock temp38 = simd_and(temp32,temp37);
     251                BitBlock temp39 = simd_or(temp31,temp38);
     252                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     253                BitBlock temp41 = simd_and(temp40,temp37);
     254                lex.ASCII_name_start = simd_or(temp39,temp41);
     255                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     256                BitBlock temp43 = simd_and(temp3,temp15);
     257                BitBlock temp44 = simd_or(temp42,temp43);
     258                BitBlock temp45 = simd_andc(temp8,temp34);
     259                BitBlock temp46 = simd_or(temp44,temp45);
     260                BitBlock temp47 = simd_or(temp46,temp38);
     261                lex.ASCII_name_char = simd_or(temp47,temp41);
     262                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
     263                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     264                BitBlock x00_x1F = simd_not(temp48);
     265                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     266                BitBlock temp50 = simd_or(temp1,temp49);
     267                lex.CR = simd_andc(temp20,temp50);
     268                lex.LF = simd_andc(temp29,temp50);
     269                BitBlock temp51 = simd_and(temp9,temp19);
     270                lex.HT = simd_andc(temp51,temp50);
     271                lex.SP = simd_andc(temp3,temp36);
     272                BitBlock temp52 = simd_or(temp20,temp29);
     273                BitBlock temp53 = simd_or(temp52,temp51);
     274                BitBlock temp54 = simd_andc(temp53,temp50);
     275                lex.WS = simd_or(temp54,lex.SP);
     276                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     277                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
     278                lex.Digit = simd_andc(temp8,temp56);
     279                BitBlock temp57 = simd_andc(temp16,temp49);
     280                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     281                BitBlock temp59 = simd_not(temp10);
     282                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     283                BitBlock temp61 = simd_and(temp58,temp60);
     284                BitBlock temp62 = simd_or(lex.Digit,temp61);
     285                BitBlock temp63 = simd_and(temp16,temp2);
     286                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     287                BitBlock temp65 = simd_and(temp64,temp60);
     288                lex.Hex = simd_or(temp62,temp65);
     289                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
     290                if (bitblock::any(lex_error))
     291                {
     292                        assert_0_error("Error: illegal character",lex_error);
     293                }
     294                u8.unibyte = simd_not(basis_bits.bit_0);
     295                u8.suffix = simd<1>::constant<0>();
     296                BitBlock u8_error = simd<1>::constant<0>();
     297                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     298                BitBlock u8anyscope = simd<1>::constant<0>();
     299                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
     300                {
     301                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
     302                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
     303                        u8.prefix3 = simd_and(u8.prefix,temp2);
     304                        u8.prefix4 = simd_and(u8.prefix,temp7);
     305                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
     306                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
     307                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     308                        BitBlock temp68 = simd_andc(temp66,temp67);
     309                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     310                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     311                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
     312                        u8.badprefix = simd_or(temp68,temp71);
     313                        u8_error = u8.badprefix;
     314                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
     315                        u8anyscope = u8.scope22;
     316                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
     317                        {
     318                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     319                                BitBlock xED = simd_and(u8.prefix3,temp20);
     320                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     321                                BitBlock temp72 = simd_andc(temp4,temp13);
     322                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
     323                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
     324                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
     325                                u8.x90_xBF = simd_and(u8.suffix,temp49);
     326                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
     327                                BitBlock xEF = simd_and(u8.prefix3,temp23);
     328                                BitBlock temp73 = simd_and(u8.suffix,temp7);
     329                                u8.xBF = simd_and(temp73,temp23);
     330                                u8.xBE = simd_and(temp73,temp15);
     331                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
     332                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
     333                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
     334                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
     335                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
     336                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
     337                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
     338                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
     339                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
     340                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
     341                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
     342                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
     343                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     344                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
     345                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     346                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     347                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     348                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
     349                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
     350                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
     351                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
     352                        }
     353                        else
     354                        {
     355                                carry_set_0.CarryDequeueEnqueue(1,9);
     356                        }
     357                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
     358                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
     359                        {
     360                                assert_0_error("UTF-8 error found",simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF));
     361                        }
     362                }
     363                else
     364                {
     365                        carry_set_0.CarryDequeueEnqueue(0,10);
     366                }
     367                carry_set_0.CarryAdjust(10);
    70368        }
    71369       
    72         void do_final_block(BitBlock & EOF_mask)
    73         {
    74                 a.b();
     370        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
     371        {
     372                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     373                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     374                BitBlock temp3 = simd_andc(temp2,temp1);
     375                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     376                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     377                BitBlock temp6 = simd_and(temp4,temp5);
     378                lex.RefStart = simd_and(temp3,temp6);
     379                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     380                BitBlock temp8 = simd_andc(temp7,temp1);
     381                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     382                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     383                BitBlock temp11 = simd_and(temp9,temp10);
     384                lex.Semicolon = simd_and(temp8,temp11);
     385                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     386                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     387                BitBlock temp14 = simd_andc(temp12,temp13);
     388                lex.LAngle = simd_and(temp8,temp14);
     389                BitBlock temp15 = simd_and(temp12,temp5);
     390                lex.RAngle = simd_and(temp8,temp15);
     391                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     392                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     393                BitBlock temp18 = simd_and(temp16,temp17);
     394                lex.LBracket = simd_and(temp18,temp11);
     395                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     396                BitBlock temp20 = simd_and(temp12,temp19);
     397                lex.RBracket = simd_and(temp18,temp20);
     398                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     399                BitBlock temp22 = simd_andc(temp19,temp21);
     400                lex.Exclam = simd_and(temp3,temp22);
     401                BitBlock temp23 = simd_and(temp12,temp10);
     402                lex.QMark = simd_and(temp8,temp23);
     403                lex.Hyphen = simd_and(temp3,temp20);
     404                lex.Equals = simd_and(temp8,temp20);
     405                BitBlock temp24 = simd_and(temp4,temp10);
     406                lex.SQuote = simd_and(temp3,temp24);
     407                BitBlock temp25 = simd_andc(temp5,temp21);
     408                lex.DQuote = simd_and(temp3,temp25);
     409                lex.Slash = simd_and(temp3,temp23);
     410                BitBlock temp26 = simd_andc(temp10,temp21);
     411                lex.Hash = simd_and(temp3,temp26);
     412                BitBlock temp27 = simd_and(temp16,temp7);
     413                BitBlock temp28 = simd_andc(temp9,temp13);
     414                lex.x = simd_and(temp27,temp28);
     415                BitBlock temp29 = simd_and(temp9,temp5);
     416                lex.Colon = simd_and(temp8,temp29);
     417                BitBlock temp30 = simd_and(temp18,temp23);
     418                BitBlock temp31 = simd_or(temp30,lex.Colon);
     419                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     420                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     421                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     422                BitBlock temp35 = simd_not(temp34);
     423                BitBlock temp36 = simd_or(temp21,temp13);
     424                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     425                BitBlock temp38 = simd_and(temp32,temp37);
     426                BitBlock temp39 = simd_or(temp31,temp38);
     427                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     428                BitBlock temp41 = simd_and(temp40,temp37);
     429                lex.ASCII_name_start = simd_or(temp39,temp41);
     430                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     431                BitBlock temp43 = simd_and(temp3,temp15);
     432                BitBlock temp44 = simd_or(temp42,temp43);
     433                BitBlock temp45 = simd_andc(temp8,temp34);
     434                BitBlock temp46 = simd_or(temp44,temp45);
     435                BitBlock temp47 = simd_or(temp46,temp38);
     436                lex.ASCII_name_char = simd_or(temp47,temp41);
     437                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
     438                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     439                BitBlock x00_x1F = simd_not(temp48);
     440                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     441                BitBlock temp50 = simd_or(temp1,temp49);
     442                lex.CR = simd_andc(temp20,temp50);
     443                lex.LF = simd_andc(temp29,temp50);
     444                BitBlock temp51 = simd_and(temp9,temp19);
     445                lex.HT = simd_andc(temp51,temp50);
     446                lex.SP = simd_andc(temp3,temp36);
     447                BitBlock temp52 = simd_or(temp20,temp29);
     448                BitBlock temp53 = simd_or(temp52,temp51);
     449                BitBlock temp54 = simd_andc(temp53,temp50);
     450                lex.WS = simd_or(temp54,lex.SP);
     451                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     452                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
     453                lex.Digit = simd_andc(temp8,temp56);
     454                BitBlock temp57 = simd_andc(temp16,temp49);
     455                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     456                BitBlock temp59 = simd_not(temp10);
     457                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     458                BitBlock temp61 = simd_and(temp58,temp60);
     459                BitBlock temp62 = simd_or(lex.Digit,temp61);
     460                BitBlock temp63 = simd_and(temp16,temp2);
     461                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     462                BitBlock temp65 = simd_and(temp64,temp60);
     463                lex.Hex = simd_or(temp62,temp65);
     464                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
     465                if (bitblock::any(simd_and(lex_error,EOF_mask)))
     466                {
     467                        assert_0_error("Error: illegal character",simd_and(lex_error,EOF_mask));
     468                }
     469                u8.unibyte = simd_not(basis_bits.bit_0);
     470                u8.suffix = simd<1>::constant<0>();
     471                BitBlock u8_error = simd<1>::constant<0>();
     472                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     473                BitBlock u8anyscope = simd<1>::constant<0>();
     474                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
     475                {
     476                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
     477                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
     478                        u8.prefix3 = simd_and(u8.prefix,temp2);
     479                        u8.prefix4 = simd_and(u8.prefix,temp7);
     480                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
     481                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
     482                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     483                        BitBlock temp68 = simd_andc(temp66,temp67);
     484                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     485                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     486                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
     487                        u8.badprefix = simd_or(temp68,temp71);
     488                        u8_error = u8.badprefix;
     489                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
     490                        u8anyscope = u8.scope22;
     491                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
     492                        {
     493                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     494                                BitBlock xED = simd_and(u8.prefix3,temp20);
     495                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     496                                BitBlock temp72 = simd_andc(temp4,temp13);
     497                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
     498                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
     499                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
     500                                u8.x90_xBF = simd_and(u8.suffix,temp49);
     501                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
     502                                BitBlock xEF = simd_and(u8.prefix3,temp23);
     503                                BitBlock temp73 = simd_and(u8.suffix,temp7);
     504                                u8.xBF = simd_and(temp73,temp23);
     505                                u8.xBE = simd_and(temp73,temp15);
     506                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
     507                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
     508                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
     509                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
     510                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
     511                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
     512                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
     513                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
     514                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
     515                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
     516                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
     517                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
     518                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     519                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
     520                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     521                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     522                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     523                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
     524                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
     525                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
     526                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
     527                        }
     528                        else
     529                        {
     530                                carry_set_0.CarryDequeueEnqueue(1,9);
     531                        }
     532                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
     533                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
     534                        {
     535                                assert_0_error("UTF-8 error found",simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF));
     536                        }
     537                }
     538                else
     539                {
     540                        carry_set_0.CarryDequeueEnqueue(0,10);
     541                }
    75542        }
    76543       
    77         CarryDeclare(carry_set_0, 0, 0);
     544        CarryDeclare(carry_set_0,10,0);
     545};
     546 
     547struct Parse_CtCDPI
     548{
     549        Parse_CtCDPI()
     550        {
     551                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)),2);
     552        }
     553         
     554        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
     555        {
     556                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     557                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     558                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     559                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     560                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     561                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     562                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     563                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     564                BitBlock CtCDPI_starts = simd<1>::constant<0>();
     565                BitBlock CtCDPI_ends = simd<1>::constant<0>();
     566                BitBlock ctCDPI_mask = simd<1>::constant<0>();
     567                BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     568                BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     569                BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
     570                BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
     571                BitBlock LAngle_scope = simd_andc(v1,w1);
     572                BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     573                BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     574                BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     575                BitBlock CD_closer = simd<1>::constant<0>();
     576                BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     577                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
     578                {
     579                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
     580                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
     581                }
     582                else
     583                {
     584                        carry_set_0.CarryDequeueEnqueue(0,2);
     585                }
     586                BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     587                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
     588                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.CarryRange(3,13))))
     589                {
     590                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     591                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     592                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
     593                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     594                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     595                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
     596                        {
     597                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     598                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
     599                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     600                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
     601                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     602                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     603                                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)));
     604                                if (bitblock::any(PI_error))
     605                                {
     606                                        assert_0_error("Error in PI syntax",PI_error);
     607                                }
     608                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     609                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),carry_set_0.GetCarry(7),7);
     610                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     611                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     612                        }
     613                        else
     614                        {
     615                                carry_set_0.CarryDequeueEnqueue(4,4);
     616                        }
     617                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
     618                        {
     619                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     620                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),carry_set_0.GetCarry(8),8);
     621                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     622                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     623                        }
     624                        else
     625                        {
     626                                carry_set_0.CarryDequeueEnqueue(8,1);
     627                        }
     628                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
     629                        {
     630                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     631                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
     632                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     633                                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);
     634                                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);
     635                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     636                                {
     637                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     638                                }
     639                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     640                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     641                        }
     642                        else
     643                        {
     644                                carry_set_0.CarryDequeueEnqueue(9,5);
     645                        }
     646                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     647                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
     648                        if (bitblock::any(simd<1>::constant<0>()))
     649                        {
     650                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
     651                        }
     652                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.GetCarry(15),15);
     653                        while (bitblock::any(CtCDPI_Cursor))
     654                        {
     655                                CarryDeclare(carry_set_1,13,0);
     656                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     657                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     658                                BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     659                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     660                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     661                                if (bitblock::any(PI_Cursor))
     662                                {
     663                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     664                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     665                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     666                                        BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     667                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     668                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     669                                        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)));
     670                                        if (bitblock::any(PI_error))
     671                                        {
     672                                                assert_0_error("Error in PI syntax",PI_error);
     673                                        }
     674                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     675                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),simd<1>::constant<0>(),4);
     676                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     677                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     678                                }
     679                                if (bitblock::any(CD_Cursor))
     680                                {
     681                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     682                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),simd<1>::constant<0>(),5);
     683                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     684                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     685                                }
     686                                if (bitblock::any(Ct_Cursor))
     687                                {
     688                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     689                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     690                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     691                                        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);
     692                                        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);
     693                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     694                                        {
     695                                                assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     696                                        }
     697                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     698                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     699                                }
     700                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     701                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     702                                if (bitblock::any(simd<1>::constant<0>()))
     703                                {
     704                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
     705                                }
     706                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),simd<1>::constant<0>(),12);
     707                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     708                        }
     709                }
     710                else
     711                {
     712                        carry_set_0.CarryDequeueEnqueue(3,13);
     713                }
     714                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);
     715                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     716                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     717                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     718                carry_set_0.CarryAdjust(17);
     719        }
     720       
     721        void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
     722        {
     723                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     724                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     725                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     726                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     727                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     728                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     729                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     730                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     731                BitBlock CtCDPI_starts = simd<1>::constant<0>();
     732                BitBlock CtCDPI_ends = simd<1>::constant<0>();
     733                BitBlock ctCDPI_mask = simd<1>::constant<0>();
     734                BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     735                BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     736                BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v,carry_set_0.Pending64(0),0);
     737                BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w,carry_set_0.Pending64(1),1);
     738                BitBlock LAngle_scope = simd_andc(v1,w1);
     739                BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     740                BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     741                BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     742                BitBlock CD_closer = simd<1>::constant<0>();
     743                BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     744                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.CarryRange(0,2))))
     745                {
     746                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket,carry_set_0.GetCarry(0),0),lex.RBracket);
     747                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
     748                }
     749                else
     750                {
     751                        carry_set_0.CarryDequeueEnqueue(0,2);
     752                }
     753                BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     754                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
     755                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.CarryRange(3,13))))
     756                {
     757                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     758                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     759                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
     760                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     761                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     762                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
     763                        {
     764                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     765                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
     766                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     767                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
     768                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     769                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     770                                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)));
     771                                if (bitblock::any(PI_error))
     772                                {
     773                                        assert_0_error("Error in PI syntax",PI_error);
     774                                }
     775                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     776                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.GetCarry(7),7);
     777                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     778                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     779                        }
     780                        else
     781                        {
     782                                carry_set_0.CarryDequeueEnqueue(4,4);
     783                        }
     784                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
     785                        {
     786                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     787                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.GetCarry(8),8);
     788                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     789                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     790                        }
     791                        else
     792                        {
     793                                carry_set_0.CarryDequeueEnqueue(8,1);
     794                        }
     795                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
     796                        {
     797                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     798                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
     799                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     800                                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);
     801                                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);
     802                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     803                                {
     804                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     805                                }
     806                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     807                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     808                        }
     809                        else
     810                        {
     811                                carry_set_0.CarryDequeueEnqueue(9,5);
     812                        }
     813                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     814                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
     815                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     816                        {
     817                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
     818                        }
     819                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.GetCarry(15),15);
     820                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
     821                        {
     822                                CarryDeclare(carry_set_1,13,0);
     823                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     824                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     825                                BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
     826                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     827                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     828                                if (bitblock::any(PI_Cursor))
     829                                {
     830                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     831                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
     832                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     833                                        BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
     834                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     835                                        BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     836                                        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)));
     837                                        if (bitblock::any(PI_error))
     838                                        {
     839                                                assert_0_error("Error in PI syntax",PI_error);
     840                                        }
     841                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     842                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),simd<1>::constant<0>(),4);
     843                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     844                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     845                                }
     846                                if (bitblock::any(CD_Cursor))
     847                                {
     848                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     849                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),simd<1>::constant<0>(),5);
     850                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     851                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     852                                }
     853                                if (bitblock::any(Ct_Cursor))
     854                                {
     855                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     856                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
     857                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     858                                        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);
     859                                        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);
     860                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     861                                        {
     862                                                assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     863                                        }
     864                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     865                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     866                                }
     867                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     868                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
     869                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     870                                {
     871                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
     872                                }
     873                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),simd<1>::constant<0>(),12);
     874                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     875                        }
     876                }
     877                else
     878                {
     879                        carry_set_0.CarryDequeueEnqueue(3,13);
     880                }
     881                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);
     882                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     883                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     884                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     885        }
     886       
     887        CarryDeclare(carry_set_0,17,2);
     888};
     889 
     890struct Parse_tags
     891{
     892        Parse_tags()
     893        {
     894               
     895        }
     896         
     897        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
     898        {
     899                BitBlock EqExpected = simd<1>::constant<0>();
     900                BitBlock AttListEnd = simd<1>::constant<0>();
     901                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     902                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     903                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
     904                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
     905                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
     906                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
     907                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     908                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     909                tag_Callouts.AttName_ends = simd<1>::constant<0>();
     910                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
     911                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
     912                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
     913                {
     914                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
     915                        AttListEnd = simd_and(AfterWS,AttListDelim);
     916                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
     917                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.CarryRange(2,7))))
     918                        {
     919                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     920                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     921                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
     922                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     923                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
     924                                {
     925                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
     926                                }
     927                                else
     928                                {
     929                                        EqExpected = AttNameFollow;
     930                                        carry_set_0.CarryDequeueEnqueue(3,1);
     931                                }
     932                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     933                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
     934                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     935                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     936                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     937                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.GetCarry(5),5);
     938                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.GetCarry(6),6);
     939                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     940                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     941                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
     942                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     943                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
     944                                {
     945                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
     946                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     947                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     948                                }
     949                                else
     950                                {
     951                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     952                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
     953                                        carry_set_0.CarryDequeueEnqueue(8,1);
     954                                }
     955                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     956                                while (bitblock::any(AttNameStart))
     957                                {
     958                                        CarryDeclare(carry_set_1,7,0);
     959                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     960                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     961                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
     962                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     963                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
     964                                        {
     965                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
     966                                        }
     967                                        else
     968                                        {
     969                                                EqExpected = AttNameFollow;
     970                                        }
     971                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     972                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
     973                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     974                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     975                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     976                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),simd<1>::constant<0>(),3);
     977                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),simd<1>::constant<0>(),4);
     978                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     979                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     980                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
     981                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     982                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
     983                                        {
     984                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
     985                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     986                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     987                                        }
     988                                        else
     989                                        {
     990                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     991                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
     992                                        }
     993                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     994                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     995                                }
     996                        }
     997                        else
     998                        {
     999                                carry_set_0.CarryDequeueEnqueue(2,7);
     1000                        }
     1001                }
     1002                else
     1003                {
     1004                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
     1005                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
     1006                        carry_set_0.CarryDequeueEnqueue(1,8);
     1007                }
     1008                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
     1009                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
     1010                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
     1011                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
     1012                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
     1013                {
     1014                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
     1015                }
     1016                else
     1017                {
     1018                        carry_set_0.CarryDequeueEnqueue(11,1);
     1019                }
     1020                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     1021                if (bitblock::any(ParseError))
     1022                {
     1023                        assert_0_error("Tag parsing error found",ParseError);
     1024                }
     1025                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
     1026                carry_set_0.CarryAdjust(13);
     1027        }
     1028       
     1029        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
     1030        {
     1031                BitBlock EqExpected = simd<1>::constant<0>();
     1032                BitBlock AttListEnd = simd<1>::constant<0>();
     1033                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     1034                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     1035                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
     1036                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
     1037                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
     1038                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
     1039                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     1040                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     1041                tag_Callouts.AttName_ends = simd<1>::constant<0>();
     1042                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
     1043                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
     1044                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
     1045                {
     1046                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
     1047                        AttListEnd = simd_and(AfterWS,AttListDelim);
     1048                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
     1049                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.CarryRange(2,7))))
     1050                        {
     1051                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1052                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     1053                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
     1054                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     1055                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
     1056                                {
     1057                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
     1058                                }
     1059                                else
     1060                                {
     1061                                        EqExpected = AttNameFollow;
     1062                                        carry_set_0.CarryDequeueEnqueue(3,1);
     1063                                }
     1064                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     1065                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
     1066                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1067                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1068                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1069                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.GetCarry(5),5);
     1070                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.GetCarry(6),6);
     1071                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1072                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     1073                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
     1074                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     1075                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
     1076                                {
     1077                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
     1078                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1079                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     1080                                }
     1081                                else
     1082                                {
     1083                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1084                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
     1085                                        carry_set_0.CarryDequeueEnqueue(8,1);
     1086                                }
     1087                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1088                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
     1089                                {
     1090                                        CarryDeclare(carry_set_1,7,0);
     1091                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1092                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     1093                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
     1094                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     1095                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
     1096                                        {
     1097                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
     1098                                        }
     1099                                        else
     1100                                        {
     1101                                                EqExpected = AttNameFollow;
     1102                                        }
     1103                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
     1104                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
     1105                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1106                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1107                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1108                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),simd<1>::constant<0>(),3);
     1109                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),simd<1>::constant<0>(),4);
     1110                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1111                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     1112                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
     1113                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     1114                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
     1115                                        {
     1116                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
     1117                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1118                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     1119                                        }
     1120                                        else
     1121                                        {
     1122                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1123                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
     1124                                        }
     1125                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1126                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
     1127                                }
     1128                        }
     1129                        else
     1130                        {
     1131                                carry_set_0.CarryDequeueEnqueue(2,7);
     1132                        }
     1133                }
     1134                else
     1135                {
     1136                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
     1137                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
     1138                        carry_set_0.CarryDequeueEnqueue(1,8);
     1139                }
     1140                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
     1141                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
     1142                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
     1143                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
     1144                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
     1145                {
     1146                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
     1147                }
     1148                else
     1149                {
     1150                        carry_set_0.CarryDequeueEnqueue(11,1);
     1151                }
     1152                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     1153                if (bitblock::any(ParseError))
     1154                {
     1155                        assert_0_error("Tag parsing error found",ParseError);
     1156                }
     1157                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
     1158        }
     1159       
     1160        CarryDeclare(carry_set_0,13,0);
     1161};
     1162 
     1163struct Parse_refs
     1164{
     1165        Parse_refs()
     1166        {
     1167               
     1168        }
     1169         
     1170        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
     1171        {
     1172                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
     1173                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
     1174                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
     1175                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
     1176                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
     1177                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
     1178                BitBlock ref_error = simd<1>::constant<0>();
     1179                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
     1180                {
     1181                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
     1182                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
     1183                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
     1184                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
     1185                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
     1186                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
     1187                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
     1188                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
     1189                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
     1190                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
     1191                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     1192                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     1193                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     1194                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
     1195                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
     1196                        {
     1197                                assert_0_error("Reference error found",simd_or(simd_or(ref_error1,ref_error2),ref_error3));
     1198                        }
     1199                }
     1200                else
     1201                {
     1202                        carry_set_0.CarryDequeueEnqueue(0,6);
     1203                }
     1204                carry_set_0.CarryAdjust(6);
     1205        }
     1206       
     1207        void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
     1208        {
     1209                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
     1210                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
     1211                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
     1212                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
     1213                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
     1214                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
     1215                BitBlock ref_error = simd<1>::constant<0>();
     1216                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
     1217                {
     1218                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
     1219                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
     1220                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
     1221                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
     1222                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
     1223                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
     1224                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
     1225                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
     1226                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
     1227                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
     1228                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     1229                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     1230                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     1231                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
     1232                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
     1233                        {
     1234                                assert_0_error("Reference error found",simd_or(simd_or(ref_error1,ref_error2),ref_error3));
     1235                        }
     1236                }
     1237                else
     1238                {
     1239                        carry_set_0.CarryDequeueEnqueue(0,6);
     1240                }
     1241        }
     1242       
     1243        CarryDeclare(carry_set_0,6,0);
     1244};
     1245 
     1246struct Validate_xml_names
     1247{
     1248        Validate_xml_names()
     1249        {
     1250               
     1251        }
     1252         
     1253        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)
     1254        {
     1255                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);
     1256                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);<