     @prefix : <http://www.w3.org/2000/10/swap/grammar/bnf#> .
    @prefix n3: <http://www.w3.org/2000/10/swap/grammar/n3#> .
    @prefix rul: <http://www.w3.org/2000/10/swap/grammar/bnf-rules#> .
    
     @forSome <#_g0>,
                <#_g1>,
                <#_g2>,
                <#_g3>,
                <#_g4>,
                <#_g5> .
    
    "!"     :canPrecede n3:expression;
         :canStartWith "!" .
    
    "("     :canPrecede ")",
                n3:pathlist;
         :canStartWith "(" .
    
    ")"     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail .
    
    ","     :canPrecede n3:barename,
                n3:object,
                n3:symbol;
         :canStartWith "," .
    
    "."     :canPrecede "}",
                :eof,
                n3:statementlist,
                n3:statements_optional;
         :canStartWith "." .
    
    ";"     :canPrecede ".",
                "]",
                "}",
                n3:propertylist,
                n3:statementtail;
         :canStartWith ";" .
    
    "<="     :canPrecede n3:object;
         :canStartWith "<=" .
    
    "="     :canPrecede n3:object;
         :canStartWith "=" .
    
    "=>"     :canPrecede n3:object;
         :canStartWith "=>" .
    
    "@"     :canPrecede n3:langcode;
         :canStartWith "@" .
    
    "@a"     :canPrecede n3:object;
         :canStartWith "@a" .
    
    "@base"     :canPrecede n3:explicituri;
         :canStartWith "@base" .
    
    "@false"     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "@false" .
    
    "@forAll"     :canPrecede ".",
                "}",
                n3:statementtail,
                <#_g0>;
         :canStartWith "@forAll" .
    
    "@forSome"     :canPrecede ".",
                "}",
                n3:statementtail,
                <#_g1>;
         :canStartWith "@forSome" .
    
    "@has"     :canPrecede n3:expression;
         :canStartWith "@has" .
    
    "@is"     :canPrecede n3:expression;
         :canStartWith "@is" .
    
    "@keywords"     :canPrecede ".",
                "}",
                n3:statementtail,
                <#_g2>;
         :canStartWith "@keywords" .
    
    "@of"     :canPrecede n3:object .
    
    "@prefix"     :canPrecede n3:prefix;
         :canStartWith "@prefix" .
    
    "@true"     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "@true" .
    
    "["     :canPrecede ".",
                "]",
                "}",
                n3:propertylist,
                n3:statementtail;
         :canStartWith "[" .
    
    "]"     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail .
    
    "^"     :canPrecede n3:expression;
         :canStartWith "^" .
    
    "^^"     :canPrecede n3:symbol;
         :canStartWith "^^" .
    
    "{"     :canPrecede n3:formulacontent;
         :canStartWith "{" .
    
    "}"     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail .
    
    <n3.n3>     :syntaxFor  [
             :internetMediaType <http://www.w3.org/2003/mediatypes#application/n3> ] .
    
    :eof     :canStartWith "@EOFDUMMY" .
    
    n3:barename     :canPrecede ".",
                "}",
                n3:statementtail,
                <#_g3>;
         :canStartWith "_",
                "a";
         :matches "[A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿][\\-0-9A-Z_a-z·À-ÖØ-öø-ͽͿ-῿‌-‍‿-⁀⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿]*" .
    
    n3:boolean     :TEST "@false",
                "@true";
         :branch  [
             :branchTail  (
            "@true" );
             :condition "@true";
             :sequence  (
            "@true" ) ],
                 [
             :branchTail  (
            "@false" );
             :condition "@false";
             :sequence  (
            "@false" ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "@false",
                "@true";
         :canStartWithLiteral "@false",
                "@true";
         :mustBeOneSequence  (
         (
            "@true" )
         (
            "@false" ) ) .
    
    n3:decimal     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "+",
                "-",
                "0";
         :matches "[-+]?[0-9]+(\\.[0-9]+)?" .
    
    n3:declaration     :TEST "@base",
                "@keywords",
                "@prefix";
         :branch  [
             :branchTail  (
            "@base"
            n3:explicituri );
             :condition "@base";
             :sequence  (
            "@base"
            n3:explicituri ) ],
                 [
             :branchTail  (
            "@prefix"
            n3:prefix
            n3:explicituri );
             :condition "@prefix";
             :sequence  (
            "@prefix"
            n3:prefix
            n3:explicituri ) ],
                 [
             :branchTail  (
            "@keywords"
            <#_g2> );
             :condition "@keywords";
             :sequence  (
            "@keywords"
            <#_g2> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith "@base",
                "@keywords",
                "@prefix";
         :canStartWithLiteral "@base",
                "@keywords",
                "@prefix";
         :mustBeOneSequence  (
         (
            "@base"
            n3:explicituri )
         (
            "@prefix"
            n3:prefix
            n3:explicituri )
         (
            "@keywords"
            <#_g2> ) ) .
    
    n3:document     a rul:Used;
         :TEST n3:statements_optional;
         :branch  [
             :branchTail  (
            :eof ),
                     (
            n3:statements_optional
            :eof );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@EOFDUMMY",
                    "@base",
                    "@false",
                    "@forAll",
                    "@forSome",
                    "@keywords",
                    "@prefix",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:statements_optional
            :eof ) ];
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@EOFDUMMY",
                "@base",
                "@false",
                "@forAll",
                "@forSome",
                "@keywords",
                "@prefix",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:statements_optional
            :eof ) ) .
    
    n3:double     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "+",
                "-",
                "0";
         :matches "[-+]?[0-9]+(\\.[0-9]+)?([eE][-+]?[0-9]+)" .
    
    n3:dtlang     :TEST "@",
                "^^";
         :branch  [
             :branchTail ();
             :condition "!",
                    "\"",
                    "(",
                    ")",
                    "+",
                    ",",
                    "-",
                    ".",
                    "0",
                    ":",
                    ";",
                    "<",
                    "<=",
                    "=",
                    "=>",
                    "?",
                    "@a",
                    "@false",
                    "@has",
                    "@is",
                    "@of",
                    "@true",
                    "[",
                    "]",
                    "^",
                    "_",
                    "a",
                    "{",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            "@"
            n3:langcode );
             :condition "@";
             :sequence  (
            "@"
            n3:langcode ) ],
                 [
             :branchTail  (
            "^^"
            n3:symbol );
             :condition "^^";
             :sequence  (
            "^^"
            n3:symbol ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "@",
                "^^";
         :canStartWithLiteral "@",
                "^^";
         :mustBeOneSequence  (
        ()
         (
            "@"
            n3:langcode )
         (
            "^^"
            n3:symbol ) ) .
    
    n3:existential     :TEST "@forSome";
         :branch  [
             :branchTail  (
            "@forSome"
            <#_g1> );
             :condition "@forSome";
             :sequence  (
            "@forSome"
            <#_g1> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith "@forSome";
         :canStartWithLiteral "@forSome";
         :mustBeOneSequence  (
         (
            "@forSome"
            <#_g1> ) ) .
    
    n3:explicituri     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail,
                <#_g4>,
                <#_g5>;
         :canStartWith "<";
         :matches "<[^>]*>" .
    
    n3:expression     :TEST n3:pathitem;
         :branch  [
             :branchTail  (
            n3:pathitem
            n3:pathtail );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:pathitem
            n3:pathtail ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@false",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:pathitem
            n3:pathtail ) ) .
    
    n3:formulacontent     :TEST n3:statementlist;
         :branch  [
             :branchTail (),
                     (
            n3:statementlist );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@base",
                    "@false",
                    "@forAll",
                    "@forSome",
                    "@keywords",
                    "@prefix",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:statementlist ) ];
         :canPrecede "}";
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@base",
                "@false",
                "@forAll",
                "@forSome",
                "@keywords",
                "@prefix",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:statementlist ) ) .
    
    n3:integer     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "+",
                "-",
                "0";
         :matches "[-+]?[0-9]+" .
    
    n3:langcode     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "a";
         :matches "[a-z]+(-[a-z0-9]+)*" .
    
    n3:language     a :Language;
         :document n3:document;
         :whiteSpace "@@@@@" .
    
    n3:literal     :TEST n3:string;
         :branch  [
             :branchTail  (
            n3:string
            n3:dtlang );
             :condition "\"";
             :sequence  (
            n3:string
            n3:dtlang ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "\"";
         :mustBeOneSequence  (
         (
            n3:string
            n3:dtlang ) ) .
    
    n3:numericliteral     :TEST n3:decimal,
                n3:double,
                n3:integer;
         :branch  [
             :branchTail  (
            n3:integer );
             :condition "+",
                    "-",
                    "0";
             :sequence  (
            n3:integer ) ],
                 [
             :branchTail  (
            n3:double );
             :condition "+",
                    "-",
                    "0";
             :sequence  (
            n3:double ) ],
                 [
             :branchTail  (
            n3:decimal );
             :condition "+",
                    "-",
                    "0";
             :sequence  (
            n3:decimal ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "+",
                "-",
                "0";
         :mustBeOneSequence  (
         (
            n3:integer )
         (
            n3:double )
         (
            n3:decimal ) ) .
    
    n3:object     :TEST n3:expression;
         :branch  [
             :branchTail  (
            n3:expression );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:expression ) ];
         :canPrecede ".",
                "]",
                "}",
                n3:objecttail,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@false",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:expression ) ) .
    
    n3:objecttail     :TEST ",";
         :branch  [
             :branchTail ();
             :condition ".",
                    ";",
                    "]",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            ","
            n3:object
            n3:objecttail );
             :condition ",";
             :sequence  (
            ","
            n3:object
            n3:objecttail ) ];
         :canPrecede ".",
                "]",
                "}",
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith ",";
         :canStartWithLiteral ",";
         :mustBeOneSequence  (
        ()
         (
            ","
            n3:object
            n3:objecttail ) ) .
    
    n3:pathitem     :TEST "(",
                "[",
                "{",
                n3:boolean,
                n3:literal,
                n3:numericliteral,
                n3:quickvariable,
                n3:symbol;
         :branch  [
             :branchTail  (
            n3:symbol );
             :condition ":",
                    "<",
                    "_",
                    "a";
             :sequence  (
            n3:symbol ) ],
                 [
             :branchTail  (
            "{"
            n3:formulacontent
            "}" );
             :condition "{";
             :sequence  (
            "{"
            n3:formulacontent
            "}" ) ],
                 [
             :branchTail  (
            n3:quickvariable );
             :condition "?";
             :sequence  (
            n3:quickvariable ) ],
                 [
             :branchTail  (
            n3:numericliteral );
             :condition "+",
                    "-",
                    "0";
             :sequence  (
            n3:numericliteral ) ],
                 [
             :branchTail  (
            n3:literal );
             :condition "\"";
             :sequence  (
            n3:literal ) ],
                 [
             :branchTail  (
            "["
            n3:propertylist
            "]" );
             :condition "[";
             :sequence  (
            "["
            n3:propertylist
            "]" ) ],
                 [
             :branchTail  (
            "("
            n3:pathlist
            ")" );
             :condition "(";
             :sequence  (
            "("
            n3:pathlist
            ")" ) ],
                 [
             :branchTail  (
            n3:boolean );
             :condition "@false",
                    "@true";
             :sequence  (
            n3:boolean ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@false",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :canStartWithLiteral "(",
                "[",
                "{";
         :mustBeOneSequence  (
         (
            n3:symbol )
         (
            "{"
            n3:formulacontent
            "}" )
         (
            n3:quickvariable )
         (
            n3:numericliteral )
         (
            n3:literal )
         (
            "["
            n3:propertylist
            "]" )
         (
            "("
            n3:pathlist
            ")" )
         (
            n3:boolean ) ) .
    
    n3:pathlist     :TEST n3:expression;
         :branch  [
             :branchTail ();
             :condition ")";
             :sequence () ],
                 [
             :branchTail  (
            n3:expression
            n3:pathlist );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:expression
            n3:pathlist ) ];
         :canPrecede ")";
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@false",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
        ()
         (
            n3:expression
            n3:pathlist ) ) .
    
    n3:pathtail     :TEST "!",
                "^";
         :branch  [
             :branchTail ();
             :condition "\"",
                    "(",
                    ")",
                    "+",
                    ",",
                    "-",
                    ".",
                    "0",
                    ":",
                    ";",
                    "<",
                    "<=",
                    "=",
                    "=>",
                    "?",
                    "@a",
                    "@false",
                    "@has",
                    "@is",
                    "@of",
                    "@true",
                    "[",
                    "]",
                    "_",
                    "a",
                    "{",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            "!"
            n3:expression );
             :condition "!";
             :sequence  (
            "!"
            n3:expression ) ],
                 [
             :branchTail  (
            "^"
            n3:expression );
             :condition "^";
             :sequence  (
            "^"
            n3:expression ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "!",
                "^";
         :canStartWithLiteral "!",
                "^";
         :mustBeOneSequence  (
        ()
         (
            "!"
            n3:expression )
         (
            "^"
            n3:expression ) ) .
    
    n3:prefix     :canPrecede n3:explicituri;
         :canStartWith ":",
                "_",
                "a";
         :matches "([A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿][\\-0-9A-Z_a-z·À-ÖØ-öø-ͽͿ-῿‌-‍‿-⁀⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿]*)?:" .
    
    n3:propertylist     :TEST n3:verb;
         :branch  [
             :branchTail ();
             :condition ".",
                    "]",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            n3:verb
            n3:object
            n3:objecttail
            n3:propertylisttail );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "<=",
                    "=",
                    "=>",
                    "?",
                    "@a",
                    "@false",
                    "@has",
                    "@is",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:verb
            n3:object
            n3:objecttail
            n3:propertylisttail ) ];
         :canPrecede ".",
                "]",
                "}",
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "<=",
                "=",
                "=>",
                "?",
                "@a",
                "@false",
                "@has",
                "@is",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
        ()
         (
            n3:verb
            n3:object
            n3:objecttail
            n3:propertylisttail ) ) .
    
    n3:propertylisttail     :TEST ";";
         :branch  [
             :branchTail ();
             :condition ".",
                    "]",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            ";"
            n3:propertylist );
             :condition ";";
             :sequence  (
            ";"
            n3:propertylist ) ];
         :canPrecede ".",
                "]",
                "}",
                n3:statementtail;
         :canStartWith ";";
         :canStartWithLiteral ";";
         :mustBeOneSequence  (
        ()
         (
            ";"
            n3:propertylist ) ) .
    
    n3:qname     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail,
                <#_g4>,
                <#_g5>;
         :canStartWith ":",
                "_",
                "a";
         :matches "(([A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿][\\-0-9A-Z_a-z·À-ÖØ-öø-ͽͿ-῿‌-‍‿-⁀⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿]*)?:)?[A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿][\\-0-9A-Z_a-z·À-ÖØ-öø-ͽͿ-῿‌-‍‿-⁀⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿]*" .
    
    n3:quickvariable     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "?";
         :matches "\\?[A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿][\\-0-9A-Z_a-z·À-ÖØ-öø-ͽͿ-῿‌-‍‿-⁀⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿]*" .
    
    n3:simpleStatement     :TEST n3:subject;
         :branch  [
             :branchTail  (
            n3:subject
            n3:propertylist );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:subject
            n3:propertylist ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@false",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:subject
            n3:propertylist ) ) .
    
    n3:statement     :TEST n3:declaration,
                n3:existential,
                n3:simpleStatement,
                n3:universal;
         :branch  [
             :branchTail  (
            n3:declaration );
             :condition "@base",
                    "@keywords",
                    "@prefix";
             :sequence  (
            n3:declaration ) ],
                 [
             :branchTail  (
            n3:universal );
             :condition "@forAll";
             :sequence  (
            n3:universal ) ],
                 [
             :branchTail  (
            n3:existential );
             :condition "@forSome";
             :sequence  (
            n3:existential ) ],
                 [
             :branchTail  (
            n3:simpleStatement );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:simpleStatement ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@base",
                "@false",
                "@forAll",
                "@forSome",
                "@keywords",
                "@prefix",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:declaration )
         (
            n3:universal )
         (
            n3:existential )
         (
            n3:simpleStatement ) ) .
    
    n3:statementlist     :TEST n3:statement;
         :branch  [
             :branchTail ();
             :condition "}";
             :sequence () ],
                 [
             :branchTail  (
            n3:statement
            n3:statementtail );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@base",
                    "@false",
                    "@forAll",
                    "@forSome",
                    "@keywords",
                    "@prefix",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:statement
            n3:statementtail ) ];
         :canPrecede "}";
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@base",
                "@false",
                "@forAll",
                "@forSome",
                "@keywords",
                "@prefix",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
        ()
         (
            n3:statement
            n3:statementtail ) ) .
    
    n3:statements_optional     :TEST n3:statement;
         :branch  [
             :branchTail ();
             :condition "@EOFDUMMY";
             :sequence () ],
                 [
             :branchTail  (
            n3:statement
            "."
            n3:statements_optional );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@base",
                    "@false",
                    "@forAll",
                    "@forSome",
                    "@keywords",
                    "@prefix",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:statement
            "."
            n3:statements_optional ) ];
         :canPrecede :eof;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@base",
                "@false",
                "@forAll",
                "@forSome",
                "@keywords",
                "@prefix",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
        ()
         (
            n3:statement
            "."
            n3:statements_optional ) ) .
    
    n3:statementtail     :TEST ".";
         :branch  [
             :branchTail ();
             :condition "}";
             :sequence () ],
                 [
             :branchTail  (
            "."
            n3:statementlist );
             :condition ".";
             :sequence  (
            "."
            n3:statementlist ) ];
         :canPrecede "}";
         :canStartWith ".";
         :canStartWithLiteral ".";
         :mustBeOneSequence  (
        ()
         (
            "."
            n3:statementlist ) ) .
    
    n3:string     :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:dtlang,
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail;
         :canStartWith "\"";
         :matches """(\"""[^"\\\\]*(?:(?:\\\\.|"(?!""))[^"\\\\]*)*\""")|("[^"\\\\]*(?:\\\\.[^"\\\\]*)*")""" .
    
    n3:subject     :TEST n3:expression;
         :branch  [
             :branchTail  (
            n3:expression );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:expression ) ];
         :canPrecede ".",
                "]",
                "}",
                n3:propertylist,
                n3:statementtail;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "?",
                "@false",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :mustBeOneSequence  (
         (
            n3:expression ) ) .
    
    n3:symbol     :TEST n3:explicituri,
                n3:qname;
         :branch  [
             :branchTail  (
            n3:explicituri );
             :condition "<";
             :sequence  (
            n3:explicituri ) ],
                 [
             :branchTail  (
            n3:qname );
             :condition ":",
                    "_",
                    "a";
             :sequence  (
            n3:qname ) ];
         :canPrecede ")",
                ".",
                "@of",
                "]",
                "}",
                n3:object,
                n3:objecttail,
                n3:pathlist,
                n3:pathtail,
                n3:propertylist,
                n3:propertylisttail,
                n3:statementtail,
                <#_g4>,
                <#_g5>;
         :canStartWith ":",
                "<",
                "_",
                "a";
         :mustBeOneSequence  (
         (
            n3:explicituri )
         (
            n3:qname ) ) .
    
    n3:universal     :TEST "@forAll";
         :branch  [
             :branchTail  (
            "@forAll"
            <#_g0> );
             :condition "@forAll";
             :sequence  (
            "@forAll"
            <#_g0> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith "@forAll";
         :canStartWithLiteral "@forAll";
         :mustBeOneSequence  (
         (
            "@forAll"
            <#_g0> ) ) .
    
    n3:verb     :TEST "<=",
                "=",
                "=>",
                "@a",
                "@has",
                "@is",
                n3:expression;
         :branch  [
             :branchTail  (
            n3:expression );
             :condition "\"",
                    "(",
                    "+",
                    "-",
                    "0",
                    ":",
                    "<",
                    "?",
                    "@false",
                    "@true",
                    "[",
                    "_",
                    "a",
                    "{";
             :sequence  (
            n3:expression ) ],
                 [
             :branchTail  (
            "@has"
            n3:expression );
             :condition "@has";
             :sequence  (
            "@has"
            n3:expression ) ],
                 [
             :branchTail  (
            "@is"
            n3:expression
            "@of" );
             :condition "@is";
             :sequence  (
            "@is"
            n3:expression
            "@of" ) ],
                 [
             :branchTail  (
            "@a" );
             :condition "@a";
             :sequence  (
            "@a" ) ],
                 [
             :branchTail  (
            "=" );
             :condition "=";
             :sequence  (
            "=" ) ],
                 [
             :branchTail  (
            "=>" );
             :condition "=>";
             :sequence  (
            "=>" ) ],
                 [
             :branchTail  (
            "<=" );
             :condition "<=";
             :sequence  (
            "<=" ) ];
         :canPrecede n3:object;
         :canStartWith "\"",
                "(",
                "+",
                "-",
                "0",
                ":",
                "<",
                "<=",
                "=",
                "=>",
                "?",
                "@a",
                "@false",
                "@has",
                "@is",
                "@true",
                "[",
                "_",
                "a",
                "{";
         :canStartWithLiteral "<=",
                "=",
                "=>",
                "@a",
                "@has",
                "@is";
         :mustBeOneSequence  (
         (
            n3:expression )
         (
            "@has"
            n3:expression )
         (
            "@is"
            n3:expression
            "@of" )
         (
            "@a" )
         (
            "=" )
         (
            "=>" )
         (
            "<=" ) ) .
    
    <#_g0>     :TEST n3:symbol;
         :branch  [
             :branchTail ();
             :condition ".",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            n3:symbol
            <#_g5> );
             :condition ":",
                    "<",
                    "_",
                    "a";
             :sequence  (
            n3:symbol
            <#_g5> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith ":",
                "<",
                "_",
                "a";
         :commaSeparatedListOf n3:symbol;
         :mustBeOneSequence  (
        ()
         (
            n3:symbol
            <#_g5> ) ) .
    
    <#_g1>     :TEST n3:symbol;
         :branch  [
             :branchTail ();
             :condition ".",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            n3:symbol
            <#_g4> );
             :condition ":",
                    "<",
                    "_",
                    "a";
             :sequence  (
            n3:symbol
            <#_g4> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith ":",
                "<",
                "_",
                "a";
         :commaSeparatedListOf n3:symbol;
         :mustBeOneSequence  (
        ()
         (
            n3:symbol
            <#_g4> ) ) .
    
    <#_g2>     :TEST n3:barename;
         :branch  [
             :branchTail ();
             :condition ".",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            n3:barename
            <#_g3> );
             :condition "_",
                    "a";
             :sequence  (
            n3:barename
            <#_g3> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith "_",
                "a";
         :commaSeparatedListOf n3:barename;
         :mustBeOneSequence  (
        ()
         (
            n3:barename
            <#_g3> ) ) .
    
    <#_g3>     :CSLTail2 n3:barename;
         :TEST ",";
         :branch  [
             :branchTail ();
             :condition ".",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            ","
            n3:barename
            <#_g3> );
             :condition ",";
             :sequence  (
            ","
            n3:barename
            <#_g3> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith ",";
         :canStartWithLiteral ",";
         :mustBeOneSequence  (
        ()
         (
            ","
            n3:barename
            <#_g3> ) ) .
    
    <#_g4>     :CSLTail2 n3:symbol;
         :TEST ",";
         :branch  [
             :branchTail ();
             :condition ".",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            ","
            n3:symbol
            <#_g4> );
             :condition ",";
             :sequence  (
            ","
            n3:symbol
            <#_g4> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith ",";
         :canStartWithLiteral ",";
         :mustBeOneSequence  (
        ()
         (
            ","
            n3:symbol
            <#_g4> ) ) .
    
    <#_g5>     :CSLTail2 n3:symbol;
         :TEST ",";
         :branch  [
             :branchTail ();
             :condition ".",
                    "}";
             :sequence () ],
                 [
             :branchTail  (
            ","
            n3:symbol
            <#_g5> );
             :condition ",";
             :sequence  (
            ","
            n3:symbol
            <#_g5> ) ];
         :canPrecede ".",
                "}",
                n3:statementtail;
         :canStartWith ",";
         :canStartWithLiteral ",";
         :mustBeOneSequence  (
        ()
         (
            ","
            n3:symbol
            <#_g5> ) ) .
    
